/[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 471 by capela, Thu Mar 17 00:14:41 2005 UTC revision 492 by capela, Sat Apr 2 12:23:18 2005 UTC
# Line 54  void qsamplerDeviceParam::setParam ( lsc Line 54  void qsamplerDeviceParam::setParam ( lsc
54  {  {
55          if (pParamInfo == NULL)          if (pParamInfo == NULL)
56                  return;                  return;
57                    
58          // Info structure field members.          // Info structure field members.
59            
60          type = pParamInfo->type;          type = pParamInfo->type;
61            
62          if (pParamInfo->description)          if (pParamInfo->description)
63                  description = pParamInfo->description;                  description = pParamInfo->description;
64          else          else
65                  description = QString::null;                  description = QString::null;
66            
67          mandatory = (bool) pParamInfo->multiplicity;          mandatory = (bool) pParamInfo->mandatory;
68          fix = (bool) pParamInfo->fix;          fix = (bool) pParamInfo->fix;
69          multiplicity = (bool) pParamInfo->multiplicity;          multiplicity = (bool) pParamInfo->multiplicity;
70            
71          depends.clear();          depends.clear();
72          for (int i = 0; pParamInfo->depends && pParamInfo->depends[i]; i++)          for (int i = 0; pParamInfo->depends && pParamInfo->depends[i]; i++)
73                  depends.append(pParamInfo->depends[i]);                  depends.append(pParamInfo->depends[i]);
74            
75          if (pParamInfo->defaultv)          if (pParamInfo->defaultv)
76                  defaultv = pParamInfo->defaultv;                  defaultv = pParamInfo->defaultv;
77          else          else
78                  defaultv = QString::null;                  defaultv = QString::null;
79            
80          if (pParamInfo->range_min)          if (pParamInfo->range_min)
81                  range_min = pParamInfo->range_min;                  range_min = pParamInfo->range_min;
82          else          else
83                  range_min = QString::null;                  range_min = QString::null;
84            
85          if (pParamInfo->range_max)          if (pParamInfo->range_max)
86                  range_max = pParamInfo->range_max;                  range_max = pParamInfo->range_max;
87          else          else
88                  range_max = QString::null;                  range_max = QString::null;
89            
90          possibilities.clear();          possibilities.clear();
91          for (int i = 0; pParamInfo->possibilities && pParamInfo->possibilities[i]; i++)          for (int i = 0; pParamInfo->possibilities && pParamInfo->possibilities[i]; i++)
92                  possibilities.append(pParamInfo->possibilities[i]);                  possibilities.append(pParamInfo->possibilities[i]);
93                    
94          // The current parameter value.          // The current parameter value.
95          if (pszValue)          if (pszValue)
96                  value = pszValue;                  value = pszValue;
# Line 104  void qsamplerDeviceParam::setParam ( lsc Line 104  void qsamplerDeviceParam::setParam ( lsc
104  //  //
105    
106  // Constructor.  // Constructor.
107  qsamplerDevice::qsamplerDevice ( lscp_client_t *pClient,  qsamplerDevice::qsamplerDevice ( qsamplerMainForm *pMainForm,
108          qsamplerDeviceType deviceType, int iDeviceID )          qsamplerDeviceType deviceType, int iDeviceID )
109  {  {
110            m_pMainForm = pMainForm;
111    
112          m_ports.setAutoDelete(true);          m_ports.setAutoDelete(true);
113            
114          setDevice(pClient, deviceType, iDeviceID);          setDevice(deviceType, iDeviceID);
115  }  }
116    
117  // Default destructor.  // Default destructor.
# Line 117  qsamplerDevice::~qsamplerDevice (void) Line 119  qsamplerDevice::~qsamplerDevice (void)
119  {  {
120  }  }
121    
122    // Copy constructor.
123    qsamplerDevice::qsamplerDevice ( const qsamplerDevice& device )
124            : m_params(device.m_params), m_ports(m_ports)
125    {
126            m_pMainForm   = device.m_pMainForm;
127            m_iDeviceID   = device.m_iDeviceID;
128            m_deviceType  = device.m_deviceType;
129            m_sDeviceType = device.m_sDeviceType;
130            m_sDriverName = device.m_sDriverName;
131            m_sDeviceName = device.m_sDeviceName;
132    }
133    
134    
135  // Initializer.  // Initializer.
136  void qsamplerDevice::setDevice ( lscp_client_t *pClient,  void qsamplerDevice::setDevice ( qsamplerDeviceType deviceType, int iDeviceID )
         qsamplerDeviceType deviceType, int iDeviceID )  
137  {  {
138          // Device id and type should be always set.          // Device id and type should be always set.
139          m_iDeviceID  = iDeviceID;          m_iDeviceID  = iDeviceID;
140          m_deviceType = deviceType;          m_deviceType = deviceType;
141            
142          // Reset device parameters and ports anyway.          // Reset device parameters and ports anyway.
143          m_params.clear();          m_params.clear();
144          m_ports.clear();          m_ports.clear();
# Line 135  void qsamplerDevice::setDevice ( lscp_cl Line 148  void qsamplerDevice::setDevice ( lscp_cl
148          switch (deviceType) {          switch (deviceType) {
149          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
150                  m_sDeviceType = QObject::tr("Audio");                  m_sDeviceType = QObject::tr("Audio");
151                  pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);                  if (m_iDeviceID >= 0 && (pDeviceInfo = ::lscp_get_audio_device_info(
152                                    client(), m_iDeviceID)) == NULL)
153                            appendMessagesClient("lscp_get_audio_device_info");
154                  break;                  break;
155          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
156                  m_sDeviceType = QObject::tr("MIDI");                  m_sDeviceType = QObject::tr("MIDI");
157                  pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);                  if (m_iDeviceID >= 0 && (pDeviceInfo = ::lscp_get_midi_device_info(
158                                    client(), m_iDeviceID)) == NULL)
159                            appendMessagesClient("lscp_get_midi_device_info");
160                  break;                  break;
161          case qsamplerDevice::None:          case qsamplerDevice::None:
162                  m_sDeviceType = QString::null;                  m_sDeviceType = QString::null;
163                  break;                  break;
164          }          }
   
165          // If we're bogus, bail out...          // If we're bogus, bail out...
166          if (pDeviceInfo == NULL) {          if (pDeviceInfo == NULL) {
167                  m_sDriverName = QString::null;                  m_sDriverName = QString::null;
# Line 164  void qsamplerDevice::setDevice ( lscp_cl Line 180  void qsamplerDevice::setDevice ( lscp_cl
180                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
181                  switch (deviceType) {                  switch (deviceType) {
182                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
183                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,                          if ((pParamInfo = ::lscp_get_audio_driver_param_info(client(),
184                                  m_sDriverName.latin1(), sParam.latin1(), NULL);                                          m_sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
185                                    appendMessagesClient("lscp_get_audio_driver_param_info");
186                          break;                          break;
187                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
188                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,                          if ((pParamInfo = ::lscp_get_midi_driver_param_info(client(),
189                                  m_sDriverName.latin1(), sParam.latin1(), NULL);                                          m_sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
190                                    appendMessagesClient("lscp_get_midi_driver_param_info");
191                          break;                          break;
192                  case qsamplerDevice::None:                  case qsamplerDevice::None:
193                          break;                          break;
# Line 181  void qsamplerDevice::setDevice ( lscp_cl Line 199  void qsamplerDevice::setDevice ( lscp_cl
199          }          }
200    
201          // Refresh parameter dependencies...          // Refresh parameter dependencies...
202          refreshParams(pClient);          refreshParams();
203          // Set port/channel list...          // Set port/channel list...
204          refreshPorts(pClient);          refreshPorts();
205  }  }
206    
207    
208  // Driver name initializer/settler.  // Driver name initializer/settler.
209  void qsamplerDevice::setDriver ( lscp_client_t *pClient,  void qsamplerDevice::setDriver ( const QString& sDriverName )
         const QString& sDriverName )  
210  {  {
211          // Valid only for scratch devices.          // Valid only for scratch devices.
212          if (m_sDriverName == sDriverName)          if (m_sDriverName == sDriverName)
# Line 203  void qsamplerDevice::setDriver ( lscp_cl Line 220  void qsamplerDevice::setDriver ( lscp_cl
220          lscp_driver_info_t *pDriverInfo = NULL;          lscp_driver_info_t *pDriverInfo = NULL;
221          switch (m_deviceType) {          switch (m_deviceType) {
222          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
223                  pDriverInfo = ::lscp_get_audio_driver_info(pClient,                  if ((pDriverInfo = ::lscp_get_audio_driver_info(client(),
224                          sDriverName.latin1());                                  sDriverName.latin1())) == NULL)
225                            appendMessagesClient("lscp_get_audio_driver_info");
226                  break;                  break;
227          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
228                  pDriverInfo = ::lscp_get_midi_driver_info(pClient,                  if ((pDriverInfo = ::lscp_get_midi_driver_info(client(),
229                          sDriverName.latin1());                                  sDriverName.latin1())) == NULL)
230                            appendMessagesClient("lscp_get_midi_driver_info");
231                  break;                  break;
232          case qsamplerDevice::None:          case qsamplerDevice::None:
233                  break;                  break;
# Line 227  void qsamplerDevice::setDriver ( lscp_cl Line 246  void qsamplerDevice::setDriver ( lscp_cl
246                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
247                  switch (m_deviceType) {                  switch (m_deviceType) {
248                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
249                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,                          if ((pParamInfo = ::lscp_get_audio_driver_param_info(client(),
250                                  sDriverName.latin1(), sParam.latin1(), NULL);                                          sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
251                                    appendMessagesClient("lscp_get_audio_driver_param_info");
252                          break;                          break;
253                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
254                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,                          if ((pParamInfo = ::lscp_get_midi_driver_param_info(client(),
255                                  sDriverName.latin1(), sParam.latin1(), NULL);                                          sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
256                                    appendMessagesClient("lscp_get_midi_driver_param_info");
257                          break;                          break;
258                  case qsamplerDevice::None:                  case qsamplerDevice::None:
259                          break;                          break;
# Line 244  void qsamplerDevice::setDriver ( lscp_cl Line 265  void qsamplerDevice::setDriver ( lscp_cl
265          }          }
266    
267          // Refresh parameter dependencies...          // Refresh parameter dependencies...
268          refreshParams(pClient);          refreshParams();
269          // Set port/channel list...          // Set port/channel list...
270          refreshPorts(pClient);          refreshPorts();
271    }
272    
273    
274    // The client descriptor delegated property.
275    lscp_client_t *qsamplerDevice::client (void) const
276    {
277            if (m_pMainForm == NULL)
278                    return NULL;
279    
280            return m_pMainForm->client();
281  }  }
282    
283    
# Line 271  const QString& qsamplerDevice::driverNam Line 302  const QString& qsamplerDevice::driverNam
302          return m_sDriverName;          return m_sDriverName;
303  }  }
304    
305  const QString& qsamplerDevice::deviceName (void) const  // Special device name formatter.
306    QString qsamplerDevice::deviceName (void) const
307  {  {
308          return m_sDeviceName;          QString sPrefix;
309            if (m_iDeviceID >= 0)
310                sPrefix += m_sDeviceType + ' ';
311            return sPrefix + m_sDeviceName;
312  }  }
313    
314    
315  // Set the proper device parameter value.  // Set the proper device parameter value.
316  void qsamplerDevice::setParam ( const QString& sParam,  bool qsamplerDevice::setParam ( const QString& sParam,
317          const QString& sValue )          const QString& sValue )
318  {  {
319            // Set proper device parameter.
320          m_params[sParam.upper()].value = sValue;          m_params[sParam.upper()].value = sValue;
321    
322            // If the device already exists, things get immediate...
323            int iRefresh = 0;
324            if (m_iDeviceID >= 0) {
325                    // Prepare parameter struct.
326                    lscp_param_t param;
327                    param.key   = (char *) sParam.latin1();
328                    param.value = (char *) sValue.latin1();
329                    // Now it depends on the device type...
330                    lscp_status_t ret = LSCP_FAILED;
331                    switch (m_deviceType) {
332                    case qsamplerDevice::Audio:
333                        if (sParam == "CHANNELS") iRefresh++;
334                            if ((ret = ::lscp_set_audio_device_param(client(),
335                                            m_iDeviceID, &param)) != LSCP_OK)
336                                    appendMessagesClient("lscp_set_audio_device_param");
337                            break;
338                    case qsamplerDevice::Midi:
339                        if (sParam == "PORTS") iRefresh++;
340                            if ((ret = ::lscp_set_midi_device_param(client(),
341                                            m_iDeviceID, &param)) != LSCP_OK)
342                                    appendMessagesClient("lscp_set_midi_device_param");
343                            break;
344                    case qsamplerDevice::None:
345                            break;
346                    }
347                    // Show result.
348                    if (ret == LSCP_OK) {
349                            appendMessages(QString("%1: %2.").arg(sParam).arg(sValue));
350                            // Special care for specific parameter changes...
351                            if (iRefresh > 0)
352                                    iRefresh += refreshPorts();
353                            iRefresh += refreshDepends(sParam);
354                    } else {
355                            // Oops...
356                            appendMessagesError(
357                                    QObject::tr("Could not set device parameter value.\n\nSorry."));
358                    }
359            }
360    
361            // Return whether we're need a view refresh.
362            return (iRefresh > 0);
363  }  }
364    
365    
# Line 299  qsamplerDevicePortList& qsamplerDevice:: Line 377  qsamplerDevicePortList& qsamplerDevice::
377  }  }
378    
379    
380    // Create a new device, as a copy of this current one.
381    bool qsamplerDevice::createDevice (void)
382    {
383            if (client() == NULL)
384                    return false;
385    
386            // Build the parameter list...
387            lscp_param_t *pParams = new lscp_param_t [m_params.count() + 1];
388            int iParam = 0;
389            qsamplerDeviceParamMap::ConstIterator iter;
390            for (iter = m_params.begin(); iter != m_params.end(); ++iter) {
391                    pParams[iParam].key   = (char *) iter.key().latin1();
392                    pParams[iParam].value = (char *) iter.data().value.latin1();
393                    ++iParam;
394            }
395            // Null terminated.
396            pParams[iParam].key   = NULL;
397            pParams[iParam].value = NULL;
398    
399            // Now it depends on the device type...
400            switch (m_deviceType) {
401            case qsamplerDevice::Audio:
402                    if ((m_iDeviceID = ::lscp_create_audio_device(client(),
403                                    m_sDriverName.latin1(), pParams)) < 0)
404                            appendMessagesClient("lscp_create_audio_device");
405                    break;
406            case qsamplerDevice::Midi:
407                    if ((m_iDeviceID = ::lscp_create_midi_device(client(),
408                                    m_sDriverName.latin1(), pParams)) < 0)
409                            appendMessagesClient("lscp_create_midi_device");
410                    break;
411            case qsamplerDevice::None:
412                    break;
413            }
414    
415            // Free used parameter array.
416            delete pParams;
417    
418            // Show result.
419            if (m_iDeviceID >= 0) {
420                    // Refresh our own stuff...
421                    setDevice(m_deviceType, m_iDeviceID);
422                    appendMessages(QObject::tr("created."));
423            } else {
424                    appendMessagesError(QObject::tr("Could not create device.\n\nSorry."));
425            }
426    
427            // Return whether we're a valid device...
428            return (m_iDeviceID >= 0);
429    }
430    
431    
432    // Destroy existing device.
433    bool qsamplerDevice::deleteDevice (void)
434    {
435            // Now it depends on the device type...
436            lscp_status_t ret = LSCP_FAILED;
437            switch (m_deviceType) {
438            case qsamplerDevice::Audio:
439                    if ((ret = ::lscp_destroy_audio_device(client(),
440                                    m_iDeviceID)) != LSCP_OK)
441                            appendMessagesClient("lscp_destroy_audio_device");
442                    break;
443            case qsamplerDevice::Midi:
444                    if ((ret = ::lscp_destroy_midi_device(client(),
445                                    m_iDeviceID)) != LSCP_OK)
446                            appendMessagesClient("lscp_destroy_midi_device");
447                    break;
448            case qsamplerDevice::None:
449                    break;
450            }
451    
452            // Show result.
453            if (ret == LSCP_OK) {
454                    appendMessages(QObject::tr("deleted."));
455                    m_iDeviceID = -1;
456            } else {
457                    appendMessagesError(QObject::tr("Could not delete device.\n\nSorry."));
458            }
459    
460            // Return whether we've done it..
461            return (ret == LSCP_OK);
462    }
463    
464    
465  // Device parameter dependencies refreshner.  // Device parameter dependencies refreshner.
466  int qsamplerDevice::refreshParams ( lscp_client_t *pClient )  int qsamplerDevice::refreshParams (void)
467  {  {
468          // This should only make sense for scratch devices...          // This should only make sense for scratch devices...
469          if (m_iDeviceID >= 0)          if (m_iDeviceID >= 0)
# Line 309  int qsamplerDevice::refreshParams ( lscp Line 472  int qsamplerDevice::refreshParams ( lscp
472          int iParams = 0;          int iParams = 0;
473          qsamplerDeviceParamMap::ConstIterator iter;          qsamplerDeviceParamMap::ConstIterator iter;
474          for (iter = m_params.begin(); iter != m_params.end(); ++iter)          for (iter = m_params.begin(); iter != m_params.end(); ++iter)
475                  iParams += refreshParam(pClient, iter.key());                  iParams += refreshParam(iter.key());
476          // Return how many parameters have been refreshed...          // Return how many parameters have been refreshed...
477          return iParams;          return iParams;
478  }  }
479    
480    
481  // Device port/channel list refreshner.  // Device port/channel list refreshner.
482  int qsamplerDevice::refreshPorts ( lscp_client_t *pClient )  int qsamplerDevice::refreshPorts (void)
483  {  {
484          // This should only make sense for actual devices...          // This should only make sense for actual devices...
485          if (m_iDeviceID < 0)          if (m_iDeviceID < 0)
# Line 336  int qsamplerDevice::refreshPorts ( lscp_ Line 499  int qsamplerDevice::refreshPorts ( lscp_
499          // Retrieve port/channel information...          // Retrieve port/channel information...
500          m_ports.clear();          m_ports.clear();
501          for (int iPort = 0; iPort < iPorts; iPort++)          for (int iPort = 0; iPort < iPorts; iPort++)
502                  m_ports.append(new qsamplerDevicePort(pClient, *this, iPort));                  m_ports.append(new qsamplerDevicePort(*this, iPort));
503          // Return how many ports have been refreshed...          // Return how many ports have been refreshed...
504          return iPorts;          return iPorts;
505  }  }
506    
507    
508  // Refresh/set dependencies given that some parameter has changed.  // Refresh/set dependencies given that some parameter has changed.
509  int qsamplerDevice::refreshDepends ( lscp_client_t *pClient,  int qsamplerDevice::refreshDepends ( const QString& sParam )
         const QString& sParam )  
510  {  {
511          // This should only make sense for scratch devices...          // This should only make sense for scratch devices...
512          if (m_iDeviceID >= 0)          if (m_iDeviceID >= 0)
# Line 355  int qsamplerDevice::refreshDepends ( lsc Line 517  int qsamplerDevice::refreshDepends ( lsc
517          for (iter = m_params.begin(); iter != m_params.end(); ++iter) {          for (iter = m_params.begin(); iter != m_params.end(); ++iter) {
518                  const QStringList& depends = iter.data().depends;                  const QStringList& depends = iter.data().depends;
519                  if (depends.find(sParam) != depends.end())                  if (depends.find(sParam) != depends.end())
520                          iDepends += refreshParam(pClient, iter.key());                          iDepends += refreshParam(iter.key());
521          }          }
522          // Return how many dependencies have been refreshed...          // Return how many dependencies have been refreshed...
523          return iDepends;          return iDepends;
# Line 363  int qsamplerDevice::refreshDepends ( lsc Line 525  int qsamplerDevice::refreshDepends ( lsc
525    
526    
527  // Refresh/set given parameter based on driver supplied dependencies.  // Refresh/set given parameter based on driver supplied dependencies.
528  int qsamplerDevice::refreshParam ( lscp_client_t *pClient,  int qsamplerDevice::refreshParam ( const QString& sParam )
         const QString& sParam )  
529  {  {
530          // Check if we have dependencies...          // Check if we have dependencies...
531          qsamplerDeviceParam& param = m_params[sParam.upper()];          qsamplerDeviceParam& param = m_params[sParam.upper()];
# Line 396  int qsamplerDevice::refreshParam ( lscp_ Line 557  int qsamplerDevice::refreshParam ( lscp_
557          lscp_param_info_t *pParamInfo = NULL;          lscp_param_info_t *pParamInfo = NULL;
558          switch (m_deviceType) {          switch (m_deviceType) {
559          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
560                  pParamInfo = ::lscp_get_audio_driver_param_info(pClient,                  if ((pParamInfo = ::lscp_get_audio_driver_param_info(client(),
561                          m_sDriverName.latin1(), sParam.latin1(), pDepends);                                  m_sDriverName.latin1(), sParam.latin1(), pDepends)) == NULL)
562                            appendMessagesClient("lscp_get_audio_driver_param_info");
563                  break;                  break;
564          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
565                  pParamInfo = ::lscp_get_midi_driver_param_info(pClient,                  if ((pParamInfo = ::lscp_get_midi_driver_param_info(client(),
566                          m_sDriverName.latin1(), sParam.latin1(), pDepends);                                  m_sDriverName.latin1(), sParam.latin1(), pDepends)) == NULL)
567                            appendMessagesClient("lscp_get_midi_driver_param_info");
568                  break;                  break;
569          case qsamplerDevice::None:          case qsamplerDevice::None:
570                  break;                  break;
# Line 419  int qsamplerDevice::refreshParam ( lscp_ Line 582  int qsamplerDevice::refreshParam ( lscp_
582  }  }
583    
584    
585    // Redirected messages output methods.
586    void qsamplerDevice::appendMessages( const QString& s ) const
587    {
588            if (m_pMainForm)
589                    m_pMainForm->appendMessages(deviceName() + ' ' + s);
590    }
591    
592    void qsamplerDevice::appendMessagesColor( const QString& s,
593            const QString& c ) const
594    {
595            if (m_pMainForm)
596                    m_pMainForm->appendMessagesColor(deviceName() + ' ' + s, c);
597    }
598    
599    void qsamplerDevice::appendMessagesText( const QString& s ) const
600    {
601            if (m_pMainForm)
602                    m_pMainForm->appendMessagesText(deviceName() + ' ' + s);
603    }
604    
605    void qsamplerDevice::appendMessagesError( const QString& s ) const
606    {
607            if (m_pMainForm)
608                    m_pMainForm->appendMessagesError(deviceName() + "\n\n" + s);
609    }
610    
611    void qsamplerDevice::appendMessagesClient( const QString& s ) const
612    {
613            if (m_pMainForm)
614                    m_pMainForm->appendMessagesClient(deviceName() + ' ' + s);
615    }
616    
617    
618  // Device ids enumerator.  // Device ids enumerator.
619  int *qsamplerDevice::getDevices ( lscp_client_t *pClient,  int *qsamplerDevice::getDevices ( lscp_client_t *pClient,
620          qsamplerDeviceType deviceType )          qsamplerDeviceType deviceType )
# Line 443  QStringList qsamplerDevice::getDrivers ( Line 639  QStringList qsamplerDevice::getDrivers (
639          qsamplerDeviceType deviceType )          qsamplerDeviceType deviceType )
640  {  {
641          QStringList drivers;          QStringList drivers;
642            
643          const char **ppszDrivers = NULL;          const char **ppszDrivers = NULL;
644          switch (deviceType) {          switch (deviceType) {
645          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
# Line 455  QStringList qsamplerDevice::getDrivers ( Line 651  QStringList qsamplerDevice::getDrivers (
651          case qsamplerDevice::None:          case qsamplerDevice::None:
652                  break;                  break;
653          }          }
654            
655          for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)          for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)
656                  drivers.append(ppszDrivers[iDriver]);                  drivers.append(ppszDrivers[iDriver]);
657    
# Line 468  QStringList qsamplerDevice::getDrivers ( Line 664  QStringList qsamplerDevice::getDrivers (
664  //  //
665    
666  // Constructor.  // Constructor.
667  qsamplerDevicePort::qsamplerDevicePort ( lscp_client_t *pClient,  qsamplerDevicePort::qsamplerDevicePort ( qsamplerDevice& device,
668          const qsamplerDevice& device, int iPortID )          int iPortID ) : m_device(device)
669  {  {
670          setDevicePort(pClient, device, iPortID);          setDevicePort(iPortID);
671  }  }
672    
673  // Default destructor.  // Default destructor.
# Line 481  qsamplerDevicePort::~qsamplerDevicePort Line 677  qsamplerDevicePort::~qsamplerDevicePort
677    
678    
679  // Initializer.  // Initializer.
680  void qsamplerDevicePort::setDevicePort ( lscp_client_t *pClient,  void qsamplerDevicePort::setDevicePort ( int iPortID )
         const qsamplerDevice& device, int iPortID )  
681  {  {
682          // Device port id should be always set.          // Device port id should be always set.
683          m_iPortID = iPortID;          m_iPortID = iPortID;
# Line 492  void qsamplerDevicePort::setDevicePort ( Line 687  void qsamplerDevicePort::setDevicePort (
687    
688          // Retrieve device port/channel info, if any.          // Retrieve device port/channel info, if any.
689          lscp_device_port_info_t *pPortInfo = NULL;          lscp_device_port_info_t *pPortInfo = NULL;
690          switch (device.deviceType()) {          switch (m_device.deviceType()) {
691          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
692                  pPortInfo = ::lscp_get_audio_channel_info(pClient, device.deviceID(), iPortID);                  if ((pPortInfo = ::lscp_get_audio_channel_info(m_device.client(),
693                                    m_device.deviceID(), m_iPortID)) == NULL)
694                            m_device.appendMessagesClient("lscp_get_audio_channel_info");
695                  break;                  break;
696          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
697                  pPortInfo = ::lscp_get_midi_port_info(pClient, device.deviceID(), iPortID);                  if ((pPortInfo = ::lscp_get_midi_port_info(m_device.client(),
698                                    m_device.deviceID(), m_iPortID)) == NULL)
699                            m_device.appendMessagesClient("lscp_get_midi_port_info");
700                  break;                  break;
701          case qsamplerDevice::None:          case qsamplerDevice::None:
702                  break;                  break;
# Line 510  void qsamplerDevicePort::setDevicePort ( Line 709  void qsamplerDevicePort::setDevicePort (
709          }          }
710    
711          // Set device port/channel properties...          // Set device port/channel properties...
712          m_sPortName += device.driverName() + ' ' + pPortInfo->name;          m_sPortName = pPortInfo->name;
713    
714          // Grab device port/channel parameters...          // Grab device port/channel parameters...
715          m_params.clear();          m_params.clear();
716          for (int i = 0; pPortInfo->params && pPortInfo->params[i].key; i++) {          for (int i = 0; pPortInfo->params && pPortInfo->params[i].key; i++) {
717                  const QString sParam = pPortInfo->params[i].key;                  const QString sParam = pPortInfo->params[i].key;
718                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
719                  switch (device.deviceType()) {                  switch (m_device.deviceType()) {
720                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
721                          pParamInfo = ::lscp_get_audio_channel_param_info(pClient,                          if ((pParamInfo = ::lscp_get_audio_channel_param_info(
722                                  device.deviceID(), iPortID, sParam.latin1());                                          m_device.client(), m_device.deviceID(),
723                                            m_iPortID, sParam.latin1())) == NULL)
724                                    m_device.appendMessagesClient("lscp_get_audio_channel_param_info");
725                          break;                          break;
726                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
727                          pParamInfo = ::lscp_get_midi_port_param_info(pClient,                          if ((pParamInfo = ::lscp_get_midi_port_param_info(
728                                  device.deviceID(), iPortID, sParam.latin1());                                          m_device.client(), m_device.deviceID(),
729                                            m_iPortID, sParam.latin1())) == NULL)
730                                    m_device.appendMessagesClient("lscp_get_midi_port_param_info");
731                          break;                          break;
732                  case qsamplerDevice::None:                  case qsamplerDevice::None:
733                          break;                          break;
# Line 556  const qsamplerDeviceParamMap& qsamplerDe Line 759  const qsamplerDeviceParamMap& qsamplerDe
759    
760    
761  // Set the proper device port/channel parameter value.  // Set the proper device port/channel parameter value.
762  void qsamplerDevicePort::setParam ( const QString& sParam,  bool qsamplerDevicePort::setParam ( const QString& sParam,
763          const QString& sValue )          const QString& sValue )
764  {  {
765            // Set proper port/channel parameter.
766          m_params[sParam.upper()].value = sValue;          m_params[sParam.upper()].value = sValue;
767    
768            // If the device already exists, things get immediate...
769            int iRefresh = 0;
770            if (m_device.deviceID() >= 0 && m_iPortID >= 0) {
771                    // Prepare parameter struct.
772                    lscp_param_t param;
773                    param.key   = (char *) sParam.latin1();
774                    param.value = (char *) sValue.latin1();
775                    // Now it depends on the device type...
776                    lscp_status_t ret = LSCP_FAILED;
777                    switch (m_device.deviceType()) {
778                    case qsamplerDevice::Audio:
779                            if ((ret = ::lscp_set_audio_channel_param(m_device.client(),
780                                            m_device.deviceID(), m_iPortID, &param)) != LSCP_OK)
781                                    m_device.appendMessagesClient("lscp_set_audio_channel_param");
782                            break;
783                    case qsamplerDevice::Midi:
784                            if ((ret = ::lscp_set_midi_port_param(m_device.client(),
785                                            m_device.deviceID(), m_iPortID, &param)) != LSCP_OK)
786                                    m_device.appendMessagesClient("lscp_set_midi_port_param");
787                            break;
788                    case qsamplerDevice::None:
789                            break;
790                    }
791                    // Show result.
792                    if (ret == LSCP_OK) {
793                            m_device.appendMessages(m_sPortName
794                                    + ' ' + QString("%1: %2.").arg(sParam).arg(sValue));
795                            iRefresh++;
796                    } else {
797                            m_device.appendMessagesError(
798                                    QObject::tr("Could not set %1 parameter value.\n\n"
799                                            "Sorry.").arg(m_sPortName));
800                    }
801            }
802    
803            // Return whether we're need a view refresh.
804            return (iRefresh > 0);
805  }  }
806    
807    
# Line 569  void qsamplerDevicePort::setParam ( cons Line 811  void qsamplerDevicePort::setParam ( cons
811    
812  // Constructors.  // Constructors.
813  qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView,  qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView,
814          lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType )          qsamplerMainForm *pMainForm, qsamplerDevice::qsamplerDeviceType deviceType )
815          : QListViewItem(pListView), m_device(pClient, deviceType)          : QListViewItem(pListView), m_device(pMainForm, deviceType)
816  {  {
817          switch(m_device.deviceType()) {          switch(m_device.deviceType()) {
818          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
# Line 587  qsamplerDeviceItem::qsamplerDeviceItem ( Line 829  qsamplerDeviceItem::qsamplerDeviceItem (
829  }  }
830    
831  qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem,  qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem,
832          lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType,          qsamplerMainForm *pMainForm, qsamplerDevice::qsamplerDeviceType deviceType,
833          int iDeviceID )          int iDeviceID )
834          : QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)          : QListViewItem(pItem), m_device(pMainForm, deviceType, iDeviceID)
835  {  {
836          switch(m_device.deviceType()) {          switch(m_device.deviceType()) {
837          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
# Line 686  void qsamplerDeviceParamTable::refresh ( Line 928  void qsamplerDeviceParamTable::refresh (
928                          pComboItem->setEnabled(bEnabled);                          pComboItem->setEnabled(bEnabled);
929                          QTable::setItem(iRow, 2, pComboItem);                          QTable::setItem(iRow, 2, pComboItem);
930                  } else if (param.possibilities.count() > 0 && bEnabled) {                  } else if (param.possibilities.count() > 0 && bEnabled) {
931                          QComboTableItem *pComboItem = new QComboTableItem(this,                          QStringList opts = param.possibilities;
932                                  param.possibilities);                          if (param.multiplicity)
933                          pComboItem->setCurrentItem(param.value);                                  opts.prepend(tr("(none)"));
934                            QComboTableItem *pComboItem = new QComboTableItem(this, opts);
935                            if (param.value.isEmpty())
936                                    pComboItem->setCurrentItem(0);
937                            else
938                                    pComboItem->setCurrentItem(param.value);
939                          pComboItem->setEnabled(bEnabled);                          pComboItem->setEnabled(bEnabled);
                         pComboItem->setEditable(bEnabled && param.multiplicity);  
940                          QTable::setItem(iRow, 2, pComboItem);                          QTable::setItem(iRow, 2, pComboItem);
941                  } else if (param.type == LSCP_TYPE_INT && bEnabled                  } else if (param.type == LSCP_TYPE_INT && bEnabled
942                                  && !param.range_min.isEmpty()                                  && !param.range_min.isEmpty()
# Line 805  void qsamplerDeviceParamTableEditBox::se Line 1051  void qsamplerDeviceParamTableEditBox::se
1051    
1052    
1053  // end of qsamplerDevice.cpp  // end of qsamplerDevice.cpp
1054    
Legend:
Removed from v.471  
changed lines
  Added in v.492
  ViewVC Help
Powered by ViewVC