/[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 431 by capela, Tue Mar 8 20:12:08 2005 UTC revision 442 by capela, Thu Mar 10 15:48:38 2005 UTC
# 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 122  void qsamplerDevice::setDevice ( lscp_cl Line 125  void qsamplerDevice::setDevice ( lscp_cl
125          m_deviceType  = deviceType;          m_deviceType  = deviceType;
126    
127          // Retrieve device info, if any.          // Retrieve device info, if any.
         QString sDeviceType;  
128          lscp_device_info_t *pDeviceInfo = NULL;          lscp_device_info_t *pDeviceInfo = NULL;
129          switch (deviceType) {          switch (deviceType) {
130          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
131                  sDeviceType = QObject::tr("Audio");                  m_sDeviceType = QObject::tr("Audio");
132                  pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);                  pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);
133                  break;                  break;
134          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
135                  sDeviceType = QObject::tr("MIDI");                  m_sDeviceType = QObject::tr("MIDI");
136                  pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);                  pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);
137                  break;                  break;
138            case qsamplerDevice::None:
139                    m_sDeviceType = QString::null;
140                    break;
141          }          }
142    
143          // If we're bogus, bail out...          // If we're bogus, bail out...
144          if (pDeviceInfo == NULL) {          if (pDeviceInfo == NULL) {
145                  m_sDriverName = QString::null;                  m_sDriverName = QString::null;
146                  m_sDeviceName = QObject::tr("New %1 device").arg(sDeviceType);                  m_sDeviceName = QObject::tr("New device");
147                  return;                  return;
148          }          }
149    
# Line 161  void qsamplerDevice::setDevice ( lscp_cl Line 166  void qsamplerDevice::setDevice ( lscp_cl
166                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
167                                  m_sDriverName.latin1(), pszParam, NULL);                                  m_sDriverName.latin1(), pszParam, NULL);
168                          break;                          break;
169                    case qsamplerDevice::None:
170                            break;
171                    }
172                    if (pParamInfo) {
173                            m_params[pszParam] = qsamplerDeviceParam(pParamInfo,
174                                    pDeviceInfo->params[i].value);
175                  }                  }
                 m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pDeviceInfo->params[i].value);  
176          }          }
177  }  }
178    
# Line 186  void qsamplerDevice::setDriver ( lscp_cl Line 196  void qsamplerDevice::setDriver ( lscp_cl
196                  pDriverInfo = ::lscp_get_midi_driver_info(pClient,                  pDriverInfo = ::lscp_get_midi_driver_info(pClient,
197                          sDriverName.latin1());                          sDriverName.latin1());
198                  break;                  break;
199            case qsamplerDevice::None:
200                    break;
201          }          }
202    
203          // If we're bogus, bail out...          // If we're bogus, bail out...
# Line 209  void qsamplerDevice::setDriver ( lscp_cl Line 221  void qsamplerDevice::setDriver ( lscp_cl
221                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
222                                  sDriverName.latin1(), pszParam, NULL);                                  sDriverName.latin1(), pszParam, NULL);
223                          break;                          break;
224                    case qsamplerDevice::None:
225                            break;
226                  }                  }
227                  m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pParamInfo->defaultv);                  if (pParamInfo)
228                            m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pParamInfo->defaultv);
229          }          }
230  }  }
231    
# Line 226  qsamplerDevice::qsamplerDeviceType qsamp Line 241  qsamplerDevice::qsamplerDeviceType qsamp
241          return m_deviceType;          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  const QString& qsamplerDevice::driverName (void) const
250  {  {
251          return m_sDriverName;          return m_sDriverName;
# Line 260  int *qsamplerDevice::getDevices ( lscp_c Line 280  int *qsamplerDevice::getDevices ( lscp_c
280          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
281                  piDeviceIDs = ::lscp_list_midi_devices(pClient);                  piDeviceIDs = ::lscp_list_midi_devices(pClient);
282                  break;                  break;
283            case qsamplerDevice::None:
284                    break;
285          }          }
286          return piDeviceIDs;          return piDeviceIDs;
287  }  }
# Line 279  QStringList qsamplerDevice::getDrivers ( Line 301  QStringList qsamplerDevice::getDrivers (
301          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
302                  ppszDrivers = ::lscp_get_available_midi_drivers(pClient);                  ppszDrivers = ::lscp_get_available_midi_drivers(pClient);
303                  break;                  break;
304            case qsamplerDevice::None:
305                    break;
306          }          }
307                    
308          for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)          for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)
# Line 293  QStringList qsamplerDevice::getDrivers ( Line 317  QStringList qsamplerDevice::getDrivers (
317  //  //
318    
319  // Constructors.  // Constructors.
320  qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView, lscp_client_t *pClient,  qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView,
321          qsamplerDevice::qsamplerDeviceType deviceType )          lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType )
322          : QListViewItem(pListView), m_device(pClient, deviceType)          : QListViewItem(pListView), m_device(pClient, deviceType)
323  {  {
324          switch(m_device.deviceType()) {          switch(m_device.deviceType()) {
# Line 306  qsamplerDeviceItem::qsamplerDeviceItem ( Line 330  qsamplerDeviceItem::qsamplerDeviceItem (
330                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));
331                  QListViewItem::setText(0, QObject::tr("MIDI devices"));                  QListViewItem::setText(0, QObject::tr("MIDI devices"));
332                  break;                  break;
333            case qsamplerDevice::None:
334                    break;
335          }          }
336  }  }
337    
338  qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem, lscp_client_t *pClient,  qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem,
339          qsamplerDevice::qsamplerDeviceType deviceType, int iDeviceID )          lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType,
340            int iDeviceID )
341          : QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)          : QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)
342  {  {
343          switch(m_device.deviceType()) {          switch(m_device.deviceType()) {
# Line 320  qsamplerDeviceItem::qsamplerDeviceItem ( Line 347  qsamplerDeviceItem::qsamplerDeviceItem (
347          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
348                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));
349                  break;                  break;
350            case qsamplerDevice::None:
351                    break;
352          }          }
353    
354          QListViewItem::setText(0, m_device.deviceName());          QListViewItem::setText(0, m_device.deviceName());
# Line 349  int qsamplerDeviceItem::rtti() const Line 378  int qsamplerDeviceItem::rtti() const
378  //  //
379    
380  // Constructor.  // Constructor.
381  qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent, const char *pszName )  qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent,
382            const char *pszName )
383          : QTable(pParent, pszName)          : QTable(pParent, pszName)
384  {  {
385          // Set fixed number of columns.          // Set fixed number of columns.
# Line 364  qsamplerDeviceParamTable::qsamplerDevice Line 394  qsamplerDeviceParamTable::qsamplerDevice
394          // Initialize the fixed table column headings.          // Initialize the fixed table column headings.
395          QHeader *pHeader = QTable::horizontalHeader();          QHeader *pHeader = QTable::horizontalHeader();
396          pHeader->setLabel(0, tr("Parameter"));          pHeader->setLabel(0, tr("Parameter"));
397          pHeader->setLabel(1, tr("Value"));          pHeader->setLabel(1, tr("Description"));
398          pHeader->setLabel(2, tr("Description"));          pHeader->setLabel(2, tr("Value"));
399          // Set read-onlyness of each column          // Set read-onlyness of each column
400          QTable::setColumnReadOnly(0, true);          QTable::setColumnReadOnly(0, true);
401  //  QTable::setColumnReadOnly(1, true); -- of course not.          QTable::setColumnReadOnly(1, true);
402          QTable::setColumnReadOnly(2, true);  //  QTable::setColumnReadOnly(2, true); -- of course not.
403            QTable::setColumnStretchable(1, true);
404  }  }
405    
406  // Default destructor.  // Default destructor.
# Line 382  qsamplerDeviceParamTable::~qsamplerDevic Line 413  qsamplerDeviceParamTable::~qsamplerDevic
413  void qsamplerDeviceParamTable::refresh ( qsamplerDevice& device )  void qsamplerDeviceParamTable::refresh ( qsamplerDevice& device )
414  {  {
415          // Always (re)start it empty.          // Always (re)start it empty.
416            QTable::setUpdatesEnabled(false);
417          QTable::setNumRows(0);          QTable::setNumRows(0);
418    
419          // Now fill the parameter table...          // Now fill the parameter table...
# Line 390  void qsamplerDeviceParamTable::refresh ( Line 422  void qsamplerDeviceParamTable::refresh (
422          int iRow = 0;          int iRow = 0;
423          qsamplerDeviceParamMap::ConstIterator iter;          qsamplerDeviceParamMap::ConstIterator iter;
424          for (iter = params.begin(); iter != params.end(); ++iter) {          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());                  QTable::setText(iRow, 0, iter.key());
428                  QTable::setText(iRow, 1, iter.data().value);                  QTable::setText(iRow, 1, param.description);
429                  QTable::setText(iRow, 2, iter.data().description);                  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;                  ++iRow;
460          }          }
461    
462          // Adjust optimal column width.          // Adjust optimal column widths.
463          for (int iCol = 0; iCol < QTable::numCols(); iCol++)          QTable::adjustColumn(0);
464                  QTable::adjustColumn(iCol);          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    // Virtual implemetations.
536    QWidget *qsamplerDeviceParamTableEditBox::createEditor (void) const
537    {
538            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    void qsamplerDeviceParamTableEditBox::setContentFromEditor ( QWidget *pWidget )
547    {
548            if (pWidget->inherits("QLineEdit"))
549                QTableItem::setText(((QLineEdit *) pWidget)->text());
550            else
551                QTableItem::setContentFromEditor(pWidget);
552  }  }
553    
554    
Legend:
Removed from v.431  
changed lines
  Added in v.442
  ViewVC Help
Powered by ViewVC