/[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 462 by capela, Tue Mar 15 11:39:12 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 118  void qsamplerDevice::setDevice ( lscp_cl Line 121  void qsamplerDevice::setDevice ( lscp_cl
121          qsamplerDeviceType deviceType, int iDeviceID )          qsamplerDeviceType deviceType, int iDeviceID )
122  {  {
123          // Device id and type should be always set.          // Device id and type should be always set.
124          m_iDeviceID   = iDeviceID;          m_iDeviceID  = iDeviceID;
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 %1 device").arg(m_sDeviceType);
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    
179    
180  // Driver name initializer.  // Driver name initializer/settler.
181  void qsamplerDevice::setDriver ( lscp_client_t *pClient,  void qsamplerDevice::setDriver ( lscp_client_t *pClient,
182          const QString& sDriverName )          const QString& sDriverName )
183  {  {
# 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 237  const QString& qsamplerDevice::deviceNam Line 257  const QString& qsamplerDevice::deviceNam
257  }  }
258    
259  // Device parameter accessor.  // Device parameter accessor.
260  qsamplerDeviceParamMap& qsamplerDevice::params (void)  const qsamplerDeviceParamMap& qsamplerDevice::params (void) const
261  {  {
262          return m_params;          return m_params;
263  }  }
264    
265    
266  // Update/refresh device/driver data.  // Set the proper device parameter value.
267  void qsamplerDevice::refresh (void)  void qsamplerDevice::setParam ( const QString& sParam,
268            const QString& sValue )
269  {  {
270            m_params[sParam].value = sValue;
271  }  }
272    
273    
274  // Device ids enumerator.  // Device ids enumerator.
275  int *qsamplerDevice::getDevices ( lscp_client_t *pClient,  int *qsamplerDevice::getDevices ( lscp_client_t *pClient,
276          qsamplerDeviceType deviceType )          qsamplerDeviceType deviceType )
# Line 260  int *qsamplerDevice::getDevices ( lscp_c Line 283  int *qsamplerDevice::getDevices ( lscp_c
283          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
284                  piDeviceIDs = ::lscp_list_midi_devices(pClient);                  piDeviceIDs = ::lscp_list_midi_devices(pClient);
285                  break;                  break;
286            case qsamplerDevice::None:
287                    break;
288          }          }
289          return piDeviceIDs;          return piDeviceIDs;
290  }  }
# Line 279  QStringList qsamplerDevice::getDrivers ( Line 304  QStringList qsamplerDevice::getDrivers (
304          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
305                  ppszDrivers = ::lscp_get_available_midi_drivers(pClient);                  ppszDrivers = ::lscp_get_available_midi_drivers(pClient);
306                  break;                  break;
307            case qsamplerDevice::None:
308                    break;
309          }          }
310                    
311          for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)          for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)
# Line 289  QStringList qsamplerDevice::getDrivers ( Line 316  QStringList qsamplerDevice::getDrivers (
316    
317    
318  //-------------------------------------------------------------------------  //-------------------------------------------------------------------------
319    // qsamplerDevicePort - MIDI/Audio Device port/channel structure.
320    //
321    
322    // Constructor.
323    qsamplerDevicePort::qsamplerDevicePort ( lscp_client_t *pClient,
324            const qsamplerDevice& device, int iPortID )
325    {
326            setDevicePort(pClient, device, iPortID);
327    }
328    
329    // Default destructor.
330    qsamplerDevicePort::~qsamplerDevicePort (void)
331    {
332    }
333    
334    
335    // Initializer.
336    void qsamplerDevicePort::setDevicePort ( lscp_client_t *pClient,
337            const qsamplerDevice& device, int iPortID )
338    {
339            // Device port id should be always set.
340            m_iPortID = iPortID;
341    
342            // Retrieve device port/channel info, if any.
343            lscp_device_port_info_t *pPortInfo = NULL;
344            switch (device.deviceType()) {
345            case qsamplerDevice::Audio:
346                    pPortInfo = ::lscp_get_audio_channel_info(pClient, device.deviceID(), iPortID);
347                    break;
348            case qsamplerDevice::Midi:
349                    pPortInfo = ::lscp_get_midi_port_info(pClient, device.deviceID(), iPortID);
350                    break;
351            case qsamplerDevice::None:
352                    break;
353            }
354    
355            // If we're bogus, bail out...
356            if (pPortInfo == NULL) {
357                    m_sPortName = QString::null;
358                    return;
359            }
360    
361            // Set device port/channel properties...
362            m_sPortName = pPortInfo->name;
363    
364            // Grab device port/channel parameters...
365            m_params.clear();
366            for (int i = 0; pPortInfo->params && pPortInfo->params[i].key; i++) {
367                    const char *pszParam = pPortInfo->params[i].key;
368                    lscp_param_info_t *pParamInfo = NULL;
369                    switch (device.deviceType()) {
370                    case qsamplerDevice::Audio:
371                            pParamInfo = ::lscp_get_audio_channel_param_info(pClient,
372                                    device.deviceID(), iPortID, pszParam);
373                            break;
374                    case qsamplerDevice::Midi:
375                            pParamInfo = ::lscp_get_midi_port_param_info(pClient,
376                                    device.deviceID(), iPortID, pszParam);
377                            break;
378                    case qsamplerDevice::None:
379                            break;
380                    }
381                    if (pParamInfo) {
382                            m_params[pszParam] = qsamplerDeviceParam(pParamInfo,
383                                    pPortInfo->params[i].value);
384                    }
385            }
386    }
387    
388    
389    // Device port/channel property accessors.
390    int qsamplerDevicePort::portID (void) const
391    {
392            return m_iPortID;
393    }
394    
395    const QString& qsamplerDevicePort::portName (void) const
396    {
397            return m_sPortName;
398    }
399    
400    // Device port/channel parameter accessor.
401    const qsamplerDeviceParamMap& qsamplerDevicePort::params (void) const
402    {
403            return m_params;
404    }
405    
406    
407    // Set the proper device port/channel parameter value.
408    void qsamplerDevicePort::setParam ( const QString& sParam,
409            const QString& sValue )
410    {
411            m_params[sParam].value = sValue;
412    }
413    
414    
415    //-------------------------------------------------------------------------
416  // qsamplerDeviceItem - QListView device item.  // qsamplerDeviceItem - QListView device item.
417  //  //
418    
419  // Constructors.  // Constructors.
420  qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView, lscp_client_t *pClient,  qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView,
421          qsamplerDevice::qsamplerDeviceType deviceType )          lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType )
422          : QListViewItem(pListView), m_device(pClient, deviceType)          : QListViewItem(pListView), m_device(pClient, deviceType)
423  {  {
424          switch(m_device.deviceType()) {          switch(m_device.deviceType()) {
# Line 306  qsamplerDeviceItem::qsamplerDeviceItem ( Line 430  qsamplerDeviceItem::qsamplerDeviceItem (
430                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));
431                  QListViewItem::setText(0, QObject::tr("MIDI devices"));                  QListViewItem::setText(0, QObject::tr("MIDI devices"));
432                  break;                  break;
433            case qsamplerDevice::None:
434                    break;
435          }          }
436  }  }
437    
438  qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem, lscp_client_t *pClient,  qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem,
439          qsamplerDevice::qsamplerDeviceType deviceType, int iDeviceID )          lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType,
440            int iDeviceID )
441          : QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)          : QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)
442  {  {
443          switch(m_device.deviceType()) {          switch(m_device.deviceType()) {
# Line 320  qsamplerDeviceItem::qsamplerDeviceItem ( Line 447  qsamplerDeviceItem::qsamplerDeviceItem (
447          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
448                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));
449                  break;                  break;
450            case qsamplerDevice::None:
451                    break;
452          }          }
453    
454          QListViewItem::setText(0, m_device.deviceName());          QListViewItem::setText(0, m_device.deviceName());
# Line 349  int qsamplerDeviceItem::rtti() const Line 478  int qsamplerDeviceItem::rtti() const
478  //  //
479    
480  // Constructor.  // Constructor.
481  qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent, const char *pszName )  qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent,
482            const char *pszName )
483          : QTable(pParent, pszName)          : QTable(pParent, pszName)
484  {  {
485          // Set fixed number of columns.          // Set fixed number of columns.
# Line 364  qsamplerDeviceParamTable::qsamplerDevice Line 494  qsamplerDeviceParamTable::qsamplerDevice
494          // Initialize the fixed table column headings.          // Initialize the fixed table column headings.
495          QHeader *pHeader = QTable::horizontalHeader();          QHeader *pHeader = QTable::horizontalHeader();
496          pHeader->setLabel(0, tr("Parameter"));          pHeader->setLabel(0, tr("Parameter"));
497          pHeader->setLabel(1, tr("Value"));          pHeader->setLabel(1, tr("Description"));
498          pHeader->setLabel(2, tr("Description"));          pHeader->setLabel(2, tr("Value"));
499          // Set read-onlyness of each column          // Set read-onlyness of each column
500          QTable::setColumnReadOnly(0, true);          QTable::setColumnReadOnly(0, true);
501  //  QTable::setColumnReadOnly(1, true); -- of course not.          QTable::setColumnReadOnly(1, true);
502          QTable::setColumnReadOnly(2, true);  //  QTable::setColumnReadOnly(2, true); -- of course not.
503            QTable::setColumnStretchable(1, true);
504  }  }
505    
506  // Default destructor.  // Default destructor.
# Line 378  qsamplerDeviceParamTable::~qsamplerDevic Line 509  qsamplerDeviceParamTable::~qsamplerDevic
509  }  }
510    
511    
512  // The main table refresher.  // Common parameter table renderer.
513  void qsamplerDeviceParamTable::refresh ( qsamplerDevice& device )  void qsamplerDeviceParamTable::refresh ( const qsamplerDeviceParamMap& params,
514            bool bEditable )
515  {  {
516          // Always (re)start it empty.          // Always (re)start it empty.
517            QTable::setUpdatesEnabled(false);
518          QTable::setNumRows(0);          QTable::setNumRows(0);
519    
520          // Now fill the parameter table...          // Fill the parameter table...
         qsamplerDeviceParamMap& params = device.params();  
521          QTable::insertRows(0, params.count());          QTable::insertRows(0, params.count());
522          int iRow = 0;          int iRow = 0;
523          qsamplerDeviceParamMap::ConstIterator iter;          qsamplerDeviceParamMap::ConstIterator iter;
524          for (iter = params.begin(); iter != params.end(); ++iter) {          for (iter = params.begin(); iter != params.end(); ++iter) {
525                    const qsamplerDeviceParam& param = iter.data();
526                    bool bEnabled = (bEditable || !param.fix);
527                  QTable::setText(iRow, 0, iter.key());                  QTable::setText(iRow, 0, iter.key());
528                  QTable::setText(iRow, 1, iter.data().value);                  QTable::setText(iRow, 1, param.description);
529                  QTable::setText(iRow, 2, iter.data().description);                  if (param.type == LSCP_TYPE_BOOL) {
530                            QStringList opts;
531                            opts.append(tr("False"));
532                            opts.append(tr("True"));
533                            QComboTableItem *pComboItem = new QComboTableItem(this, opts);
534                            pComboItem->setCurrentItem(param.value.lower() == "true" ? 1 : 0);
535                            pComboItem->setEnabled(bEnabled);
536                            QTable::setItem(iRow, 2, pComboItem);
537                    } else if (param.possibilities.count() > 0 && bEnabled) {
538                            QComboTableItem *pComboItem = new QComboTableItem(this,
539                                    param.possibilities);
540                            pComboItem->setCurrentItem(param.value);
541                            pComboItem->setEnabled(bEnabled);
542                            pComboItem->setEditable(bEnabled && param.multiplicity);
543                            QTable::setItem(iRow, 2, pComboItem);
544                    } else if (param.type == LSCP_TYPE_INT && bEnabled
545                                    && !param.range_min.isEmpty()
546                                    && !param.range_max.isEmpty()) {
547                            qsamplerDeviceParamTableSpinBox *pSpinItem =
548                                    new qsamplerDeviceParamTableSpinBox(this,
549                                            bEnabled ? QTableItem::OnTyping : QTableItem::Never,
550                                            param.value);
551                            pSpinItem->setMinValue(param.range_min.toInt());
552                            pSpinItem->setMaxValue(param.range_max.toInt());
553                            QTable::setItem(iRow, 2, pSpinItem);
554                    } else {
555                            qsamplerDeviceParamTableEditBox *pEditItem =
556                                    new qsamplerDeviceParamTableEditBox(this,
557                                            bEnabled ? QTableItem::OnTyping : QTableItem::Never,
558                                            param.value);
559                            QTable::setItem(iRow, 2, pEditItem);
560                    }
561                  ++iRow;                  ++iRow;
562          }          }
563    
564          // Adjust optimal column width.          // Adjust optimal column widths.
565          for (int iCol = 0; iCol < QTable::numCols(); iCol++)          QTable::adjustColumn(0);
566                  QTable::adjustColumn(iCol);          QTable::adjustColumn(2);
567    
568            QTable::setUpdatesEnabled(true);
569            QTable::updateContents();
570    }
571    
572    
573    //-------------------------------------------------------------------------
574    // qsamplerDeviceParamTableSpinBox - Custom spin box for parameter table.
575    //
576    
577    // Constructor.
578    qsamplerDeviceParamTableSpinBox::qsamplerDeviceParamTableSpinBox (
579            QTable *pTable, EditType editType, const QString& sText )
580            : QTableItem(pTable, editType, sText)
581    {
582            m_iValue = sText.toInt();
583            m_iMinValue = m_iMaxValue = 0;
584    }
585    
586    // Public accessors.
587    void qsamplerDeviceParamTableSpinBox::setValue ( int iValue )
588    {
589            m_iValue = iValue;
590            QTableItem::setText(QString::number(m_iValue));
591    }
592    
593    void qsamplerDeviceParamTableSpinBox::setMinValue ( int iMinValue )
594    {
595            m_iMinValue = iMinValue;
596    }
597    
598    void qsamplerDeviceParamTableSpinBox::setMaxValue ( int iMaxValue )
599    {
600            m_iMaxValue = iMaxValue;
601    }
602    
603    // Virtual implemetations.
604    QWidget *qsamplerDeviceParamTableSpinBox::createEditor (void) const
605    {
606            QSpinBox *pSpinBox = new QSpinBox(QTableItem::table()->viewport());
607            QObject::connect(pSpinBox, SIGNAL(valueChanged(int)),
608                    QTableItem::table(), SLOT(doValueChanged()));
609            if (m_iValue >= m_iMinValue && m_iMaxValue >= m_iValue) {
610                    pSpinBox->setMinValue(m_iMinValue);
611                    pSpinBox->setMaxValue(m_iMaxValue);
612            }
613            pSpinBox->setValue(m_iValue);
614            return pSpinBox;
615    }
616    
617    void qsamplerDeviceParamTableSpinBox::setContentFromEditor ( QWidget *pWidget )
618    {
619            if (pWidget->inherits("QSpinBox"))
620                    QTableItem::setText(QString::number(((QSpinBox *) pWidget)->value()));
621            else
622                    QTableItem::setContentFromEditor(pWidget);
623    }
624    
625    
626    //-------------------------------------------------------------------------
627    // qsamplerDeviceParamTableEditBox - Custom edit box for parameter table.
628    //
629    
630    // Constructor.
631    qsamplerDeviceParamTableEditBox::qsamplerDeviceParamTableEditBox (
632            QTable *pTable, EditType editType, const QString& sText )
633            : QTableItem(pTable, editType, sText)
634    {
635    }
636    
637    // Virtual implemetations.
638    QWidget *qsamplerDeviceParamTableEditBox::createEditor (void) const
639    {
640            QLineEdit *pEditBox = new QLineEdit(QTableItem::table()->viewport());
641            QObject::connect(pEditBox, SIGNAL(returnPressed()),
642                    QTableItem::table(), SLOT(doValueChanged()));
643            pEditBox->setText(QTableItem::text());
644            return pEditBox;
645    }
646    
647    void qsamplerDeviceParamTableEditBox::setContentFromEditor ( QWidget *pWidget )
648    {
649            if (pWidget->inherits("QLineEdit"))
650                    QTableItem::setText(((QLineEdit *) pWidget)->text());
651            else
652                    QTableItem::setContentFromEditor(pWidget);
653  }  }
654    
655    
Legend:
Removed from v.431  
changed lines
  Added in v.462
  ViewVC Help
Powered by ViewVC