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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 432 - (hide annotations) (download)
Wed Mar 9 11:33:27 2005 UTC (19 years ago) by capela
File size: 11400 byte(s)
Device configuration table is now editable, but non-applicable yet.

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     QString sDeviceType;
126 capela 429 lscp_device_info_t *pDeviceInfo = NULL;
127     switch (deviceType) {
128 capela 431 case qsamplerDevice::Audio:
129     sDeviceType = QObject::tr("Audio");
130     pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);
131     break;
132     case qsamplerDevice::Midi:
133     sDeviceType = QObject::tr("MIDI");
134 capela 429 pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);
135     break;
136     }
137 capela 431
138 capela 430 // If we're bogus, bail out...
139     if (pDeviceInfo == NULL) {
140     m_sDriverName = QString::null;
141     m_sDeviceName = QObject::tr("New %1 device").arg(sDeviceType);
142 capela 431 return;
143 capela 430 }
144 capela 431
145 capela 430 // Other device properties...
146 capela 429 m_sDriverName = pDeviceInfo->driver;
147 capela 430 m_sDeviceName = m_sDriverName + ' '
148     + QObject::tr("Device %1").arg(m_iDeviceID);
149 capela 429
150 capela 431 // Grab device parameters...
151 capela 429 m_params.clear();
152     for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {
153     const char *pszParam = pDeviceInfo->params[i].key;
154     lscp_param_info_t *pParamInfo = NULL;
155     switch (deviceType) {
156 capela 431 case qsamplerDevice::Audio:
157     pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
158 capela 429 m_sDriverName.latin1(), pszParam, NULL);
159 capela 431 break;
160     case qsamplerDevice::Midi:
161     pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
162 capela 429 m_sDriverName.latin1(), pszParam, NULL);
163     break;
164     }
165     m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pDeviceInfo->params[i].value);
166     }
167     }
168    
169    
170 capela 431 // Driver name initializer.
171     void qsamplerDevice::setDriver ( lscp_client_t *pClient,
172     const QString& sDriverName )
173     {
174     // Valid only for scratch devices.
175     if (m_sDriverName == sDriverName)
176     return;
177    
178     // Retrieve driver info, if any.
179     lscp_driver_info_t *pDriverInfo = NULL;
180     switch (m_deviceType) {
181     case qsamplerDevice::Audio:
182     pDriverInfo = ::lscp_get_audio_driver_info(pClient,
183     sDriverName.latin1());
184     break;
185     case qsamplerDevice::Midi:
186     pDriverInfo = ::lscp_get_midi_driver_info(pClient,
187     sDriverName.latin1());
188     break;
189     }
190    
191     // If we're bogus, bail out...
192     if (pDriverInfo == NULL)
193     return;
194    
195     // Remember device parameters...
196     m_sDriverName = sDriverName;
197    
198     // Grab driver parameters...
199     m_params.clear();
200     for (int i = 0; pDriverInfo->parameters && pDriverInfo->parameters[i]; i++) {
201     const char *pszParam = pDriverInfo->parameters[i];
202     lscp_param_info_t *pParamInfo = NULL;
203     switch (m_deviceType) {
204     case qsamplerDevice::Audio:
205     pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
206     sDriverName.latin1(), pszParam, NULL);
207     break;
208     case qsamplerDevice::Midi:
209     pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
210     sDriverName.latin1(), pszParam, NULL);
211     break;
212     }
213     m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pParamInfo->defaultv);
214     }
215     }
216    
217    
218 capela 429 // Device property accessors.
219     int qsamplerDevice::deviceID (void) const
220     {
221     return m_iDeviceID;
222     }
223    
224     qsamplerDevice::qsamplerDeviceType qsamplerDevice::deviceType (void) const
225     {
226     return m_deviceType;
227     }
228    
229     const QString& qsamplerDevice::driverName (void) const
230     {
231     return m_sDriverName;
232     }
233    
234     const QString& qsamplerDevice::deviceName (void) const
235     {
236     return m_sDeviceName;
237     }
238    
239     // Device parameter accessor.
240     qsamplerDeviceParamMap& qsamplerDevice::params (void)
241     {
242     return m_params;
243     }
244    
245    
246     // Update/refresh device/driver data.
247     void qsamplerDevice::refresh (void)
248     {
249     }
250    
251 capela 430 // Device ids enumerator.
252 capela 429 int *qsamplerDevice::getDevices ( lscp_client_t *pClient,
253     qsamplerDeviceType deviceType )
254     {
255     int *piDeviceIDs = NULL;
256     switch (deviceType) {
257 capela 431 case qsamplerDevice::Audio:
258     piDeviceIDs = ::lscp_list_audio_devices(pClient);
259 capela 429 break;
260 capela 431 case qsamplerDevice::Midi:
261     piDeviceIDs = ::lscp_list_midi_devices(pClient);
262     break;
263 capela 429 }
264     return piDeviceIDs;
265     }
266    
267 capela 430
268     // Driver names enumerator.
269     QStringList qsamplerDevice::getDrivers ( lscp_client_t *pClient,
270     qsamplerDeviceType deviceType )
271     {
272     QStringList drivers;
273    
274     const char **ppszDrivers = NULL;
275     switch (deviceType) {
276 capela 431 case qsamplerDevice::Audio:
277     ppszDrivers = ::lscp_get_available_audio_drivers(pClient);
278 capela 430 break;
279 capela 431 case qsamplerDevice::Midi:
280     ppszDrivers = ::lscp_get_available_midi_drivers(pClient);
281     break;
282 capela 430 }
283    
284 capela 431 for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)
285     drivers.append(ppszDrivers[iDriver]);
286 capela 430
287     return drivers;
288     }
289    
290    
291 capela 429 //-------------------------------------------------------------------------
292     // qsamplerDeviceItem - QListView device item.
293     //
294    
295     // Constructors.
296     qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView, lscp_client_t *pClient,
297     qsamplerDevice::qsamplerDeviceType deviceType )
298     : QListViewItem(pListView), m_device(pClient, deviceType)
299     {
300     switch(m_device.deviceType()) {
301 capela 431 case qsamplerDevice::Audio:
302 capela 429 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio1.png"));
303     QListViewItem::setText(0, QObject::tr("Audio devices"));
304     break;
305 capela 431 case qsamplerDevice::Midi:
306 capela 429 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));
307     QListViewItem::setText(0, QObject::tr("MIDI devices"));
308     break;
309     }
310     }
311    
312     qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem, lscp_client_t *pClient,
313     qsamplerDevice::qsamplerDeviceType deviceType, int iDeviceID )
314     : QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)
315     {
316     switch(m_device.deviceType()) {
317 capela 431 case qsamplerDevice::Audio:
318 capela 429 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio2.png"));
319     break;
320 capela 431 case qsamplerDevice::Midi:
321 capela 429 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));
322     break;
323     }
324    
325     QListViewItem::setText(0, m_device.deviceName());
326     }
327    
328     // Default destructor.
329     qsamplerDeviceItem::~qsamplerDeviceItem (void)
330     {
331     }
332    
333     // Instance accessors.
334 capela 431 qsamplerDevice& qsamplerDeviceItem::device (void)
335 capela 429 {
336     return m_device;
337     }
338    
339     // To virtually distinguish between list view items.
340     int qsamplerDeviceItem::rtti() const
341     {
342     return QSAMPLER_DEVICE_ITEM;
343     }
344    
345    
346    
347     //-------------------------------------------------------------------------
348     // qsamplerDeviceParamTable - Device parameter view table.
349     //
350    
351     // Constructor.
352     qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent, const char *pszName )
353 capela 426 : QTable(pParent, pszName)
354     {
355 capela 428 // Set fixed number of columns.
356 capela 429 QTable::setNumCols(3);
357 capela 428 QTable::setShowGrid(false);
358     QTable::setSorting(false);
359     QTable::setFocusStyle(QTable::FollowStyle);
360     QTable::setSelectionMode(QTable::NoSelection);
361     // No vertical header.
362     QTable::verticalHeader()->hide();
363     QTable::setLeftMargin(0);
364     // Initialize the fixed table column headings.
365     QHeader *pHeader = QTable::horizontalHeader();
366 capela 432 pHeader->setLabel(0, tr("Description"));
367 capela 431 pHeader->setLabel(1, tr("Value"));
368 capela 432 pHeader->setLabel(2, tr("Parameter"));
369 capela 428 // Set read-onlyness of each column
370     QTable::setColumnReadOnly(0, true);
371 capela 431 // QTable::setColumnReadOnly(1, true); -- of course not.
372     QTable::setColumnReadOnly(2, true);
373 capela 432 QTable::setColumnStretchable(0, true);
374 capela 426 }
375    
376     // Default destructor.
377 capela 429 qsamplerDeviceParamTable::~qsamplerDeviceParamTable (void)
378 capela 426 {
379     }
380    
381    
382 capela 429 // The main table refresher.
383 capela 431 void qsamplerDeviceParamTable::refresh ( qsamplerDevice& device )
384 capela 429 {
385     // Always (re)start it empty.
386     QTable::setNumRows(0);
387    
388     // Now fill the parameter table...
389 capela 431 qsamplerDeviceParamMap& params = device.params();
390 capela 429 QTable::insertRows(0, params.count());
391     int iRow = 0;
392 capela 431 qsamplerDeviceParamMap::ConstIterator iter;
393 capela 429 for (iter = params.begin(); iter != params.end(); ++iter) {
394 capela 432 const qsamplerDeviceParam& param = iter.data();
395     QTable::setText(iRow, 0, param.description);
396     if (param.type == LSCP_TYPE_BOOL) {
397     QStringList opts;
398     opts.append(tr("false"));
399     opts.append(tr("true"));
400     QComboTableItem *pComboItem = new QComboTableItem(this, opts);
401     pComboItem->setCurrentItem(param.value.lower() == "true" ? 1 : 0);
402     pComboItem->setEnabled(param.fix);
403     QTable::setItem(iRow, 1, pComboItem);
404     } else if (param.possibilities.count() > 0) {
405     QComboTableItem *pComboItem = new QComboTableItem(this,
406     param.possibilities);
407     pComboItem->setCurrentItem(param.value);
408     pComboItem->setEnabled(param.fix);
409     QTable::setItem(iRow, 1, pComboItem);
410     } else {
411     QTableItem* pTableItem = new QTableItem(this,
412     param.fix ? QTableItem::Never : QTableItem::OnTyping,
413     param.value);
414     QTable::setItem(iRow, 1, pTableItem);
415     }
416     QTable::setText(iRow, 2, iter.key());
417 capela 431 ++iRow;
418 capela 429 }
419    
420     // Adjust optimal column width.
421     for (int iCol = 0; iCol < QTable::numCols(); iCol++)
422     QTable::adjustColumn(iCol);
423     }
424    
425    
426 capela 426 // end of qsamplerDevice.cpp

  ViewVC Help
Powered by ViewVC