/[svn]/qsampler/trunk/src/qsamplerDevice.cpp
ViewVC logotype

Diff of /qsampler/trunk/src/qsamplerDevice.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 471 by capela, Thu Mar 17 00:14:41 2005 UTC revision 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            m_pMainForm = pMainForm;
110    
111          m_ports.setAutoDelete(true);          m_ports.setAutoDelete(true);
112            
113          setDevice(pClient, deviceType, iDeviceID);          setDevice(deviceType, iDeviceID);
114  }  }
115    
116  // Default destructor.  // Default destructor.
# Line 117  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.          // Reset device parameters and ports anyway.
142          m_params.clear();          m_params.clear();
143          m_ports.clear();          m_ports.clear();
# Line 135  void qsamplerDevice::setDevice ( lscp_cl Line 147  void qsamplerDevice::setDevice ( lscp_cl
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 164  void qsamplerDevice::setDevice ( lscp_cl Line 179  void qsamplerDevice::setDevice ( lscp_cl
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(), sParam.latin1(), 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(), sParam.latin1(), 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;
# Line 181  void qsamplerDevice::setDevice ( lscp_cl Line 198  void qsamplerDevice::setDevice ( lscp_cl
198          }          }
199    
200          // Refresh parameter dependencies...          // Refresh parameter dependencies...
201          refreshParams(pClient);          refreshParams();
202          // Set port/channel list...          // Set port/channel list...
203          refreshPorts(pClient);          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)
# Line 203  void qsamplerDevice::setDriver ( lscp_cl Line 219  void qsamplerDevice::setDriver ( lscp_cl
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 227  void qsamplerDevice::setDriver ( lscp_cl Line 245  void qsamplerDevice::setDriver ( lscp_cl
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(), sParam.latin1(), 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(), sParam.latin1(), 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;
# Line 244  void qsamplerDevice::setDriver ( lscp_cl Line 264  void qsamplerDevice::setDriver ( lscp_cl
264          }          }
265    
266          // Refresh parameter dependencies...          // Refresh parameter dependencies...
267          refreshParams(pClient);          refreshParams();
268          // Set port/channel list...          // Set port/channel list...
269          refreshPorts(pClient);          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 271  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.  // Set the proper device parameter value.
315  void qsamplerDevice::setParam ( const QString& sParam,  bool qsamplerDevice::setParam ( const QString& sParam,
316          const QString& sValue )          const QString& sValue )
317  {  {
318            // Set proper device parameter.
319          m_params[sParam.upper()].value = sValue;          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    
# Line 299  qsamplerDevicePortList& qsamplerDevice:: Line 376  qsamplerDevicePortList& qsamplerDevice::
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.  // Device parameter dependencies refreshner.
465  int qsamplerDevice::refreshParams ( lscp_client_t *pClient )  int qsamplerDevice::refreshParams (void)
466  {  {
467          // This should only make sense for scratch devices...          // This should only make sense for scratch devices...
468          if (m_iDeviceID >= 0)          if (m_iDeviceID >= 0)
# Line 309  int qsamplerDevice::refreshParams ( lscp Line 471  int qsamplerDevice::refreshParams ( lscp
471          int iParams = 0;          int iParams = 0;
472          qsamplerDeviceParamMap::ConstIterator iter;          qsamplerDeviceParamMap::ConstIterator iter;
473          for (iter = m_params.begin(); iter != m_params.end(); ++iter)          for (iter = m_params.begin(); iter != m_params.end(); ++iter)
474                  iParams += refreshParam(pClient, iter.key());                  iParams += refreshParam(iter.key());
475          // Return how many parameters have been refreshed...          // Return how many parameters have been refreshed...
476          return iParams;          return iParams;
477  }  }
478    
479    
480  // Device port/channel list refreshner.  // Device port/channel list refreshner.
481  int qsamplerDevice::refreshPorts ( lscp_client_t *pClient )  int qsamplerDevice::refreshPorts (void)
482  {  {
483          // This should only make sense for actual devices...          // This should only make sense for actual devices...
484          if (m_iDeviceID < 0)          if (m_iDeviceID < 0)
# Line 336  int qsamplerDevice::refreshPorts ( lscp_ Line 498  int qsamplerDevice::refreshPorts ( lscp_
498          // Retrieve port/channel information...          // Retrieve port/channel information...
499          m_ports.clear();          m_ports.clear();
500          for (int iPort = 0; iPort < iPorts; iPort++)          for (int iPort = 0; iPort < iPorts; iPort++)
501                  m_ports.append(new qsamplerDevicePort(pClient, *this, iPort));                  m_ports.append(new qsamplerDevicePort(*this, iPort));
502          // Return how many ports have been refreshed...          // Return how many ports have been refreshed...
503          return iPorts;          return iPorts;
504  }  }
505    
506    
507  // Refresh/set dependencies given that some parameter has changed.  // Refresh/set dependencies given that some parameter has changed.
508  int qsamplerDevice::refreshDepends ( lscp_client_t *pClient,  int qsamplerDevice::refreshDepends ( const QString& sParam )
         const QString& sParam )  
509  {  {
510          // This should only make sense for scratch devices...          // This should only make sense for scratch devices...
511          if (m_iDeviceID >= 0)          if (m_iDeviceID >= 0)
# Line 355  int qsamplerDevice::refreshDepends ( lsc Line 516  int qsamplerDevice::refreshDepends ( lsc
516          for (iter = m_params.begin(); iter != m_params.end(); ++iter) {          for (iter = m_params.begin(); iter != m_params.end(); ++iter) {
517                  const QStringList& depends = iter.data().depends;                  const QStringList& depends = iter.data().depends;
518                  if (depends.find(sParam) != depends.end())                  if (depends.find(sParam) != depends.end())
519                          iDepends += refreshParam(pClient, iter.key());                          iDepends += refreshParam(iter.key());
520          }          }
521          // Return how many dependencies have been refreshed...          // Return how many dependencies have been refreshed...
522          return iDepends;          return iDepends;
# Line 363  int qsamplerDevice::refreshDepends ( lsc Line 524  int qsamplerDevice::refreshDepends ( lsc
524    
525    
526  // Refresh/set given parameter based on driver supplied dependencies.  // Refresh/set given parameter based on driver supplied dependencies.
527  int qsamplerDevice::refreshParam ( lscp_client_t *pClient,  int qsamplerDevice::refreshParam ( const QString& sParam )
         const QString& sParam )  
528  {  {
529          // Check if we have dependencies...          // Check if we have dependencies...
530          qsamplerDeviceParam& param = m_params[sParam.upper()];          qsamplerDeviceParam& param = m_params[sParam.upper()];
# Line 396  int qsamplerDevice::refreshParam ( lscp_ Line 556  int qsamplerDevice::refreshParam ( lscp_
556          lscp_param_info_t *pParamInfo = NULL;          lscp_param_info_t *pParamInfo = NULL;
557          switch (m_deviceType) {          switch (m_deviceType) {
558          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
559                  pParamInfo = ::lscp_get_audio_driver_param_info(pClient,                  if ((pParamInfo = ::lscp_get_audio_driver_param_info(client(),
560                          m_sDriverName.latin1(), sParam.latin1(), pDepends);                                  m_sDriverName.latin1(), sParam.latin1(), pDepends)) == NULL)
561                            appendMessagesClient("lscp_get_audio_driver_param_info");
562                  break;                  break;
563          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
564                  pParamInfo = ::lscp_get_midi_driver_param_info(pClient,                  if ((pParamInfo = ::lscp_get_midi_driver_param_info(client(),
565                          m_sDriverName.latin1(), sParam.latin1(), pDepends);                                  m_sDriverName.latin1(), sParam.latin1(), pDepends)) == NULL)
566                            appendMessagesClient("lscp_get_midi_driver_param_info");
567                  break;                  break;
568          case qsamplerDevice::None:          case qsamplerDevice::None:
569                  break;                  break;
# Line 419  int qsamplerDevice::refreshParam ( lscp_ Line 581  int qsamplerDevice::refreshParam ( lscp_
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 443  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 468  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 481  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;
# Line 492  void qsamplerDevicePort::setDevicePort ( Line 686  void qsamplerDevicePort::setDevicePort (
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 510  void qsamplerDevicePort::setDevicePort ( Line 708  void qsamplerDevicePort::setDevicePort (
708          }          }
709    
710          // Set device port/channel properties...          // Set device port/channel properties...
711          m_sPortName += device.driverName() + ' ' + pPortInfo->name;          m_sPortName = pPortInfo->name;
712    
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 QString sParam = 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, sParam.latin1());                                          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, sParam.latin1());                                          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;
# Line 556  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            // Set proper port/channel parameter.
765          m_params[sParam.upper()].value = sValue;          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 569  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:
# Line 587  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 686  void qsamplerDeviceParamTable::refresh ( Line 927  void qsamplerDeviceParamTable::refresh (
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 805  void qsamplerDeviceParamTableEditBox::se Line 1050  void qsamplerDeviceParamTableEditBox::se
1050    
1051    
1052  // end of qsamplerDevice.cpp  // end of qsamplerDevice.cpp
1053    
Legend:
Removed from v.471  
changed lines
  Added in v.759
  ViewVC Help
Powered by ViewVC