/[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 442 by capela, Thu Mar 10 15:48:38 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.  // Constructor.
107  qsamplerDeviceParameterTable::qsamplerDeviceParameterTable ( QWidget *pParent, const char *pszName )  qsamplerDevice::qsamplerDevice ( lscp_client_t *pClient,
108            qsamplerDeviceType deviceType, int iDeviceID )
109    {
110            setDevice(pClient, deviceType, iDeviceID);
111    }
112    
113    // Default destructor.
114    qsamplerDevice::~qsamplerDevice (void)
115    {
116    }
117    
118    
119    // Initializer.
120    void qsamplerDevice::setDevice ( lscp_client_t *pClient,
121            qsamplerDeviceType deviceType, int iDeviceID )
122    {
123            // Device id and type should be always set.
124            m_iDeviceID   = iDeviceID;
125            m_deviceType  = deviceType;
126    
127            // Retrieve device info, if any.
128            lscp_device_info_t *pDeviceInfo = NULL;
129            switch (deviceType) {
130            case qsamplerDevice::Audio:
131                    m_sDeviceType = QObject::tr("Audio");
132                    pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);
133                    break;
134            case qsamplerDevice::Midi:
135                    m_sDeviceType = QObject::tr("MIDI");
136                    pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);
137                    break;
138            case qsamplerDevice::None:
139                    m_sDeviceType = QString::null;
140                    break;
141            }
142    
143            // If we're bogus, bail out...
144            if (pDeviceInfo == NULL) {
145                    m_sDriverName = QString::null;
146                    m_sDeviceName = QObject::tr("New device");
147                    return;
148            }
149    
150            // Other device properties...
151            m_sDriverName = pDeviceInfo->driver;
152            m_sDeviceName = m_sDriverName + ' '
153                    + QObject::tr("Device %1").arg(m_iDeviceID);
154    
155            // Grab device parameters...
156            m_params.clear();
157            for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {
158                    const char *pszParam = pDeviceInfo->params[i].key;
159                    lscp_param_info_t *pParamInfo = NULL;
160                    switch (deviceType) {
161                    case qsamplerDevice::Audio:
162                            pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
163                                    m_sDriverName.latin1(), pszParam, NULL);
164                            break;
165                    case qsamplerDevice::Midi:
166                            pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
167                                    m_sDriverName.latin1(), pszParam, NULL);
168                            break;
169                    case qsamplerDevice::None:
170                            break;
171                    }
172                    if (pParamInfo) {
173                            m_params[pszParam] = qsamplerDeviceParam(pParamInfo,
174                                    pDeviceInfo->params[i].value);
175                    }
176            }
177    }
178    
179    
180    // Driver name initializer.
181    void qsamplerDevice::setDriver ( lscp_client_t *pClient,
182            const QString& sDriverName )
183    {
184            // Valid only for scratch devices.
185            if (m_sDriverName == sDriverName)
186                    return;
187    
188            // Retrieve driver info, if any.
189            lscp_driver_info_t *pDriverInfo = NULL;
190            switch (m_deviceType) {
191            case qsamplerDevice::Audio:
192                    pDriverInfo = ::lscp_get_audio_driver_info(pClient,
193                            sDriverName.latin1());
194                    break;
195            case qsamplerDevice::Midi:
196                    pDriverInfo = ::lscp_get_midi_driver_info(pClient,
197                            sDriverName.latin1());
198                    break;
199            case qsamplerDevice::None:
200                    break;
201            }
202    
203            // If we're bogus, bail out...
204            if (pDriverInfo == NULL)
205                    return;
206    
207            // Remember device parameters...
208            m_sDriverName = sDriverName;
209    
210            // Grab driver parameters...
211            m_params.clear();
212            for (int i = 0; pDriverInfo->parameters && pDriverInfo->parameters[i]; i++) {
213                    const char *pszParam = pDriverInfo->parameters[i];
214                    lscp_param_info_t *pParamInfo = NULL;
215                    switch (m_deviceType) {
216                    case qsamplerDevice::Audio:
217                            pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
218                                    sDriverName.latin1(), pszParam, NULL);
219                            break;
220                    case qsamplerDevice::Midi:
221                            pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
222                                    sDriverName.latin1(), pszParam, NULL);
223                            break;
224                    case qsamplerDevice::None:
225                            break;
226                    }
227                    if (pParamInfo)
228                            m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pParamInfo->defaultv);
229            }
230    }
231    
232    
233    // Device property accessors.
234    int qsamplerDevice::deviceID (void) const
235    {
236            return m_iDeviceID;
237    }
238    
239    qsamplerDevice::qsamplerDeviceType qsamplerDevice::deviceType (void) const
240    {
241            return m_deviceType;
242    }
243    
244    const QString& qsamplerDevice::deviceTypeName (void) const
245    {
246            return m_sDeviceType;
247    }
248    
249    const QString& qsamplerDevice::driverName (void) const
250    {
251            return m_sDriverName;
252    }
253    
254    const QString& qsamplerDevice::deviceName (void) const
255    {
256            return m_sDeviceName;
257    }
258    
259    // Device parameter accessor.
260    qsamplerDeviceParamMap& qsamplerDevice::params (void)
261    {
262            return m_params;
263    }
264    
265    
266    // Update/refresh device/driver data.
267    void qsamplerDevice::refresh (void)
268    {
269    }
270    
271    // Device ids enumerator.
272    int *qsamplerDevice::getDevices ( lscp_client_t *pClient,
273            qsamplerDeviceType deviceType )
274    {
275            int *piDeviceIDs = NULL;
276            switch (deviceType) {
277            case qsamplerDevice::Audio:
278                    piDeviceIDs = ::lscp_list_audio_devices(pClient);
279                    break;
280            case qsamplerDevice::Midi:
281                    piDeviceIDs = ::lscp_list_midi_devices(pClient);
282                    break;
283            case qsamplerDevice::None:
284                    break;
285            }
286            return piDeviceIDs;
287    }
288    
289    
290    // Driver names enumerator.
291    QStringList qsamplerDevice::getDrivers ( lscp_client_t *pClient,
292            qsamplerDeviceType deviceType )
293    {
294            QStringList drivers;
295            
296            const char **ppszDrivers = NULL;
297            switch (deviceType) {
298            case qsamplerDevice::Audio:
299                    ppszDrivers = ::lscp_get_available_audio_drivers(pClient);
300                    break;
301            case qsamplerDevice::Midi:
302                    ppszDrivers = ::lscp_get_available_midi_drivers(pClient);
303                    break;
304            case qsamplerDevice::None:
305                    break;
306            }
307            
308            for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)
309                    drivers.append(ppszDrivers[iDriver]);
310    
311            return drivers;
312    }
313    
314    
315    //-------------------------------------------------------------------------
316    // qsamplerDeviceItem - QListView device item.
317    //
318    
319    // Constructors.
320    qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView,
321            lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType )
322            : QListViewItem(pListView), m_device(pClient, deviceType)
323    {
324            switch(m_device.deviceType()) {
325            case qsamplerDevice::Audio:
326                    QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio1.png"));
327                    QListViewItem::setText(0, QObject::tr("Audio devices"));
328                    break;
329            case qsamplerDevice::Midi:
330                    QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));
331                    QListViewItem::setText(0, QObject::tr("MIDI devices"));
332                    break;
333            case qsamplerDevice::None:
334                    break;
335            }
336    }
337    
338    qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem,
339            lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType,
340            int iDeviceID )
341            : QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)
342    {
343            switch(m_device.deviceType()) {
344            case qsamplerDevice::Audio:
345                    QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio2.png"));
346                    break;
347            case qsamplerDevice::Midi:
348                    QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));
349                    break;
350            case qsamplerDevice::None:
351                    break;
352            }
353    
354            QListViewItem::setText(0, m_device.deviceName());
355    }
356    
357    // Default destructor.
358    qsamplerDeviceItem::~qsamplerDeviceItem (void)
359    {
360    }
361    
362    // Instance accessors.
363    qsamplerDevice& qsamplerDeviceItem::device (void)
364    {
365            return m_device;
366    }
367    
368    // To virtually distinguish between list view items.
369    int qsamplerDeviceItem::rtti() const
370    {
371            return QSAMPLER_DEVICE_ITEM;
372    }
373    
374    
375    
376    //-------------------------------------------------------------------------
377    // qsamplerDeviceParamTable - Device parameter view table.
378    //
379    
380    // Constructor.
381    qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent,
382            const char *pszName )
383          : QTable(pParent, pszName)          : QTable(pParent, pszName)
384  {  {
385          m_pClient = NULL;          // Set fixed number of columns.
386            QTable::setNumCols(3);
387            QTable::setShowGrid(false);
388            QTable::setSorting(false);
389            QTable::setFocusStyle(QTable::FollowStyle);
390            QTable::setSelectionMode(QTable::NoSelection);
391            // No vertical header.
392            QTable::verticalHeader()->hide();
393            QTable::setLeftMargin(0);
394            // Initialize the fixed table column headings.
395            QHeader *pHeader = QTable::horizontalHeader();
396            pHeader->setLabel(0, tr("Parameter"));
397            pHeader->setLabel(1, tr("Description"));
398            pHeader->setLabel(2, tr("Value"));
399            // Set read-onlyness of each column
400            QTable::setColumnReadOnly(0, true);
401            QTable::setColumnReadOnly(1, true);
402    //  QTable::setColumnReadOnly(2, true); -- of course not.
403            QTable::setColumnStretchable(1, true);
404  }  }
405    
406  // Default destructor.  // Default destructor.
407  qsamplerDeviceParameterTable::~qsamplerDeviceParameterTable (void)  qsamplerDeviceParamTable::~qsamplerDeviceParamTable (void)
408    {
409    }
410    
411    
412    // The main table refresher.
413    void qsamplerDeviceParamTable::refresh ( qsamplerDevice& device )
414  {  {
415            // Always (re)start it empty.
416            QTable::setUpdatesEnabled(false);
417            QTable::setNumRows(0);
418    
419            // Now fill the parameter table...
420            qsamplerDeviceParamMap& params = device.params();
421            QTable::insertRows(0, params.count());
422            int iRow = 0;
423            qsamplerDeviceParamMap::ConstIterator iter;
424            for (iter = params.begin(); iter != params.end(); ++iter) {
425                    const qsamplerDeviceParam& param = iter.data();
426                    bool bEnabled = (device.deviceID() < 0 || !param.fix);
427                    QTable::setText(iRow, 0, iter.key());
428                    QTable::setText(iRow, 1, param.description);
429                    if (param.type == LSCP_TYPE_BOOL) {
430                            QStringList opts;
431                            opts.append(tr("false"));
432                            opts.append(tr("true"));
433                            QComboTableItem *pComboItem = new QComboTableItem(this, opts);
434                        pComboItem->setCurrentItem(param.value.lower() == "true" ? 1 : 0);
435                        pComboItem->setEnabled(bEnabled);
436                            QTable::setItem(iRow, 2, pComboItem);
437                    } else if (param.possibilities.count() > 0) {
438                            QComboTableItem *pComboItem = new QComboTableItem(this,
439                                    param.possibilities);
440                        pComboItem->setCurrentItem(param.value);
441                        pComboItem->setEnabled(bEnabled);
442                        pComboItem->setEditable(bEnabled && param.multiplicity);
443                            QTable::setItem(iRow, 2, pComboItem);
444                } else if (param.type == LSCP_TYPE_INT) {
445                    qsamplerDeviceParamTableSpinBox *pSpinItem =
446                                    new qsamplerDeviceParamTableSpinBox(this,
447                                            bEnabled ? QTableItem::OnTyping : QTableItem::Never);
448                            pSpinItem->setMinValue(param.range_min.toInt());
449                            pSpinItem->setMaxValue(param.range_max.toInt());
450                            pSpinItem->setValue(param.value.toInt());
451                            QTable::setItem(iRow, 2, pSpinItem);
452                    } else {
453                qsamplerDeviceParamTableEditBox *pEditItem =
454                                    new qsamplerDeviceParamTableEditBox(this,
455                                        bEnabled ? QTableItem::OnTyping : QTableItem::Never,
456                                            param.value);
457                            QTable::setItem(iRow, 2, pEditItem);
458                    }
459                    ++iRow;
460            }
461    
462            // Adjust optimal column widths.
463            QTable::adjustColumn(0);
464            QTable::adjustColumn(2);
465    
466            QTable::setUpdatesEnabled(true);
467            QTable::updateContents();
468    }
469    
470    
471    //-------------------------------------------------------------------------
472    // qsamplerDeviceParamTableSpinBox - Custom spin box for parameter table.
473    //
474    
475    // Constructor.
476    qsamplerDeviceParamTableSpinBox::qsamplerDeviceParamTableSpinBox (
477            QTable *pTable, EditType editType )
478            : QTableItem(pTable, editType, QString::null)
479    {
480            m_iValue = m_iMinValue = m_iMaxValue = 0;
481    }
482    
483    // Public accessors.
484    void qsamplerDeviceParamTableSpinBox::setValue ( int iValue )
485    {
486            m_iValue = iValue;
487            QTableItem::setText(QString::number(m_iValue));
488  }  }
489    
490    void qsamplerDeviceParamTableSpinBox::setMinValue ( int iMinValue )
491    {
492            m_iMinValue = iMinValue;
493    }
494    
495    void qsamplerDeviceParamTableSpinBox::setMaxValue ( int iMaxValue )
496    {
497            m_iMaxValue = iMaxValue;
498    }
499    
500    // Virtual implemetations.
501    QWidget *qsamplerDeviceParamTableSpinBox::createEditor (void) const
502    {
503            QSpinBox *pSpinBox = new QSpinBox(QTableItem::table()->viewport());
504            QObject::connect(pSpinBox, SIGNAL(valueChanged(int)),
505                    QTableItem::table(), SLOT(doValueChanged()));
506            if (m_iValue >= m_iMinValue && m_iMaxValue >= m_iValue) {
507                    pSpinBox->setMinValue(m_iMinValue);
508                    pSpinBox->setMaxValue(m_iMaxValue);
509            }
510            pSpinBox->setValue(m_iValue);
511    //      pSpinBox->setEnabled(QTableItem::isEnabled());
512            return pSpinBox;
513    }
514    
515    void qsamplerDeviceParamTableSpinBox::setContentFromEditor ( QWidget *pWidget )
516    {
517            if (pWidget->inherits("QSpinBox"))
518                QTableItem::setText(QString::number(((QSpinBox *) pWidget)->value()));
519            else
520                QTableItem::setContentFromEditor(pWidget);
521    }
522    
523    
524    //-------------------------------------------------------------------------
525    // qsamplerDeviceParamTableEditBox - Custom edit box for parameter table.
526    //
527    
528    // Constructor.
529    qsamplerDeviceParamTableEditBox::qsamplerDeviceParamTableEditBox (
530            QTable *pTable, EditType editType, const QString& sText )
531            : QTableItem(pTable, editType, sText)
532    {
533    }
534    
535  // The client descriptor property accessors.  // Virtual implemetations.
536  void qsamplerDeviceParameterTable::setClient ( lscp_client_t *pClient )  QWidget *qsamplerDeviceParamTableEditBox::createEditor (void) const
537  {  {
538      m_pClient = pClient;          QLineEdit *pEditBox = new QLineEdit(QTableItem::table()->viewport());
539            QObject::connect(pEditBox, SIGNAL(returnPressed()),
540                    QTableItem::table(), SLOT(doValueChanged()));
541            pEditBox->setText(QTableItem::text());
542    //      pEditBox->setEnabled(QTableItem::isEnabled());
543            return pEditBox;
544  }  }
545    
546  lscp_client_t *qsamplerDeviceParameterTable::client (void)  void qsamplerDeviceParamTableEditBox::setContentFromEditor ( QWidget *pWidget )
547  {  {
548      return m_pClient;          if (pWidget->inherits("QLineEdit"))
549                QTableItem::setText(((QLineEdit *) pWidget)->text());
550            else
551                QTableItem::setContentFromEditor(pWidget);
552  }  }
553    
554    
Legend:
Removed from v.426  
changed lines
  Added in v.442
  ViewVC Help
Powered by ViewVC