/[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 462 by capela, Tue Mar 15 11:39:12 2005 UTC revision 759 by capela, Sun Aug 28 11:44:10 2005 UTC
# Line 19  Line 19 
19    
20  *****************************************************************************/  *****************************************************************************/
21    
22    #include "qsamplerAbout.h"
23  #include "qsamplerDevice.h"  #include "qsamplerDevice.h"
24    
 #include <qspinbox.h>  
 #include <qlineedit.h>  
   
25  #include "qsamplerMainForm.h"  #include "qsamplerMainForm.h"
26  #include "qsamplerDeviceForm.h"  #include "qsamplerDeviceForm.h"
27    
28  #include "config.h"  #include <qspinbox.h>
29    #include <qlineedit.h>
30    
31    
32  //-------------------------------------------------------------------------  //-------------------------------------------------------------------------
# Line 54  void qsamplerDeviceParam::setParam ( lsc Line 53  void qsamplerDeviceParam::setParam ( lsc
53  {  {
54          if (pParamInfo == NULL)          if (pParamInfo == NULL)
55                  return;                  return;
56                    
57          // Info structure field members.          // Info structure field members.
58            
59          type = pParamInfo->type;          type = pParamInfo->type;
60            
61          if (pParamInfo->description)          if (pParamInfo->description)
62                  description = pParamInfo->description;                  description = pParamInfo->description;
63          else          else
64                  description = QString::null;                  description = QString::null;
65            
66          mandatory = (bool) pParamInfo->multiplicity;          mandatory = (bool) pParamInfo->mandatory;
67          fix = (bool) pParamInfo->fix;          fix = (bool) pParamInfo->fix;
68          multiplicity = (bool) pParamInfo->multiplicity;          multiplicity = (bool) pParamInfo->multiplicity;
69            
70          depends.clear();          depends.clear();
71          for (int i = 0; pParamInfo->depends && pParamInfo->depends[i]; i++)          for (int i = 0; pParamInfo->depends && pParamInfo->depends[i]; i++)
72                  depends.append(pParamInfo->depends[i]);                  depends.append(pParamInfo->depends[i]);
73            
74          if (pParamInfo->defaultv)          if (pParamInfo->defaultv)
75                  defaultv = pParamInfo->defaultv;                  defaultv = pParamInfo->defaultv;
76          else          else
77                  defaultv = QString::null;                  defaultv = QString::null;
78            
79          if (pParamInfo->range_min)          if (pParamInfo->range_min)
80                  range_min = pParamInfo->range_min;                  range_min = pParamInfo->range_min;
81          else          else
82                  range_min = QString::null;                  range_min = QString::null;
83            
84          if (pParamInfo->range_max)          if (pParamInfo->range_max)
85                  range_max = pParamInfo->range_max;                  range_max = pParamInfo->range_max;
86          else          else
87                  range_max = QString::null;                  range_max = QString::null;
88            
89          possibilities.clear();          possibilities.clear();
90          for (int i = 0; pParamInfo->possibilities && pParamInfo->possibilities[i]; i++)          for (int i = 0; pParamInfo->possibilities && pParamInfo->possibilities[i]; i++)
91                  possibilities.append(pParamInfo->possibilities[i]);                  possibilities.append(pParamInfo->possibilities[i]);
92                    
93          // The current parameter value.          // The current parameter value.
94          if (pszValue)          if (pszValue)
95                  value = pszValue;                  value = pszValue;
# Line 104  void qsamplerDeviceParam::setParam ( lsc Line 103  void qsamplerDeviceParam::setParam ( lsc
103  //  //
104    
105  // Constructor.  // Constructor.
106  qsamplerDevice::qsamplerDevice ( lscp_client_t *pClient,  qsamplerDevice::qsamplerDevice ( qsamplerMainForm *pMainForm,
107          qsamplerDeviceType deviceType, int iDeviceID )          qsamplerDeviceType deviceType, int iDeviceID )
108  {  {
109          setDevice(pClient, deviceType, iDeviceID);          m_pMainForm = pMainForm;
110    
111            m_ports.setAutoDelete(true);
112    
113            setDevice(deviceType, iDeviceID);
114  }  }
115    
116  // Default destructor.  // Default destructor.
# Line 115  qsamplerDevice::~qsamplerDevice (void) Line 118  qsamplerDevice::~qsamplerDevice (void)
118  {  {
119  }  }
120    
121    // Copy constructor.
122    qsamplerDevice::qsamplerDevice ( const qsamplerDevice& device )
123            : m_params(device.m_params), m_ports(m_ports)
124    {
125            m_pMainForm   = device.m_pMainForm;
126            m_iDeviceID   = device.m_iDeviceID;
127            m_deviceType  = device.m_deviceType;
128            m_sDeviceType = device.m_sDeviceType;
129            m_sDriverName = device.m_sDriverName;
130            m_sDeviceName = device.m_sDeviceName;
131    }
132    
133    
134  // Initializer.  // Initializer.
135  void qsamplerDevice::setDevice ( lscp_client_t *pClient,  void qsamplerDevice::setDevice ( qsamplerDeviceType deviceType, int iDeviceID )
         qsamplerDeviceType deviceType, int iDeviceID )  
136  {  {
137          // Device id and type should be always set.          // Device id and type should be always set.
138          m_iDeviceID  = iDeviceID;          m_iDeviceID  = iDeviceID;
139          m_deviceType = deviceType;          m_deviceType = deviceType;
140    
141            // Reset device parameters and ports anyway.
142            m_params.clear();
143            m_ports.clear();
144    
145          // Retrieve device info, if any.          // Retrieve device info, if any.
146          lscp_device_info_t *pDeviceInfo = NULL;          lscp_device_info_t *pDeviceInfo = NULL;
147          switch (deviceType) {          switch (deviceType) {
148          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
149                  m_sDeviceType = QObject::tr("Audio");                  m_sDeviceType = QObject::tr("Audio");
150                  pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);                  if (m_iDeviceID >= 0 && (pDeviceInfo = ::lscp_get_audio_device_info(
151                                    client(), m_iDeviceID)) == NULL)
152                            appendMessagesClient("lscp_get_audio_device_info");
153                  break;                  break;
154          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
155                  m_sDeviceType = QObject::tr("MIDI");                  m_sDeviceType = QObject::tr("MIDI");
156                  pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);                  if (m_iDeviceID >= 0 && (pDeviceInfo = ::lscp_get_midi_device_info(
157                                    client(), m_iDeviceID)) == NULL)
158                            appendMessagesClient("lscp_get_midi_device_info");
159                  break;                  break;
160          case qsamplerDevice::None:          case qsamplerDevice::None:
161                  m_sDeviceType = QString::null;                  m_sDeviceType = QString::null;
162                  break;                  break;
163          }          }
   
164          // If we're bogus, bail out...          // If we're bogus, bail out...
165          if (pDeviceInfo == NULL) {          if (pDeviceInfo == NULL) {
166                  m_sDriverName = QString::null;                  m_sDriverName = QString::null;
# Line 153  void qsamplerDevice::setDevice ( lscp_cl Line 174  void qsamplerDevice::setDevice ( lscp_cl
174                  + QObject::tr("Device %1").arg(m_iDeviceID);                  + QObject::tr("Device %1").arg(m_iDeviceID);
175    
176          // Grab device parameters...          // Grab device parameters...
         m_params.clear();  
177          for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {          for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {
178                  const char *pszParam = pDeviceInfo->params[i].key;                  const QString sParam = pDeviceInfo->params[i].key;
179                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
180                  switch (deviceType) {                  switch (deviceType) {
181                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
182                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,                          if ((pParamInfo = ::lscp_get_audio_driver_param_info(client(),
183                                  m_sDriverName.latin1(), pszParam, NULL);                                          m_sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
184                                    appendMessagesClient("lscp_get_audio_driver_param_info");
185                          break;                          break;
186                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
187                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,                          if ((pParamInfo = ::lscp_get_midi_driver_param_info(client(),
188                                  m_sDriverName.latin1(), pszParam, NULL);                                          m_sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
189                                    appendMessagesClient("lscp_get_midi_driver_param_info");
190                          break;                          break;
191                  case qsamplerDevice::None:                  case qsamplerDevice::None:
192                          break;                          break;
193                  }                  }
194                  if (pParamInfo) {                  if (pParamInfo) {
195                          m_params[pszParam] = qsamplerDeviceParam(pParamInfo,                          m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
196                                  pDeviceInfo->params[i].value);                                  pDeviceInfo->params[i].value);
197                  }                  }
198          }          }
199    
200            // Refresh parameter dependencies...
201            refreshParams();
202            // Set port/channel list...
203            refreshPorts();
204  }  }
205    
206    
207  // Driver name initializer/settler.  // Driver name initializer/settler.
208  void qsamplerDevice::setDriver ( lscp_client_t *pClient,  void qsamplerDevice::setDriver ( const QString& sDriverName )
         const QString& sDriverName )  
209  {  {
210          // Valid only for scratch devices.          // Valid only for scratch devices.
211          if (m_sDriverName == sDriverName)          if (m_sDriverName == sDriverName)
212                  return;                  return;
213    
214            // Reset device parameters and ports anyway.
215            m_params.clear();
216            m_ports.clear();
217    
218          // Retrieve driver info, if any.          // Retrieve driver info, if any.
219          lscp_driver_info_t *pDriverInfo = NULL;          lscp_driver_info_t *pDriverInfo = NULL;
220          switch (m_deviceType) {          switch (m_deviceType) {
221          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
222                  pDriverInfo = ::lscp_get_audio_driver_info(pClient,                  if ((pDriverInfo = ::lscp_get_audio_driver_info(client(),
223                          sDriverName.latin1());                                  sDriverName.latin1())) == NULL)
224                            appendMessagesClient("lscp_get_audio_driver_info");
225                  break;                  break;
226          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
227                  pDriverInfo = ::lscp_get_midi_driver_info(pClient,                  if ((pDriverInfo = ::lscp_get_midi_driver_info(client(),
228                          sDriverName.latin1());                                  sDriverName.latin1())) == NULL)
229                            appendMessagesClient("lscp_get_midi_driver_info");
230                  break;                  break;
231          case qsamplerDevice::None:          case qsamplerDevice::None:
232                  break;                  break;
# Line 208  void qsamplerDevice::setDriver ( lscp_cl Line 240  void qsamplerDevice::setDriver ( lscp_cl
240          m_sDriverName = sDriverName;          m_sDriverName = sDriverName;
241    
242          // Grab driver parameters...          // Grab driver parameters...
         m_params.clear();  
243          for (int i = 0; pDriverInfo->parameters && pDriverInfo->parameters[i]; i++) {          for (int i = 0; pDriverInfo->parameters && pDriverInfo->parameters[i]; i++) {
244                  const char *pszParam = pDriverInfo->parameters[i];                  const QString sParam = pDriverInfo->parameters[i];
245                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
246                  switch (m_deviceType) {                  switch (m_deviceType) {
247                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
248                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,                          if ((pParamInfo = ::lscp_get_audio_driver_param_info(client(),
249                                  sDriverName.latin1(), pszParam, NULL);                                          sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
250                                    appendMessagesClient("lscp_get_audio_driver_param_info");
251                          break;                          break;
252                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
253                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,                          if ((pParamInfo = ::lscp_get_midi_driver_param_info(client(),
254                                  sDriverName.latin1(), pszParam, NULL);                                          sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
255                                    appendMessagesClient("lscp_get_midi_driver_param_info");
256                          break;                          break;
257                  case qsamplerDevice::None:                  case qsamplerDevice::None:
258                          break;                          break;
259                  }                  }
260                  if (pParamInfo)                  if (pParamInfo) {
261                          m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pParamInfo->defaultv);                          m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
262                                    pParamInfo->defaultv);
263                    }
264          }          }
265    
266            // Refresh parameter dependencies...
267            refreshParams();
268            // Set port/channel list...
269            refreshPorts();
270    }
271    
272    
273    // The client descriptor delegated property.
274    lscp_client_t *qsamplerDevice::client (void) const
275    {
276            if (m_pMainForm == NULL)
277                    return NULL;
278    
279            return m_pMainForm->client();
280  }  }
281    
282    
# Line 251  const QString& qsamplerDevice::driverNam Line 301  const QString& qsamplerDevice::driverNam
301          return m_sDriverName;          return m_sDriverName;
302  }  }
303    
304  const QString& qsamplerDevice::deviceName (void) const  // Special device name formatter.
305    QString qsamplerDevice::deviceName (void) const
306  {  {
307          return m_sDeviceName;          QString sPrefix;
308            if (m_iDeviceID >= 0)
309                sPrefix += m_sDeviceType + ' ';
310            return sPrefix + m_sDeviceName;
311  }  }
312    
313    
314    // Set the proper device parameter value.
315    bool qsamplerDevice::setParam ( const QString& sParam,
316            const QString& sValue )
317    {
318            // Set proper device parameter.
319            m_params[sParam.upper()].value = sValue;
320    
321            // If the device already exists, things get immediate...
322            int iRefresh = 0;
323            if (m_iDeviceID >= 0) {
324                    // Prepare parameter struct.
325                    lscp_param_t param;
326                    param.key   = (char *) sParam.latin1();
327                    param.value = (char *) sValue.latin1();
328                    // Now it depends on the device type...
329                    lscp_status_t ret = LSCP_FAILED;
330                    switch (m_deviceType) {
331                    case qsamplerDevice::Audio:
332                        if (sParam == "CHANNELS") iRefresh++;
333                            if ((ret = ::lscp_set_audio_device_param(client(),
334                                            m_iDeviceID, &param)) != LSCP_OK)
335                                    appendMessagesClient("lscp_set_audio_device_param");
336                            break;
337                    case qsamplerDevice::Midi:
338                        if (sParam == "PORTS") iRefresh++;
339                            if ((ret = ::lscp_set_midi_device_param(client(),
340                                            m_iDeviceID, &param)) != LSCP_OK)
341                                    appendMessagesClient("lscp_set_midi_device_param");
342                            break;
343                    case qsamplerDevice::None:
344                            break;
345                    }
346                    // Show result.
347                    if (ret == LSCP_OK) {
348                            appendMessages(QString("%1: %2.").arg(sParam).arg(sValue));
349                            // Special care for specific parameter changes...
350                            if (iRefresh > 0)
351                                    iRefresh += refreshPorts();
352                            iRefresh += refreshDepends(sParam);
353                    } else {
354                            // Oops...
355                            appendMessagesError(
356                                    QObject::tr("Could not set device parameter value.\n\nSorry."));
357                    }
358            }
359    
360            // Return whether we're need a view refresh.
361            return (iRefresh > 0);
362    }
363    
364    
365  // Device parameter accessor.  // Device parameter accessor.
366  const qsamplerDeviceParamMap& qsamplerDevice::params (void) const  const qsamplerDeviceParamMap& qsamplerDevice::params (void) const
367  {  {
# Line 263  const qsamplerDeviceParamMap& qsamplerDe Line 369  const qsamplerDeviceParamMap& qsamplerDe
369  }  }
370    
371    
372  // Set the proper device parameter value.  // Device port/channel list accessor.
373  void qsamplerDevice::setParam ( const QString& sParam,  qsamplerDevicePortList& qsamplerDevice::ports (void)
374          const QString& sValue )  {
375            return m_ports;
376    }
377    
378    
379    // Create a new device, as a copy of this current one.
380    bool qsamplerDevice::createDevice (void)
381    {
382            if (client() == NULL)
383                    return false;
384    
385            // Build the parameter list...
386            lscp_param_t *pParams = new lscp_param_t [m_params.count() + 1];
387            int iParam = 0;
388            qsamplerDeviceParamMap::ConstIterator iter;
389            for (iter = m_params.begin(); iter != m_params.end(); ++iter) {
390                    pParams[iParam].key   = (char *) iter.key().latin1();
391                    pParams[iParam].value = (char *) iter.data().value.latin1();
392                    ++iParam;
393            }
394            // Null terminated.
395            pParams[iParam].key   = NULL;
396            pParams[iParam].value = NULL;
397    
398            // Now it depends on the device type...
399            switch (m_deviceType) {
400            case qsamplerDevice::Audio:
401                    if ((m_iDeviceID = ::lscp_create_audio_device(client(),
402                                    m_sDriverName.latin1(), pParams)) < 0)
403                            appendMessagesClient("lscp_create_audio_device");
404                    break;
405            case qsamplerDevice::Midi:
406                    if ((m_iDeviceID = ::lscp_create_midi_device(client(),
407                                    m_sDriverName.latin1(), pParams)) < 0)
408                            appendMessagesClient("lscp_create_midi_device");
409                    break;
410            case qsamplerDevice::None:
411                    break;
412            }
413    
414            // Free used parameter array.
415            delete pParams;
416    
417            // Show result.
418            if (m_iDeviceID >= 0) {
419                    // Refresh our own stuff...
420                    setDevice(m_deviceType, m_iDeviceID);
421                    appendMessages(QObject::tr("created."));
422            } else {
423                    appendMessagesError(QObject::tr("Could not create device.\n\nSorry."));
424            }
425    
426            // Return whether we're a valid device...
427            return (m_iDeviceID >= 0);
428    }
429    
430    
431    // Destroy existing device.
432    bool qsamplerDevice::deleteDevice (void)
433    {
434            // Now it depends on the device type...
435            lscp_status_t ret = LSCP_FAILED;
436            switch (m_deviceType) {
437            case qsamplerDevice::Audio:
438                    if ((ret = ::lscp_destroy_audio_device(client(),
439                                    m_iDeviceID)) != LSCP_OK)
440                            appendMessagesClient("lscp_destroy_audio_device");
441                    break;
442            case qsamplerDevice::Midi:
443                    if ((ret = ::lscp_destroy_midi_device(client(),
444                                    m_iDeviceID)) != LSCP_OK)
445                            appendMessagesClient("lscp_destroy_midi_device");
446                    break;
447            case qsamplerDevice::None:
448                    break;
449            }
450    
451            // Show result.
452            if (ret == LSCP_OK) {
453                    appendMessages(QObject::tr("deleted."));
454                    m_iDeviceID = -1;
455            } else {
456                    appendMessagesError(QObject::tr("Could not delete device.\n\nSorry."));
457            }
458    
459            // Return whether we've done it..
460            return (ret == LSCP_OK);
461    }
462    
463    
464    // Device parameter dependencies refreshner.
465    int qsamplerDevice::refreshParams (void)
466    {
467            // This should only make sense for scratch devices...
468            if (m_iDeviceID >= 0)
469                return 0;
470            // Refresh all parameters that have dependencies...
471            int iParams = 0;
472            qsamplerDeviceParamMap::ConstIterator iter;
473            for (iter = m_params.begin(); iter != m_params.end(); ++iter)
474                    iParams += refreshParam(iter.key());
475            // Return how many parameters have been refreshed...
476            return iParams;
477    }
478    
479    
480    // Device port/channel list refreshner.
481    int qsamplerDevice::refreshPorts (void)
482  {  {
483          m_params[sParam].value = sValue;          // This should only make sense for actual devices...
484            if (m_iDeviceID < 0)
485                return 0;
486            // Port/channel count determination...
487            int iPorts = 0;
488            switch (m_deviceType) {
489            case qsamplerDevice::Audio:
490                    iPorts = m_params["CHANNELS"].value.toInt();
491                    break;
492            case qsamplerDevice::Midi:
493                    iPorts = m_params["PORTS"].value.toInt();
494                    break;
495            case qsamplerDevice::None:
496                    break;
497            }
498            // Retrieve port/channel information...
499            m_ports.clear();
500            for (int iPort = 0; iPort < iPorts; iPort++)
501                    m_ports.append(new qsamplerDevicePort(*this, iPort));
502            // Return how many ports have been refreshed...
503            return iPorts;
504    }
505    
506    
507    // Refresh/set dependencies given that some parameter has changed.
508    int qsamplerDevice::refreshDepends ( const QString& sParam )
509    {
510            // This should only make sense for scratch devices...
511            if (m_iDeviceID >= 0)
512                return 0;
513            // Refresh all parameters that depend on this one...
514            int iDepends = 0;
515            qsamplerDeviceParamMap::ConstIterator iter;
516            for (iter = m_params.begin(); iter != m_params.end(); ++iter) {
517                    const QStringList& depends = iter.data().depends;
518                    if (depends.find(sParam) != depends.end())
519                            iDepends += refreshParam(iter.key());
520            }
521            // Return how many dependencies have been refreshed...
522            return iDepends;
523    }
524    
525    
526    // Refresh/set given parameter based on driver supplied dependencies.
527    int qsamplerDevice::refreshParam ( const QString& sParam )
528    {
529            // Check if we have dependencies...
530            qsamplerDeviceParam& param = m_params[sParam.upper()];
531            if (param.depends.isEmpty())
532                    return 0;
533    
534            int iRefresh = 0;
535    
536            // Build dependency list...
537            lscp_param_t *pDepends = new lscp_param_t [param.depends.count() + 1];
538            int iDepend = 0;
539            QStringList::ConstIterator iter;
540            for (iter = param.depends.begin(); iter != param.depends.end(); ++iter) {
541                    const QString& sDepend = *iter;
542                    pDepends[iDepend].key   = (char *) sDepend.latin1();
543                    pDepends[iDepend].value = (char *) m_params[sDepend.upper()].value.latin1();
544                    ++iDepend;
545            }
546            // Null terminated.
547            pDepends[iDepend].key   = NULL;
548            pDepends[iDepend].value = NULL;
549    
550            // FIXME: Some parameter dependencies (e.g.ALSA CARD)
551            // are blocking for no reason, causing potential timeout-crashes.
552            // hopefully this gets mitigated if this dependency hell is only
553            // carried out for scratch devices...
554    
555            // Retrieve some modern parameters...
556            lscp_param_info_t *pParamInfo = NULL;
557            switch (m_deviceType) {
558            case qsamplerDevice::Audio:
559                    if ((pParamInfo = ::lscp_get_audio_driver_param_info(client(),
560                                    m_sDriverName.latin1(), sParam.latin1(), pDepends)) == NULL)
561                            appendMessagesClient("lscp_get_audio_driver_param_info");
562                    break;
563            case qsamplerDevice::Midi:
564                    if ((pParamInfo = ::lscp_get_midi_driver_param_info(client(),
565                                    m_sDriverName.latin1(), sParam.latin1(), pDepends)) == NULL)
566                            appendMessagesClient("lscp_get_midi_driver_param_info");
567                    break;
568            case qsamplerDevice::None:
569                    break;
570            }
571            if (pParamInfo) {
572                    param = qsamplerDeviceParam(pParamInfo, QString(param.value));
573                    iRefresh++;
574            }
575    
576            // Free used parameter array.
577            delete pDepends;
578    
579            // Return whether the parameters has been changed...
580            return iRefresh;
581    }
582    
583    
584    // Redirected messages output methods.
585    void qsamplerDevice::appendMessages( const QString& s ) const
586    {
587            if (m_pMainForm)
588                    m_pMainForm->appendMessages(deviceName() + ' ' + s);
589    }
590    
591    void qsamplerDevice::appendMessagesColor( const QString& s,
592            const QString& c ) const
593    {
594            if (m_pMainForm)
595                    m_pMainForm->appendMessagesColor(deviceName() + ' ' + s, c);
596    }
597    
598    void qsamplerDevice::appendMessagesText( const QString& s ) const
599    {
600            if (m_pMainForm)
601                    m_pMainForm->appendMessagesText(deviceName() + ' ' + s);
602    }
603    
604    void qsamplerDevice::appendMessagesError( const QString& s ) const
605    {
606            if (m_pMainForm)
607                    m_pMainForm->appendMessagesError(deviceName() + "\n\n" + s);
608    }
609    
610    void qsamplerDevice::appendMessagesClient( const QString& s ) const
611    {
612            if (m_pMainForm)
613                    m_pMainForm->appendMessagesClient(deviceName() + ' ' + s);
614  }  }
615    
616    
# Line 295  QStringList qsamplerDevice::getDrivers ( Line 638  QStringList qsamplerDevice::getDrivers (
638          qsamplerDeviceType deviceType )          qsamplerDeviceType deviceType )
639  {  {
640          QStringList drivers;          QStringList drivers;
641            
642          const char **ppszDrivers = NULL;          const char **ppszDrivers = NULL;
643          switch (deviceType) {          switch (deviceType) {
644          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
645                  ppszDrivers = ::lscp_get_available_audio_drivers(pClient);                  ppszDrivers = ::lscp_list_available_audio_drivers(pClient);
646                  break;                  break;
647          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
648                  ppszDrivers = ::lscp_get_available_midi_drivers(pClient);                  ppszDrivers = ::lscp_list_available_midi_drivers(pClient);
649                  break;                  break;
650          case qsamplerDevice::None:          case qsamplerDevice::None:
651                  break;                  break;
652          }          }
653            
654          for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)          for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)
655                  drivers.append(ppszDrivers[iDriver]);                  drivers.append(ppszDrivers[iDriver]);
656    
# Line 320  QStringList qsamplerDevice::getDrivers ( Line 663  QStringList qsamplerDevice::getDrivers (
663  //  //
664    
665  // Constructor.  // Constructor.
666  qsamplerDevicePort::qsamplerDevicePort ( lscp_client_t *pClient,  qsamplerDevicePort::qsamplerDevicePort ( qsamplerDevice& device,
667          const qsamplerDevice& device, int iPortID )          int iPortID ) : m_device(device)
668  {  {
669          setDevicePort(pClient, device, iPortID);          setDevicePort(iPortID);
670  }  }
671    
672  // Default destructor.  // Default destructor.
# Line 333  qsamplerDevicePort::~qsamplerDevicePort Line 676  qsamplerDevicePort::~qsamplerDevicePort
676    
677    
678  // Initializer.  // Initializer.
679  void qsamplerDevicePort::setDevicePort ( lscp_client_t *pClient,  void qsamplerDevicePort::setDevicePort ( int iPortID )
         const qsamplerDevice& device, int iPortID )  
680  {  {
681          // Device port id should be always set.          // Device port id should be always set.
682          m_iPortID = iPortID;          m_iPortID = iPortID;
683    
684            // Reset port parameters anyway.
685            m_params.clear();
686    
687          // Retrieve device port/channel info, if any.          // Retrieve device port/channel info, if any.
688          lscp_device_port_info_t *pPortInfo = NULL;          lscp_device_port_info_t *pPortInfo = NULL;
689          switch (device.deviceType()) {          switch (m_device.deviceType()) {
690          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
691                  pPortInfo = ::lscp_get_audio_channel_info(pClient, device.deviceID(), iPortID);                  if ((pPortInfo = ::lscp_get_audio_channel_info(m_device.client(),
692                                    m_device.deviceID(), m_iPortID)) == NULL)
693                            m_device.appendMessagesClient("lscp_get_audio_channel_info");
694                  break;                  break;
695          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
696                  pPortInfo = ::lscp_get_midi_port_info(pClient, device.deviceID(), iPortID);                  if ((pPortInfo = ::lscp_get_midi_port_info(m_device.client(),
697                                    m_device.deviceID(), m_iPortID)) == NULL)
698                            m_device.appendMessagesClient("lscp_get_midi_port_info");
699                  break;                  break;
700          case qsamplerDevice::None:          case qsamplerDevice::None:
701                  break;                  break;
# Line 364  void qsamplerDevicePort::setDevicePort ( Line 713  void qsamplerDevicePort::setDevicePort (
713          // Grab device port/channel parameters...          // Grab device port/channel parameters...
714          m_params.clear();          m_params.clear();
715          for (int i = 0; pPortInfo->params && pPortInfo->params[i].key; i++) {          for (int i = 0; pPortInfo->params && pPortInfo->params[i].key; i++) {
716                  const char *pszParam = pPortInfo->params[i].key;                  const QString sParam = pPortInfo->params[i].key;
717                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
718                  switch (device.deviceType()) {                  switch (m_device.deviceType()) {
719                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
720                          pParamInfo = ::lscp_get_audio_channel_param_info(pClient,                          if ((pParamInfo = ::lscp_get_audio_channel_param_info(
721                                  device.deviceID(), iPortID, pszParam);                                          m_device.client(), m_device.deviceID(),
722                                            m_iPortID, sParam.latin1())) == NULL)
723                                    m_device.appendMessagesClient("lscp_get_audio_channel_param_info");
724                          break;                          break;
725                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
726                          pParamInfo = ::lscp_get_midi_port_param_info(pClient,                          if ((pParamInfo = ::lscp_get_midi_port_param_info(
727                                  device.deviceID(), iPortID, pszParam);                                          m_device.client(), m_device.deviceID(),
728                                            m_iPortID, sParam.latin1())) == NULL)
729                                    m_device.appendMessagesClient("lscp_get_midi_port_param_info");
730                          break;                          break;
731                  case qsamplerDevice::None:                  case qsamplerDevice::None:
732                          break;                          break;
733                  }                  }
734                  if (pParamInfo) {                  if (pParamInfo) {
735                          m_params[pszParam] = qsamplerDeviceParam(pParamInfo,                          m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
736                                  pPortInfo->params[i].value);                                  pPortInfo->params[i].value);
737                  }                  }
738          }          }
# Line 405  const qsamplerDeviceParamMap& qsamplerDe Line 758  const qsamplerDeviceParamMap& qsamplerDe
758    
759    
760  // Set the proper device port/channel parameter value.  // Set the proper device port/channel parameter value.
761  void qsamplerDevicePort::setParam ( const QString& sParam,  bool qsamplerDevicePort::setParam ( const QString& sParam,
762          const QString& sValue )          const QString& sValue )
763  {  {
764          m_params[sParam].value = sValue;          // Set proper port/channel parameter.
765            m_params[sParam.upper()].value = sValue;
766    
767            // If the device already exists, things get immediate...
768            int iRefresh = 0;
769            if (m_device.deviceID() >= 0 && m_iPortID >= 0) {
770                    // Prepare parameter struct.
771                    lscp_param_t param;
772                    param.key   = (char *) sParam.latin1();
773                    param.value = (char *) sValue.latin1();
774                    // Now it depends on the device type...
775                    lscp_status_t ret = LSCP_FAILED;
776                    switch (m_device.deviceType()) {
777                    case qsamplerDevice::Audio:
778                            if ((ret = ::lscp_set_audio_channel_param(m_device.client(),
779                                            m_device.deviceID(), m_iPortID, &param)) != LSCP_OK)
780                                    m_device.appendMessagesClient("lscp_set_audio_channel_param");
781                            break;
782                    case qsamplerDevice::Midi:
783                            if ((ret = ::lscp_set_midi_port_param(m_device.client(),
784                                            m_device.deviceID(), m_iPortID, &param)) != LSCP_OK)
785                                    m_device.appendMessagesClient("lscp_set_midi_port_param");
786                            break;
787                    case qsamplerDevice::None:
788                            break;
789                    }
790                    // Show result.
791                    if (ret == LSCP_OK) {
792                            m_device.appendMessages(m_sPortName
793                                    + ' ' + QString("%1: %2.").arg(sParam).arg(sValue));
794                            iRefresh++;
795                    } else {
796                            m_device.appendMessagesError(
797                                    QObject::tr("Could not set %1 parameter value.\n\n"
798                                            "Sorry.").arg(m_sPortName));
799                    }
800            }
801    
802            // Return whether we're need a view refresh.
803            return (iRefresh > 0);
804  }  }
805    
806    
# Line 418  void qsamplerDevicePort::setParam ( cons Line 810  void qsamplerDevicePort::setParam ( cons
810    
811  // Constructors.  // Constructors.
812  qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView,  qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView,
813          lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType )          qsamplerMainForm *pMainForm, qsamplerDevice::qsamplerDeviceType deviceType )
814          : QListViewItem(pListView), m_device(pClient, deviceType)          : QListViewItem(pListView), m_device(pMainForm, deviceType)
815  {  {
816          switch(m_device.deviceType()) {          switch(m_device.deviceType()) {
817          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
818                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio1.png"));                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio1.png"));
819                  QListViewItem::setText(0, QObject::tr("Audio devices"));                  QListViewItem::setText(0, QObject::tr("Audio Devices"));
820                  break;                  break;
821          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
822                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));
823                  QListViewItem::setText(0, QObject::tr("MIDI devices"));                  QListViewItem::setText(0, QObject::tr("MIDI Devices"));
824                  break;                  break;
825          case qsamplerDevice::None:          case qsamplerDevice::None:
826                  break;                  break;
# Line 436  qsamplerDeviceItem::qsamplerDeviceItem ( Line 828  qsamplerDeviceItem::qsamplerDeviceItem (
828  }  }
829    
830  qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem,  qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem,
831          lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType,          qsamplerMainForm *pMainForm, qsamplerDevice::qsamplerDeviceType deviceType,
832          int iDeviceID )          int iDeviceID )
833          : QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)          : QListViewItem(pItem), m_device(pMainForm, deviceType, iDeviceID)
834  {  {
835          switch(m_device.deviceType()) {          switch(m_device.deviceType()) {
836          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
# Line 499  qsamplerDeviceParamTable::qsamplerDevice Line 891  qsamplerDeviceParamTable::qsamplerDevice
891          // Set read-onlyness of each column          // Set read-onlyness of each column
892          QTable::setColumnReadOnly(0, true);          QTable::setColumnReadOnly(0, true);
893          QTable::setColumnReadOnly(1, true);          QTable::setColumnReadOnly(1, true);
894  //  QTable::setColumnReadOnly(2, true); -- of course not.  //  QTable::setColumnReadOnly(2, false); -- of course not.
895          QTable::setColumnStretchable(1, true);          QTable::setColumnStretchable(1, true);
896  }  }
897    
# Line 528  void qsamplerDeviceParamTable::refresh ( Line 920  void qsamplerDeviceParamTable::refresh (
920                  QTable::setText(iRow, 1, param.description);                  QTable::setText(iRow, 1, param.description);
921                  if (param.type == LSCP_TYPE_BOOL) {                  if (param.type == LSCP_TYPE_BOOL) {
922                          QStringList opts;                          QStringList opts;
923                          opts.append(tr("False"));                          opts.append(tr("false"));
924                          opts.append(tr("True"));                          opts.append(tr("true"));
925                          QComboTableItem *pComboItem = new QComboTableItem(this, opts);                          QComboTableItem *pComboItem = new QComboTableItem(this, opts);
926                          pComboItem->setCurrentItem(param.value.lower() == "true" ? 1 : 0);                          pComboItem->setCurrentItem(param.value.lower() == "true" ? 1 : 0);
927                          pComboItem->setEnabled(bEnabled);                          pComboItem->setEnabled(bEnabled);
928                          QTable::setItem(iRow, 2, pComboItem);                          QTable::setItem(iRow, 2, pComboItem);
929                  } else if (param.possibilities.count() > 0 && bEnabled) {                  } else if (param.possibilities.count() > 0 && bEnabled) {
930                          QComboTableItem *pComboItem = new QComboTableItem(this,                          QStringList opts = param.possibilities;
931                                  param.possibilities);                          if (param.multiplicity)
932                          pComboItem->setCurrentItem(param.value);                                  opts.prepend(tr("(none)"));
933                            QComboTableItem *pComboItem = new QComboTableItem(this, opts);
934                            if (param.value.isEmpty())
935                                    pComboItem->setCurrentItem(0);
936                            else
937                                    pComboItem->setCurrentItem(param.value);
938                          pComboItem->setEnabled(bEnabled);                          pComboItem->setEnabled(bEnabled);
                         pComboItem->setEditable(bEnabled && param.multiplicity);  
939                          QTable::setItem(iRow, 2, pComboItem);                          QTable::setItem(iRow, 2, pComboItem);
940                  } else if (param.type == LSCP_TYPE_INT && bEnabled                  } else if (param.type == LSCP_TYPE_INT && bEnabled
941                                  && !param.range_min.isEmpty()                                  && !param.range_min.isEmpty()
# Line 654  void qsamplerDeviceParamTableEditBox::se Line 1050  void qsamplerDeviceParamTableEditBox::se
1050    
1051    
1052  // end of qsamplerDevice.cpp  // end of qsamplerDevice.cpp
1053    
Legend:
Removed from v.462  
changed lines
  Added in v.759
  ViewVC Help
Powered by ViewVC