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

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

Parent Directory Parent Directory | Revision Log Revision Log


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

1 // qsamplerDevice.cpp
2 //
3 /****************************************************************************
4 Copyright (C) 2005, rncbc aka Rui Nuno Capela. All rights reserved.
5
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 // 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.
104 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 // 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
177 // 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 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
458 // end of qsamplerDevice.cpp

  ViewVC Help
Powered by ViewVC