/[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 451 by capela, Fri Mar 11 17:24:06 2005 UTC revision 463 by capela, Tue Mar 15 15:32:29 2005 UTC
# Line 107  void qsamplerDeviceParam::setParam ( lsc Line 107  void qsamplerDeviceParam::setParam ( lsc
107  qsamplerDevice::qsamplerDevice ( lscp_client_t *pClient,  qsamplerDevice::qsamplerDevice ( lscp_client_t *pClient,
108          qsamplerDeviceType deviceType, int iDeviceID )          qsamplerDeviceType deviceType, int iDeviceID )
109  {  {
110            m_ports.setAutoDelete(true);
111            
112          setDevice(pClient, deviceType, iDeviceID);          setDevice(pClient, deviceType, iDeviceID);
113  }  }
114    
# Line 121  void qsamplerDevice::setDevice ( lscp_cl Line 123  void qsamplerDevice::setDevice ( lscp_cl
123          qsamplerDeviceType deviceType, int iDeviceID )          qsamplerDeviceType deviceType, int iDeviceID )
124  {  {
125          // Device id and type should be always set.          // Device id and type should be always set.
126          m_iDeviceID   = iDeviceID;          m_iDeviceID  = iDeviceID;
127          m_deviceType  = deviceType;          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.          // Retrieve device info, if any.
134          lscp_device_info_t *pDeviceInfo = NULL;          lscp_device_info_t *pDeviceInfo = NULL;
# Line 143  void qsamplerDevice::setDevice ( lscp_cl Line 149  void qsamplerDevice::setDevice ( lscp_cl
149          // If we're bogus, bail out...          // If we're bogus, bail out...
150          if (pDeviceInfo == NULL) {          if (pDeviceInfo == NULL) {
151                  m_sDriverName = QString::null;                  m_sDriverName = QString::null;
152                  m_sDeviceName = QObject::tr("New device");                  m_sDeviceName = QObject::tr("New %1 device").arg(m_sDeviceType);
153                  return;                  return;
154          }          }
155    
# Line 153  void qsamplerDevice::setDevice ( lscp_cl Line 159  void qsamplerDevice::setDevice ( lscp_cl
159                  + QObject::tr("Device %1").arg(m_iDeviceID);                  + QObject::tr("Device %1").arg(m_iDeviceID);
160    
161          // Grab device parameters...          // Grab device parameters...
         m_params.clear();  
162          for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {          for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {
163                  const char *pszParam = pDeviceInfo->params[i].key;                  const QString sParam = pDeviceInfo->params[i].key;
164                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
165                  switch (deviceType) {                  switch (deviceType) {
166                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
167                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
168                                  m_sDriverName.latin1(), pszParam, NULL);                                  m_sDriverName.latin1(), sParam.latin1(), NULL);
169                          break;                          break;
170                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
171                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
172                                  m_sDriverName.latin1(), pszParam, NULL);                                  m_sDriverName.latin1(), sParam.latin1(), NULL);
173                          break;                          break;
174                  case qsamplerDevice::None:                  case qsamplerDevice::None:
175                          break;                          break;
176                  }                  }
177                  if (pParamInfo) {                  if (pParamInfo) {
178                          m_params[pszParam] = qsamplerDeviceParam(pParamInfo,                          m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
179                                  pDeviceInfo->params[i].value);                                  pDeviceInfo->params[i].value);
180                  }                  }
181          }          }
182    
183            // Grab port/channel list...
184            refresh(pClient);
185  }  }
186    
187    
188  // Driver name initializer.  // Driver name initializer/settler.
189  void qsamplerDevice::setDriver ( lscp_client_t *pClient,  void qsamplerDevice::setDriver ( lscp_client_t *pClient,
190          const QString& sDriverName )          const QString& sDriverName )
191  {  {
# Line 185  void qsamplerDevice::setDriver ( lscp_cl Line 193  void qsamplerDevice::setDriver ( lscp_cl
193          if (m_sDriverName == sDriverName)          if (m_sDriverName == sDriverName)
194                  return;                  return;
195    
196            // Reset device parameters and ports anyway.
197            m_params.clear();
198            m_ports.clear();
199    
200          // Retrieve driver info, if any.          // Retrieve driver info, if any.
201          lscp_driver_info_t *pDriverInfo = NULL;          lscp_driver_info_t *pDriverInfo = NULL;
202          switch (m_deviceType) {          switch (m_deviceType) {
# Line 208  void qsamplerDevice::setDriver ( lscp_cl Line 220  void qsamplerDevice::setDriver ( lscp_cl
220          m_sDriverName = sDriverName;          m_sDriverName = sDriverName;
221    
222          // Grab driver parameters...          // Grab driver parameters...
         m_params.clear();  
223          for (int i = 0; pDriverInfo->parameters && pDriverInfo->parameters[i]; i++) {          for (int i = 0; pDriverInfo->parameters && pDriverInfo->parameters[i]; i++) {
224                  const char *pszParam = pDriverInfo->parameters[i];                  const QString sParam = pDriverInfo->parameters[i];
225                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
226                  switch (m_deviceType) {                  switch (m_deviceType) {
227                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
228                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
229                                  sDriverName.latin1(), pszParam, NULL);                                  sDriverName.latin1(), sParam.latin1(), NULL);
230                          break;                          break;
231                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
232                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
233                                  sDriverName.latin1(), pszParam, NULL);                                  sDriverName.latin1(), sParam.latin1(), NULL);
234                          break;                          break;
235                  case qsamplerDevice::None:                  case qsamplerDevice::None:
236                          break;                          break;
237                  }                  }
238                  if (pParamInfo)                  if (pParamInfo) {
239                          m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pParamInfo->defaultv);                          m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
240                                    pParamInfo->defaultv);
241                    }
242          }          }
243  }  }
244    
# Line 256  const QString& qsamplerDevice::deviceNam Line 269  const QString& qsamplerDevice::deviceNam
269          return m_sDeviceName;          return m_sDeviceName;
270  }  }
271    
272    
273    // Set the proper device parameter value.
274    void qsamplerDevice::setParam ( const QString& sParam,
275            const QString& sValue )
276    {
277            m_params[sParam.upper()].value = sValue;
278    }
279    
280    
281  // Device parameter accessor.  // Device parameter accessor.
282  qsamplerDeviceParamMap& qsamplerDevice::params (void)  const qsamplerDeviceParamMap& qsamplerDevice::params (void) const
283  {  {
284          return m_params;          return m_params;
285  }  }
286    
287    
288  // Update/refresh device/driver data.  // Device port/channel list accessor.
289  void qsamplerDevice::refresh (void)  qsamplerDevicePortList& qsamplerDevice::ports (void)
290  {  {
291            return m_ports;
292  }  }
293    
294    
295    // Device port/channel list refreshner.
296    void qsamplerDevice::refresh ( lscp_client_t *pClient )
297    {
298            // Port/channel count determination...
299            int iPorts = 0;
300            switch (m_deviceType) {
301            case qsamplerDevice::Audio:
302                    iPorts = m_params["CHANNELS"].value.toInt();
303                    break;
304            case qsamplerDevice::Midi:
305                    iPorts = m_params["PORTS"].value.toInt();
306                    break;
307            case qsamplerDevice::None:
308                    break;
309            }
310    
311            // Retrieve port/channel information...
312            m_ports.clear();
313            for (int iPort = 0; iPort < iPorts; iPort++)
314                    m_ports.append(new qsamplerDevicePort(pClient, *this, iPort));
315    }
316    
317    
318  // Device ids enumerator.  // Device ids enumerator.
319  int *qsamplerDevice::getDevices ( lscp_client_t *pClient,  int *qsamplerDevice::getDevices ( lscp_client_t *pClient,
320          qsamplerDeviceType deviceType )          qsamplerDeviceType deviceType )
# Line 313  QStringList qsamplerDevice::getDrivers ( Line 360  QStringList qsamplerDevice::getDrivers (
360    
361    
362  //-------------------------------------------------------------------------  //-------------------------------------------------------------------------
363    // qsamplerDevicePort - MIDI/Audio Device port/channel structure.
364    //
365    
366    // Constructor.
367    qsamplerDevicePort::qsamplerDevicePort ( lscp_client_t *pClient,
368            const qsamplerDevice& device, int iPortID )
369    {
370            setDevicePort(pClient, device, iPortID);
371    }
372    
373    // Default destructor.
374    qsamplerDevicePort::~qsamplerDevicePort (void)
375    {
376    }
377    
378    
379    // Initializer.
380    void qsamplerDevicePort::setDevicePort ( lscp_client_t *pClient,
381            const qsamplerDevice& device, int iPortID )
382    {
383            // Device port id should be always set.
384            m_iPortID = iPortID;
385    
386            // Reset port parameters anyway.
387            m_params.clear();
388    
389            // Retrieve device port/channel info, if any.
390            QString sPrefix = device.driverName() + ' ';
391            lscp_device_port_info_t *pPortInfo = NULL;
392            switch (device.deviceType()) {
393            case qsamplerDevice::Audio:
394                sPrefix += QObject::tr("Channel");
395                    pPortInfo = ::lscp_get_audio_channel_info(pClient, device.deviceID(), iPortID);
396                    break;
397            case qsamplerDevice::Midi:
398                sPrefix += QObject::tr("Port");
399                    pPortInfo = ::lscp_get_midi_port_info(pClient, device.deviceID(), iPortID);
400                    break;
401            case qsamplerDevice::None:
402                    break;
403            }
404    
405            // If we're bogus, bail out...
406            if (pPortInfo == NULL) {
407                    m_sPortName = QString::null;
408                    return;
409            }
410    
411            // Set device port/channel properties...
412            sPrefix += " %1:";
413            m_sPortName = sPrefix.arg(m_iPortID)  + ' ' + pPortInfo->name;
414    
415            // Grab device port/channel parameters...
416            m_params.clear();
417            for (int i = 0; pPortInfo->params && pPortInfo->params[i].key; i++) {
418                    const QString sParam = pPortInfo->params[i].key;
419                    lscp_param_info_t *pParamInfo = NULL;
420                    switch (device.deviceType()) {
421                    case qsamplerDevice::Audio:
422                            pParamInfo = ::lscp_get_audio_channel_param_info(pClient,
423                                    device.deviceID(), iPortID, sParam.latin1());
424                            break;
425                    case qsamplerDevice::Midi:
426                            pParamInfo = ::lscp_get_midi_port_param_info(pClient,
427                                    device.deviceID(), iPortID, sParam.latin1());
428                            break;
429                    case qsamplerDevice::None:
430                            break;
431                    }
432                    if (pParamInfo) {
433                            m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
434                                    pPortInfo->params[i].value);
435                    }
436            }
437    }
438    
439    
440    // Device port/channel property accessors.
441    int qsamplerDevicePort::portID (void) const
442    {
443            return m_iPortID;
444    }
445    
446    const QString& qsamplerDevicePort::portName (void) const
447    {
448            return m_sPortName;
449    }
450    
451    // Device port/channel parameter accessor.
452    const qsamplerDeviceParamMap& qsamplerDevicePort::params (void) const
453    {
454            return m_params;
455    }
456    
457    
458    // Set the proper device port/channel parameter value.
459    void qsamplerDevicePort::setParam ( const QString& sParam,
460            const QString& sValue )
461    {
462            m_params[sParam.upper()].value = sValue;
463    }
464    
465    
466    //-------------------------------------------------------------------------
467  // qsamplerDeviceItem - QListView device item.  // qsamplerDeviceItem - QListView device item.
468  //  //
469    
# Line 409  qsamplerDeviceParamTable::~qsamplerDevic Line 560  qsamplerDeviceParamTable::~qsamplerDevic
560  }  }
561    
562    
563  // The main table refresher.  // Common parameter table renderer.
564  void qsamplerDeviceParamTable::refresh ( qsamplerDevice& device )  void qsamplerDeviceParamTable::refresh ( const qsamplerDeviceParamMap& params,
565            bool bEditable )
566  {  {
567          // Always (re)start it empty.          // Always (re)start it empty.
568          QTable::setUpdatesEnabled(false);          QTable::setUpdatesEnabled(false);
569          QTable::setNumRows(0);          QTable::setNumRows(0);
570    
571          // Now fill the parameter table...          // Fill the parameter table...
         qsamplerDeviceParamMap& params = device.params();  
572          QTable::insertRows(0, params.count());          QTable::insertRows(0, params.count());
573          int iRow = 0;          int iRow = 0;
574          qsamplerDeviceParamMap::ConstIterator iter;          qsamplerDeviceParamMap::ConstIterator iter;
575          for (iter = params.begin(); iter != params.end(); ++iter) {          for (iter = params.begin(); iter != params.end(); ++iter) {
576                  const qsamplerDeviceParam& param = iter.data();                  const qsamplerDeviceParam& param = iter.data();
577                  bool bEnabled = (device.deviceID() < 0 || !param.fix);                  bool bEnabled = (bEditable || !param.fix);
578                  QTable::setText(iRow, 0, iter.key());                  QTable::setText(iRow, 0, iter.key());
579                  QTable::setText(iRow, 1, param.description);                  QTable::setText(iRow, 1, param.description);
580                  if (param.type == LSCP_TYPE_BOOL && bEnabled) {                  if (param.type == LSCP_TYPE_BOOL) {
581                          QStringList opts;                          QStringList opts;
582                          opts.append(tr("false"));                          opts.append(tr("false"));
583                          opts.append(tr("true"));                          opts.append(tr("true"));
Legend:
Removed from v.451  
changed lines
  Added in v.463
  ViewVC Help
Powered by ViewVC