/[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 442 by capela, Thu Mar 10 15:48:38 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;
167                  m_sDeviceName = QObject::tr("New device");                  m_sDeviceName = QObject::tr("New %1 device").arg(m_sDeviceType);
168                  return;                  return;
169          }          }
170    
# 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.  // 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  qsamplerDeviceParamMap& qsamplerDevice::params (void)  const qsamplerDeviceParamMap& qsamplerDevice::params (void) const
367  {  {
368          return m_params;          return m_params;
369  }  }
370    
371    
372  // Update/refresh device/driver data.  // Device port/channel list accessor.
373  void qsamplerDevice::refresh (void)  qsamplerDevicePortList& qsamplerDevice::ports (void)
374    {
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            // 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    
617  // Device ids enumerator.  // Device ids enumerator.
618  int *qsamplerDevice::getDevices ( lscp_client_t *pClient,  int *qsamplerDevice::getDevices ( lscp_client_t *pClient,
619          qsamplerDeviceType deviceType )          qsamplerDeviceType deviceType )
# Line 292  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 313  QStringList qsamplerDevice::getDrivers ( Line 659  QStringList qsamplerDevice::getDrivers (
659    
660    
661  //-------------------------------------------------------------------------  //-------------------------------------------------------------------------
662    // qsamplerDevicePort - MIDI/Audio Device port/channel structure.
663    //
664    
665    // Constructor.
666    qsamplerDevicePort::qsamplerDevicePort ( qsamplerDevice& device,
667            int iPortID ) : m_device(device)
668    {
669            setDevicePort(iPortID);
670    }
671    
672    // Default destructor.
673    qsamplerDevicePort::~qsamplerDevicePort (void)
674    {
675    }
676    
677    
678    // Initializer.
679    void qsamplerDevicePort::setDevicePort ( int iPortID )
680    {
681            // Device port id should be always set.
682            m_iPortID = iPortID;
683    
684            // Reset port parameters anyway.
685            m_params.clear();
686    
687            // Retrieve device port/channel info, if any.
688            lscp_device_port_info_t *pPortInfo = NULL;
689            switch (m_device.deviceType()) {
690            case qsamplerDevice::Audio:
691                    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;
695            case qsamplerDevice::Midi:
696                    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;
700            case qsamplerDevice::None:
701                    break;
702            }
703    
704            // If we're bogus, bail out...
705            if (pPortInfo == NULL) {
706                    m_sPortName = QString::null;
707                    return;
708            }
709    
710            // Set device port/channel properties...
711            m_sPortName = pPortInfo->name;
712    
713            // Grab device port/channel parameters...
714            m_params.clear();
715            for (int i = 0; pPortInfo->params && pPortInfo->params[i].key; i++) {
716                    const QString sParam = pPortInfo->params[i].key;
717                    lscp_param_info_t *pParamInfo = NULL;
718                    switch (m_device.deviceType()) {
719                    case qsamplerDevice::Audio:
720                            if ((pParamInfo = ::lscp_get_audio_channel_param_info(
721                                            m_device.client(), m_device.deviceID(),
722                                            m_iPortID, sParam.latin1())) == NULL)
723                                    m_device.appendMessagesClient("lscp_get_audio_channel_param_info");
724                            break;
725                    case qsamplerDevice::Midi:
726                            if ((pParamInfo = ::lscp_get_midi_port_param_info(
727                                            m_device.client(), m_device.deviceID(),
728                                            m_iPortID, sParam.latin1())) == NULL)
729                                    m_device.appendMessagesClient("lscp_get_midi_port_param_info");
730                            break;
731                    case qsamplerDevice::None:
732                            break;
733                    }
734                    if (pParamInfo) {
735                            m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
736                                    pPortInfo->params[i].value);
737                    }
738            }
739    }
740    
741    
742    // Device port/channel property accessors.
743    int qsamplerDevicePort::portID (void) const
744    {
745            return m_iPortID;
746    }
747    
748    const QString& qsamplerDevicePort::portName (void) const
749    {
750            return m_sPortName;
751    }
752    
753    // Device port/channel parameter accessor.
754    const qsamplerDeviceParamMap& qsamplerDevicePort::params (void) const
755    {
756            return m_params;
757    }
758    
759    
760    // Set the proper device port/channel parameter value.
761    bool qsamplerDevicePort::setParam ( const QString& sParam,
762            const QString& sValue )
763    {
764            // 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    
807    //-------------------------------------------------------------------------
808  // qsamplerDeviceItem - QListView device item.  // qsamplerDeviceItem - QListView device item.
809  //  //
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 336  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 399  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 409  qsamplerDeviceParamTable::~qsamplerDevic Line 901  qsamplerDeviceParamTable::~qsamplerDevic
901  }  }
902    
903    
904  // The main table refresher.  // Common parameter table renderer.
905  void qsamplerDeviceParamTable::refresh ( qsamplerDevice& device )  void qsamplerDeviceParamTable::refresh ( const qsamplerDeviceParamMap& params,
906            bool bEditable )
907  {  {
908          // Always (re)start it empty.          // Always (re)start it empty.
909          QTable::setUpdatesEnabled(false);          QTable::setUpdatesEnabled(false);
910          QTable::setNumRows(0);          QTable::setNumRows(0);
911    
912          // Now fill the parameter table...          // Fill the parameter table...
         qsamplerDeviceParamMap& params = device.params();  
913          QTable::insertRows(0, params.count());          QTable::insertRows(0, params.count());
914          int iRow = 0;          int iRow = 0;
915          qsamplerDeviceParamMap::ConstIterator iter;          qsamplerDeviceParamMap::ConstIterator iter;
916          for (iter = params.begin(); iter != params.end(); ++iter) {          for (iter = params.begin(); iter != params.end(); ++iter) {
917                  const qsamplerDeviceParam& param = iter.data();                  const qsamplerDeviceParam& param = iter.data();
918                  bool bEnabled = (device.deviceID() < 0 || !param.fix);                  bool bEnabled = (bEditable || !param.fix);
919                  QTable::setText(iRow, 0, iter.key());                  QTable::setText(iRow, 0, iter.key());
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) {
# Line 431  void qsamplerDeviceParamTable::refresh ( Line 923  void qsamplerDeviceParamTable::refresh (
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) {                  } 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                      pComboItem->setEnabled(bEnabled);                          QComboTableItem *pComboItem = new QComboTableItem(this, opts);
934                      pComboItem->setEditable(bEnabled && param.multiplicity);                          if (param.value.isEmpty())
935                                    pComboItem->setCurrentItem(0);
936                            else
937                                    pComboItem->setCurrentItem(param.value);
938                            pComboItem->setEnabled(bEnabled);
939                          QTable::setItem(iRow, 2, pComboItem);                          QTable::setItem(iRow, 2, pComboItem);
940              } else if (param.type == LSCP_TYPE_INT) {                  } else if (param.type == LSCP_TYPE_INT && bEnabled
941                  qsamplerDeviceParamTableSpinBox *pSpinItem =                                  && !param.range_min.isEmpty()
942                                    && !param.range_max.isEmpty()) {
943                            qsamplerDeviceParamTableSpinBox *pSpinItem =
944                                  new qsamplerDeviceParamTableSpinBox(this,                                  new qsamplerDeviceParamTableSpinBox(this,
945                                          bEnabled ? QTableItem::OnTyping : QTableItem::Never);                                          bEnabled ? QTableItem::OnTyping : QTableItem::Never,
946                                            param.value);
947                          pSpinItem->setMinValue(param.range_min.toInt());                          pSpinItem->setMinValue(param.range_min.toInt());
948                          pSpinItem->setMaxValue(param.range_max.toInt());                          pSpinItem->setMaxValue(param.range_max.toInt());
                         pSpinItem->setValue(param.value.toInt());  
949                          QTable::setItem(iRow, 2, pSpinItem);                          QTable::setItem(iRow, 2, pSpinItem);
950                  } else {                  } else {
951              qsamplerDeviceParamTableEditBox *pEditItem =                          qsamplerDeviceParamTableEditBox *pEditItem =
952                                  new qsamplerDeviceParamTableEditBox(this,                                  new qsamplerDeviceParamTableEditBox(this,
953                                      bEnabled ? QTableItem::OnTyping : QTableItem::Never,                                          bEnabled ? QTableItem::OnTyping : QTableItem::Never,
954                                          param.value);                                          param.value);
955                          QTable::setItem(iRow, 2, pEditItem);                          QTable::setItem(iRow, 2, pEditItem);
956                  }                  }
# Line 474  void qsamplerDeviceParamTable::refresh ( Line 972  void qsamplerDeviceParamTable::refresh (
972    
973  // Constructor.  // Constructor.
974  qsamplerDeviceParamTableSpinBox::qsamplerDeviceParamTableSpinBox (  qsamplerDeviceParamTableSpinBox::qsamplerDeviceParamTableSpinBox (
975          QTable *pTable, EditType editType )          QTable *pTable, EditType editType, const QString& sText )
976          : QTableItem(pTable, editType, QString::null)          : QTableItem(pTable, editType, sText)
977  {  {
978          m_iValue = m_iMinValue = m_iMaxValue = 0;          m_iValue = sText.toInt();
979            m_iMinValue = m_iMaxValue = 0;
980  }  }
981    
982  // Public accessors.  // Public accessors.
# Line 508  QWidget *qsamplerDeviceParamTableSpinBox Line 1007  QWidget *qsamplerDeviceParamTableSpinBox
1007                  pSpinBox->setMaxValue(m_iMaxValue);                  pSpinBox->setMaxValue(m_iMaxValue);
1008          }          }
1009          pSpinBox->setValue(m_iValue);          pSpinBox->setValue(m_iValue);
 //      pSpinBox->setEnabled(QTableItem::isEnabled());  
1010          return pSpinBox;          return pSpinBox;
1011  }  }
1012    
1013  void qsamplerDeviceParamTableSpinBox::setContentFromEditor ( QWidget *pWidget )  void qsamplerDeviceParamTableSpinBox::setContentFromEditor ( QWidget *pWidget )
1014  {  {
1015          if (pWidget->inherits("QSpinBox"))          if (pWidget->inherits("QSpinBox"))
1016              QTableItem::setText(QString::number(((QSpinBox *) pWidget)->value()));                  QTableItem::setText(QString::number(((QSpinBox *) pWidget)->value()));
1017          else          else
1018              QTableItem::setContentFromEditor(pWidget);                  QTableItem::setContentFromEditor(pWidget);
1019  }  }
1020    
1021    
# Line 539  QWidget *qsamplerDeviceParamTableEditBox Line 1037  QWidget *qsamplerDeviceParamTableEditBox
1037          QObject::connect(pEditBox, SIGNAL(returnPressed()),          QObject::connect(pEditBox, SIGNAL(returnPressed()),
1038                  QTableItem::table(), SLOT(doValueChanged()));                  QTableItem::table(), SLOT(doValueChanged()));
1039          pEditBox->setText(QTableItem::text());          pEditBox->setText(QTableItem::text());
 //      pEditBox->setEnabled(QTableItem::isEnabled());  
1040          return pEditBox;          return pEditBox;
1041  }  }
1042    
1043  void qsamplerDeviceParamTableEditBox::setContentFromEditor ( QWidget *pWidget )  void qsamplerDeviceParamTableEditBox::setContentFromEditor ( QWidget *pWidget )
1044  {  {
1045          if (pWidget->inherits("QLineEdit"))          if (pWidget->inherits("QLineEdit"))
1046              QTableItem::setText(((QLineEdit *) pWidget)->text());                  QTableItem::setText(((QLineEdit *) pWidget)->text());
1047          else          else
1048              QTableItem::setContentFromEditor(pWidget);                  QTableItem::setContentFromEditor(pWidget);
1049  }  }
1050    
1051    
1052  // end of qsamplerDevice.cpp  // end of qsamplerDevice.cpp
1053    
Legend:
Removed from v.442  
changed lines
  Added in v.759
  ViewVC Help
Powered by ViewVC