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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 436 - (hide annotations) (download)
Wed Mar 9 20:55:04 2005 UTC (19 years ago) by capela
File size: 11975 byte(s)
Device configuration is now partially functional (2nd.fix).

1 capela 426 // qsamplerDevice.cpp
2     //
3     /****************************************************************************
4 capela 430 Copyright (C) 2005, rncbc aka Rui Nuno Capela. All rights reserved.
5 capela 426
6     This program is free software; you can redistribute it and/or
7     modify it under the terms of the GNU General Public License
8     as published by the Free Software Foundation; either version 2
9     of the License, or (at your option) any later version.
10    
11     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14     GNU General Public License for more details.
15    
16     You should have received a copy of the GNU General Public License
17     along with this program; if not, write to the Free Software
18     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19    
20     *****************************************************************************/
21    
22     #include "qsamplerDevice.h"
23    
24     #include "qsamplerMainForm.h"
25     #include "qsamplerDeviceForm.h"
26    
27     #include "config.h"
28    
29    
30     //-------------------------------------------------------------------------
31 capela 429 // qsamplerDeviceParam - MIDI/Audio Device parameter structure.
32 capela 426 //
33    
34 capela 429 // 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 capela 431 return;
54    
55     // Info structure field members.
56    
57 capela 429 type = pParamInfo->type;
58 capela 431
59 capela 429 if (pParamInfo->description)
60     description = pParamInfo->description;
61     else
62     description = QString::null;
63 capela 431
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 capela 429 if (pParamInfo->defaultv)
73     defaultv = pParamInfo->defaultv;
74     else
75     defaultv = QString::null;
76 capela 431
77 capela 429 if (pParamInfo->range_min)
78 capela 431 range_min = pParamInfo->range_min;
79 capela 429 else
80     range_min = QString::null;
81 capela 431
82 capela 429 if (pParamInfo->range_max)
83 capela 431 range_max = pParamInfo->range_max;
84 capela 429 else
85     range_max = QString::null;
86 capela 431
87 capela 429 possibilities.clear();
88 capela 431 for (int i = 0; pParamInfo->possibilities && pParamInfo->possibilities[i]; i++)
89     possibilities.append(pParamInfo->possibilities[i]);
90    
91     // The current parameter value.
92 capela 429 if (pszValue)
93 capela 431 value = pszValue;
94 capela 429 else
95     value = QString::null;
96     }
97    
98    
99     //-------------------------------------------------------------------------
100     // qsamplerDevice - MIDI/Audio Device structure.
101     //
102    
103 capela 426 // Constructor.
104 capela 429 qsamplerDevice::qsamplerDevice ( lscp_client_t *pClient,
105     qsamplerDeviceType deviceType, int iDeviceID )
106     {
107     setDevice(pClient, deviceType, iDeviceID);
108     }
109    
110     // Default destructor.
111     qsamplerDevice::~qsamplerDevice (void)
112     {
113     }
114    
115    
116     // Initializer.
117     void qsamplerDevice::setDevice ( lscp_client_t *pClient,
118     qsamplerDeviceType deviceType, int iDeviceID )
119     {
120 capela 430 // Device id and type should be always set.
121     m_iDeviceID = iDeviceID;
122     m_deviceType = deviceType;
123    
124     // Retrieve device info, if any.
125 capela 429 lscp_device_info_t *pDeviceInfo = NULL;
126     switch (deviceType) {
127 capela 431 case qsamplerDevice::Audio:
128 capela 433 m_sDeviceType = QObject::tr("Audio");
129 capela 431 pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);
130     break;
131     case qsamplerDevice::Midi:
132 capela 433 m_sDeviceType = QObject::tr("MIDI");
133 capela 429 pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);
134     break;
135 capela 436 case qsamplerDevice::None:
136 capela 433 m_sDeviceType = QString::null;
137     break;
138 capela 429 }
139 capela 431
140 capela 430 // If we're bogus, bail out...
141     if (pDeviceInfo == NULL) {
142     m_sDriverName = QString::null;
143 capela 433 m_sDeviceName = QObject::tr("New device");
144 capela 431 return;
145 capela 430 }
146 capela 431
147 capela 430 // Other device properties...
148 capela 429 m_sDriverName = pDeviceInfo->driver;
149 capela 430 m_sDeviceName = m_sDriverName + ' '
150     + QObject::tr("Device %1").arg(m_iDeviceID);
151 capela 429
152 capela 431 // Grab device parameters...
153 capela 429 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 capela 431 case qsamplerDevice::Audio:
159     pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
160 capela 429 m_sDriverName.latin1(), pszParam, NULL);
161 capela 431 break;
162     case qsamplerDevice::Midi:
163     pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
164 capela 429 m_sDriverName.latin1(), pszParam, NULL);
165     break;
166 capela 436 case qsamplerDevice::None:
167     break;
168 capela 429 }
169 capela 436 if (pParamInfo) {
170 capela 433 m_params[pszParam] = qsamplerDeviceParam(pParamInfo,
171     pDeviceInfo->params[i].value);
172 capela 436 }
173 capela 429 }
174     }
175    
176    
177 capela 431 // Driver name initializer.
178     void qsamplerDevice::setDriver ( lscp_client_t *pClient,
179     const QString& sDriverName )
180     {
181     // 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 capela 436 case qsamplerDevice::None:
197     break;
198 capela 431 }
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 capela 436 case qsamplerDevice::None:
222     break;
223 capela 431 }
224 capela 436 if (pParamInfo)
225     m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pParamInfo->defaultv);
226 capela 431 }
227     }
228    
229    
230 capela 429 // 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 capela 433 const QString& qsamplerDevice::deviceTypeName (void) const
242     {
243     return m_sDeviceType;
244     }
245    
246 capela 429 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 capela 430 // Device ids enumerator.
269 capela 429 int *qsamplerDevice::getDevices ( lscp_client_t *pClient,
270     qsamplerDeviceType deviceType )
271     {
272     int *piDeviceIDs = NULL;
273     switch (deviceType) {
274 capela 431 case qsamplerDevice::Audio:
275     piDeviceIDs = ::lscp_list_audio_devices(pClient);
276 capela 429 break;
277 capela 431 case qsamplerDevice::Midi:
278     piDeviceIDs = ::lscp_list_midi_devices(pClient);
279     break;
280 capela 436 case qsamplerDevice::None:
281     break;
282 capela 429 }
283     return piDeviceIDs;
284     }
285    
286 capela 430
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 capela 431 case qsamplerDevice::Audio:
296     ppszDrivers = ::lscp_get_available_audio_drivers(pClient);
297 capela 430 break;
298 capela 431 case qsamplerDevice::Midi:
299     ppszDrivers = ::lscp_get_available_midi_drivers(pClient);
300     break;
301 capela 436 case qsamplerDevice::None:
302     break;
303 capela 430 }
304    
305 capela 431 for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)
306     drivers.append(ppszDrivers[iDriver]);
307 capela 430
308     return drivers;
309     }
310    
311    
312 capela 429 //-------------------------------------------------------------------------
313     // qsamplerDeviceItem - QListView device item.
314     //
315    
316     // Constructors.
317 capela 433 qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView,
318     lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType )
319 capela 429 : QListViewItem(pListView), m_device(pClient, deviceType)
320     {
321     switch(m_device.deviceType()) {
322 capela 431 case qsamplerDevice::Audio:
323 capela 429 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio1.png"));
324     QListViewItem::setText(0, QObject::tr("Audio devices"));
325     break;
326 capela 431 case qsamplerDevice::Midi:
327 capela 429 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));
328     QListViewItem::setText(0, QObject::tr("MIDI devices"));
329     break;
330 capela 436 case qsamplerDevice::None:
331     break;
332 capela 429 }
333     }
334    
335 capela 433 qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem,
336     lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType,
337     int iDeviceID )
338 capela 429 : QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)
339     {
340     switch(m_device.deviceType()) {
341 capela 431 case qsamplerDevice::Audio:
342 capela 429 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio2.png"));
343     break;
344 capela 431 case qsamplerDevice::Midi:
345 capela 429 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));
346     break;
347 capela 436 case qsamplerDevice::None:
348     break;
349 capela 429 }
350    
351     QListViewItem::setText(0, m_device.deviceName());
352     }
353    
354     // Default destructor.
355     qsamplerDeviceItem::~qsamplerDeviceItem (void)
356     {
357     }
358    
359     // Instance accessors.
360 capela 431 qsamplerDevice& qsamplerDeviceItem::device (void)
361 capela 429 {
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 capela 433 qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent,
379     const char *pszName )
380 capela 426 : QTable(pParent, pszName)
381     {
382 capela 428 // Set fixed number of columns.
383 capela 429 QTable::setNumCols(3);
384 capela 428 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 capela 436 pHeader->setLabel(0, tr("Parameter"));
394     pHeader->setLabel(1, tr("Description"));
395     pHeader->setLabel(2, tr("Value"));
396 capela 428 // Set read-onlyness of each column
397     QTable::setColumnReadOnly(0, true);
398 capela 436 QTable::setColumnReadOnly(1, true);
399     // QTable::setColumnReadOnly(2, true); -- of course not.
400     QTable::setColumnStretchable(1, true);
401 capela 426 }
402    
403     // Default destructor.
404 capela 429 qsamplerDeviceParamTable::~qsamplerDeviceParamTable (void)
405 capela 426 {
406     }
407    
408    
409 capela 429 // The main table refresher.
410 capela 431 void qsamplerDeviceParamTable::refresh ( qsamplerDevice& device )
411 capela 429 {
412     // Always (re)start it empty.
413 capela 433 QTable::setUpdatesEnabled(false);
414 capela 429 QTable::setNumRows(0);
415    
416     // Now fill the parameter table...
417 capela 431 qsamplerDeviceParamMap& params = device.params();
418 capela 429 QTable::insertRows(0, params.count());
419     int iRow = 0;
420 capela 431 qsamplerDeviceParamMap::ConstIterator iter;
421 capela 429 for (iter = params.begin(); iter != params.end(); ++iter) {
422 capela 432 const qsamplerDeviceParam& param = iter.data();
423 capela 434 bool fEnabled = (device.deviceID() < 0 || !param.fix);
424 capela 436 QTable::setText(iRow, 0, iter.key());
425     QTable::setText(iRow, 1, param.description);
426 capela 432 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 capela 433 pComboItem->setEnabled(fEnabled);
433 capela 436 QTable::setItem(iRow, 2, pComboItem);
434 capela 433 } else if (param.possibilities.count() > 0 && !param.multiplicity) {
435 capela 432 QComboTableItem *pComboItem = new QComboTableItem(this,
436     param.possibilities);
437     pComboItem->setCurrentItem(param.value);
438 capela 433 pComboItem->setEnabled(fEnabled);
439 capela 436 QTable::setItem(iRow, 2, pComboItem);
440 capela 432 } else {
441     QTableItem* pTableItem = new QTableItem(this,
442 capela 436 fEnabled ? QTableItem::OnTyping : QTableItem::Never,
443 capela 432 param.value);
444 capela 436 QTable::setItem(iRow, 2, pTableItem);
445 capela 432 }
446 capela 431 ++iRow;
447 capela 429 }
448    
449 capela 433 // Adjust optimal column widths.
450 capela 436 QTable::adjustColumn(0);
451 capela 433 QTable::adjustColumn(2);
452 capela 436
453 capela 433 QTable::setUpdatesEnabled(true);
454     QTable::updateContents();
455 capela 429 }
456    
457    
458 capela 426 // end of qsamplerDevice.cpp

  ViewVC Help
Powered by ViewVC