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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 451 - (show annotations) (download)
Fri Mar 11 17:24:06 2005 UTC (15 years, 3 months ago) by capela
File size: 14914 byte(s)
Particular device parameter edit 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 <qspinbox.h>
25 #include <qlineedit.h>
26
27 #include "qsamplerMainForm.h"
28 #include "qsamplerDeviceForm.h"
29
30 #include "config.h"
31
32
33 //-------------------------------------------------------------------------
34 // qsamplerDeviceParam - MIDI/Audio Device parameter structure.
35 //
36
37 // Constructors.
38 qsamplerDeviceParam::qsamplerDeviceParam ( lscp_param_info_t *pParamInfo,
39 const char *pszValue )
40 {
41 setParam(pParamInfo, pszValue);
42 }
43
44
45 // Default destructor.
46 qsamplerDeviceParam::~qsamplerDeviceParam (void)
47 {
48 }
49
50
51 // Initializer.
52 void qsamplerDeviceParam::setParam ( lscp_param_info_t *pParamInfo,
53 const char *pszValue )
54 {
55 if (pParamInfo == NULL)
56 return;
57
58 // Info structure field members.
59
60 type = pParamInfo->type;
61
62 if (pParamInfo->description)
63 description = pParamInfo->description;
64 else
65 description = QString::null;
66
67 mandatory = (bool) pParamInfo->multiplicity;
68 fix = (bool) pParamInfo->fix;
69 multiplicity = (bool) pParamInfo->multiplicity;
70
71 depends.clear();
72 for (int i = 0; pParamInfo->depends && pParamInfo->depends[i]; i++)
73 depends.append(pParamInfo->depends[i]);
74
75 if (pParamInfo->defaultv)
76 defaultv = pParamInfo->defaultv;
77 else
78 defaultv = QString::null;
79
80 if (pParamInfo->range_min)
81 range_min = pParamInfo->range_min;
82 else
83 range_min = QString::null;
84
85 if (pParamInfo->range_max)
86 range_max = pParamInfo->range_max;
87 else
88 range_max = QString::null;
89
90 possibilities.clear();
91 for (int i = 0; pParamInfo->possibilities && pParamInfo->possibilities[i]; i++)
92 possibilities.append(pParamInfo->possibilities[i]);
93
94 // The current parameter value.
95 if (pszValue)
96 value = pszValue;
97 else
98 value = QString::null;
99 }
100
101
102 //-------------------------------------------------------------------------
103 // qsamplerDevice - MIDI/Audio Device structure.
104 //
105
106 // Constructor.
107 qsamplerDevice::qsamplerDevice ( lscp_client_t *pClient,
108 qsamplerDeviceType deviceType, int iDeviceID )
109 {
110 setDevice(pClient, deviceType, iDeviceID);
111 }
112
113 // Default destructor.
114 qsamplerDevice::~qsamplerDevice (void)
115 {
116 }
117
118
119 // Initializer.
120 void qsamplerDevice::setDevice ( lscp_client_t *pClient,
121 qsamplerDeviceType deviceType, int iDeviceID )
122 {
123 // Device id and type should be always set.
124 m_iDeviceID = iDeviceID;
125 m_deviceType = deviceType;
126
127 // Retrieve device info, if any.
128 lscp_device_info_t *pDeviceInfo = NULL;
129 switch (deviceType) {
130 case qsamplerDevice::Audio:
131 m_sDeviceType = QObject::tr("Audio");
132 pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);
133 break;
134 case qsamplerDevice::Midi:
135 m_sDeviceType = QObject::tr("MIDI");
136 pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);
137 break;
138 case qsamplerDevice::None:
139 m_sDeviceType = QString::null;
140 break;
141 }
142
143 // If we're bogus, bail out...
144 if (pDeviceInfo == NULL) {
145 m_sDriverName = QString::null;
146 m_sDeviceName = QObject::tr("New device");
147 return;
148 }
149
150 // Other device properties...
151 m_sDriverName = pDeviceInfo->driver;
152 m_sDeviceName = m_sDriverName + ' '
153 + QObject::tr("Device %1").arg(m_iDeviceID);
154
155 // Grab device parameters...
156 m_params.clear();
157 for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {
158 const char *pszParam = pDeviceInfo->params[i].key;
159 lscp_param_info_t *pParamInfo = NULL;
160 switch (deviceType) {
161 case qsamplerDevice::Audio:
162 pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
163 m_sDriverName.latin1(), pszParam, NULL);
164 break;
165 case qsamplerDevice::Midi:
166 pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
167 m_sDriverName.latin1(), pszParam, NULL);
168 break;
169 case qsamplerDevice::None:
170 break;
171 }
172 if (pParamInfo) {
173 m_params[pszParam] = qsamplerDeviceParam(pParamInfo,
174 pDeviceInfo->params[i].value);
175 }
176 }
177 }
178
179
180 // Driver name initializer.
181 void qsamplerDevice::setDriver ( lscp_client_t *pClient,
182 const QString& sDriverName )
183 {
184 // Valid only for scratch devices.
185 if (m_sDriverName == sDriverName)
186 return;
187
188 // Retrieve driver info, if any.
189 lscp_driver_info_t *pDriverInfo = NULL;
190 switch (m_deviceType) {
191 case qsamplerDevice::Audio:
192 pDriverInfo = ::lscp_get_audio_driver_info(pClient,
193 sDriverName.latin1());
194 break;
195 case qsamplerDevice::Midi:
196 pDriverInfo = ::lscp_get_midi_driver_info(pClient,
197 sDriverName.latin1());
198 break;
199 case qsamplerDevice::None:
200 break;
201 }
202
203 // If we're bogus, bail out...
204 if (pDriverInfo == NULL)
205 return;
206
207 // Remember device parameters...
208 m_sDriverName = sDriverName;
209
210 // Grab driver parameters...
211 m_params.clear();
212 for (int i = 0; pDriverInfo->parameters && pDriverInfo->parameters[i]; i++) {
213 const char *pszParam = pDriverInfo->parameters[i];
214 lscp_param_info_t *pParamInfo = NULL;
215 switch (m_deviceType) {
216 case qsamplerDevice::Audio:
217 pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
218 sDriverName.latin1(), pszParam, NULL);
219 break;
220 case qsamplerDevice::Midi:
221 pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
222 sDriverName.latin1(), pszParam, NULL);
223 break;
224 case qsamplerDevice::None:
225 break;
226 }
227 if (pParamInfo)
228 m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pParamInfo->defaultv);
229 }
230 }
231
232
233 // Device property accessors.
234 int qsamplerDevice::deviceID (void) const
235 {
236 return m_iDeviceID;
237 }
238
239 qsamplerDevice::qsamplerDeviceType qsamplerDevice::deviceType (void) const
240 {
241 return m_deviceType;
242 }
243
244 const QString& qsamplerDevice::deviceTypeName (void) const
245 {
246 return m_sDeviceType;
247 }
248
249 const QString& qsamplerDevice::driverName (void) const
250 {
251 return m_sDriverName;
252 }
253
254 const QString& qsamplerDevice::deviceName (void) const
255 {
256 return m_sDeviceName;
257 }
258
259 // Device parameter accessor.
260 qsamplerDeviceParamMap& qsamplerDevice::params (void)
261 {
262 return m_params;
263 }
264
265
266 // Update/refresh device/driver data.
267 void qsamplerDevice::refresh (void)
268 {
269 }
270
271 // Device ids enumerator.
272 int *qsamplerDevice::getDevices ( lscp_client_t *pClient,
273 qsamplerDeviceType deviceType )
274 {
275 int *piDeviceIDs = NULL;
276 switch (deviceType) {
277 case qsamplerDevice::Audio:
278 piDeviceIDs = ::lscp_list_audio_devices(pClient);
279 break;
280 case qsamplerDevice::Midi:
281 piDeviceIDs = ::lscp_list_midi_devices(pClient);
282 break;
283 case qsamplerDevice::None:
284 break;
285 }
286 return piDeviceIDs;
287 }
288
289
290 // Driver names enumerator.
291 QStringList qsamplerDevice::getDrivers ( lscp_client_t *pClient,
292 qsamplerDeviceType deviceType )
293 {
294 QStringList drivers;
295
296 const char **ppszDrivers = NULL;
297 switch (deviceType) {
298 case qsamplerDevice::Audio:
299 ppszDrivers = ::lscp_get_available_audio_drivers(pClient);
300 break;
301 case qsamplerDevice::Midi:
302 ppszDrivers = ::lscp_get_available_midi_drivers(pClient);
303 break;
304 case qsamplerDevice::None:
305 break;
306 }
307
308 for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)
309 drivers.append(ppszDrivers[iDriver]);
310
311 return drivers;
312 }
313
314
315 //-------------------------------------------------------------------------
316 // qsamplerDeviceItem - QListView device item.
317 //
318
319 // Constructors.
320 qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView,
321 lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType )
322 : QListViewItem(pListView), m_device(pClient, deviceType)
323 {
324 switch(m_device.deviceType()) {
325 case qsamplerDevice::Audio:
326 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio1.png"));
327 QListViewItem::setText(0, QObject::tr("Audio devices"));
328 break;
329 case qsamplerDevice::Midi:
330 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));
331 QListViewItem::setText(0, QObject::tr("MIDI devices"));
332 break;
333 case qsamplerDevice::None:
334 break;
335 }
336 }
337
338 qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem,
339 lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType,
340 int iDeviceID )
341 : QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)
342 {
343 switch(m_device.deviceType()) {
344 case qsamplerDevice::Audio:
345 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio2.png"));
346 break;
347 case qsamplerDevice::Midi:
348 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));
349 break;
350 case qsamplerDevice::None:
351 break;
352 }
353
354 QListViewItem::setText(0, m_device.deviceName());
355 }
356
357 // Default destructor.
358 qsamplerDeviceItem::~qsamplerDeviceItem (void)
359 {
360 }
361
362 // Instance accessors.
363 qsamplerDevice& qsamplerDeviceItem::device (void)
364 {
365 return m_device;
366 }
367
368 // To virtually distinguish between list view items.
369 int qsamplerDeviceItem::rtti() const
370 {
371 return QSAMPLER_DEVICE_ITEM;
372 }
373
374
375
376 //-------------------------------------------------------------------------
377 // qsamplerDeviceParamTable - Device parameter view table.
378 //
379
380 // Constructor.
381 qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent,
382 const char *pszName )
383 : QTable(pParent, pszName)
384 {
385 // Set fixed number of columns.
386 QTable::setNumCols(3);
387 QTable::setShowGrid(false);
388 QTable::setSorting(false);
389 QTable::setFocusStyle(QTable::FollowStyle);
390 QTable::setSelectionMode(QTable::NoSelection);
391 // No vertical header.
392 QTable::verticalHeader()->hide();
393 QTable::setLeftMargin(0);
394 // Initialize the fixed table column headings.
395 QHeader *pHeader = QTable::horizontalHeader();
396 pHeader->setLabel(0, tr("Parameter"));
397 pHeader->setLabel(1, tr("Description"));
398 pHeader->setLabel(2, tr("Value"));
399 // Set read-onlyness of each column
400 QTable::setColumnReadOnly(0, true);
401 QTable::setColumnReadOnly(1, true);
402 // QTable::setColumnReadOnly(2, true); -- of course not.
403 QTable::setColumnStretchable(1, true);
404 }
405
406 // Default destructor.
407 qsamplerDeviceParamTable::~qsamplerDeviceParamTable (void)
408 {
409 }
410
411
412 // The main table refresher.
413 void qsamplerDeviceParamTable::refresh ( qsamplerDevice& device )
414 {
415 // Always (re)start it empty.
416 QTable::setUpdatesEnabled(false);
417 QTable::setNumRows(0);
418
419 // Now fill the parameter table...
420 qsamplerDeviceParamMap& params = device.params();
421 QTable::insertRows(0, params.count());
422 int iRow = 0;
423 qsamplerDeviceParamMap::ConstIterator iter;
424 for (iter = params.begin(); iter != params.end(); ++iter) {
425 const qsamplerDeviceParam& param = iter.data();
426 bool bEnabled = (device.deviceID() < 0 || !param.fix);
427 QTable::setText(iRow, 0, iter.key());
428 QTable::setText(iRow, 1, param.description);
429 if (param.type == LSCP_TYPE_BOOL && bEnabled) {
430 QStringList opts;
431 opts.append(tr("false"));
432 opts.append(tr("true"));
433 QComboTableItem *pComboItem = new QComboTableItem(this, opts);
434 pComboItem->setCurrentItem(param.value.lower() == "true" ? 1 : 0);
435 pComboItem->setEnabled(bEnabled);
436 QTable::setItem(iRow, 2, pComboItem);
437 } else if (param.possibilities.count() > 0 && bEnabled) {
438 QComboTableItem *pComboItem = new QComboTableItem(this,
439 param.possibilities);
440 pComboItem->setCurrentItem(param.value);
441 pComboItem->setEnabled(bEnabled);
442 pComboItem->setEditable(bEnabled && param.multiplicity);
443 QTable::setItem(iRow, 2, pComboItem);
444 } else if (param.type == LSCP_TYPE_INT && bEnabled
445 && !param.range_min.isEmpty()
446 && !param.range_max.isEmpty()) {
447 qsamplerDeviceParamTableSpinBox *pSpinItem =
448 new qsamplerDeviceParamTableSpinBox(this,
449 bEnabled ? QTableItem::OnTyping : QTableItem::Never,
450 param.value);
451 pSpinItem->setMinValue(param.range_min.toInt());
452 pSpinItem->setMaxValue(param.range_max.toInt());
453 QTable::setItem(iRow, 2, pSpinItem);
454 } else {
455 qsamplerDeviceParamTableEditBox *pEditItem =
456 new qsamplerDeviceParamTableEditBox(this,
457 bEnabled ? QTableItem::OnTyping : QTableItem::Never,
458 param.value);
459 QTable::setItem(iRow, 2, pEditItem);
460 }
461 ++iRow;
462 }
463
464 // Adjust optimal column widths.
465 QTable::adjustColumn(0);
466 QTable::adjustColumn(2);
467
468 QTable::setUpdatesEnabled(true);
469 QTable::updateContents();
470 }
471
472
473 //-------------------------------------------------------------------------
474 // qsamplerDeviceParamTableSpinBox - Custom spin box for parameter table.
475 //
476
477 // Constructor.
478 qsamplerDeviceParamTableSpinBox::qsamplerDeviceParamTableSpinBox (
479 QTable *pTable, EditType editType, const QString& sText )
480 : QTableItem(pTable, editType, sText)
481 {
482 m_iValue = sText.toInt();
483 m_iMinValue = m_iMaxValue = 0;
484 }
485
486 // Public accessors.
487 void qsamplerDeviceParamTableSpinBox::setValue ( int iValue )
488 {
489 m_iValue = iValue;
490 QTableItem::setText(QString::number(m_iValue));
491 }
492
493 void qsamplerDeviceParamTableSpinBox::setMinValue ( int iMinValue )
494 {
495 m_iMinValue = iMinValue;
496 }
497
498 void qsamplerDeviceParamTableSpinBox::setMaxValue ( int iMaxValue )
499 {
500 m_iMaxValue = iMaxValue;
501 }
502
503 // Virtual implemetations.
504 QWidget *qsamplerDeviceParamTableSpinBox::createEditor (void) const
505 {
506 QSpinBox *pSpinBox = new QSpinBox(QTableItem::table()->viewport());
507 QObject::connect(pSpinBox, SIGNAL(valueChanged(int)),
508 QTableItem::table(), SLOT(doValueChanged()));
509 if (m_iValue >= m_iMinValue && m_iMaxValue >= m_iValue) {
510 pSpinBox->setMinValue(m_iMinValue);
511 pSpinBox->setMaxValue(m_iMaxValue);
512 }
513 pSpinBox->setValue(m_iValue);
514 return pSpinBox;
515 }
516
517 void qsamplerDeviceParamTableSpinBox::setContentFromEditor ( QWidget *pWidget )
518 {
519 if (pWidget->inherits("QSpinBox"))
520 QTableItem::setText(QString::number(((QSpinBox *) pWidget)->value()));
521 else
522 QTableItem::setContentFromEditor(pWidget);
523 }
524
525
526 //-------------------------------------------------------------------------
527 // qsamplerDeviceParamTableEditBox - Custom edit box for parameter table.
528 //
529
530 // Constructor.
531 qsamplerDeviceParamTableEditBox::qsamplerDeviceParamTableEditBox (
532 QTable *pTable, EditType editType, const QString& sText )
533 : QTableItem(pTable, editType, sText)
534 {
535 }
536
537 // Virtual implemetations.
538 QWidget *qsamplerDeviceParamTableEditBox::createEditor (void) const
539 {
540 QLineEdit *pEditBox = new QLineEdit(QTableItem::table()->viewport());
541 QObject::connect(pEditBox, SIGNAL(returnPressed()),
542 QTableItem::table(), SLOT(doValueChanged()));
543 pEditBox->setText(QTableItem::text());
544 return pEditBox;
545 }
546
547 void qsamplerDeviceParamTableEditBox::setContentFromEditor ( QWidget *pWidget )
548 {
549 if (pWidget->inherits("QLineEdit"))
550 QTableItem::setText(((QLineEdit *) pWidget)->text());
551 else
552 QTableItem::setContentFromEditor(pWidget);
553 }
554
555
556 // end of qsamplerDevice.cpp

  ViewVC Help
Powered by ViewVC