/[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 430 by capela, Tue Mar 8 17:23:29 2005 UTC revision 463 by capela, Tue Mar 15 15:32:29 2005 UTC
# Line 21  Line 21 
21    
22  #include "qsamplerDevice.h"  #include "qsamplerDevice.h"
23    
24    #include <qspinbox.h>
25    #include <qlineedit.h>
26    
27  #include "qsamplerMainForm.h"  #include "qsamplerMainForm.h"
28  #include "qsamplerDeviceForm.h"  #include "qsamplerDeviceForm.h"
29    
# Line 50  void qsamplerDeviceParam::setParam ( lsc Line 53  void qsamplerDeviceParam::setParam ( lsc
53          const char *pszValue )          const char *pszValue )
54  {  {
55          if (pParamInfo == NULL)          if (pParamInfo == NULL)
56              return;                  return;
57                                
58      // Info structure field members.          // Info structure field members.
59            
60          type = pParamInfo->type;          type = pParamInfo->type;
61            
62          if (pParamInfo->description)          if (pParamInfo->description)
63                  description = pParamInfo->description;                  description = pParamInfo->description;
64          else          else
65                  description = QString::null;                  description = QString::null;
66            
67      mandatory = (bool) pParamInfo->multiplicity;          mandatory = (bool) pParamInfo->multiplicity;
68      fix = (bool) pParamInfo->fix;          fix = (bool) pParamInfo->fix;
69      multiplicity = (bool) pParamInfo->multiplicity;          multiplicity = (bool) pParamInfo->multiplicity;
70            
71          depends.clear();          depends.clear();
72          for (int i = 0; pParamInfo->depends && pParamInfo->depends[i]; i++)          for (int i = 0; pParamInfo->depends && pParamInfo->depends[i]; i++)
73              depends.append(pParamInfo->depends[i]);                  depends.append(pParamInfo->depends[i]);
74            
75          if (pParamInfo->defaultv)          if (pParamInfo->defaultv)
76                  defaultv = pParamInfo->defaultv;                  defaultv = pParamInfo->defaultv;
77          else          else
78                  defaultv = QString::null;                  defaultv = QString::null;
79            
80          if (pParamInfo->range_min)          if (pParamInfo->range_min)
81          range_min = pParamInfo->range_min;                  range_min = pParamInfo->range_min;
82          else          else
83                  range_min = QString::null;                  range_min = QString::null;
84            
85          if (pParamInfo->range_max)          if (pParamInfo->range_max)
86          range_max = pParamInfo->range_max;                  range_max = pParamInfo->range_max;
87          else          else
88                  range_max = QString::null;                  range_max = QString::null;
89            
90          possibilities.clear();          possibilities.clear();
91          for (int i = 0; pParamInfo->possibilities && pParamInfo->possibilities[i]; i++)          for (int i = 0; pParamInfo->possibilities && pParamInfo->possibilities[i]; i++)
92              possibilities.append(pParamInfo->possibilities[i]);                  possibilities.append(pParamInfo->possibilities[i]);
93                                
94      // The current parameter value.          // The current parameter value.
95          if (pszValue)          if (pszValue)
96              value = pszValue;                  value = pszValue;
97          else          else
98                  value = QString::null;                  value = QString::null;
99  }  }
# Line 104  void qsamplerDeviceParam::setParam ( lsc Line 107  void qsamplerDeviceParam::setParam ( lsc
107  qsamplerDevice::qsamplerDevice ( lscp_client_t *pClient,  qsamplerDevice::qsamplerDevice ( lscp_client_t *pClient,
108          qsamplerDeviceType deviceType, int iDeviceID )          qsamplerDeviceType deviceType, int iDeviceID )
109  {  {
110            m_ports.setAutoDelete(true);
111            
112          setDevice(pClient, deviceType, iDeviceID);          setDevice(pClient, deviceType, iDeviceID);
113  }  }
114    
# Line 118  void qsamplerDevice::setDevice ( lscp_cl Line 123  void qsamplerDevice::setDevice ( lscp_cl
123          qsamplerDeviceType deviceType, int iDeviceID )          qsamplerDeviceType deviceType, int iDeviceID )
124  {  {
125          // Device id and type should be always set.          // Device id and type should be always set.
126          m_iDeviceID   = iDeviceID;          m_iDeviceID  = iDeviceID;
127          m_deviceType  = deviceType;          m_deviceType = deviceType;
128            
129            // Reset device parameters and ports anyway.
130            m_params.clear();
131            m_ports.clear();
132    
133          // Retrieve device info, if any.          // Retrieve device info, if any.
         QString sDeviceType;  
134          lscp_device_info_t *pDeviceInfo = NULL;          lscp_device_info_t *pDeviceInfo = NULL;
135          switch (deviceType) {          switch (deviceType) {
136            case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
137              sDeviceType = QObject::tr("Audio");                  m_sDeviceType = QObject::tr("Audio");
138              pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);                  pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);
139                  break;                  break;
140            case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
141              sDeviceType = QObject::tr("MIDI");                  m_sDeviceType = QObject::tr("MIDI");
142                  pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);                  pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);
143                  break;                  break;
144            case qsamplerDevice::None:
145                    m_sDeviceType = QString::null;
146                    break;
147          }          }
148            
149          // If we're bogus, bail out...          // If we're bogus, bail out...
150          if (pDeviceInfo == NULL) {          if (pDeviceInfo == NULL) {
151                  m_sDriverName = QString::null;                  m_sDriverName = QString::null;
152                  m_sDeviceName = QObject::tr("New %1 device").arg(sDeviceType);                  m_sDeviceName = QObject::tr("New %1 device").arg(m_sDeviceType);
153              return;                  return;
154          }          }
155            
156          // Other device properties...          // Other device properties...
157          m_sDriverName = pDeviceInfo->driver;          m_sDriverName = pDeviceInfo->driver;
158          m_sDeviceName = m_sDriverName + ' '          m_sDeviceName = m_sDriverName + ' '
159                  + QObject::tr("Device %1").arg(m_iDeviceID);                  + QObject::tr("Device %1").arg(m_iDeviceID);
160    
161          // Grab device/driver parameters...          // Grab device parameters...
         m_params.clear();  
162          for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {          for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {
163                  const char *pszParam = pDeviceInfo->params[i].key;                  const QString sParam = pDeviceInfo->params[i].key;
164                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
165                  switch (deviceType) {                  switch (deviceType) {
166                    case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
167                      pParamInfo = ::lscp_get_audio_driver_param_info(pClient,                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
168                                  m_sDriverName.latin1(), pszParam, NULL);                                  m_sDriverName.latin1(), sParam.latin1(), NULL);
169                          break;                          break;
170                    case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
171                      pParamInfo = ::lscp_get_midi_driver_param_info(pClient,                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
172                                  m_sDriverName.latin1(), pszParam, NULL);                                  m_sDriverName.latin1(), sParam.latin1(), NULL);
173                            break;
174                    case qsamplerDevice::None:
175                            break;
176                    }
177                    if (pParamInfo) {
178                            m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
179                                    pDeviceInfo->params[i].value);
180                    }
181            }
182    
183            // Grab port/channel list...
184            refresh(pClient);
185    }
186    
187    
188    // Driver name initializer/settler.
189    void qsamplerDevice::setDriver ( lscp_client_t *pClient,
190            const QString& sDriverName )
191    {
192            // Valid only for scratch devices.
193            if (m_sDriverName == sDriverName)
194                    return;
195    
196            // Reset device parameters and ports anyway.
197            m_params.clear();
198            m_ports.clear();
199    
200            // Retrieve driver info, if any.
201            lscp_driver_info_t *pDriverInfo = NULL;
202            switch (m_deviceType) {
203            case qsamplerDevice::Audio:
204                    pDriverInfo = ::lscp_get_audio_driver_info(pClient,
205                            sDriverName.latin1());
206                    break;
207            case qsamplerDevice::Midi:
208                    pDriverInfo = ::lscp_get_midi_driver_info(pClient,
209                            sDriverName.latin1());
210                    break;
211            case qsamplerDevice::None:
212                    break;
213            }
214    
215            // If we're bogus, bail out...
216            if (pDriverInfo == NULL)
217                    return;
218    
219            // Remember device parameters...
220            m_sDriverName = sDriverName;
221    
222            // Grab driver parameters...
223            for (int i = 0; pDriverInfo->parameters && pDriverInfo->parameters[i]; i++) {
224                    const QString sParam = pDriverInfo->parameters[i];
225                    lscp_param_info_t *pParamInfo = NULL;
226                    switch (m_deviceType) {
227                    case qsamplerDevice::Audio:
228                            pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
229                                    sDriverName.latin1(), sParam.latin1(), NULL);
230                            break;
231                    case qsamplerDevice::Midi:
232                            pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
233                                    sDriverName.latin1(), sParam.latin1(), NULL);
234                          break;                          break;
235                    case qsamplerDevice::None:
236                            break;
237                    }
238                    if (pParamInfo) {
239                            m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
240                                    pParamInfo->defaultv);
241                  }                  }
                 m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pDeviceInfo->params[i].value);  
242          }          }
243  }  }
244    
# Line 178  qsamplerDevice::qsamplerDeviceType qsamp Line 254  qsamplerDevice::qsamplerDeviceType qsamp
254          return m_deviceType;          return m_deviceType;
255  }  }
256    
257    const QString& qsamplerDevice::deviceTypeName (void) const
258    {
259            return m_sDeviceType;
260    }
261    
262  const QString& qsamplerDevice::driverName (void) const  const QString& qsamplerDevice::driverName (void) const
263  {  {
264          return m_sDriverName;          return m_sDriverName;
# Line 188  const QString& qsamplerDevice::deviceNam Line 269  const QString& qsamplerDevice::deviceNam
269          return m_sDeviceName;          return m_sDeviceName;
270  }  }
271    
272    
273    // Set the proper device parameter value.
274    void qsamplerDevice::setParam ( const QString& sParam,
275            const QString& sValue )
276    {
277            m_params[sParam.upper()].value = sValue;
278    }
279    
280    
281  // Device parameter accessor.  // Device parameter accessor.
282  qsamplerDeviceParamMap& qsamplerDevice::params (void)  const qsamplerDeviceParamMap& qsamplerDevice::params (void) const
283  {  {
284          return m_params;          return m_params;
285  }  }
286    
287    
288  // Update/refresh device/driver data.  // Device port/channel list accessor.
289  void qsamplerDevice::refresh (void)  qsamplerDevicePortList& qsamplerDevice::ports (void)
290  {  {
291            return m_ports;
292    }
293    
294    
295    // Device port/channel list refreshner.
296    void qsamplerDevice::refresh ( lscp_client_t *pClient )
297    {
298            // Port/channel count determination...
299            int iPorts = 0;
300            switch (m_deviceType) {
301            case qsamplerDevice::Audio:
302                    iPorts = m_params["CHANNELS"].value.toInt();
303                    break;
304            case qsamplerDevice::Midi:
305                    iPorts = m_params["PORTS"].value.toInt();
306                    break;
307            case qsamplerDevice::None:
308                    break;
309            }
310    
311            // Retrieve port/channel information...
312            m_ports.clear();
313            for (int iPort = 0; iPort < iPorts; iPort++)
314                    m_ports.append(new qsamplerDevicePort(pClient, *this, iPort));
315  }  }
316    
317    
318  // Device ids enumerator.  // Device ids enumerator.
319  int *qsamplerDevice::getDevices ( lscp_client_t *pClient,  int *qsamplerDevice::getDevices ( lscp_client_t *pClient,
320          qsamplerDeviceType deviceType )          qsamplerDeviceType deviceType )
321  {  {
322          int *piDeviceIDs = NULL;          int *piDeviceIDs = NULL;
323          switch (deviceType) {          switch (deviceType) {
324            case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
325              piDeviceIDs = ::lscp_list_audio_devices(pClient);                  piDeviceIDs = ::lscp_list_audio_devices(pClient);
326                  break;                  break;
327            case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
328              piDeviceIDs = ::lscp_list_midi_devices(pClient);                  piDeviceIDs = ::lscp_list_midi_devices(pClient);
329                    break;
330            case qsamplerDevice::None:
331                  break;                  break;
332          }          }
333          return piDeviceIDs;          return piDeviceIDs;
# Line 225  QStringList qsamplerDevice::getDrivers ( Line 342  QStringList qsamplerDevice::getDrivers (
342                    
343          const char **ppszDrivers = NULL;          const char **ppszDrivers = NULL;
344          switch (deviceType) {          switch (deviceType) {
345            case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
346              ppszDrivers = ::lscp_get_available_audio_drivers(pClient);                  ppszDrivers = ::lscp_get_available_audio_drivers(pClient);
347                  break;                  break;
348            case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
349              ppszDrivers = ::lscp_get_available_midi_drivers(pClient);                  ppszDrivers = ::lscp_get_available_midi_drivers(pClient);
350                    break;
351            case qsamplerDevice::None:
352                  break;                  break;
353          }          }
354                    
355      for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)          for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)
356          drivers.append(ppszDrivers[iDriver]);                  drivers.append(ppszDrivers[iDriver]);
357    
358          return drivers;          return drivers;
359  }  }
360    
361    
362  //-------------------------------------------------------------------------  //-------------------------------------------------------------------------
363    // qsamplerDevicePort - MIDI/Audio Device port/channel structure.
364    //
365    
366    // Constructor.
367    qsamplerDevicePort::qsamplerDevicePort ( lscp_client_t *pClient,
368            const qsamplerDevice& device, int iPortID )
369    {
370            setDevicePort(pClient, device, iPortID);
371    }
372    
373    // Default destructor.
374    qsamplerDevicePort::~qsamplerDevicePort (void)
375    {
376    }
377    
378    
379    // Initializer.
380    void qsamplerDevicePort::setDevicePort ( lscp_client_t *pClient,
381            const qsamplerDevice& device, int iPortID )
382    {
383            // Device port id should be always set.
384            m_iPortID = iPortID;
385    
386            // Reset port parameters anyway.
387            m_params.clear();
388    
389            // Retrieve device port/channel info, if any.
390            QString sPrefix = device.driverName() + ' ';
391            lscp_device_port_info_t *pPortInfo = NULL;
392            switch (device.deviceType()) {
393            case qsamplerDevice::Audio:
394                sPrefix += QObject::tr("Channel");
395                    pPortInfo = ::lscp_get_audio_channel_info(pClient, device.deviceID(), iPortID);
396                    break;
397            case qsamplerDevice::Midi:
398                sPrefix += QObject::tr("Port");
399                    pPortInfo = ::lscp_get_midi_port_info(pClient, device.deviceID(), iPortID);
400                    break;
401            case qsamplerDevice::None:
402                    break;
403            }
404    
405            // If we're bogus, bail out...
406            if (pPortInfo == NULL) {
407                    m_sPortName = QString::null;
408                    return;
409            }
410    
411            // Set device port/channel properties...
412            sPrefix += " %1:";
413            m_sPortName = sPrefix.arg(m_iPortID)  + ' ' + pPortInfo->name;
414    
415            // Grab device port/channel parameters...
416            m_params.clear();
417            for (int i = 0; pPortInfo->params && pPortInfo->params[i].key; i++) {
418                    const QString sParam = pPortInfo->params[i].key;
419                    lscp_param_info_t *pParamInfo = NULL;
420                    switch (device.deviceType()) {
421                    case qsamplerDevice::Audio:
422                            pParamInfo = ::lscp_get_audio_channel_param_info(pClient,
423                                    device.deviceID(), iPortID, sParam.latin1());
424                            break;
425                    case qsamplerDevice::Midi:
426                            pParamInfo = ::lscp_get_midi_port_param_info(pClient,
427                                    device.deviceID(), iPortID, sParam.latin1());
428                            break;
429                    case qsamplerDevice::None:
430                            break;
431                    }
432                    if (pParamInfo) {
433                            m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
434                                    pPortInfo->params[i].value);
435                    }
436            }
437    }
438    
439    
440    // Device port/channel property accessors.
441    int qsamplerDevicePort::portID (void) const
442    {
443            return m_iPortID;
444    }
445    
446    const QString& qsamplerDevicePort::portName (void) const
447    {
448            return m_sPortName;
449    }
450    
451    // Device port/channel parameter accessor.
452    const qsamplerDeviceParamMap& qsamplerDevicePort::params (void) const
453    {
454            return m_params;
455    }
456    
457    
458    // Set the proper device port/channel parameter value.
459    void qsamplerDevicePort::setParam ( const QString& sParam,
460            const QString& sValue )
461    {
462            m_params[sParam.upper()].value = sValue;
463    }
464    
465    
466    //-------------------------------------------------------------------------
467  // qsamplerDeviceItem - QListView device item.  // qsamplerDeviceItem - QListView device item.
468  //  //
469    
470  // Constructors.  // Constructors.
471  qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView, lscp_client_t *pClient,  qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView,
472          qsamplerDevice::qsamplerDeviceType deviceType )          lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType )
473          : QListViewItem(pListView), m_device(pClient, deviceType)          : QListViewItem(pListView), m_device(pClient, deviceType)
474  {  {
475          switch(m_device.deviceType()) {          switch(m_device.deviceType()) {
476            case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
477                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio1.png"));                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio1.png"));
478                  QListViewItem::setText(0, QObject::tr("Audio devices"));                  QListViewItem::setText(0, QObject::tr("Audio devices"));
479                  break;                  break;
480            case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
481                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));
482                  QListViewItem::setText(0, QObject::tr("MIDI devices"));                  QListViewItem::setText(0, QObject::tr("MIDI devices"));
483                  break;                  break;
484            case qsamplerDevice::None:
485                    break;
486          }          }
487  }  }
488    
489  qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem, lscp_client_t *pClient,  qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem,
490          qsamplerDevice::qsamplerDeviceType deviceType, int iDeviceID )          lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType,
491            int iDeviceID )
492          : QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)          : QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)
493  {  {
494          switch(m_device.deviceType()) {          switch(m_device.deviceType()) {
495            case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
496                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio2.png"));                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio2.png"));
497                  break;                  break;
498            case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
499                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));                  QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));
500                  break;                  break;
501            case qsamplerDevice::None:
502                    break;
503          }          }
504    
505          QListViewItem::setText(0, m_device.deviceName());          QListViewItem::setText(0, m_device.deviceName());
# Line 283  qsamplerDeviceItem::~qsamplerDeviceItem Line 511  qsamplerDeviceItem::~qsamplerDeviceItem
511  }  }
512    
513  // Instance accessors.  // Instance accessors.
514  const qsamplerDevice& qsamplerDeviceItem::device (void)  qsamplerDevice& qsamplerDeviceItem::device (void)
515  {  {
516          return m_device;          return m_device;
517  }  }
# Line 301  int qsamplerDeviceItem::rtti() const Line 529  int qsamplerDeviceItem::rtti() const
529  //  //
530    
531  // Constructor.  // Constructor.
532  qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent, const char *pszName )  qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent,
533            const char *pszName )
534          : QTable(pParent, pszName)          : QTable(pParent, pszName)
535  {  {
         m_pClient = NULL;  
         m_iDeviceID = -1;  
   
536          // Set fixed number of columns.          // Set fixed number of columns.
537          QTable::setNumCols(3);          QTable::setNumCols(3);
538          QTable::setShowGrid(false);          QTable::setShowGrid(false);
# Line 325  qsamplerDeviceParamTable::qsamplerDevice Line 551  qsamplerDeviceParamTable::qsamplerDevice
551          QTable::setColumnReadOnly(0, true);          QTable::setColumnReadOnly(0, true);
552          QTable::setColumnReadOnly(1, true);          QTable::setColumnReadOnly(1, true);
553  //  QTable::setColumnReadOnly(2, true); -- of course not.  //  QTable::setColumnReadOnly(2, true); -- of course not.
554            QTable::setColumnStretchable(1, true);
555  }  }
556    
557  // Default destructor.  // Default destructor.
# Line 333  qsamplerDeviceParamTable::~qsamplerDevic Line 560  qsamplerDeviceParamTable::~qsamplerDevic
560  }  }
561    
562    
563  // Client/device descriptor selector.  // Common parameter table renderer.
564  void qsamplerDeviceParamTable::setDevice ( lscp_client_t *pClient,  void qsamplerDeviceParamTable::refresh ( const qsamplerDeviceParamMap& params,
565                  qsamplerDevice::qsamplerDeviceType deviceType, int iDeviceID )          bool bEditable )
566  {  {
567          if (m_pClient          // Always (re)start it empty.
568                  && m_pClient    == pClient          QTable::setUpdatesEnabled(false);
569                  && m_deviceType == deviceType          QTable::setNumRows(0);
570                  && m_iDeviceID  == iDeviceID)  
571              return;          // Fill the parameter table...
572                        QTable::insertRows(0, params.count());
573      m_pClient = pClient;          int iRow = 0;
574      m_deviceType = deviceType;          qsamplerDeviceParamMap::ConstIterator iter;
575      m_iDeviceID = iDeviceID;          for (iter = params.begin(); iter != params.end(); ++iter) {
576                        const qsamplerDeviceParam& param = iter.data();
577      refresh();                  bool bEnabled = (bEditable || !param.fix);
578                    QTable::setText(iRow, 0, iter.key());
579                    QTable::setText(iRow, 1, param.description);
580                    if (param.type == LSCP_TYPE_BOOL) {
581                            QStringList opts;
582                            opts.append(tr("false"));
583                            opts.append(tr("true"));
584                            QComboTableItem *pComboItem = new QComboTableItem(this, opts);
585                            pComboItem->setCurrentItem(param.value.lower() == "true" ? 1 : 0);
586                            pComboItem->setEnabled(bEnabled);
587                            QTable::setItem(iRow, 2, pComboItem);
588                    } else if (param.possibilities.count() > 0 && bEnabled) {
589                            QComboTableItem *pComboItem = new QComboTableItem(this,
590                                    param.possibilities);
591                            pComboItem->setCurrentItem(param.value);
592                            pComboItem->setEnabled(bEnabled);
593                            pComboItem->setEditable(bEnabled && param.multiplicity);
594                            QTable::setItem(iRow, 2, pComboItem);
595                    } else if (param.type == LSCP_TYPE_INT && bEnabled
596                                    && !param.range_min.isEmpty()
597                                    && !param.range_max.isEmpty()) {
598                            qsamplerDeviceParamTableSpinBox *pSpinItem =
599                                    new qsamplerDeviceParamTableSpinBox(this,
600                                            bEnabled ? QTableItem::OnTyping : QTableItem::Never,
601                                            param.value);
602                            pSpinItem->setMinValue(param.range_min.toInt());
603                            pSpinItem->setMaxValue(param.range_max.toInt());
604                            QTable::setItem(iRow, 2, pSpinItem);
605                    } else {
606                            qsamplerDeviceParamTableEditBox *pEditItem =
607                                    new qsamplerDeviceParamTableEditBox(this,
608                                            bEnabled ? QTableItem::OnTyping : QTableItem::Never,
609                                            param.value);
610                            QTable::setItem(iRow, 2, pEditItem);
611                    }
612                    ++iRow;
613            }
614    
615            // Adjust optimal column widths.
616            QTable::adjustColumn(0);
617            QTable::adjustColumn(2);
618    
619            QTable::setUpdatesEnabled(true);
620            QTable::updateContents();
621  }  }
622    
623    
624  // Client/device descriptor accessors.  //-------------------------------------------------------------------------
625  lscp_client_t *qsamplerDeviceParamTable::client (void)  // qsamplerDeviceParamTableSpinBox - Custom spin box for parameter table.
626    //
627    
628    // Constructor.
629    qsamplerDeviceParamTableSpinBox::qsamplerDeviceParamTableSpinBox (
630            QTable *pTable, EditType editType, const QString& sText )
631            : QTableItem(pTable, editType, sText)
632  {  {
633      return m_pClient;          m_iValue = sText.toInt();
634            m_iMinValue = m_iMaxValue = 0;
635  }  }
636    
637  int qsamplerDeviceParamTable::deviceID (void)  // Public accessors.
638    void qsamplerDeviceParamTableSpinBox::setValue ( int iValue )
639  {  {
640      return m_iDeviceID;          m_iValue = iValue;
641            QTableItem::setText(QString::number(m_iValue));
642  }  }
643    
644    void qsamplerDeviceParamTableSpinBox::setMinValue ( int iMinValue )
645    {
646            m_iMinValue = iMinValue;
647    }
648    
649  // The main table refresher.  void qsamplerDeviceParamTableSpinBox::setMaxValue ( int iMaxValue )
 void qsamplerDeviceParamTable::refresh (void)  
650  {  {
651          // Always (re)start it empty.          m_iMaxValue = iMaxValue;
652          QTable::setNumRows(0);  }
653    
654          if (m_pClient == NULL)  // Virtual implemetations.
655              return;  QWidget *qsamplerDeviceParamTableSpinBox::createEditor (void) const
656                {
657          // Construct the local device object here.          QSpinBox *pSpinBox = new QSpinBox(QTableItem::table()->viewport());
658          qsamplerDevice device(m_pClient, m_deviceType, m_iDeviceID);          QObject::connect(pSpinBox, SIGNAL(valueChanged(int)),
659                    QTableItem::table(), SLOT(doValueChanged()));
660            if (m_iValue >= m_iMinValue && m_iMaxValue >= m_iValue) {
661                    pSpinBox->setMinValue(m_iMinValue);
662                    pSpinBox->setMaxValue(m_iMaxValue);
663            }
664            pSpinBox->setValue(m_iValue);
665            return pSpinBox;
666    }
667    
668    void qsamplerDeviceParamTableSpinBox::setContentFromEditor ( QWidget *pWidget )
669    {
670            if (pWidget->inherits("QSpinBox"))
671                    QTableItem::setText(QString::number(((QSpinBox *) pWidget)->value()));
672            else
673                    QTableItem::setContentFromEditor(pWidget);
674    }
675    
         // Now fill the parameter table...  
         QHeader *pHeader = QTable::verticalHeader();  
     qsamplerDeviceParamMap& params = device.params();  
         QTable::insertRows(0, params.count());  
         int iRow = 0;  
         qsamplerDeviceParamMap::Iterator iter;  
         for (iter = params.begin(); iter != params.end(); ++iter) {  
         QTable::setText(iRow, 0, iter.key());  
             QTable::setText(iRow, 1, iter.data().description);  
             QTable::setText(iRow, 2, iter.data().value);  
             ++iRow;  
         }  
676    
677          // Adjust optimal column width.  //-------------------------------------------------------------------------
678          for (int iCol = 0; iCol < QTable::numCols(); iCol++)  // qsamplerDeviceParamTableEditBox - Custom edit box for parameter table.
679                  QTable::adjustColumn(iCol);  //
680    
681    // Constructor.
682    qsamplerDeviceParamTableEditBox::qsamplerDeviceParamTableEditBox (
683            QTable *pTable, EditType editType, const QString& sText )
684            : QTableItem(pTable, editType, sText)
685    {
686    }
687    
688    // Virtual implemetations.
689    QWidget *qsamplerDeviceParamTableEditBox::createEditor (void) const
690    {
691            QLineEdit *pEditBox = new QLineEdit(QTableItem::table()->viewport());
692            QObject::connect(pEditBox, SIGNAL(returnPressed()),
693                    QTableItem::table(), SLOT(doValueChanged()));
694            pEditBox->setText(QTableItem::text());
695            return pEditBox;
696    }
697    
698    void qsamplerDeviceParamTableEditBox::setContentFromEditor ( QWidget *pWidget )
699    {
700            if (pWidget->inherits("QLineEdit"))
701                    QTableItem::setText(((QLineEdit *) pWidget)->text());
702            else
703                    QTableItem::setContentFromEditor(pWidget);
704  }  }
705    
706    
Legend:
Removed from v.430  
changed lines
  Added in v.463
  ViewVC Help
Powered by ViewVC