/[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 430 by capela, Tue Mar 8 17:23:29 2005 UTC revision 434 by capela, Wed Mar 9 17:23:57 2005 UTC
# Line 50  void qsamplerDeviceParam::setParam ( lsc Line 50  void qsamplerDeviceParam::setParam ( lsc
50          const char *pszValue )          const char *pszValue )
51  {  {
52          if (pParamInfo == NULL)          if (pParamInfo == NULL)
53              return;                  return;
54                                
55      // Info structure field members.          // Info structure field members.
56            
57          type = pParamInfo->type;          type = pParamInfo->type;
58            
59          if (pParamInfo->description)          if (pParamInfo->description)
60                  description = pParamInfo->description;                  description = pParamInfo->description;
61          else          else
62                  description = QString::null;                  description = QString::null;
63            
64      mandatory = (bool) pParamInfo->multiplicity;          mandatory = (bool) pParamInfo->multiplicity;
65      fix = (bool) pParamInfo->fix;          fix = (bool) pParamInfo->fix;
66      multiplicity = (bool) pParamInfo->multiplicity;          multiplicity = (bool) pParamInfo->multiplicity;
67            
68          depends.clear();          depends.clear();
69          for (int i = 0; pParamInfo->depends && pParamInfo->depends[i]; i++)          for (int i = 0; pParamInfo->depends && pParamInfo->depends[i]; i++)
70              depends.append(pParamInfo->depends[i]);                  depends.append(pParamInfo->depends[i]);
71            
72          if (pParamInfo->defaultv)          if (pParamInfo->defaultv)
73                  defaultv = pParamInfo->defaultv;                  defaultv = pParamInfo->defaultv;
74          else          else
75                  defaultv = QString::null;                  defaultv = QString::null;
76            
77          if (pParamInfo->range_min)          if (pParamInfo->range_min)
78          range_min = pParamInfo->range_min;                  range_min = pParamInfo->range_min;
79          else          else
80                  range_min = QString::null;                  range_min = QString::null;
81            
82          if (pParamInfo->range_max)          if (pParamInfo->range_max)
83          range_max = pParamInfo->range_max;                  range_max = pParamInfo->range_max;
84          else          else
85                  range_max = QString::null;                  range_max = QString::null;
86            
87          possibilities.clear();          possibilities.clear();
88          for (int i = 0; pParamInfo->possibilities && pParamInfo->possibilities[i]; i++)          for (int i = 0; pParamInfo->possibilities && pParamInfo->possibilities[i]; i++)
89              possibilities.append(pParamInfo->possibilities[i]);                  possibilities.append(pParamInfo->possibilities[i]);
90                                
91      // The current parameter value.          // The current parameter value.
92          if (pszValue)          if (pszValue)
93              value = pszValue;                  value = pszValue;
94          else          else
95                  value = QString::null;                  value = QString::null;
96  }  }
# Line 122  void qsamplerDevice::setDevice ( lscp_cl Line 122  void qsamplerDevice::setDevice ( lscp_cl
122          m_deviceType  = deviceType;          m_deviceType  = deviceType;
123    
124          // Retrieve device info, if any.          // Retrieve device info, if any.
         QString sDeviceType;  
125          lscp_device_info_t *pDeviceInfo = NULL;          lscp_device_info_t *pDeviceInfo = NULL;
126          switch (deviceType) {          switch (deviceType) {
127            case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
128              sDeviceType = QObject::tr("Audio");                  m_sDeviceType = QObject::tr("Audio");
129              pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);                  pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);
130                  break;                  break;
131            case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
132              sDeviceType = QObject::tr("MIDI");                  m_sDeviceType = QObject::tr("MIDI");
133                  pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);                  pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);
134                  break;                  break;
135            default:
136                    m_sDeviceType = QString::null;
137                    break;
138          }          }
139            
140          // If we're bogus, bail out...          // If we're bogus, bail out...
141          if (pDeviceInfo == NULL) {          if (pDeviceInfo == NULL) {
142                  m_sDriverName = QString::null;                  m_sDriverName = QString::null;
143                  m_sDeviceName = QObject::tr("New %1 device").arg(sDeviceType);                  m_sDeviceName = QObject::tr("New device");
144              return;                  return;
145          }          }
146            
147          // Other device properties...          // Other device properties...
148          m_sDriverName = pDeviceInfo->driver;          m_sDriverName = pDeviceInfo->driver;
149          m_sDeviceName = m_sDriverName + ' '          m_sDeviceName = m_sDriverName + ' '
150                  + QObject::tr("Device %1").arg(m_iDeviceID);                  + QObject::tr("Device %1").arg(m_iDeviceID);
151    
152          // Grab device/driver parameters...          // Grab device parameters...
153          m_params.clear();          m_params.clear();
154          for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {          for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {
155                  const char *pszParam = pDeviceInfo->params[i].key;                  const char *pszParam = pDeviceInfo->params[i].key;
156                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
157                  switch (deviceType) {                  switch (deviceType) {
158                    case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
159                      pParamInfo = ::lscp_get_audio_driver_param_info(pClient,                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
160                                  m_sDriverName.latin1(), pszParam, NULL);                                  m_sDriverName.latin1(), pszParam, NULL);
161                          break;                          break;
162                    case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
163                      pParamInfo = ::lscp_get_midi_driver_param_info(pClient,                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
164                                  m_sDriverName.latin1(), pszParam, NULL);                                  m_sDriverName.latin1(), pszParam, NULL);
165                          break;                          break;
166                  }                  }
167                  m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pDeviceInfo->params[i].value);                  if (pParamInfo)
168                            m_params[pszParam] = qsamplerDeviceParam(pParamInfo,
169                                    pDeviceInfo->params[i].value);
170            }
171    }
172    
173    
174    // Driver name initializer.
175    void qsamplerDevice::setDriver ( lscp_client_t *pClient,
176            const QString& sDriverName )
177    {
178            // Valid only for scratch devices.
179            if (m_sDriverName == sDriverName)
180                    return;
181    
182            // Retrieve driver info, if any.
183            lscp_driver_info_t *pDriverInfo = NULL;
184            switch (m_deviceType) {
185            case qsamplerDevice::Audio:
186                    pDriverInfo = ::lscp_get_audio_driver_info(pClient,
187                            sDriverName.latin1());
188                    break;
189            case qsamplerDevice::Midi:
190                    pDriverInfo = ::lscp_get_midi_driver_info(pClient,
191                            sDriverName.latin1());
192                    break;
193            }
194    
195            // If we're bogus, bail out...
196            if (pDriverInfo == NULL)
197                    return;
198    
199            // Remember device parameters...
200            m_sDriverName = sDriverName;
201    
202            // Grab driver parameters...
203            m_params.clear();
204            for (int i = 0; pDriverInfo->parameters && pDriverInfo->parameters[i]; i++) {
205                    const char *pszParam = pDriverInfo->parameters[i];
206                    lscp_param_info_t *pParamInfo = NULL;
207                    switch (m_deviceType) {
208                    case qsamplerDevice::Audio:
209                            pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
210                                    sDriverName.latin1(), pszParam, NULL);
211                            break;
212                    case qsamplerDevice::Midi:
213                            pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
214                                    sDriverName.latin1(), pszParam, NULL);
215                            break;
216                    }
217                    m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pParamInfo->defaultv);
218          }          }
219  }  }
220    
# Line 178  qsamplerDevice::qsamplerDeviceType qsamp Line 230  qsamplerDevice::qsamplerDeviceType qsamp
230          return m_deviceType;          return m_deviceType;
231  }  }
232    
233    const QString& qsamplerDevice::deviceTypeName (void) const
234    {
235            return m_sDeviceType;
236    }
237    
238  const QString& qsamplerDevice::driverName (void) const  const QString& qsamplerDevice::driverName (void) const
239  {  {
240          return m_sDriverName;          return m_sDriverName;
# Line 206  int *qsamplerDevice::getDevices ( lscp_c Line 263  int *qsamplerDevice::getDevices ( lscp_c
263  {  {
264          int *piDeviceIDs = NULL;          int *piDeviceIDs = NULL;
265          switch (deviceType) {          switch (deviceType) {
266            case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
267              piDeviceIDs = ::lscp_list_audio_devices(pClient);                  piDeviceIDs = ::lscp_list_audio_devices(pClient);
268                  break;                  break;
269            case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
270              piDeviceIDs = ::lscp_list_midi_devices(pClient);                  piDeviceIDs = ::lscp_list_midi_devices(pClient);
271                  break;                  break;
272          }          }
273          return piDeviceIDs;          return piDeviceIDs;
# Line 225  QStringList qsamplerDevice::getDrivers ( Line 282  QStringList qsamplerDevice::getDrivers (
282                    
283          const char **ppszDrivers = NULL;          const char **ppszDrivers = NULL;
284          switch (deviceType) {          switch (deviceType) {
285            case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
286              ppszDrivers = ::lscp_get_available_audio_drivers(pClient);                  ppszDrivers = ::lscp_get_available_audio_drivers(pClient);
287                  break;                  break;
288            case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
289              ppszDrivers = ::lscp_get_available_midi_drivers(pClient);                  ppszDrivers = ::lscp_get_available_midi_drivers(pClient);
290                  break;                  break;
291          }          }
292                    
293      for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)          for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)
294          drivers.append(ppszDrivers[iDriver]);                  drivers.append(ppszDrivers[iDriver]);
295    
296          return drivers;          return drivers;
297  }  }
# Line 245  QStringList qsamplerDevice::getDrivers ( Line 302  QStringList qsamplerDevice::getDrivers (
302  //  //
303    
304  // Constructors.  // Constructors.
305  qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView, lscp_client_t *pClient,  qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView,
306          qsamplerDevice::qsamplerDeviceType deviceType )          lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType )
307          : QListViewItem(pListView), m_device(pClient, deviceType)          : QListViewItem(pListView), m_device(pClient, deviceType)
308  {  {
309          switch(m_device.deviceType()) {          switch(m_device.deviceType()) {
310            case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
311                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio1.png"));                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio1.png"));
312                  QListViewItem::setText(0, QObject::tr("Audio devices"));                  QListViewItem::setText(0, QObject::tr("Audio devices"));
313                  break;                  break;
314            case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
315                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));
316                  QListViewItem::setText(0, QObject::tr("MIDI devices"));                  QListViewItem::setText(0, QObject::tr("MIDI devices"));
317                  break;                  break;
318          }          }
319  }  }
320    
321  qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem, lscp_client_t *pClient,  qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem,
322          qsamplerDevice::qsamplerDeviceType deviceType, int iDeviceID )          lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType,
323            int iDeviceID )
324          : QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)          : QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)
325  {  {
326          switch(m_device.deviceType()) {          switch(m_device.deviceType()) {
327            case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
328                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio2.png"));                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio2.png"));
329                  break;                  break;
330            case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
331                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));
332                  break;                  break;
333          }          }
# Line 283  qsamplerDeviceItem::~qsamplerDeviceItem Line 341  qsamplerDeviceItem::~qsamplerDeviceItem
341  }  }
342    
343  // Instance accessors.  // Instance accessors.
344  const qsamplerDevice& qsamplerDeviceItem::device (void)  qsamplerDevice& qsamplerDeviceItem::device (void)
345  {  {
346          return m_device;          return m_device;
347  }  }
# Line 301  int qsamplerDeviceItem::rtti() const Line 359  int qsamplerDeviceItem::rtti() const
359  //  //
360    
361  // Constructor.  // Constructor.
362  qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent, const char *pszName )  qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent,
363            const char *pszName )
364          : QTable(pParent, pszName)          : QTable(pParent, pszName)
365  {  {
         m_pClient = NULL;  
         m_iDeviceID = -1;  
   
366          // Set fixed number of columns.          // Set fixed number of columns.
367          QTable::setNumCols(3);          QTable::setNumCols(3);
368          QTable::setShowGrid(false);          QTable::setShowGrid(false);
# Line 318  qsamplerDeviceParamTable::qsamplerDevice Line 374  qsamplerDeviceParamTable::qsamplerDevice
374          QTable::setLeftMargin(0);          QTable::setLeftMargin(0);
375          // Initialize the fixed table column headings.          // Initialize the fixed table column headings.
376          QHeader *pHeader = QTable::horizontalHeader();          QHeader *pHeader = QTable::horizontalHeader();
377          pHeader->setLabel(0, tr("Parameter"));          pHeader->setLabel(0, tr("Description"));
378          pHeader->setLabel(1, tr("Description"));          pHeader->setLabel(1, tr("Value"));
379          pHeader->setLabel(2, tr("Value"));          pHeader->setLabel(2, tr("Parameter"));
380          // Set read-onlyness of each column          // Set read-onlyness of each column
381          QTable::setColumnReadOnly(0, true);          QTable::setColumnReadOnly(0, true);
382          QTable::setColumnReadOnly(1, true);  //  QTable::setColumnReadOnly(1, true); -- of course not.
383  //  QTable::setColumnReadOnly(2, true); -- of course not.          QTable::setColumnReadOnly(2, true);
384            QTable::setColumnStretchable(0, true);
385  }  }
386    
387  // Default destructor.  // Default destructor.
# Line 333  qsamplerDeviceParamTable::~qsamplerDevic Line 390  qsamplerDeviceParamTable::~qsamplerDevic
390  }  }
391    
392    
 // Client/device descriptor selector.  
 void qsamplerDeviceParamTable::setDevice ( lscp_client_t *pClient,  
                 qsamplerDevice::qsamplerDeviceType deviceType, int iDeviceID )  
 {  
         if (m_pClient  
                 && m_pClient    == pClient  
                 && m_deviceType == deviceType  
                 && m_iDeviceID  == iDeviceID)  
             return;  
               
     m_pClient = pClient;  
     m_deviceType = deviceType;  
     m_iDeviceID = iDeviceID;  
       
     refresh();  
 }  
   
   
 // Client/device descriptor accessors.  
 lscp_client_t *qsamplerDeviceParamTable::client (void)  
 {  
     return m_pClient;  
 }  
   
 int qsamplerDeviceParamTable::deviceID (void)  
 {  
     return m_iDeviceID;  
 }  
   
   
393  // The main table refresher.  // The main table refresher.
394  void qsamplerDeviceParamTable::refresh (void)  void qsamplerDeviceParamTable::refresh ( qsamplerDevice& device )
395  {  {
396          // Always (re)start it empty.          // Always (re)start it empty.
397            QTable::setUpdatesEnabled(false);
398          QTable::setNumRows(0);          QTable::setNumRows(0);
399    
         if (m_pClient == NULL)  
             return;  
               
         // Construct the local device object here.  
         qsamplerDevice device(m_pClient, m_deviceType, m_iDeviceID);  
   
   
400          // Now fill the parameter table...          // Now fill the parameter table...
401          QHeader *pHeader = QTable::verticalHeader();          qsamplerDeviceParamMap& params = device.params();
     qsamplerDeviceParamMap& params = device.params();  
402          QTable::insertRows(0, params.count());          QTable::insertRows(0, params.count());
403          int iRow = 0;          int iRow = 0;
404          qsamplerDeviceParamMap::Iterator iter;          qsamplerDeviceParamMap::ConstIterator iter;
405          for (iter = params.begin(); iter != params.end(); ++iter) {          for (iter = params.begin(); iter != params.end(); ++iter) {
406          QTable::setText(iRow, 0, iter.key());                  const qsamplerDeviceParam& param = iter.data();
407              QTable::setText(iRow, 1, iter.data().description);                  bool fEnabled = (device.deviceID() < 0 || !param.fix);
408              QTable::setText(iRow, 2, iter.data().value);                  QTable::setText(iRow, 0, param.description);
409              ++iRow;                  if (param.type == LSCP_TYPE_BOOL) {
410                            QStringList opts;
411                            opts.append(tr("false"));
412                            opts.append(tr("true"));
413                            QComboTableItem *pComboItem = new QComboTableItem(this, opts);
414                        pComboItem->setCurrentItem(param.value.lower() == "true" ? 1 : 0);
415                        pComboItem->setEnabled(fEnabled);
416                            QTable::setItem(iRow, 1, pComboItem);
417                    } else if (param.possibilities.count() > 0 && !param.multiplicity) {
418                            QComboTableItem *pComboItem = new QComboTableItem(this,
419                                    param.possibilities);
420                        pComboItem->setCurrentItem(param.value);
421                        pComboItem->setEnabled(fEnabled);
422                            QTable::setItem(iRow, 1, pComboItem);
423                    } else {
424                            QTableItem* pTableItem = new QTableItem(this,
425                                    fEnabled ? QTableItem::Never : QTableItem::OnTyping,
426                                    param.value);
427                            QTable::setItem(iRow, 1, pTableItem);
428                    }
429                    QTable::setText(iRow, 2, iter.key());
430                    ++iRow;
431          }          }
432    
433          // Adjust optimal column width.          // Adjust optimal column widths.
434          for (int iCol = 0; iCol < QTable::numCols(); iCol++)          QTable::adjustColumn(1);
435                  QTable::adjustColumn(iCol);          QTable::adjustColumn(2);
436            
437            QTable::setUpdatesEnabled(true);
438            QTable::updateContents();
439  }  }
440    
441    
Legend:
Removed from v.430  
changed lines
  Added in v.434
  ViewVC Help
Powered by ViewVC