/[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 980 by capela, Sun Dec 17 22:29:29 2006 UTC
# Line 1  Line 1 
1  // qsamplerDevice.cpp  // qsamplerDevice.cpp
2  //  //
3  /****************************************************************************  /****************************************************************************
4     Copyright (C) 2005, rncbc aka Rui Nuno Capela. All rights reserved.     Copyright (C) 2004-2006, rncbc aka Rui Nuno Capela. All rights reserved.
5    
6     This program is free software; you can redistribute it and/or     This program is free software; you can redistribute it and/or
7     modify it under the terms of the GNU General Public License     modify it under the terms of the GNU General Public License
# Line 13  Line 13 
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.     GNU General Public License for more details.
15    
16     You should have received a copy of the GNU General Public License     You should have received a copy of the GNU General Public License along
17     along with this program; if not, write to the Free Software     with this program; if not, write to the Free Software Foundation, Inc.,
18     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
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 ( qsamplerDeviceType deviceType, int iDeviceID )
         qsamplerDeviceType deviceType, int iDeviceID )  
107  {  {
108          m_ports.setAutoDelete(true);          m_ports.setAutoDelete(true);
109            
110          setDevice(pClient, deviceType, iDeviceID);          setDevice(deviceType, iDeviceID);
111  }  }
112    
113  // Default destructor.  // Default destructor.
# Line 117  qsamplerDevice::~qsamplerDevice (void) Line 115  qsamplerDevice::~qsamplerDevice (void)
115  {  {
116  }  }
117    
118    // Copy constructor.
119    qsamplerDevice::qsamplerDevice ( const qsamplerDevice& device )
120            : m_params(device.m_params), m_ports(m_ports)
121    {
122            m_iDeviceID   = device.m_iDeviceID;
123            m_deviceType  = device.m_deviceType;
124            m_sDeviceType = device.m_sDeviceType;
125            m_sDriverName = device.m_sDriverName;
126            m_sDeviceName = device.m_sDeviceName;
127    }
128    
129    
130  // Initializer.  // Initializer.
131  void qsamplerDevice::setDevice ( lscp_client_t *pClient,  void qsamplerDevice::setDevice ( qsamplerDeviceType deviceType, int iDeviceID )
         qsamplerDeviceType deviceType, int iDeviceID )  
132  {  {
133            qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
134            if (pMainForm == NULL)
135                    return;
136            if (pMainForm->client() == NULL)
137                    return;
138    
139          // Device id and type should be always set.          // Device id and type should be always set.
140          m_iDeviceID  = iDeviceID;          m_iDeviceID  = iDeviceID;
141          m_deviceType = deviceType;          m_deviceType = deviceType;
142            
143          // Reset device parameters and ports anyway.          // Reset device parameters and ports anyway.
144          m_params.clear();          m_params.clear();
145          m_ports.clear();          m_ports.clear();
# Line 135  void qsamplerDevice::setDevice ( lscp_cl Line 149  void qsamplerDevice::setDevice ( lscp_cl
149          switch (deviceType) {          switch (deviceType) {
150          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
151                  m_sDeviceType = QObject::tr("Audio");                  m_sDeviceType = QObject::tr("Audio");
152                  pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);                  if (m_iDeviceID >= 0 && (pDeviceInfo = ::lscp_get_audio_device_info(
153                                    pMainForm->client(), m_iDeviceID)) == NULL)
154                            appendMessagesClient("lscp_get_audio_device_info");
155                  break;                  break;
156          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
157                  m_sDeviceType = QObject::tr("MIDI");                  m_sDeviceType = QObject::tr("MIDI");
158                  pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);                  if (m_iDeviceID >= 0 && (pDeviceInfo = ::lscp_get_midi_device_info(
159                                    pMainForm->client(), m_iDeviceID)) == NULL)
160                            appendMessagesClient("lscp_get_midi_device_info");
161                  break;                  break;
162          case qsamplerDevice::None:          case qsamplerDevice::None:
163                  m_sDeviceType = QString::null;                  m_sDeviceType = QString::null;
164                  break;                  break;
165          }          }
   
166          // If we're bogus, bail out...          // If we're bogus, bail out...
167          if (pDeviceInfo == NULL) {          if (pDeviceInfo == NULL) {
168                  m_sDriverName = QString::null;                  m_sDriverName = QString::null;
# Line 164  void qsamplerDevice::setDevice ( lscp_cl Line 181  void qsamplerDevice::setDevice ( lscp_cl
181                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
182                  switch (deviceType) {                  switch (deviceType) {
183                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
184                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,                          if ((pParamInfo = ::lscp_get_audio_driver_param_info(pMainForm->client(),
185                                  m_sDriverName.latin1(), sParam.latin1(), NULL);                                          m_sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
186                                    appendMessagesClient("lscp_get_audio_driver_param_info");
187                          break;                          break;
188                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
189                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,                          if ((pParamInfo = ::lscp_get_midi_driver_param_info(pMainForm->client(),
190                                  m_sDriverName.latin1(), sParam.latin1(), NULL);                                          m_sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
191                                    appendMessagesClient("lscp_get_midi_driver_param_info");
192                          break;                          break;
193                  case qsamplerDevice::None:                  case qsamplerDevice::None:
194                          break;                          break;
# Line 181  void qsamplerDevice::setDevice ( lscp_cl Line 200  void qsamplerDevice::setDevice ( lscp_cl
200          }          }
201    
202          // Refresh parameter dependencies...          // Refresh parameter dependencies...
203          refreshParams(pClient);          refreshParams();
204          // Set port/channel list...          // Set port/channel list...
205          refreshPorts(pClient);          refreshPorts();
206  }  }
207    
208    
209  // Driver name initializer/settler.  // Driver name initializer/settler.
210  void qsamplerDevice::setDriver ( lscp_client_t *pClient,  void qsamplerDevice::setDriver ( const QString& sDriverName )
         const QString& sDriverName )  
211  {  {
212            qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
213            if (pMainForm == NULL)
214                    return;
215            if (pMainForm->client() == NULL)
216                    return;
217    
218          // Valid only for scratch devices.          // Valid only for scratch devices.
219          if (m_sDriverName == sDriverName)          if (m_sDriverName == sDriverName)
220                  return;                  return;
# Line 203  void qsamplerDevice::setDriver ( lscp_cl Line 227  void qsamplerDevice::setDriver ( lscp_cl
227          lscp_driver_info_t *pDriverInfo = NULL;          lscp_driver_info_t *pDriverInfo = NULL;
228          switch (m_deviceType) {          switch (m_deviceType) {
229          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
230                  pDriverInfo = ::lscp_get_audio_driver_info(pClient,                  if ((pDriverInfo = ::lscp_get_audio_driver_info(pMainForm->client(),
231                          sDriverName.latin1());                                  sDriverName.latin1())) == NULL)
232                            appendMessagesClient("lscp_get_audio_driver_info");
233                  break;                  break;
234          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
235                  pDriverInfo = ::lscp_get_midi_driver_info(pClient,                  if ((pDriverInfo = ::lscp_get_midi_driver_info(pMainForm->client(),
236                          sDriverName.latin1());                                  sDriverName.latin1())) == NULL)
237                            appendMessagesClient("lscp_get_midi_driver_info");
238                  break;                  break;
239          case qsamplerDevice::None:          case qsamplerDevice::None:
240                  break;                  break;
# Line 227  void qsamplerDevice::setDriver ( lscp_cl Line 253  void qsamplerDevice::setDriver ( lscp_cl
253                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
254                  switch (m_deviceType) {                  switch (m_deviceType) {
255                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
256                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,                          if ((pParamInfo = ::lscp_get_audio_driver_param_info(pMainForm->client(),
257                                  sDriverName.latin1(), sParam.latin1(), NULL);                                          sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
258                                    appendMessagesClient("lscp_get_audio_driver_param_info");
259                          break;                          break;
260                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
261                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,                          if ((pParamInfo = ::lscp_get_midi_driver_param_info(pMainForm->client(),
262                                  sDriverName.latin1(), sParam.latin1(), NULL);                                          sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
263                                    appendMessagesClient("lscp_get_midi_driver_param_info");
264                          break;                          break;
265                  case qsamplerDevice::None:                  case qsamplerDevice::None:
266                          break;                          break;
# Line 244  void qsamplerDevice::setDriver ( lscp_cl Line 272  void qsamplerDevice::setDriver ( lscp_cl
272          }          }
273    
274          // Refresh parameter dependencies...          // Refresh parameter dependencies...
275          refreshParams(pClient);          refreshParams();
276          // Set port/channel list...          // Set port/channel list...
277          refreshPorts(pClient);          refreshPorts();
278  }  }
279    
280    
# Line 271  const QString& qsamplerDevice::driverNam Line 299  const QString& qsamplerDevice::driverNam
299          return m_sDriverName;          return m_sDriverName;
300  }  }
301    
302  const QString& qsamplerDevice::deviceName (void) const  // Special device name formatter.
303    QString qsamplerDevice::deviceName (void) const
304  {  {
305          return m_sDeviceName;          QString sPrefix;
306            if (m_iDeviceID >= 0)
307                sPrefix += m_sDeviceType + ' ';
308            return sPrefix + m_sDeviceName;
309  }  }
310    
311    
312  // Set the proper device parameter value.  // Set the proper device parameter value.
313  void qsamplerDevice::setParam ( const QString& sParam,  bool qsamplerDevice::setParam ( const QString& sParam,
314          const QString& sValue )          const QString& sValue )
315  {  {
316            qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
317            if (pMainForm == NULL)
318                    return false;
319            if (pMainForm->client() == NULL)
320                    return false;
321    
322            // Set proper device parameter.
323          m_params[sParam.upper()].value = sValue;          m_params[sParam.upper()].value = sValue;
324    
325            // If the device already exists, things get immediate...
326            int iRefresh = 0;
327            if (m_iDeviceID >= 0) {
328                    // Prepare parameter struct.
329                    lscp_param_t param;
330                    param.key   = (char *) sParam.latin1();
331                    param.value = (char *) sValue.latin1();
332                    // Now it depends on the device type...
333                    lscp_status_t ret = LSCP_FAILED;
334                    switch (m_deviceType) {
335                    case qsamplerDevice::Audio:
336                        if (sParam == "CHANNELS") iRefresh++;
337                            if ((ret = ::lscp_set_audio_device_param(pMainForm->client(),
338                                            m_iDeviceID, &param)) != LSCP_OK)
339                                    appendMessagesClient("lscp_set_audio_device_param");
340                            break;
341                    case qsamplerDevice::Midi:
342                        if (sParam == "PORTS") iRefresh++;
343                            if ((ret = ::lscp_set_midi_device_param(pMainForm->client(),
344                                            m_iDeviceID, &param)) != LSCP_OK)
345                                    appendMessagesClient("lscp_set_midi_device_param");
346                            break;
347                    case qsamplerDevice::None:
348                            break;
349                    }
350                    // Show result.
351                    if (ret == LSCP_OK) {
352                            appendMessages(QString("%1: %2.").arg(sParam).arg(sValue));
353                            // Special care for specific parameter changes...
354                            if (iRefresh > 0)
355                                    iRefresh += refreshPorts();
356                            iRefresh += refreshDepends(sParam);
357                    } else {
358                            // Oops...
359                            appendMessagesError(
360                                    QObject::tr("Could not set device parameter value.\n\nSorry."));
361                    }
362            }
363    
364            // Return whether we're need a view refresh.
365            return (iRefresh > 0);
366  }  }
367    
368    
# Line 299  qsamplerDevicePortList& qsamplerDevice:: Line 380  qsamplerDevicePortList& qsamplerDevice::
380  }  }
381    
382    
383    // Create a new device, as a copy of this current one.
384    bool qsamplerDevice::createDevice (void)
385    {
386            qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
387            if (pMainForm == NULL)
388                    return false;
389            if (pMainForm->client() == NULL)
390                    return false;
391    
392            // Build the parameter list...
393            lscp_param_t *pParams = new lscp_param_t [m_params.count() + 1];
394            int iParam = 0;
395            qsamplerDeviceParamMap::ConstIterator iter;
396            for (iter = m_params.begin(); iter != m_params.end(); ++iter) {
397                    pParams[iParam].key   = (char *) iter.key().latin1();
398                    pParams[iParam].value = (char *) iter.data().value.latin1();
399                    ++iParam;
400            }
401            // Null terminated.
402            pParams[iParam].key   = NULL;
403            pParams[iParam].value = NULL;
404    
405            // Now it depends on the device type...
406            switch (m_deviceType) {
407            case qsamplerDevice::Audio:
408                    if ((m_iDeviceID = ::lscp_create_audio_device(pMainForm->client(),
409                                    m_sDriverName.latin1(), pParams)) < 0)
410                            appendMessagesClient("lscp_create_audio_device");
411                    break;
412            case qsamplerDevice::Midi:
413                    if ((m_iDeviceID = ::lscp_create_midi_device(pMainForm->client(),
414                                    m_sDriverName.latin1(), pParams)) < 0)
415                            appendMessagesClient("lscp_create_midi_device");
416                    break;
417            case qsamplerDevice::None:
418                    break;
419            }
420    
421            // Free used parameter array.
422            delete pParams;
423    
424            // Show result.
425            if (m_iDeviceID >= 0) {
426                    // Refresh our own stuff...
427                    setDevice(m_deviceType, m_iDeviceID);
428                    appendMessages(QObject::tr("created."));
429            } else {
430                    appendMessagesError(QObject::tr("Could not create device.\n\nSorry."));
431            }
432    
433            // Return whether we're a valid device...
434            return (m_iDeviceID >= 0);
435    }
436    
437    
438    // Destroy existing device.
439    bool qsamplerDevice::deleteDevice (void)
440    {
441            qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
442            if (pMainForm == NULL)
443                    return false;
444            if (pMainForm->client() == NULL)
445                    return false;
446    
447            // Now it depends on the device type...
448            lscp_status_t ret = LSCP_FAILED;
449            switch (m_deviceType) {
450            case qsamplerDevice::Audio:
451                    if ((ret = ::lscp_destroy_audio_device(pMainForm->client(),
452                                    m_iDeviceID)) != LSCP_OK)
453                            appendMessagesClient("lscp_destroy_audio_device");
454                    break;
455            case qsamplerDevice::Midi:
456                    if ((ret = ::lscp_destroy_midi_device(pMainForm->client(),
457                                    m_iDeviceID)) != LSCP_OK)
458                            appendMessagesClient("lscp_destroy_midi_device");
459                    break;
460            case qsamplerDevice::None:
461                    break;
462            }
463    
464            // Show result.
465            if (ret == LSCP_OK) {
466                    appendMessages(QObject::tr("deleted."));
467                    m_iDeviceID = -1;
468            } else {
469                    appendMessagesError(QObject::tr("Could not delete device.\n\nSorry."));
470            }
471    
472            // Return whether we've done it..
473            return (ret == LSCP_OK);
474    }
475    
476    
477  // Device parameter dependencies refreshner.  // Device parameter dependencies refreshner.
478  int qsamplerDevice::refreshParams ( lscp_client_t *pClient )  int qsamplerDevice::refreshParams (void)
479  {  {
480          // This should only make sense for scratch devices...          // This should only make sense for scratch devices...
481          if (m_iDeviceID >= 0)          if (m_iDeviceID >= 0)
# Line 309  int qsamplerDevice::refreshParams ( lscp Line 484  int qsamplerDevice::refreshParams ( lscp
484          int iParams = 0;          int iParams = 0;
485          qsamplerDeviceParamMap::ConstIterator iter;          qsamplerDeviceParamMap::ConstIterator iter;
486          for (iter = m_params.begin(); iter != m_params.end(); ++iter)          for (iter = m_params.begin(); iter != m_params.end(); ++iter)
487                  iParams += refreshParam(pClient, iter.key());                  iParams += refreshParam(iter.key());
488          // Return how many parameters have been refreshed...          // Return how many parameters have been refreshed...
489          return iParams;          return iParams;
490  }  }
491    
492    
493  // Device port/channel list refreshner.  // Device port/channel list refreshner.
494  int qsamplerDevice::refreshPorts ( lscp_client_t *pClient )  int qsamplerDevice::refreshPorts (void)
495  {  {
496          // This should only make sense for actual devices...          // This should only make sense for actual devices...
497          if (m_iDeviceID < 0)          if (m_iDeviceID < 0)
# Line 336  int qsamplerDevice::refreshPorts ( lscp_ Line 511  int qsamplerDevice::refreshPorts ( lscp_
511          // Retrieve port/channel information...          // Retrieve port/channel information...
512          m_ports.clear();          m_ports.clear();
513          for (int iPort = 0; iPort < iPorts; iPort++)          for (int iPort = 0; iPort < iPorts; iPort++)
514                  m_ports.append(new qsamplerDevicePort(pClient, *this, iPort));                  m_ports.append(new qsamplerDevicePort(*this, iPort));
515          // Return how many ports have been refreshed...          // Return how many ports have been refreshed...
516          return iPorts;          return iPorts;
517  }  }
518    
519    
520  // Refresh/set dependencies given that some parameter has changed.  // Refresh/set dependencies given that some parameter has changed.
521  int qsamplerDevice::refreshDepends ( lscp_client_t *pClient,  int qsamplerDevice::refreshDepends ( const QString& sParam )
         const QString& sParam )  
522  {  {
523          // This should only make sense for scratch devices...          // This should only make sense for scratch devices...
524          if (m_iDeviceID >= 0)          if (m_iDeviceID >= 0)
# Line 355  int qsamplerDevice::refreshDepends ( lsc Line 529  int qsamplerDevice::refreshDepends ( lsc
529          for (iter = m_params.begin(); iter != m_params.end(); ++iter) {          for (iter = m_params.begin(); iter != m_params.end(); ++iter) {
530                  const QStringList& depends = iter.data().depends;                  const QStringList& depends = iter.data().depends;
531                  if (depends.find(sParam) != depends.end())                  if (depends.find(sParam) != depends.end())
532                          iDepends += refreshParam(pClient, iter.key());                          iDepends += refreshParam(iter.key());
533          }          }
534          // Return how many dependencies have been refreshed...          // Return how many dependencies have been refreshed...
535          return iDepends;          return iDepends;
# Line 363  int qsamplerDevice::refreshDepends ( lsc Line 537  int qsamplerDevice::refreshDepends ( lsc
537    
538    
539  // Refresh/set given parameter based on driver supplied dependencies.  // Refresh/set given parameter based on driver supplied dependencies.
540  int qsamplerDevice::refreshParam ( lscp_client_t *pClient,  int qsamplerDevice::refreshParam ( const QString& sParam )
         const QString& sParam )  
541  {  {
542            qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
543            if (pMainForm == NULL)
544                    return 0;
545            if (pMainForm->client() == NULL)
546                    return 0;
547    
548          // Check if we have dependencies...          // Check if we have dependencies...
549          qsamplerDeviceParam& param = m_params[sParam.upper()];          qsamplerDeviceParam& param = m_params[sParam.upper()];
550          if (param.depends.isEmpty())          if (param.depends.isEmpty())
# Line 396  int qsamplerDevice::refreshParam ( lscp_ Line 575  int qsamplerDevice::refreshParam ( lscp_
575          lscp_param_info_t *pParamInfo = NULL;          lscp_param_info_t *pParamInfo = NULL;
576          switch (m_deviceType) {          switch (m_deviceType) {
577          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
578                  pParamInfo = ::lscp_get_audio_driver_param_info(pClient,                  if ((pParamInfo = ::lscp_get_audio_driver_param_info(pMainForm->client(),
579                          m_sDriverName.latin1(), sParam.latin1(), pDepends);                                  m_sDriverName.latin1(), sParam.latin1(), pDepends)) == NULL)
580                            appendMessagesClient("lscp_get_audio_driver_param_info");
581                  break;                  break;
582          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
583                  pParamInfo = ::lscp_get_midi_driver_param_info(pClient,                  if ((pParamInfo = ::lscp_get_midi_driver_param_info(pMainForm->client(),
584                          m_sDriverName.latin1(), sParam.latin1(), pDepends);                                  m_sDriverName.latin1(), sParam.latin1(), pDepends)) == NULL)
585                            appendMessagesClient("lscp_get_midi_driver_param_info");
586                  break;                  break;
587          case qsamplerDevice::None:          case qsamplerDevice::None:
588                  break;                  break;
# Line 419  int qsamplerDevice::refreshParam ( lscp_ Line 600  int qsamplerDevice::refreshParam ( lscp_
600  }  }
601    
602    
603    // Redirected messages output methods.
604    void qsamplerDevice::appendMessages( const QString& s ) const
605    {
606            qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
607            if (pMainForm)
608                    pMainForm->appendMessages(deviceName() + ' ' + s);
609    }
610    
611    void qsamplerDevice::appendMessagesColor( const QString& s,
612            const QString& c ) const
613    {
614            qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
615            if (pMainForm)
616                    pMainForm->appendMessagesColor(deviceName() + ' ' + s, c);
617    }
618    
619    void qsamplerDevice::appendMessagesText( const QString& s ) const
620    {
621            qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
622            if (pMainForm)
623                    pMainForm->appendMessagesText(deviceName() + ' ' + s);
624    }
625    
626    void qsamplerDevice::appendMessagesError( const QString& s ) const
627    {
628            qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
629            if (pMainForm)
630                    pMainForm->appendMessagesError(deviceName() + "\n\n" + s);
631    }
632    
633    void qsamplerDevice::appendMessagesClient( const QString& s ) const
634    {
635            qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
636            if (pMainForm)
637                    pMainForm->appendMessagesClient(deviceName() + ' ' + s);
638    }
639    
640    
641  // Device ids enumerator.  // Device ids enumerator.
642  int *qsamplerDevice::getDevices ( lscp_client_t *pClient,  int *qsamplerDevice::getDevices ( lscp_client_t *pClient,
643          qsamplerDeviceType deviceType )          qsamplerDeviceType deviceType )
# Line 443  QStringList qsamplerDevice::getDrivers ( Line 662  QStringList qsamplerDevice::getDrivers (
662          qsamplerDeviceType deviceType )          qsamplerDeviceType deviceType )
663  {  {
664          QStringList drivers;          QStringList drivers;
665            
666          const char **ppszDrivers = NULL;          const char **ppszDrivers = NULL;
667          switch (deviceType) {          switch (deviceType) {
668          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
669                  ppszDrivers = ::lscp_get_available_audio_drivers(pClient);                  ppszDrivers = ::lscp_list_available_audio_drivers(pClient);
670                  break;                  break;
671          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
672                  ppszDrivers = ::lscp_get_available_midi_drivers(pClient);                  ppszDrivers = ::lscp_list_available_midi_drivers(pClient);
673                  break;                  break;
674          case qsamplerDevice::None:          case qsamplerDevice::None:
675                  break;                  break;
676          }          }
677            
678          for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)          for (int iDriver = 0; ppszDrivers && ppszDrivers[iDriver]; iDriver++)
679                  drivers.append(ppszDrivers[iDriver]);                  drivers.append(ppszDrivers[iDriver]);
680    
681          return drivers;          return drivers;
# Line 468  QStringList qsamplerDevice::getDrivers ( Line 687  QStringList qsamplerDevice::getDrivers (
687  //  //
688    
689  // Constructor.  // Constructor.
690  qsamplerDevicePort::qsamplerDevicePort ( lscp_client_t *pClient,  qsamplerDevicePort::qsamplerDevicePort ( qsamplerDevice& device,
691          const qsamplerDevice& device, int iPortID )          int iPortID ) : m_device(device)
692  {  {
693          setDevicePort(pClient, device, iPortID);          setDevicePort(iPortID);
694  }  }
695    
696  // Default destructor.  // Default destructor.
# Line 481  qsamplerDevicePort::~qsamplerDevicePort Line 700  qsamplerDevicePort::~qsamplerDevicePort
700    
701    
702  // Initializer.  // Initializer.
703  void qsamplerDevicePort::setDevicePort ( lscp_client_t *pClient,  void qsamplerDevicePort::setDevicePort ( int iPortID )
         const qsamplerDevice& device, int iPortID )  
704  {  {
705            qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
706            if (pMainForm == NULL)
707                    return;
708            if (pMainForm->client() == NULL)
709                    return;
710    
711          // Device port id should be always set.          // Device port id should be always set.
712          m_iPortID = iPortID;          m_iPortID = iPortID;
713    
# Line 492  void qsamplerDevicePort::setDevicePort ( Line 716  void qsamplerDevicePort::setDevicePort (
716    
717          // Retrieve device port/channel info, if any.          // Retrieve device port/channel info, if any.
718          lscp_device_port_info_t *pPortInfo = NULL;          lscp_device_port_info_t *pPortInfo = NULL;
719          switch (device.deviceType()) {          switch (m_device.deviceType()) {
720          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
721                  pPortInfo = ::lscp_get_audio_channel_info(pClient, device.deviceID(), iPortID);                  if ((pPortInfo = ::lscp_get_audio_channel_info(pMainForm->client(),
722                                    m_device.deviceID(), m_iPortID)) == NULL)
723                            m_device.appendMessagesClient("lscp_get_audio_channel_info");
724                  break;                  break;
725          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
726                  pPortInfo = ::lscp_get_midi_port_info(pClient, device.deviceID(), iPortID);                  if ((pPortInfo = ::lscp_get_midi_port_info(pMainForm->client(),
727                                    m_device.deviceID(), m_iPortID)) == NULL)
728                            m_device.appendMessagesClient("lscp_get_midi_port_info");
729                  break;                  break;
730          case qsamplerDevice::None:          case qsamplerDevice::None:
731                  break;                  break;
# Line 510  void qsamplerDevicePort::setDevicePort ( Line 738  void qsamplerDevicePort::setDevicePort (
738          }          }
739    
740          // Set device port/channel properties...          // Set device port/channel properties...
741          m_sPortName += device.driverName() + ' ' + pPortInfo->name;          m_sPortName = pPortInfo->name;
742    
743          // Grab device port/channel parameters...          // Grab device port/channel parameters...
744          m_params.clear();          m_params.clear();
745          for (int i = 0; pPortInfo->params && pPortInfo->params[i].key; i++) {          for (int i = 0; pPortInfo->params && pPortInfo->params[i].key; i++) {
746                  const QString sParam = pPortInfo->params[i].key;                  const QString sParam = pPortInfo->params[i].key;
747                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
748                  switch (device.deviceType()) {                  switch (m_device.deviceType()) {
749                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
750                          pParamInfo = ::lscp_get_audio_channel_param_info(pClient,                          if ((pParamInfo = ::lscp_get_audio_channel_param_info(
751                                  device.deviceID(), iPortID, sParam.latin1());                                          pMainForm->client(), m_device.deviceID(),
752                                            m_iPortID, sParam.latin1())) == NULL)
753                                    m_device.appendMessagesClient("lscp_get_audio_channel_param_info");
754                          break;                          break;
755                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
756                          pParamInfo = ::lscp_get_midi_port_param_info(pClient,                          if ((pParamInfo = ::lscp_get_midi_port_param_info(
757                                  device.deviceID(), iPortID, sParam.latin1());                                          pMainForm->client(), m_device.deviceID(),
758                                            m_iPortID, sParam.latin1())) == NULL)
759                                    m_device.appendMessagesClient("lscp_get_midi_port_param_info");
760                          break;                          break;
761                  case qsamplerDevice::None:                  case qsamplerDevice::None:
762                          break;                          break;
# Line 556  const qsamplerDeviceParamMap& qsamplerDe Line 788  const qsamplerDeviceParamMap& qsamplerDe
788    
789    
790  // Set the proper device port/channel parameter value.  // Set the proper device port/channel parameter value.
791  void qsamplerDevicePort::setParam ( const QString& sParam,  bool qsamplerDevicePort::setParam ( const QString& sParam,
792          const QString& sValue )          const QString& sValue )
793  {  {
794            qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
795            if (pMainForm == NULL)
796                    return false;
797            if (pMainForm->client() == NULL)
798                    return false;
799    
800            // Set proper port/channel parameter.
801          m_params[sParam.upper()].value = sValue;          m_params[sParam.upper()].value = sValue;
802    
803            // If the device already exists, things get immediate...
804            int iRefresh = 0;
805            if (m_device.deviceID() >= 0 && m_iPortID >= 0) {
806                    // Prepare parameter struct.
807                    lscp_param_t param;
808                    param.key   = (char *) sParam.latin1();
809                    param.value = (char *) sValue.latin1();
810                    // Now it depends on the device type...
811                    lscp_status_t ret = LSCP_FAILED;
812                    switch (m_device.deviceType()) {
813                    case qsamplerDevice::Audio:
814                            if ((ret = ::lscp_set_audio_channel_param(pMainForm->client(),
815                                            m_device.deviceID(), m_iPortID, &param)) != LSCP_OK)
816                                    m_device.appendMessagesClient("lscp_set_audio_channel_param");
817                            break;
818                    case qsamplerDevice::Midi:
819                            if ((ret = ::lscp_set_midi_port_param(pMainForm->client(),
820                                            m_device.deviceID(), m_iPortID, &param)) != LSCP_OK)
821                                    m_device.appendMessagesClient("lscp_set_midi_port_param");
822                            break;
823                    case qsamplerDevice::None:
824                            break;
825                    }
826                    // Show result.
827                    if (ret == LSCP_OK) {
828                            m_device.appendMessages(m_sPortName
829                                    + ' ' + QString("%1: %2.").arg(sParam).arg(sValue));
830                            iRefresh++;
831                    } else {
832                            m_device.appendMessagesError(
833                                    QObject::tr("Could not set %1 parameter value.\n\n"
834                                            "Sorry.").arg(m_sPortName));
835                    }
836            }
837    
838            // Return whether we're need a view refresh.
839            return (iRefresh > 0);
840  }  }
841    
842    
# Line 569  void qsamplerDevicePort::setParam ( cons Line 846  void qsamplerDevicePort::setParam ( cons
846    
847  // Constructors.  // Constructors.
848  qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView,  qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView,
849          lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType )          qsamplerDevice::qsamplerDeviceType deviceType )
850          : QListViewItem(pListView), m_device(pClient, deviceType)          : QListViewItem(pListView), m_device(deviceType)
851  {  {
852          switch(m_device.deviceType()) {          switch(m_device.deviceType()) {
853          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
# Line 587  qsamplerDeviceItem::qsamplerDeviceItem ( Line 864  qsamplerDeviceItem::qsamplerDeviceItem (
864  }  }
865    
866  qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem,  qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem,
867          lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType,          qsamplerDevice::qsamplerDeviceType deviceType,
868          int iDeviceID )          int iDeviceID )
869          : QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)          : QListViewItem(pItem), m_device(deviceType, iDeviceID)
870  {  {
871          switch(m_device.deviceType()) {          switch(m_device.deviceType()) {
872          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
# Line 686  void qsamplerDeviceParamTable::refresh ( Line 963  void qsamplerDeviceParamTable::refresh (
963                          pComboItem->setEnabled(bEnabled);                          pComboItem->setEnabled(bEnabled);
964                          QTable::setItem(iRow, 2, pComboItem);                          QTable::setItem(iRow, 2, pComboItem);
965                  } else if (param.possibilities.count() > 0 && bEnabled) {                  } else if (param.possibilities.count() > 0 && bEnabled) {
966                          QComboTableItem *pComboItem = new QComboTableItem(this,                          QStringList opts = param.possibilities;
967                                  param.possibilities);                          if (param.multiplicity)
968                          pComboItem->setCurrentItem(param.value);                                  opts.prepend(tr("(none)"));
969                            QComboTableItem *pComboItem = new QComboTableItem(this, opts);
970                            if (param.value.isEmpty())
971                                    pComboItem->setCurrentItem(0);
972                            else
973                                    pComboItem->setCurrentItem(param.value);
974                          pComboItem->setEnabled(bEnabled);                          pComboItem->setEnabled(bEnabled);
                         pComboItem->setEditable(bEnabled && param.multiplicity);  
975                          QTable::setItem(iRow, 2, pComboItem);                          QTable::setItem(iRow, 2, pComboItem);
976                  } else if (param.type == LSCP_TYPE_INT && bEnabled                  } else if (param.type == LSCP_TYPE_INT && bEnabled
977                                  && !param.range_min.isEmpty()                                  && !param.range_min.isEmpty()
# Line 805  void qsamplerDeviceParamTableEditBox::se Line 1086  void qsamplerDeviceParamTableEditBox::se
1086    
1087    
1088  // end of qsamplerDevice.cpp  // end of qsamplerDevice.cpp
1089    
Legend:
Removed from v.471  
changed lines
  Added in v.980
  ViewVC Help
Powered by ViewVC