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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 442 - (hide annotations) (download)
Thu Mar 10 15:48:38 2005 UTC (16 years, 10 months ago) by capela
File size: 14955 byte(s)
Refinements on the device list view and parameter table editing.

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 capela 442 #include <qspinbox.h>
25     #include <qlineedit.h>
26    
27 capela 426 #include "qsamplerMainForm.h"
28     #include "qsamplerDeviceForm.h"
29    
30     #include "config.h"
31    
32    
33     //-------------------------------------------------------------------------
34 capela 429 // qsamplerDeviceParam - MIDI/Audio Device parameter structure.
35 capela 426 //
36    
37 capela 429 // 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 capela 431 return;
57    
58     // Info structure field members.
59    
60 capela 429 type = pParamInfo->type;
61 capela 431
62 capela 429 if (pParamInfo->description)
63     description = pParamInfo->description;
64     else
65     description = QString::null;
66 capela 431
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 capela 429 if (pParamInfo->defaultv)
76     defaultv = pParamInfo->defaultv;
77     else
78     defaultv = QString::null;
79 capela 431
80 capela 429 if (pParamInfo->range_min)
81 capela 431 range_min = pParamInfo->range_min;
82 capela 429 else
83     range_min = QString::null;
84 capela 431
85 capela 429 if (pParamInfo->range_max)
86 capela 431 range_max = pParamInfo->range_max;
87 capela 429 else
88     range_max = QString::null;
89 capela 431
90 capela 429 possibilities.clear();
91 capela 431 for (int i = 0; pParamInfo->possibilities && pParamInfo->possibilities[i]; i++)
92     possibilities.append(pParamInfo->possibilities[i]);
93    
94     // The current parameter value.
95 capela 429 if (pszValue)
96 capela 431 value = pszValue;
97 capela 429 else
98     value = QString::null;
99     }
100    
101    
102     //-------------------------------------------------------------------------
103     // qsamplerDevice - MIDI/Audio Device structure.
104     //
105    
106 capela 426 // Constructor.
107 capela 429 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 capela 430 // Device id and type should be always set.
124     m_iDeviceID = iDeviceID;
125     m_deviceType = deviceType;
126    
127     // Retrieve device info, if any.
128 capela 429 lscp_device_info_t *pDeviceInfo = NULL;
129     switch (deviceType) {
130 capela 431 case qsamplerDevice::Audio:
131 capela 433 m_sDeviceType = QObject::tr("Audio");
132 capela 431 pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);
133     break;
134     case qsamplerDevice::Midi:
135 capela 433 m_sDeviceType = QObject::tr("MIDI");
136 capela 429 pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);
137     break;
138 capela 436 case qsamplerDevice::None:
139 capela 433 m_sDeviceType = QString::null;
140     break;
141 capela 429 }
142 capela 431
143 capela 430 // If we're bogus, bail out...
144     if (pDeviceInfo == NULL) {
145     m_sDriverName = QString::null;
146 capela 433 m_sDeviceName = QObject::tr("New device");
147 capela 431 return;
148 capela 430 }
149 capela 431
150 capela 430 // Other device properties...
151 capela 429 m_sDriverName = pDeviceInfo->driver;
152 capela 430 m_sDeviceName = m_sDriverName + ' '
153     + QObject::tr("Device %1").arg(m_iDeviceID);
154 capela 429
155 capela 431 // Grab device parameters...
156 capela 429 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 capela 431 case qsamplerDevice::Audio:
162     pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
163 capela 429 m_sDriverName.latin1(), pszParam, NULL);
164 capela 431 break;
165     case qsamplerDevice::Midi:
166     pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
167 capela 429 m_sDriverName.latin1(), pszParam, NULL);
168     break;
169 capela 436 case qsamplerDevice::None:
170     break;
171 capela 429 }
172 capela 436 if (pParamInfo) {
173 capela 433 m_params[pszParam] = qsamplerDeviceParam(pParamInfo,
174     pDeviceInfo->params[i].value);
175 capela 436 }
176 capela 429 }
177     }
178    
179    
180 capela 431 // 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 capela 436 case qsamplerDevice::None:
200     break;
201 capela 431 }
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 capela 436 case qsamplerDevice::None:
225     break;
226 capela 431 }
227 capela 436 if (pParamInfo)
228     m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pParamInfo->defaultv);
229 capela 431 }
230     }
231    
232    
233 capela 429 // 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 capela 433 const QString& qsamplerDevice::deviceTypeName (void) const
245     {
246     return m_sDeviceType;
247     }
248    
249 capela 429 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 capela 430 // Device ids enumerator.
272 capela 429 int *qsamplerDevice::getDevices ( lscp_client_t *pClient,
273     qsamplerDeviceType deviceType )
274     {
275     int *piDeviceIDs = NULL;
276     switch (deviceType) {
277 capela 431 case qsamplerDevice::Audio:
278     piDeviceIDs = ::lscp_list_audio_devices(pClient);
279 capela 429 break;
280 capela 431 case qsamplerDevice::Midi:
281     piDeviceIDs = ::lscp_list_midi_devices(pClient);
282     break;
283 capela 436 case qsamplerDevice::None:
284     break;
285 capela 429 }
286     return piDeviceIDs;
287     }
288    
289 capela 430
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 capela 431 case qsamplerDevice::Audio:
299     ppszDrivers = ::lscp_get_available_audio_drivers(pClient);
300 capela 430 break;
301 capela 431 case qsamplerDevice::Midi:
302     ppszDrivers = ::lscp_get_available_midi_drivers(pClient);
303     break;
304 capela 436 case qsamplerDevice::None:
305     break;
306 capela 430 }
307    
308 capela 431 for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)
309     drivers.append(ppszDrivers[iDriver]);
310 capela 430
311     return drivers;
312     }
313    
314    
315 capela 429 //-------------------------------------------------------------------------
316     // qsamplerDeviceItem - QListView device item.
317     //
318    
319     // Constructors.
320 capela 433 qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView,
321     lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType )
322 capela 429 : QListViewItem(pListView), m_device(pClient, deviceType)
323     {
324     switch(m_device.deviceType()) {
325 capela 431 case qsamplerDevice::Audio:
326 capela 429 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio1.png"));
327     QListViewItem::setText(0, QObject::tr("Audio devices"));
328     break;
329 capela 431 case qsamplerDevice::Midi:
330 capela 429 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));
331     QListViewItem::setText(0, QObject::tr("MIDI devices"));
332     break;
333 capela 436 case qsamplerDevice::None:
334     break;
335 capela 429 }
336     }
337    
338 capela 433 qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem,
339     lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType,
340     int iDeviceID )
341 capela 429 : QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)
342     {
343     switch(m_device.deviceType()) {
344 capela 431 case qsamplerDevice::Audio:
345 capela 429 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio2.png"));
346     break;
347 capela 431 case qsamplerDevice::Midi:
348 capela 429 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));
349     break;
350 capela 436 case qsamplerDevice::None:
351     break;
352 capela 429 }
353    
354     QListViewItem::setText(0, m_device.deviceName());
355     }
356    
357     // Default destructor.
358     qsamplerDeviceItem::~qsamplerDeviceItem (void)
359     {
360     }
361    
362     // Instance accessors.
363 capela 431 qsamplerDevice& qsamplerDeviceItem::device (void)
364 capela 429 {
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 capela 433 qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent,
382     const char *pszName )
383 capela 426 : QTable(pParent, pszName)
384     {
385 capela 428 // Set fixed number of columns.
386 capela 429 QTable::setNumCols(3);
387 capela 428 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 capela 436 pHeader->setLabel(0, tr("Parameter"));
397     pHeader->setLabel(1, tr("Description"));
398     pHeader->setLabel(2, tr("Value"));
399 capela 428 // Set read-onlyness of each column
400     QTable::setColumnReadOnly(0, true);
401 capela 436 QTable::setColumnReadOnly(1, true);
402     // QTable::setColumnReadOnly(2, true); -- of course not.
403     QTable::setColumnStretchable(1, true);
404 capela 426 }
405    
406     // Default destructor.
407 capela 429 qsamplerDeviceParamTable::~qsamplerDeviceParamTable (void)
408 capela 426 {
409     }
410    
411    
412 capela 429 // The main table refresher.
413 capela 431 void qsamplerDeviceParamTable::refresh ( qsamplerDevice& device )
414 capela 429 {
415     // Always (re)start it empty.
416 capela 433 QTable::setUpdatesEnabled(false);
417 capela 429 QTable::setNumRows(0);
418    
419     // Now fill the parameter table...
420 capela 431 qsamplerDeviceParamMap& params = device.params();
421 capela 429 QTable::insertRows(0, params.count());
422     int iRow = 0;
423 capela 431 qsamplerDeviceParamMap::ConstIterator iter;
424 capela 429 for (iter = params.begin(); iter != params.end(); ++iter) {
425 capela 432 const qsamplerDeviceParam& param = iter.data();
426 capela 442 bool bEnabled = (device.deviceID() < 0 || !param.fix);
427 capela 436 QTable::setText(iRow, 0, iter.key());
428     QTable::setText(iRow, 1, param.description);
429 capela 432 if (param.type == LSCP_TYPE_BOOL) {
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 capela 442 pComboItem->setEnabled(bEnabled);
436 capela 436 QTable::setItem(iRow, 2, pComboItem);
437 capela 442 } else if (param.possibilities.count() > 0) {
438 capela 432 QComboTableItem *pComboItem = new QComboTableItem(this,
439     param.possibilities);
440     pComboItem->setCurrentItem(param.value);
441 capela 442 pComboItem->setEnabled(bEnabled);
442     pComboItem->setEditable(bEnabled && param.multiplicity);
443 capela 436 QTable::setItem(iRow, 2, pComboItem);
444 capela 442 } else if (param.type == LSCP_TYPE_INT) {
445     qsamplerDeviceParamTableSpinBox *pSpinItem =
446     new qsamplerDeviceParamTableSpinBox(this,
447     bEnabled ? QTableItem::OnTyping : QTableItem::Never);
448     pSpinItem->setMinValue(param.range_min.toInt());
449     pSpinItem->setMaxValue(param.range_max.toInt());
450     pSpinItem->setValue(param.value.toInt());
451     QTable::setItem(iRow, 2, pSpinItem);
452 capela 432 } else {
453 capela 442 qsamplerDeviceParamTableEditBox *pEditItem =
454     new qsamplerDeviceParamTableEditBox(this,
455     bEnabled ? QTableItem::OnTyping : QTableItem::Never,
456     param.value);
457     QTable::setItem(iRow, 2, pEditItem);
458 capela 432 }
459 capela 431 ++iRow;
460 capela 429 }
461    
462 capela 433 // Adjust optimal column widths.
463 capela 436 QTable::adjustColumn(0);
464 capela 433 QTable::adjustColumn(2);
465 capela 436
466 capela 433 QTable::setUpdatesEnabled(true);
467     QTable::updateContents();
468 capela 429 }
469    
470    
471 capela 442 //-------------------------------------------------------------------------
472     // qsamplerDeviceParamTableSpinBox - Custom spin box for parameter table.
473     //
474    
475     // Constructor.
476     qsamplerDeviceParamTableSpinBox::qsamplerDeviceParamTableSpinBox (
477     QTable *pTable, EditType editType )
478     : QTableItem(pTable, editType, QString::null)
479     {
480     m_iValue = m_iMinValue = m_iMaxValue = 0;
481     }
482    
483     // Public accessors.
484     void qsamplerDeviceParamTableSpinBox::setValue ( int iValue )
485     {
486     m_iValue = iValue;
487     QTableItem::setText(QString::number(m_iValue));
488     }
489    
490     void qsamplerDeviceParamTableSpinBox::setMinValue ( int iMinValue )
491     {
492     m_iMinValue = iMinValue;
493     }
494    
495     void qsamplerDeviceParamTableSpinBox::setMaxValue ( int iMaxValue )
496     {
497     m_iMaxValue = iMaxValue;
498     }
499    
500     // Virtual implemetations.
501     QWidget *qsamplerDeviceParamTableSpinBox::createEditor (void) const
502     {
503     QSpinBox *pSpinBox = new QSpinBox(QTableItem::table()->viewport());
504     QObject::connect(pSpinBox, SIGNAL(valueChanged(int)),
505     QTableItem::table(), SLOT(doValueChanged()));
506     if (m_iValue >= m_iMinValue && m_iMaxValue >= m_iValue) {
507     pSpinBox->setMinValue(m_iMinValue);
508     pSpinBox->setMaxValue(m_iMaxValue);
509     }
510     pSpinBox->setValue(m_iValue);
511     // pSpinBox->setEnabled(QTableItem::isEnabled());
512     return pSpinBox;
513     }
514    
515     void qsamplerDeviceParamTableSpinBox::setContentFromEditor ( QWidget *pWidget )
516     {
517     if (pWidget->inherits("QSpinBox"))
518     QTableItem::setText(QString::number(((QSpinBox *) pWidget)->value()));
519     else
520     QTableItem::setContentFromEditor(pWidget);
521     }
522    
523    
524     //-------------------------------------------------------------------------
525     // qsamplerDeviceParamTableEditBox - Custom edit box for parameter table.
526     //
527    
528     // Constructor.
529     qsamplerDeviceParamTableEditBox::qsamplerDeviceParamTableEditBox (
530     QTable *pTable, EditType editType, const QString& sText )
531     : QTableItem(pTable, editType, sText)
532     {
533     }
534    
535     // Virtual implemetations.
536     QWidget *qsamplerDeviceParamTableEditBox::createEditor (void) const
537     {
538     QLineEdit *pEditBox = new QLineEdit(QTableItem::table()->viewport());
539     QObject::connect(pEditBox, SIGNAL(returnPressed()),
540     QTableItem::table(), SLOT(doValueChanged()));
541     pEditBox->setText(QTableItem::text());
542     // pEditBox->setEnabled(QTableItem::isEnabled());
543     return pEditBox;
544     }
545    
546     void qsamplerDeviceParamTableEditBox::setContentFromEditor ( QWidget *pWidget )
547     {
548     if (pWidget->inherits("QLineEdit"))
549     QTableItem::setText(((QLineEdit *) pWidget)->text());
550     else
551     QTableItem::setContentFromEditor(pWidget);
552     }
553    
554    
555 capela 426 // end of qsamplerDevice.cpp

  ViewVC Help
Powered by ViewVC