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

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

Parent Directory Parent Directory | Revision Log Revision Log


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

  ViewVC Help
Powered by ViewVC