/[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 426 by capela, Mon Mar 7 11:09:32 2005 UTC revision 436 by capela, Wed Mar 9 20:55:04 2005 UTC
# Line 1  Line 1 
1  // qsamplerDevice.cpp  // qsamplerDevice.cpp
2  //  //
3  /****************************************************************************  /****************************************************************************
4     Copyright (C) 2003-2005, rncbc aka Rui Nuno Capela. All rights reserved.     Copyright (C) 2005, 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 28  Line 28 
28    
29    
30  //-------------------------------------------------------------------------  //-------------------------------------------------------------------------
31  // qsamplerDeviceParameterTable - Device parameter view table.  // qsamplerDeviceParam - MIDI/Audio Device parameter structure.
32    //
33    
34    // Constructors.
35    qsamplerDeviceParam::qsamplerDeviceParam ( lscp_param_info_t *pParamInfo,
36            const char *pszValue )
37    {
38            setParam(pParamInfo, pszValue);
39    }
40    
41    
42    // Default destructor.
43    qsamplerDeviceParam::~qsamplerDeviceParam (void)
44    {
45    }
46    
47    
48    // Initializer.
49    void qsamplerDeviceParam::setParam ( lscp_param_info_t *pParamInfo,
50            const char *pszValue )
51    {
52            if (pParamInfo == NULL)
53                    return;
54                    
55            // Info structure field members.
56            
57            type = pParamInfo->type;
58            
59            if (pParamInfo->description)
60                    description = pParamInfo->description;
61            else
62                    description = QString::null;
63            
64            mandatory = (bool) pParamInfo->multiplicity;
65            fix = (bool) pParamInfo->fix;
66            multiplicity = (bool) pParamInfo->multiplicity;
67            
68            depends.clear();
69            for (int i = 0; pParamInfo->depends && pParamInfo->depends[i]; i++)
70                    depends.append(pParamInfo->depends[i]);
71            
72            if (pParamInfo->defaultv)
73                    defaultv = pParamInfo->defaultv;
74            else
75                    defaultv = QString::null;
76            
77            if (pParamInfo->range_min)
78                    range_min = pParamInfo->range_min;
79            else
80                    range_min = QString::null;
81            
82            if (pParamInfo->range_max)
83                    range_max = pParamInfo->range_max;
84            else
85                    range_max = QString::null;
86            
87            possibilities.clear();
88            for (int i = 0; pParamInfo->possibilities && pParamInfo->possibilities[i]; i++)
89                    possibilities.append(pParamInfo->possibilities[i]);
90                    
91            // The current parameter value.
92            if (pszValue)
93                    value = pszValue;
94            else
95                    value = QString::null;
96    }
97    
98    
99    //-------------------------------------------------------------------------
100    // qsamplerDevice - MIDI/Audio Device structure.
101  //  //
102    
103  // Constructor.  // Constructor.
104  qsamplerDeviceParameterTable::qsamplerDeviceParameterTable ( QWidget *pParent, const char *pszName )  qsamplerDevice::qsamplerDevice ( lscp_client_t *pClient,
105          : QTable(pParent, pszName)          qsamplerDeviceType deviceType, int iDeviceID )
106  {  {
107          m_pClient = NULL;          setDevice(pClient, deviceType, iDeviceID);
108  }  }
109    
110  // Default destructor.  // Default destructor.
111  qsamplerDeviceParameterTable::~qsamplerDeviceParameterTable (void)  qsamplerDevice::~qsamplerDevice (void)
112  {  {
113  }  }
114    
115    
116  // The client descriptor property accessors.  // Initializer.
117  void qsamplerDeviceParameterTable::setClient ( lscp_client_t *pClient )  void qsamplerDevice::setDevice ( lscp_client_t *pClient,
118            qsamplerDeviceType deviceType, int iDeviceID )
119  {  {
120      m_pClient = pClient;          // Device id and type should be always set.
121            m_iDeviceID   = iDeviceID;
122            m_deviceType  = deviceType;
123    
124            // Retrieve device info, if any.
125            lscp_device_info_t *pDeviceInfo = NULL;
126            switch (deviceType) {
127            case qsamplerDevice::Audio:
128                    m_sDeviceType = QObject::tr("Audio");
129                    pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);
130                    break;
131            case qsamplerDevice::Midi:
132                    m_sDeviceType = QObject::tr("MIDI");
133                    pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);
134                    break;
135            case qsamplerDevice::None:
136                    m_sDeviceType = QString::null;
137                    break;
138            }
139    
140            // If we're bogus, bail out...
141            if (pDeviceInfo == NULL) {
142                    m_sDriverName = QString::null;
143                    m_sDeviceName = QObject::tr("New device");
144                    return;
145            }
146    
147            // Other device properties...
148            m_sDriverName = pDeviceInfo->driver;
149            m_sDeviceName = m_sDriverName + ' '
150                    + QObject::tr("Device %1").arg(m_iDeviceID);
151    
152            // Grab device parameters...
153            m_params.clear();
154            for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {
155                    const char *pszParam = pDeviceInfo->params[i].key;
156                    lscp_param_info_t *pParamInfo = NULL;
157                    switch (deviceType) {
158                    case qsamplerDevice::Audio:
159                            pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
160                                    m_sDriverName.latin1(), pszParam, NULL);
161                            break;
162                    case qsamplerDevice::Midi:
163                            pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
164                                    m_sDriverName.latin1(), pszParam, NULL);
165                            break;
166                    case qsamplerDevice::None:
167                            break;
168                    }
169                    if (pParamInfo) {
170                            m_params[pszParam] = qsamplerDeviceParam(pParamInfo,
171                                    pDeviceInfo->params[i].value);
172                    }
173            }
174  }  }
175    
176  lscp_client_t *qsamplerDeviceParameterTable::client (void)  
177    // Driver name initializer.
178    void qsamplerDevice::setDriver ( lscp_client_t *pClient,
179            const QString& sDriverName )
180  {  {
181      return m_pClient;          // Valid only for scratch devices.
182            if (m_sDriverName == sDriverName)
183                    return;
184    
185            // Retrieve driver info, if any.
186            lscp_driver_info_t *pDriverInfo = NULL;
187            switch (m_deviceType) {
188            case qsamplerDevice::Audio:
189                    pDriverInfo = ::lscp_get_audio_driver_info(pClient,
190                            sDriverName.latin1());
191                    break;
192            case qsamplerDevice::Midi:
193                    pDriverInfo = ::lscp_get_midi_driver_info(pClient,
194                            sDriverName.latin1());
195                    break;
196            case qsamplerDevice::None:
197                    break;
198            }
199    
200            // If we're bogus, bail out...
201            if (pDriverInfo == NULL)
202                    return;
203    
204            // Remember device parameters...
205            m_sDriverName = sDriverName;
206    
207            // Grab driver parameters...
208            m_params.clear();
209            for (int i = 0; pDriverInfo->parameters && pDriverInfo->parameters[i]; i++) {
210                    const char *pszParam = pDriverInfo->parameters[i];
211                    lscp_param_info_t *pParamInfo = NULL;
212                    switch (m_deviceType) {
213                    case qsamplerDevice::Audio:
214                            pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
215                                    sDriverName.latin1(), pszParam, NULL);
216                            break;
217                    case qsamplerDevice::Midi:
218                            pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
219                                    sDriverName.latin1(), pszParam, NULL);
220                            break;
221                    case qsamplerDevice::None:
222                            break;
223                    }
224                    if (pParamInfo)
225                            m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pParamInfo->defaultv);
226            }
227    }
228    
229    
230    // Device property accessors.
231    int qsamplerDevice::deviceID (void) const
232    {
233            return m_iDeviceID;
234    }
235    
236    qsamplerDevice::qsamplerDeviceType qsamplerDevice::deviceType (void) const
237    {
238            return m_deviceType;
239    }
240    
241    const QString& qsamplerDevice::deviceTypeName (void) const
242    {
243            return m_sDeviceType;
244    }
245    
246    const QString& qsamplerDevice::driverName (void) const
247    {
248            return m_sDriverName;
249    }
250    
251    const QString& qsamplerDevice::deviceName (void) const
252    {
253            return m_sDeviceName;
254    }
255    
256    // Device parameter accessor.
257    qsamplerDeviceParamMap& qsamplerDevice::params (void)
258    {
259            return m_params;
260    }
261    
262    
263    // Update/refresh device/driver data.
264    void qsamplerDevice::refresh (void)
265    {
266    }
267    
268    // Device ids enumerator.
269    int *qsamplerDevice::getDevices ( lscp_client_t *pClient,
270            qsamplerDeviceType deviceType )
271    {
272            int *piDeviceIDs = NULL;
273            switch (deviceType) {
274            case qsamplerDevice::Audio:
275                    piDeviceIDs = ::lscp_list_audio_devices(pClient);
276                    break;
277            case qsamplerDevice::Midi:
278                    piDeviceIDs = ::lscp_list_midi_devices(pClient);
279                    break;
280            case qsamplerDevice::None:
281                    break;
282            }
283            return piDeviceIDs;
284    }
285    
286    
287    // Driver names enumerator.
288    QStringList qsamplerDevice::getDrivers ( lscp_client_t *pClient,
289            qsamplerDeviceType deviceType )
290    {
291            QStringList drivers;
292            
293            const char **ppszDrivers = NULL;
294            switch (deviceType) {
295            case qsamplerDevice::Audio:
296                    ppszDrivers = ::lscp_get_available_audio_drivers(pClient);
297                    break;
298            case qsamplerDevice::Midi:
299                    ppszDrivers = ::lscp_get_available_midi_drivers(pClient);
300                    break;
301            case qsamplerDevice::None:
302                    break;
303            }
304            
305            for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)
306                    drivers.append(ppszDrivers[iDriver]);
307    
308            return drivers;
309    }
310    
311    
312    //-------------------------------------------------------------------------
313    // qsamplerDeviceItem - QListView device item.
314    //
315    
316    // Constructors.
317    qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView,
318            lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType )
319            : QListViewItem(pListView), m_device(pClient, deviceType)
320    {
321            switch(m_device.deviceType()) {
322            case qsamplerDevice::Audio:
323                    QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio1.png"));
324                    QListViewItem::setText(0, QObject::tr("Audio devices"));
325                    break;
326            case qsamplerDevice::Midi:
327                    QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));
328                    QListViewItem::setText(0, QObject::tr("MIDI devices"));
329                    break;
330            case qsamplerDevice::None:
331                    break;
332            }
333    }
334    
335    qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem,
336            lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType,
337            int iDeviceID )
338            : QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)
339    {
340            switch(m_device.deviceType()) {
341            case qsamplerDevice::Audio:
342                    QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio2.png"));
343                    break;
344            case qsamplerDevice::Midi:
345                    QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));
346                    break;
347            case qsamplerDevice::None:
348                    break;
349            }
350    
351            QListViewItem::setText(0, m_device.deviceName());
352    }
353    
354    // Default destructor.
355    qsamplerDeviceItem::~qsamplerDeviceItem (void)
356    {
357    }
358    
359    // Instance accessors.
360    qsamplerDevice& qsamplerDeviceItem::device (void)
361    {
362            return m_device;
363    }
364    
365    // To virtually distinguish between list view items.
366    int qsamplerDeviceItem::rtti() const
367    {
368            return QSAMPLER_DEVICE_ITEM;
369    }
370    
371    
372    
373    //-------------------------------------------------------------------------
374    // qsamplerDeviceParamTable - Device parameter view table.
375    //
376    
377    // Constructor.
378    qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent,
379            const char *pszName )
380            : QTable(pParent, pszName)
381    {
382            // Set fixed number of columns.
383            QTable::setNumCols(3);
384            QTable::setShowGrid(false);
385            QTable::setSorting(false);
386            QTable::setFocusStyle(QTable::FollowStyle);
387            QTable::setSelectionMode(QTable::NoSelection);
388            // No vertical header.
389            QTable::verticalHeader()->hide();
390            QTable::setLeftMargin(0);
391            // Initialize the fixed table column headings.
392            QHeader *pHeader = QTable::horizontalHeader();
393            pHeader->setLabel(0, tr("Parameter"));
394            pHeader->setLabel(1, tr("Description"));
395            pHeader->setLabel(2, tr("Value"));
396            // Set read-onlyness of each column
397            QTable::setColumnReadOnly(0, true);
398            QTable::setColumnReadOnly(1, true);
399    //  QTable::setColumnReadOnly(2, true); -- of course not.
400            QTable::setColumnStretchable(1, true);
401    }
402    
403    // Default destructor.
404    qsamplerDeviceParamTable::~qsamplerDeviceParamTable (void)
405    {
406    }
407    
408    
409    // The main table refresher.
410    void qsamplerDeviceParamTable::refresh ( qsamplerDevice& device )
411    {
412            // Always (re)start it empty.
413            QTable::setUpdatesEnabled(false);
414            QTable::setNumRows(0);
415    
416            // Now fill the parameter table...
417            qsamplerDeviceParamMap& params = device.params();
418            QTable::insertRows(0, params.count());
419            int iRow = 0;
420            qsamplerDeviceParamMap::ConstIterator iter;
421            for (iter = params.begin(); iter != params.end(); ++iter) {
422                    const qsamplerDeviceParam& param = iter.data();
423                    bool fEnabled = (device.deviceID() < 0 || !param.fix);
424                    QTable::setText(iRow, 0, iter.key());
425                    QTable::setText(iRow, 1, param.description);
426                    if (param.type == LSCP_TYPE_BOOL) {
427                            QStringList opts;
428                            opts.append(tr("false"));
429                            opts.append(tr("true"));
430                            QComboTableItem *pComboItem = new QComboTableItem(this, opts);
431                        pComboItem->setCurrentItem(param.value.lower() == "true" ? 1 : 0);
432                        pComboItem->setEnabled(fEnabled);
433                            QTable::setItem(iRow, 2, pComboItem);
434                    } else if (param.possibilities.count() > 0 && !param.multiplicity) {
435                            QComboTableItem *pComboItem = new QComboTableItem(this,
436                                    param.possibilities);
437                        pComboItem->setCurrentItem(param.value);
438                        pComboItem->setEnabled(fEnabled);
439                            QTable::setItem(iRow, 2, pComboItem);
440                    } else {
441                            QTableItem* pTableItem = new QTableItem(this,
442                                    fEnabled ? QTableItem::OnTyping : QTableItem::Never,
443                                    param.value);
444                            QTable::setItem(iRow, 2, pTableItem);
445                    }
446                    ++iRow;
447            }
448    
449            // Adjust optimal column widths.
450            QTable::adjustColumn(0);
451            QTable::adjustColumn(2);
452    
453            QTable::setUpdatesEnabled(true);
454            QTable::updateContents();
455  }  }
456    
457    
Legend:
Removed from v.426  
changed lines
  Added in v.436
  ViewVC Help
Powered by ViewVC