/[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 759 by capela, Sun Aug 28 11:44:10 2005 UTC revision 1461 by schoenebeck, Sun Oct 28 23:30:36 2007 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-2007, 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    
# Line 28  Line 28 
28  #include <qspinbox.h>  #include <qspinbox.h>
29  #include <qlineedit.h>  #include <qlineedit.h>
30    
31    using namespace QSampler;
32    
33  //-------------------------------------------------------------------------  //-------------------------------------------------------------------------
34  // qsamplerDeviceParam - MIDI/Audio Device parameter structure.  // qsamplerDeviceParam - MIDI/Audio Device parameter structure.
# Line 103  void qsamplerDeviceParam::setParam ( lsc Line 104  void qsamplerDeviceParam::setParam ( lsc
104  //  //
105    
106  // Constructor.  // Constructor.
107  qsamplerDevice::qsamplerDevice ( qsamplerMainForm *pMainForm,  qsamplerDevice::qsamplerDevice ( qsamplerDeviceType deviceType, int iDeviceID )
         qsamplerDeviceType deviceType, int iDeviceID )  
108  {  {
         m_pMainForm = pMainForm;  
   
109          m_ports.setAutoDelete(true);          m_ports.setAutoDelete(true);
110    
111          setDevice(deviceType, iDeviceID);          setDevice(deviceType, iDeviceID);
# Line 122  qsamplerDevice::~qsamplerDevice (void) Line 120  qsamplerDevice::~qsamplerDevice (void)
120  qsamplerDevice::qsamplerDevice ( const qsamplerDevice& device )  qsamplerDevice::qsamplerDevice ( const qsamplerDevice& device )
121          : m_params(device.m_params), m_ports(m_ports)          : m_params(device.m_params), m_ports(m_ports)
122  {  {
         m_pMainForm   = device.m_pMainForm;  
123          m_iDeviceID   = device.m_iDeviceID;          m_iDeviceID   = device.m_iDeviceID;
124          m_deviceType  = device.m_deviceType;          m_deviceType  = device.m_deviceType;
125          m_sDeviceType = device.m_sDeviceType;          m_sDeviceType = device.m_sDeviceType;
# Line 134  qsamplerDevice::qsamplerDevice ( const q Line 131  qsamplerDevice::qsamplerDevice ( const q
131  // Initializer.  // Initializer.
132  void qsamplerDevice::setDevice ( qsamplerDeviceType deviceType, int iDeviceID )  void qsamplerDevice::setDevice ( qsamplerDeviceType deviceType, int iDeviceID )
133  {  {
134            MainForm *pMainForm = MainForm::getInstance();
135            if (pMainForm == NULL)
136                    return;
137            if (pMainForm->client() == NULL)
138                    return;
139    
140          // Device id and type should be always set.          // Device id and type should be always set.
141          m_iDeviceID  = iDeviceID;          m_iDeviceID  = iDeviceID;
142          m_deviceType = deviceType;          m_deviceType = deviceType;
# Line 148  void qsamplerDevice::setDevice ( qsample Line 151  void qsamplerDevice::setDevice ( qsample
151          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
152                  m_sDeviceType = QObject::tr("Audio");                  m_sDeviceType = QObject::tr("Audio");
153                  if (m_iDeviceID >= 0 && (pDeviceInfo = ::lscp_get_audio_device_info(                  if (m_iDeviceID >= 0 && (pDeviceInfo = ::lscp_get_audio_device_info(
154                                  client(), m_iDeviceID)) == NULL)                                  pMainForm->client(), m_iDeviceID)) == NULL)
155                          appendMessagesClient("lscp_get_audio_device_info");                          appendMessagesClient("lscp_get_audio_device_info");
156                  break;                  break;
157          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
158                  m_sDeviceType = QObject::tr("MIDI");                  m_sDeviceType = QObject::tr("MIDI");
159                  if (m_iDeviceID >= 0 && (pDeviceInfo = ::lscp_get_midi_device_info(                  if (m_iDeviceID >= 0 && (pDeviceInfo = ::lscp_get_midi_device_info(
160                                  client(), m_iDeviceID)) == NULL)                                  pMainForm->client(), m_iDeviceID)) == NULL)
161                          appendMessagesClient("lscp_get_midi_device_info");                          appendMessagesClient("lscp_get_midi_device_info");
162                  break;                  break;
163          case qsamplerDevice::None:          case qsamplerDevice::None:
# Line 179  void qsamplerDevice::setDevice ( qsample Line 182  void qsamplerDevice::setDevice ( qsample
182                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
183                  switch (deviceType) {                  switch (deviceType) {
184                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
185                          if ((pParamInfo = ::lscp_get_audio_driver_param_info(client(),                          if ((pParamInfo = ::lscp_get_audio_driver_param_info(pMainForm->client(),
186                                          m_sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)                                          m_sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
187                                  appendMessagesClient("lscp_get_audio_driver_param_info");                                  appendMessagesClient("lscp_get_audio_driver_param_info");
188                          break;                          break;
189                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
190                          if ((pParamInfo = ::lscp_get_midi_driver_param_info(client(),                          if ((pParamInfo = ::lscp_get_midi_driver_param_info(pMainForm->client(),
191                                          m_sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)                                          m_sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
192                                  appendMessagesClient("lscp_get_midi_driver_param_info");                                  appendMessagesClient("lscp_get_midi_driver_param_info");
193                          break;                          break;
# Line 207  void qsamplerDevice::setDevice ( qsample Line 210  void qsamplerDevice::setDevice ( qsample
210  // Driver name initializer/settler.  // Driver name initializer/settler.
211  void qsamplerDevice::setDriver ( const QString& sDriverName )  void qsamplerDevice::setDriver ( const QString& sDriverName )
212  {  {
213            MainForm *pMainForm = MainForm::getInstance();
214            if (pMainForm == NULL)
215                    return;
216            if (pMainForm->client() == NULL)
217                    return;
218    
219          // Valid only for scratch devices.          // Valid only for scratch devices.
220          if (m_sDriverName == sDriverName)          if (m_sDriverName == sDriverName)
221                  return;                  return;
# Line 219  void qsamplerDevice::setDriver ( const Q Line 228  void qsamplerDevice::setDriver ( const Q
228          lscp_driver_info_t *pDriverInfo = NULL;          lscp_driver_info_t *pDriverInfo = NULL;
229          switch (m_deviceType) {          switch (m_deviceType) {
230          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
231                  if ((pDriverInfo = ::lscp_get_audio_driver_info(client(),                  if ((pDriverInfo = ::lscp_get_audio_driver_info(pMainForm->client(),
232                                  sDriverName.latin1())) == NULL)                                  sDriverName.latin1())) == NULL)
233                          appendMessagesClient("lscp_get_audio_driver_info");                          appendMessagesClient("lscp_get_audio_driver_info");
234                  break;                  break;
235          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
236                  if ((pDriverInfo = ::lscp_get_midi_driver_info(client(),                  if ((pDriverInfo = ::lscp_get_midi_driver_info(pMainForm->client(),
237                                  sDriverName.latin1())) == NULL)                                  sDriverName.latin1())) == NULL)
238                          appendMessagesClient("lscp_get_midi_driver_info");                          appendMessagesClient("lscp_get_midi_driver_info");
239                  break;                  break;
# Line 245  void qsamplerDevice::setDriver ( const Q Line 254  void qsamplerDevice::setDriver ( const Q
254                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
255                  switch (m_deviceType) {                  switch (m_deviceType) {
256                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
257                          if ((pParamInfo = ::lscp_get_audio_driver_param_info(client(),                          if ((pParamInfo = ::lscp_get_audio_driver_param_info(pMainForm->client(),
258                                          sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)                                          sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
259                                  appendMessagesClient("lscp_get_audio_driver_param_info");                                  appendMessagesClient("lscp_get_audio_driver_param_info");
260                          break;                          break;
261                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
262                          if ((pParamInfo = ::lscp_get_midi_driver_param_info(client(),                          if ((pParamInfo = ::lscp_get_midi_driver_param_info(pMainForm->client(),
263                                          sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)                                          sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
264                                  appendMessagesClient("lscp_get_midi_driver_param_info");                                  appendMessagesClient("lscp_get_midi_driver_param_info");
265                          break;                          break;
# Line 270  void qsamplerDevice::setDriver ( const Q Line 279  void qsamplerDevice::setDriver ( const Q
279  }  }
280    
281    
 // The client descriptor delegated property.  
 lscp_client_t *qsamplerDevice::client (void) const  
 {  
         if (m_pMainForm == NULL)  
                 return NULL;  
   
         return m_pMainForm->client();  
 }  
   
   
282  // Device property accessors.  // Device property accessors.
283  int qsamplerDevice::deviceID (void) const  int qsamplerDevice::deviceID (void) const
284  {  {
# Line 315  QString qsamplerDevice::deviceName (void Line 314  QString qsamplerDevice::deviceName (void
314  bool qsamplerDevice::setParam ( const QString& sParam,  bool qsamplerDevice::setParam ( const QString& sParam,
315          const QString& sValue )          const QString& sValue )
316  {  {
317            MainForm *pMainForm = MainForm::getInstance();
318            if (pMainForm == NULL)
319                    return false;
320            if (pMainForm->client() == NULL)
321                    return false;
322    
323          // Set proper device parameter.          // Set proper device parameter.
324          m_params[sParam.upper()].value = sValue;          m_params[sParam.upper()].value = sValue;
325    
# Line 330  bool qsamplerDevice::setParam ( const QS Line 335  bool qsamplerDevice::setParam ( const QS
335                  switch (m_deviceType) {                  switch (m_deviceType) {
336                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
337                      if (sParam == "CHANNELS") iRefresh++;                      if (sParam == "CHANNELS") iRefresh++;
338                          if ((ret = ::lscp_set_audio_device_param(client(),                          if ((ret = ::lscp_set_audio_device_param(pMainForm->client(),
339                                          m_iDeviceID, &param)) != LSCP_OK)                                          m_iDeviceID, &param)) != LSCP_OK)
340                                  appendMessagesClient("lscp_set_audio_device_param");                                  appendMessagesClient("lscp_set_audio_device_param");
341                          break;                          break;
342                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
343                      if (sParam == "PORTS") iRefresh++;                      if (sParam == "PORTS") iRefresh++;
344                          if ((ret = ::lscp_set_midi_device_param(client(),                          if ((ret = ::lscp_set_midi_device_param(pMainForm->client(),
345                                          m_iDeviceID, &param)) != LSCP_OK)                                          m_iDeviceID, &param)) != LSCP_OK)
346                                  appendMessagesClient("lscp_set_midi_device_param");                                  appendMessagesClient("lscp_set_midi_device_param");
347                          break;                          break;
# Line 379  qsamplerDevicePortList& qsamplerDevice:: Line 384  qsamplerDevicePortList& qsamplerDevice::
384  // Create a new device, as a copy of this current one.  // Create a new device, as a copy of this current one.
385  bool qsamplerDevice::createDevice (void)  bool qsamplerDevice::createDevice (void)
386  {  {
387          if (client() == NULL)          MainForm *pMainForm = MainForm::getInstance();
388            if (pMainForm == NULL)
389                    return false;
390            if (pMainForm->client() == NULL)
391                  return false;                  return false;
392    
393          // Build the parameter list...          // Build the parameter list...
# Line 398  bool qsamplerDevice::createDevice (void) Line 406  bool qsamplerDevice::createDevice (void)
406          // Now it depends on the device type...          // Now it depends on the device type...
407          switch (m_deviceType) {          switch (m_deviceType) {
408          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
409                  if ((m_iDeviceID = ::lscp_create_audio_device(client(),                  if ((m_iDeviceID = ::lscp_create_audio_device(pMainForm->client(),
410                                  m_sDriverName.latin1(), pParams)) < 0)                                  m_sDriverName.latin1(), pParams)) < 0)
411                          appendMessagesClient("lscp_create_audio_device");                          appendMessagesClient("lscp_create_audio_device");
412                  break;                  break;
413          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
414                  if ((m_iDeviceID = ::lscp_create_midi_device(client(),                  if ((m_iDeviceID = ::lscp_create_midi_device(pMainForm->client(),
415                                  m_sDriverName.latin1(), pParams)) < 0)                                  m_sDriverName.latin1(), pParams)) < 0)
416                          appendMessagesClient("lscp_create_midi_device");                          appendMessagesClient("lscp_create_midi_device");
417                  break;                  break;
# Line 431  bool qsamplerDevice::createDevice (void) Line 439  bool qsamplerDevice::createDevice (void)
439  // Destroy existing device.  // Destroy existing device.
440  bool qsamplerDevice::deleteDevice (void)  bool qsamplerDevice::deleteDevice (void)
441  {  {
442            MainForm *pMainForm = MainForm::getInstance();
443            if (pMainForm == NULL)
444                    return false;
445            if (pMainForm->client() == NULL)
446                    return false;
447    
448          // Now it depends on the device type...          // Now it depends on the device type...
449          lscp_status_t ret = LSCP_FAILED;          lscp_status_t ret = LSCP_FAILED;
450          switch (m_deviceType) {          switch (m_deviceType) {
451          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
452                  if ((ret = ::lscp_destroy_audio_device(client(),                  if ((ret = ::lscp_destroy_audio_device(pMainForm->client(),
453                                  m_iDeviceID)) != LSCP_OK)                                  m_iDeviceID)) != LSCP_OK)
454                          appendMessagesClient("lscp_destroy_audio_device");                          appendMessagesClient("lscp_destroy_audio_device");
455                  break;                  break;
456          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
457                  if ((ret = ::lscp_destroy_midi_device(client(),                  if ((ret = ::lscp_destroy_midi_device(pMainForm->client(),
458                                  m_iDeviceID)) != LSCP_OK)                                  m_iDeviceID)) != LSCP_OK)
459                          appendMessagesClient("lscp_destroy_midi_device");                          appendMessagesClient("lscp_destroy_midi_device");
460                  break;                  break;
# Line 526  int qsamplerDevice::refreshDepends ( con Line 540  int qsamplerDevice::refreshDepends ( con
540  // Refresh/set given parameter based on driver supplied dependencies.  // Refresh/set given parameter based on driver supplied dependencies.
541  int qsamplerDevice::refreshParam ( const QString& sParam )  int qsamplerDevice::refreshParam ( const QString& sParam )
542  {  {
543            MainForm *pMainForm = MainForm::getInstance();
544            if (pMainForm == NULL)
545                    return 0;
546            if (pMainForm->client() == NULL)
547                    return 0;
548    
549          // Check if we have dependencies...          // Check if we have dependencies...
550          qsamplerDeviceParam& param = m_params[sParam.upper()];          qsamplerDeviceParam& param = m_params[sParam.upper()];
551          if (param.depends.isEmpty())          if (param.depends.isEmpty())
# Line 556  int qsamplerDevice::refreshParam ( const Line 576  int qsamplerDevice::refreshParam ( const
576          lscp_param_info_t *pParamInfo = NULL;          lscp_param_info_t *pParamInfo = NULL;
577          switch (m_deviceType) {          switch (m_deviceType) {
578          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
579                  if ((pParamInfo = ::lscp_get_audio_driver_param_info(client(),                  if ((pParamInfo = ::lscp_get_audio_driver_param_info(pMainForm->client(),
580                                  m_sDriverName.latin1(), sParam.latin1(), pDepends)) == NULL)                                  m_sDriverName.latin1(), sParam.latin1(), pDepends)) == NULL)
581                          appendMessagesClient("lscp_get_audio_driver_param_info");                          appendMessagesClient("lscp_get_audio_driver_param_info");
582                  break;                  break;
583          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
584                  if ((pParamInfo = ::lscp_get_midi_driver_param_info(client(),                  if ((pParamInfo = ::lscp_get_midi_driver_param_info(pMainForm->client(),
585                                  m_sDriverName.latin1(), sParam.latin1(), pDepends)) == NULL)                                  m_sDriverName.latin1(), sParam.latin1(), pDepends)) == NULL)
586                          appendMessagesClient("lscp_get_midi_driver_param_info");                          appendMessagesClient("lscp_get_midi_driver_param_info");
587                  break;                  break;
# Line 584  int qsamplerDevice::refreshParam ( const Line 604  int qsamplerDevice::refreshParam ( const
604  // Redirected messages output methods.  // Redirected messages output methods.
605  void qsamplerDevice::appendMessages( const QString& s ) const  void qsamplerDevice::appendMessages( const QString& s ) const
606  {  {
607          if (m_pMainForm)          MainForm *pMainForm = MainForm::getInstance();
608                  m_pMainForm->appendMessages(deviceName() + ' ' + s);          if (pMainForm)
609                    pMainForm->appendMessages(deviceName() + ' ' + s);
610  }  }
611    
612  void qsamplerDevice::appendMessagesColor( const QString& s,  void qsamplerDevice::appendMessagesColor( const QString& s,
613          const QString& c ) const          const QString& c ) const
614  {  {
615          if (m_pMainForm)          MainForm *pMainForm = MainForm::getInstance();
616                  m_pMainForm->appendMessagesColor(deviceName() + ' ' + s, c);          if (pMainForm)
617                    pMainForm->appendMessagesColor(deviceName() + ' ' + s, c);
618  }  }
619    
620  void qsamplerDevice::appendMessagesText( const QString& s ) const  void qsamplerDevice::appendMessagesText( const QString& s ) const
621  {  {
622          if (m_pMainForm)          MainForm *pMainForm = MainForm::getInstance();
623                  m_pMainForm->appendMessagesText(deviceName() + ' ' + s);          if (pMainForm)
624                    pMainForm->appendMessagesText(deviceName() + ' ' + s);
625  }  }
626    
627  void qsamplerDevice::appendMessagesError( const QString& s ) const  void qsamplerDevice::appendMessagesError( const QString& s ) const
628  {  {
629          if (m_pMainForm)          MainForm *pMainForm = MainForm::getInstance();
630                  m_pMainForm->appendMessagesError(deviceName() + "\n\n" + s);          if (pMainForm)
631                    pMainForm->appendMessagesError(deviceName() + "\n\n" + s);
632  }  }
633    
634  void qsamplerDevice::appendMessagesClient( const QString& s ) const  void qsamplerDevice::appendMessagesClient( const QString& s ) const
635  {  {
636          if (m_pMainForm)          MainForm *pMainForm = MainForm::getInstance();
637                  m_pMainForm->appendMessagesClient(deviceName() + ' ' + s);          if (pMainForm)
638                    pMainForm->appendMessagesClient(deviceName() + ' ' + s);
639  }  }
640    
641    
# Line 651  QStringList qsamplerDevice::getDrivers ( Line 676  QStringList qsamplerDevice::getDrivers (
676                  break;                  break;
677          }          }
678    
679          for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)          for (int iDriver = 0; ppszDrivers && ppszDrivers[iDriver]; iDriver++)
680                  drivers.append(ppszDrivers[iDriver]);                  drivers.append(ppszDrivers[iDriver]);
681    
682          return drivers;          return drivers;
# Line 678  qsamplerDevicePort::~qsamplerDevicePort Line 703  qsamplerDevicePort::~qsamplerDevicePort
703  // Initializer.  // Initializer.
704  void qsamplerDevicePort::setDevicePort ( int iPortID )  void qsamplerDevicePort::setDevicePort ( int iPortID )
705  {  {
706            MainForm *pMainForm = MainForm::getInstance();
707            if (pMainForm == NULL)
708                    return;
709            if (pMainForm->client() == NULL)
710                    return;
711    
712          // Device port id should be always set.          // Device port id should be always set.
713          m_iPortID = iPortID;          m_iPortID = iPortID;
714    
# Line 688  void qsamplerDevicePort::setDevicePort ( Line 719  void qsamplerDevicePort::setDevicePort (
719          lscp_device_port_info_t *pPortInfo = NULL;          lscp_device_port_info_t *pPortInfo = NULL;
720          switch (m_device.deviceType()) {          switch (m_device.deviceType()) {
721          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
722                  if ((pPortInfo = ::lscp_get_audio_channel_info(m_device.client(),                  if ((pPortInfo = ::lscp_get_audio_channel_info(pMainForm->client(),
723                                  m_device.deviceID(), m_iPortID)) == NULL)                                  m_device.deviceID(), m_iPortID)) == NULL)
724                          m_device.appendMessagesClient("lscp_get_audio_channel_info");                          m_device.appendMessagesClient("lscp_get_audio_channel_info");
725                  break;                  break;
726          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
727                  if ((pPortInfo = ::lscp_get_midi_port_info(m_device.client(),                  if ((pPortInfo = ::lscp_get_midi_port_info(pMainForm->client(),
728                                  m_device.deviceID(), m_iPortID)) == NULL)                                  m_device.deviceID(), m_iPortID)) == NULL)
729                          m_device.appendMessagesClient("lscp_get_midi_port_info");                          m_device.appendMessagesClient("lscp_get_midi_port_info");
730                  break;                  break;
# Line 718  void qsamplerDevicePort::setDevicePort ( Line 749  void qsamplerDevicePort::setDevicePort (
749                  switch (m_device.deviceType()) {                  switch (m_device.deviceType()) {
750                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
751                          if ((pParamInfo = ::lscp_get_audio_channel_param_info(                          if ((pParamInfo = ::lscp_get_audio_channel_param_info(
752                                          m_device.client(), m_device.deviceID(),                                          pMainForm->client(), m_device.deviceID(),
753                                          m_iPortID, sParam.latin1())) == NULL)                                          m_iPortID, sParam.latin1())) == NULL)
754                                  m_device.appendMessagesClient("lscp_get_audio_channel_param_info");                                  m_device.appendMessagesClient("lscp_get_audio_channel_param_info");
755                          break;                          break;
756                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
757                          if ((pParamInfo = ::lscp_get_midi_port_param_info(                          if ((pParamInfo = ::lscp_get_midi_port_param_info(
758                                          m_device.client(), m_device.deviceID(),                                          pMainForm->client(), m_device.deviceID(),
759                                          m_iPortID, sParam.latin1())) == NULL)                                          m_iPortID, sParam.latin1())) == NULL)
760                                  m_device.appendMessagesClient("lscp_get_midi_port_param_info");                                  m_device.appendMessagesClient("lscp_get_midi_port_param_info");
761                          break;                          break;
# Line 761  const qsamplerDeviceParamMap& qsamplerDe Line 792  const qsamplerDeviceParamMap& qsamplerDe
792  bool qsamplerDevicePort::setParam ( const QString& sParam,  bool qsamplerDevicePort::setParam ( const QString& sParam,
793          const QString& sValue )          const QString& sValue )
794  {  {
795            MainForm *pMainForm = MainForm::getInstance();
796            if (pMainForm == NULL)
797                    return false;
798            if (pMainForm->client() == NULL)
799                    return false;
800    
801          // Set proper port/channel parameter.          // Set proper port/channel parameter.
802          m_params[sParam.upper()].value = sValue;          m_params[sParam.upper()].value = sValue;
803    
# Line 775  bool qsamplerDevicePort::setParam ( cons Line 812  bool qsamplerDevicePort::setParam ( cons
812                  lscp_status_t ret = LSCP_FAILED;                  lscp_status_t ret = LSCP_FAILED;
813                  switch (m_device.deviceType()) {                  switch (m_device.deviceType()) {
814                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
815                          if ((ret = ::lscp_set_audio_channel_param(m_device.client(),                          if ((ret = ::lscp_set_audio_channel_param(pMainForm->client(),
816                                          m_device.deviceID(), m_iPortID, &param)) != LSCP_OK)                                          m_device.deviceID(), m_iPortID, &param)) != LSCP_OK)
817                                  m_device.appendMessagesClient("lscp_set_audio_channel_param");                                  m_device.appendMessagesClient("lscp_set_audio_channel_param");
818                          break;                          break;
819                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
820                          if ((ret = ::lscp_set_midi_port_param(m_device.client(),                          if ((ret = ::lscp_set_midi_port_param(pMainForm->client(),
821                                          m_device.deviceID(), m_iPortID, &param)) != LSCP_OK)                                          m_device.deviceID(), m_iPortID, &param)) != LSCP_OK)
822                                  m_device.appendMessagesClient("lscp_set_midi_port_param");                                  m_device.appendMessagesClient("lscp_set_midi_port_param");
823                          break;                          break;
# Line 805  bool qsamplerDevicePort::setParam ( cons Line 842  bool qsamplerDevicePort::setParam ( cons
842    
843    
844  //-------------------------------------------------------------------------  //-------------------------------------------------------------------------
845  // qsamplerDeviceItem - QListView device item.  // qsamplerDeviceItem - QTreeWidget device item.
846  //  //
847    
848  // Constructors.  // Constructors.
849  qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView,  qsamplerDeviceItem::qsamplerDeviceItem ( QTreeWidget* pTreeWidget,
850          qsamplerMainForm *pMainForm, qsamplerDevice::qsamplerDeviceType deviceType )          qsamplerDevice::qsamplerDeviceType deviceType )
851          : QListViewItem(pListView), m_device(pMainForm, deviceType)          : QTreeWidgetItem(pTreeWidget, QSAMPLER_DEVICE_ITEM),
852          m_device(deviceType)
853  {  {
854          switch(m_device.deviceType()) {          switch(m_device.deviceType()) {
855          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
856                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio1.png"));                  setIcon(0, QPixmap(":/qsampler/pixmaps/audio1.png"));
857                  QListViewItem::setText(0, QObject::tr("Audio Devices"));                  setText(1, QObject::tr("Audio Devices"));
858                  break;                  break;
859          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
860                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));                  setIcon(0, QPixmap(":/qsampler/pixmaps/midi1.png"));
861                  QListViewItem::setText(0, QObject::tr("MIDI Devices"));                  setText(1, QObject::tr("MIDI Devices"));
862                  break;                  break;
863          case qsamplerDevice::None:          case qsamplerDevice::None:
864                  break;                  break;
865          }          }
866  }  }
867    
868  qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem,  qsamplerDeviceItem::qsamplerDeviceItem ( QTreeWidgetItem* pItem,
869          qsamplerMainForm *pMainForm, qsamplerDevice::qsamplerDeviceType deviceType,          qsamplerDevice::qsamplerDeviceType deviceType,
870          int iDeviceID )          int iDeviceID )
871          : QListViewItem(pItem), m_device(pMainForm, deviceType, iDeviceID)          : QTreeWidgetItem(pItem, QSAMPLER_DEVICE_ITEM),
872          m_device(deviceType, iDeviceID)
873  {  {
874          switch(m_device.deviceType()) {          switch(m_device.deviceType()) {
875          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
876                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio2.png"));                  setIcon(0, QPixmap(":/qsampler/pixmaps/audio2.png"));
877                  break;                  break;
878          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
879                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));                  setIcon(0, QPixmap(":/qsampler/pixmaps/midi2.png"));
880                  break;                  break;
881          case qsamplerDevice::None:          case qsamplerDevice::None:
882                  break;                  break;
883          }          }
884    
885          QListViewItem::setText(0, m_device.deviceName());          setText(1, m_device.deviceName());
886  }  }
887    
888  // Default destructor.  // Default destructor.
# Line 857  qsamplerDevice& qsamplerDeviceItem::devi Line 896  qsamplerDevice& qsamplerDeviceItem::devi
896          return m_device;          return m_device;
897  }  }
898    
 // To virtually distinguish between list view items.  
 int qsamplerDeviceItem::rtti() const  
 {  
         return QSAMPLER_DEVICE_ITEM;  
 }  
   
899    
900    
901  //-------------------------------------------------------------------------  //-------------------------------------------------------------------------
902  // qsamplerDeviceParamTable - Device parameter view table.  // qsamplerDeviceParamTable - Device parameter view table.
903  //  //
904    #if 0
905  // Constructor.  // Constructor.
906  qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent,  qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent,
907          const char *pszName )          const char *pszName )
# Line 964  void qsamplerDeviceParamTable::refresh ( Line 997  void qsamplerDeviceParamTable::refresh (
997          QTable::setUpdatesEnabled(true);          QTable::setUpdatesEnabled(true);
998          QTable::updateContents();          QTable::updateContents();
999  }  }
1000    #endif
1001    
1002    DeviceParamModel::DeviceParamModel(QObject* parent) : QAbstractTableModel(parent), bEditable(false) {
1003    }
1004    
1005    int DeviceParamModel::rowCount(const QModelIndex& /*parent*/) const {
1006        return params.size();
1007    }
1008    
1009    int DeviceParamModel::columnCount(const QModelIndex& /*parent*/) const {
1010        return 3;
1011    }
1012    
1013    QVariant DeviceParamModel::data(const QModelIndex &index, int role) const {
1014        if (!index.isValid())
1015            return QVariant();
1016        if (role != Qt::DisplayRole)
1017            return QVariant();
1018    
1019        DeviceParameterRow item;
1020        item.name  = params.keys()[index.row()];
1021        item.param = params[item.name];
1022    
1023        return QVariant::fromValue(item);
1024    }
1025    
1026    QVariant DeviceParamModel::headerData(int section, Qt::Orientation orientation, int role) const {
1027        if (role != Qt::DisplayRole) return QVariant();
1028    
1029        if (orientation == Qt::Horizontal) {
1030            switch (section) {
1031                case 0:  return tr("Parameter");
1032                case 1:  return tr("Value");
1033                case 2:  return tr("Description");
1034                default: return QVariant();
1035            }
1036        }
1037    
1038        return QVariant();
1039    }
1040    
1041    void DeviceParamModel::refresh(const qsamplerDeviceParamMap& params, bool bEditable)
1042    {
1043        this->params    = params;
1044        this->bEditable = bEditable;
1045    }
1046    
1047    void DeviceParamModel::clear() {
1048        params.clear();
1049    }
1050    
1051    
1052    DeviceParamDelegate::DeviceParamDelegate(QObject *parent) : QItemDelegate(parent) {
1053    }
1054    
1055    QWidget* DeviceParamDelegate::createEditor(QWidget *parent,
1056            const QStyleOptionViewItem &/* option */,
1057            const QModelIndex& index) const
1058    {
1059        DeviceParameterRow r = index.model()->data(index, Qt::DisplayRole).value<DeviceParameterRow>();
1060    
1061        const bool bEnabled = (/*index.model()->bEditable ||*/ !r.param.fix);
1062    
1063        switch (index.column()) {
1064            case 0:
1065                return new QLabel(r.name, parent);
1066            case 1: {
1067                if (r.param.type == LSCP_TYPE_BOOL) {
1068                    QCheckBox* pCheckBox = new QCheckBox(parent);
1069                    pCheckBox->setChecked(r.param.value.lower() == "true");
1070                    pCheckBox->setEnabled(bEnabled);
1071                    return pCheckBox;
1072                } else if (r.param.possibilities.count() > 0 && bEnabled) {
1073                    QStringList opts = r.param.possibilities;
1074                    if (r.param.multiplicity)
1075                        opts.prepend(tr("(none)"));
1076                    QComboBox* pComboBox = new QComboBox(parent);
1077                    pComboBox->addItems(opts);
1078                    if (r.param.value.isEmpty())
1079                        pComboBox->setCurrentIndex(0);
1080                    else
1081                        pComboBox->setCurrentIndex(pComboBox->findText(r.param.value));
1082                    pComboBox->setEnabled(bEnabled);
1083                    return pComboBox;
1084                } else if (r.param.type == LSCP_TYPE_INT && bEnabled
1085                           && !r.param.range_min.isEmpty()
1086                           && !r.param.range_max.isEmpty()) {
1087                    QSpinBox* pSpinBox = new QSpinBox(parent);
1088                    pSpinBox->setValue(r.param.value.toInt());
1089                    pSpinBox->setMinimum(r.param.range_min.toInt());
1090                    pSpinBox->setMaximum(r.param.range_max.toInt());
1091                    return pSpinBox;
1092                } else {
1093                    QLineEdit* pLineEdit = new QLineEdit(r.param.value, parent);
1094                    return pLineEdit;
1095                }
1096            }
1097            case 2:
1098                return new QLabel(r.param.description, parent);
1099            default:
1100                return NULL;
1101        }
1102    }
1103    
1104    void DeviceParamDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const {
1105    /*
1106        ChannelRoutingItem item = index.model()->data(index, Qt::DisplayRole).value<ChannelRoutingItem>();
1107        QComboBox* comboBox = static_cast<QComboBox*>(editor);
1108        comboBox->setCurrentIndex(item.selection);
1109    */
1110    }
1111    
1112    void DeviceParamDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const {
1113    /*
1114        QComboBox* comboBox = static_cast<QComboBox*>(editor);
1115        model->setData(index, comboBox->currentIndex());
1116    */
1117    }
1118    
1119    void DeviceParamDelegate::updateEditorGeometry(QWidget* editor,
1120            const QStyleOptionViewItem &option, const QModelIndex &/* index */) const
1121    {
1122        if (editor) editor->setGeometry(option.rect);
1123    }
1124    
1125  //-------------------------------------------------------------------------  //-------------------------------------------------------------------------
1126  // qsamplerDeviceParamTableSpinBox - Custom spin box for parameter table.  // qsamplerDeviceParamTableSpinBox - Custom spin box for parameter table.
1127  //  //
1128    
1129    #if 0
1130  // Constructor.  // Constructor.
1131  qsamplerDeviceParamTableSpinBox::qsamplerDeviceParamTableSpinBox (  qsamplerDeviceParamTableSpinBox::qsamplerDeviceParamTableSpinBox (
1132          QTable *pTable, EditType editType, const QString& sText )          QTable *pTable, EditType editType, const QString& sText )
# Line 1047  void qsamplerDeviceParamTableEditBox::se Line 1204  void qsamplerDeviceParamTableEditBox::se
1204          else          else
1205                  QTableItem::setContentFromEditor(pWidget);                  QTableItem::setContentFromEditor(pWidget);
1206  }  }
1207    #endif
1208    
1209  // end of qsamplerDevice.cpp  // end of qsamplerDevice.cpp
1210    
Legend:
Removed from v.759  
changed lines
  Added in v.1461
  ViewVC Help
Powered by ViewVC