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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 920 - (hide annotations) (download)
Sun Sep 24 12:47:51 2006 UTC (17 years, 6 months ago) by capela
File size: 28984 byte(s)
GPL address update.

1 capela 426 // qsamplerDevice.cpp
2     //
3     /****************************************************************************
4 capela 920 Copyright (C) 2004-2006, 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 capela 920 You should have received a copy of the GNU General Public License along
17     with this program; if not, write to the Free Software Foundation, Inc.,
18     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 capela 426
20     *****************************************************************************/
21    
22 capela 759 #include "qsamplerAbout.h"
23 capela 426 #include "qsamplerDevice.h"
24    
25     #include "qsamplerMainForm.h"
26     #include "qsamplerDeviceForm.h"
27    
28 capela 759 #include <qspinbox.h>
29     #include <qlineedit.h>
30 capela 426
31    
32     //-------------------------------------------------------------------------
33 capela 429 // qsamplerDeviceParam - MIDI/Audio Device parameter structure.
34 capela 426 //
35    
36 capela 429 // Constructors.
37     qsamplerDeviceParam::qsamplerDeviceParam ( lscp_param_info_t *pParamInfo,
38     const char *pszValue )
39     {
40     setParam(pParamInfo, pszValue);
41     }
42    
43    
44     // Default destructor.
45     qsamplerDeviceParam::~qsamplerDeviceParam (void)
46     {
47     }
48    
49    
50     // Initializer.
51     void qsamplerDeviceParam::setParam ( lscp_param_info_t *pParamInfo,
52     const char *pszValue )
53     {
54     if (pParamInfo == NULL)
55 capela 431 return;
56 capela 490
57 capela 431 // Info structure field members.
58 capela 490
59 capela 429 type = pParamInfo->type;
60 capela 490
61 capela 429 if (pParamInfo->description)
62     description = pParamInfo->description;
63     else
64     description = QString::null;
65 capela 490
66 capela 482 mandatory = (bool) pParamInfo->mandatory;
67 capela 431 fix = (bool) pParamInfo->fix;
68     multiplicity = (bool) pParamInfo->multiplicity;
69 capela 490
70 capela 431 depends.clear();
71     for (int i = 0; pParamInfo->depends && pParamInfo->depends[i]; i++)
72     depends.append(pParamInfo->depends[i]);
73 capela 490
74 capela 429 if (pParamInfo->defaultv)
75     defaultv = pParamInfo->defaultv;
76     else
77     defaultv = QString::null;
78 capela 490
79 capela 429 if (pParamInfo->range_min)
80 capela 431 range_min = pParamInfo->range_min;
81 capela 429 else
82     range_min = QString::null;
83 capela 490
84 capela 429 if (pParamInfo->range_max)
85 capela 431 range_max = pParamInfo->range_max;
86 capela 429 else
87     range_max = QString::null;
88 capela 490
89 capela 429 possibilities.clear();
90 capela 431 for (int i = 0; pParamInfo->possibilities && pParamInfo->possibilities[i]; i++)
91     possibilities.append(pParamInfo->possibilities[i]);
92 capela 490
93 capela 431 // The current parameter value.
94 capela 429 if (pszValue)
95 capela 431 value = pszValue;
96 capela 429 else
97     value = QString::null;
98     }
99    
100    
101     //-------------------------------------------------------------------------
102     // qsamplerDevice - MIDI/Audio Device structure.
103     //
104    
105 capela 426 // Constructor.
106 capela 484 qsamplerDevice::qsamplerDevice ( qsamplerMainForm *pMainForm,
107 capela 429 qsamplerDeviceType deviceType, int iDeviceID )
108     {
109 capela 484 m_pMainForm = pMainForm;
110    
111 capela 463 m_ports.setAutoDelete(true);
112 capela 490
113 capela 484 setDevice(deviceType, iDeviceID);
114 capela 429 }
115    
116     // Default destructor.
117     qsamplerDevice::~qsamplerDevice (void)
118     {
119     }
120    
121 capela 484 // Copy constructor.
122     qsamplerDevice::qsamplerDevice ( const qsamplerDevice& device )
123     : m_params(device.m_params), m_ports(m_ports)
124     {
125     m_pMainForm = device.m_pMainForm;
126     m_iDeviceID = device.m_iDeviceID;
127     m_deviceType = device.m_deviceType;
128     m_sDeviceType = device.m_sDeviceType;
129     m_sDriverName = device.m_sDriverName;
130     m_sDeviceName = device.m_sDeviceName;
131     }
132 capela 429
133 capela 484
134 capela 429 // Initializer.
135 capela 484 void qsamplerDevice::setDevice ( qsamplerDeviceType deviceType, int iDeviceID )
136 capela 429 {
137 capela 430 // Device id and type should be always set.
138 capela 462 m_iDeviceID = iDeviceID;
139     m_deviceType = deviceType;
140 capela 490
141 capela 463 // Reset device parameters and ports anyway.
142 capela 467 m_params.clear();
143     m_ports.clear();
144 capela 430
145     // Retrieve device info, if any.
146 capela 429 lscp_device_info_t *pDeviceInfo = NULL;
147     switch (deviceType) {
148 capela 431 case qsamplerDevice::Audio:
149 capela 433 m_sDeviceType = QObject::tr("Audio");
150 capela 484 if (m_iDeviceID >= 0 && (pDeviceInfo = ::lscp_get_audio_device_info(
151     client(), m_iDeviceID)) == NULL)
152     appendMessagesClient("lscp_get_audio_device_info");
153 capela 431 break;
154     case qsamplerDevice::Midi:
155 capela 433 m_sDeviceType = QObject::tr("MIDI");
156 capela 484 if (m_iDeviceID >= 0 && (pDeviceInfo = ::lscp_get_midi_device_info(
157     client(), m_iDeviceID)) == NULL)
158     appendMessagesClient("lscp_get_midi_device_info");
159 capela 429 break;
160 capela 436 case qsamplerDevice::None:
161 capela 433 m_sDeviceType = QString::null;
162     break;
163 capela 429 }
164 capela 430 // If we're bogus, bail out...
165     if (pDeviceInfo == NULL) {
166     m_sDriverName = QString::null;
167 capela 452 m_sDeviceName = QObject::tr("New %1 device").arg(m_sDeviceType);
168 capela 431 return;
169 capela 430 }
170 capela 431
171 capela 430 // Other device properties...
172 capela 429 m_sDriverName = pDeviceInfo->driver;
173 capela 430 m_sDeviceName = m_sDriverName + ' '
174     + QObject::tr("Device %1").arg(m_iDeviceID);
175 capela 429
176 capela 431 // Grab device parameters...
177 capela 429 for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {
178 capela 463 const QString sParam = pDeviceInfo->params[i].key;
179 capela 429 lscp_param_info_t *pParamInfo = NULL;
180     switch (deviceType) {
181 capela 431 case qsamplerDevice::Audio:
182 capela 484 if ((pParamInfo = ::lscp_get_audio_driver_param_info(client(),
183     m_sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
184     appendMessagesClient("lscp_get_audio_driver_param_info");
185 capela 431 break;
186     case qsamplerDevice::Midi:
187 capela 484 if ((pParamInfo = ::lscp_get_midi_driver_param_info(client(),
188     m_sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
189     appendMessagesClient("lscp_get_midi_driver_param_info");
190 capela 429 break;
191 capela 436 case qsamplerDevice::None:
192     break;
193 capela 429 }
194 capela 436 if (pParamInfo) {
195 capela 463 m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
196 capela 433 pDeviceInfo->params[i].value);
197 capela 436 }
198 capela 429 }
199 capela 463
200 capela 467 // Refresh parameter dependencies...
201 capela 484 refreshParams();
202 capela 467 // Set port/channel list...
203 capela 484 refreshPorts();
204 capela 429 }
205    
206    
207 capela 462 // Driver name initializer/settler.
208 capela 484 void qsamplerDevice::setDriver ( const QString& sDriverName )
209 capela 431 {
210     // Valid only for scratch devices.
211     if (m_sDriverName == sDriverName)
212     return;
213    
214 capela 463 // Reset device parameters and ports anyway.
215 capela 467 m_params.clear();
216     m_ports.clear();
217 capela 463
218 capela 431 // Retrieve driver info, if any.
219     lscp_driver_info_t *pDriverInfo = NULL;
220     switch (m_deviceType) {
221     case qsamplerDevice::Audio:
222 capela 484 if ((pDriverInfo = ::lscp_get_audio_driver_info(client(),
223     sDriverName.latin1())) == NULL)
224     appendMessagesClient("lscp_get_audio_driver_info");
225 capela 431 break;
226     case qsamplerDevice::Midi:
227 capela 484 if ((pDriverInfo = ::lscp_get_midi_driver_info(client(),
228     sDriverName.latin1())) == NULL)
229     appendMessagesClient("lscp_get_midi_driver_info");
230 capela 431 break;
231 capela 436 case qsamplerDevice::None:
232     break;
233 capela 431 }
234    
235     // If we're bogus, bail out...
236     if (pDriverInfo == NULL)
237     return;
238    
239     // Remember device parameters...
240     m_sDriverName = sDriverName;
241    
242     // Grab driver parameters...
243     for (int i = 0; pDriverInfo->parameters && pDriverInfo->parameters[i]; i++) {
244 capela 463 const QString sParam = pDriverInfo->parameters[i];
245 capela 431 lscp_param_info_t *pParamInfo = NULL;
246     switch (m_deviceType) {
247     case qsamplerDevice::Audio:
248 capela 484 if ((pParamInfo = ::lscp_get_audio_driver_param_info(client(),
249     sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
250     appendMessagesClient("lscp_get_audio_driver_param_info");
251 capela 431 break;
252     case qsamplerDevice::Midi:
253 capela 484 if ((pParamInfo = ::lscp_get_midi_driver_param_info(client(),
254     sDriverName.latin1(), sParam.latin1(), NULL)) == NULL)
255     appendMessagesClient("lscp_get_midi_driver_param_info");
256 capela 431 break;
257 capela 436 case qsamplerDevice::None:
258     break;
259 capela 431 }
260 capela 463 if (pParamInfo) {
261     m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
262     pParamInfo->defaultv);
263     }
264 capela 431 }
265 capela 467
266     // Refresh parameter dependencies...
267 capela 484 refreshParams();
268 capela 467 // Set port/channel list...
269 capela 484 refreshPorts();
270 capela 431 }
271    
272    
273 capela 484 // The client descriptor delegated property.
274     lscp_client_t *qsamplerDevice::client (void) const
275     {
276     if (m_pMainForm == NULL)
277     return NULL;
278    
279     return m_pMainForm->client();
280     }
281    
282    
283 capela 429 // Device property accessors.
284     int qsamplerDevice::deviceID (void) const
285     {
286     return m_iDeviceID;
287     }
288    
289     qsamplerDevice::qsamplerDeviceType qsamplerDevice::deviceType (void) const
290     {
291     return m_deviceType;
292     }
293    
294 capela 433 const QString& qsamplerDevice::deviceTypeName (void) const
295     {
296     return m_sDeviceType;
297     }
298    
299 capela 429 const QString& qsamplerDevice::driverName (void) const
300     {
301     return m_sDriverName;
302     }
303    
304 capela 484 // Special device name formatter.
305     QString qsamplerDevice::deviceName (void) const
306 capela 429 {
307 capela 484 QString sPrefix;
308     if (m_iDeviceID >= 0)
309     sPrefix += m_sDeviceType + ' ';
310     return sPrefix + m_sDeviceName;
311 capela 429 }
312    
313 capela 463
314     // Set the proper device parameter value.
315 capela 484 bool qsamplerDevice::setParam ( const QString& sParam,
316 capela 463 const QString& sValue )
317     {
318 capela 484 // Set proper device parameter.
319 capela 463 m_params[sParam.upper()].value = sValue;
320 capela 490
321 capela 484 // If the device already exists, things get immediate...
322     int iRefresh = 0;
323     if (m_iDeviceID >= 0) {
324     // Prepare parameter struct.
325     lscp_param_t param;
326     param.key = (char *) sParam.latin1();
327     param.value = (char *) sValue.latin1();
328     // Now it depends on the device type...
329     lscp_status_t ret = LSCP_FAILED;
330     switch (m_deviceType) {
331     case qsamplerDevice::Audio:
332     if (sParam == "CHANNELS") iRefresh++;
333     if ((ret = ::lscp_set_audio_device_param(client(),
334     m_iDeviceID, &param)) != LSCP_OK)
335     appendMessagesClient("lscp_set_audio_device_param");
336     break;
337     case qsamplerDevice::Midi:
338     if (sParam == "PORTS") iRefresh++;
339     if ((ret = ::lscp_set_midi_device_param(client(),
340     m_iDeviceID, &param)) != LSCP_OK)
341     appendMessagesClient("lscp_set_midi_device_param");
342     break;
343     case qsamplerDevice::None:
344     break;
345     }
346     // Show result.
347     if (ret == LSCP_OK) {
348     appendMessages(QString("%1: %2.").arg(sParam).arg(sValue));
349     // Special care for specific parameter changes...
350     if (iRefresh > 0)
351     iRefresh += refreshPorts();
352     iRefresh += refreshDepends(sParam);
353     } else {
354     // Oops...
355     appendMessagesError(
356     QObject::tr("Could not set device parameter value.\n\nSorry."));
357     }
358     }
359 capela 490
360 capela 484 // Return whether we're need a view refresh.
361     return (iRefresh > 0);
362 capela 463 }
363    
364    
365 capela 429 // Device parameter accessor.
366 capela 462 const qsamplerDeviceParamMap& qsamplerDevice::params (void) const
367 capela 429 {
368     return m_params;
369     }
370    
371    
372 capela 463 // Device port/channel list accessor.
373     qsamplerDevicePortList& qsamplerDevice::ports (void)
374 capela 429 {
375 capela 463 return m_ports;
376 capela 429 }
377    
378 capela 462
379 capela 484 // Create a new device, as a copy of this current one.
380     bool qsamplerDevice::createDevice (void)
381     {
382     if (client() == NULL)
383     return false;
384    
385     // Build the parameter list...
386     lscp_param_t *pParams = new lscp_param_t [m_params.count() + 1];
387     int iParam = 0;
388     qsamplerDeviceParamMap::ConstIterator iter;
389     for (iter = m_params.begin(); iter != m_params.end(); ++iter) {
390     pParams[iParam].key = (char *) iter.key().latin1();
391     pParams[iParam].value = (char *) iter.data().value.latin1();
392     ++iParam;
393     }
394     // Null terminated.
395     pParams[iParam].key = NULL;
396     pParams[iParam].value = NULL;
397    
398     // Now it depends on the device type...
399     switch (m_deviceType) {
400     case qsamplerDevice::Audio:
401     if ((m_iDeviceID = ::lscp_create_audio_device(client(),
402     m_sDriverName.latin1(), pParams)) < 0)
403     appendMessagesClient("lscp_create_audio_device");
404     break;
405     case qsamplerDevice::Midi:
406     if ((m_iDeviceID = ::lscp_create_midi_device(client(),
407     m_sDriverName.latin1(), pParams)) < 0)
408     appendMessagesClient("lscp_create_midi_device");
409     break;
410     case qsamplerDevice::None:
411     break;
412     }
413    
414     // Free used parameter array.
415     delete pParams;
416    
417     // Show result.
418     if (m_iDeviceID >= 0) {
419 capela 490 // Refresh our own stuff...
420     setDevice(m_deviceType, m_iDeviceID);
421 capela 484 appendMessages(QObject::tr("created."));
422     } else {
423     appendMessagesError(QObject::tr("Could not create device.\n\nSorry."));
424     }
425 capela 490
426 capela 484 // Return whether we're a valid device...
427     return (m_iDeviceID >= 0);
428     }
429    
430    
431     // Destroy existing device.
432     bool qsamplerDevice::deleteDevice (void)
433     {
434     // Now it depends on the device type...
435     lscp_status_t ret = LSCP_FAILED;
436     switch (m_deviceType) {
437     case qsamplerDevice::Audio:
438     if ((ret = ::lscp_destroy_audio_device(client(),
439     m_iDeviceID)) != LSCP_OK)
440     appendMessagesClient("lscp_destroy_audio_device");
441     break;
442     case qsamplerDevice::Midi:
443     if ((ret = ::lscp_destroy_midi_device(client(),
444     m_iDeviceID)) != LSCP_OK)
445     appendMessagesClient("lscp_destroy_midi_device");
446     break;
447     case qsamplerDevice::None:
448     break;
449     }
450    
451     // Show result.
452     if (ret == LSCP_OK) {
453     appendMessages(QObject::tr("deleted."));
454     m_iDeviceID = -1;
455     } else {
456     appendMessagesError(QObject::tr("Could not delete device.\n\nSorry."));
457     }
458 capela 490
459 capela 484 // Return whether we've done it..
460     return (ret == LSCP_OK);
461     }
462    
463    
464 capela 467 // Device parameter dependencies refreshner.
465 capela 484 int qsamplerDevice::refreshParams (void)
466 capela 467 {
467 capela 468 // This should only make sense for scratch devices...
468     if (m_iDeviceID >= 0)
469     return 0;
470 capela 467 // Refresh all parameters that have dependencies...
471     int iParams = 0;
472     qsamplerDeviceParamMap::ConstIterator iter;
473     for (iter = m_params.begin(); iter != m_params.end(); ++iter)
474 capela 484 iParams += refreshParam(iter.key());
475 capela 467 // Return how many parameters have been refreshed...
476     return iParams;
477     }
478    
479    
480 capela 463 // Device port/channel list refreshner.
481 capela 484 int qsamplerDevice::refreshPorts (void)
482 capela 463 {
483 capela 468 // This should only make sense for actual devices...
484     if (m_iDeviceID < 0)
485     return 0;
486 capela 463 // Port/channel count determination...
487     int iPorts = 0;
488     switch (m_deviceType) {
489     case qsamplerDevice::Audio:
490     iPorts = m_params["CHANNELS"].value.toInt();
491     break;
492     case qsamplerDevice::Midi:
493     iPorts = m_params["PORTS"].value.toInt();
494     break;
495     case qsamplerDevice::None:
496     break;
497     }
498     // Retrieve port/channel information...
499     m_ports.clear();
500     for (int iPort = 0; iPort < iPorts; iPort++)
501 capela 484 m_ports.append(new qsamplerDevicePort(*this, iPort));
502 capela 467 // Return how many ports have been refreshed...
503     return iPorts;
504 capela 463 }
505    
506    
507 capela 467 // Refresh/set dependencies given that some parameter has changed.
508 capela 484 int qsamplerDevice::refreshDepends ( const QString& sParam )
509 capela 467 {
510 capela 468 // This should only make sense for scratch devices...
511     if (m_iDeviceID >= 0)
512     return 0;
513 capela 467 // Refresh all parameters that depend on this one...
514     int iDepends = 0;
515     qsamplerDeviceParamMap::ConstIterator iter;
516     for (iter = m_params.begin(); iter != m_params.end(); ++iter) {
517     const QStringList& depends = iter.data().depends;
518     if (depends.find(sParam) != depends.end())
519 capela 484 iDepends += refreshParam(iter.key());
520 capela 467 }
521     // Return how many dependencies have been refreshed...
522     return iDepends;
523     }
524    
525    
526     // Refresh/set given parameter based on driver supplied dependencies.
527 capela 484 int qsamplerDevice::refreshParam ( const QString& sParam )
528 capela 467 {
529     // Check if we have dependencies...
530     qsamplerDeviceParam& param = m_params[sParam.upper()];
531     if (param.depends.isEmpty())
532     return 0;
533    
534     int iRefresh = 0;
535    
536     // Build dependency list...
537     lscp_param_t *pDepends = new lscp_param_t [param.depends.count() + 1];
538     int iDepend = 0;
539     QStringList::ConstIterator iter;
540     for (iter = param.depends.begin(); iter != param.depends.end(); ++iter) {
541     const QString& sDepend = *iter;
542     pDepends[iDepend].key = (char *) sDepend.latin1();
543     pDepends[iDepend].value = (char *) m_params[sDepend.upper()].value.latin1();
544     ++iDepend;
545     }
546     // Null terminated.
547     pDepends[iDepend].key = NULL;
548     pDepends[iDepend].value = NULL;
549    
550     // FIXME: Some parameter dependencies (e.g.ALSA CARD)
551 capela 468 // are blocking for no reason, causing potential timeout-crashes.
552     // hopefully this gets mitigated if this dependency hell is only
553     // carried out for scratch devices...
554 capela 467
555     // Retrieve some modern parameters...
556     lscp_param_info_t *pParamInfo = NULL;
557     switch (m_deviceType) {
558     case qsamplerDevice::Audio:
559 capela 484 if ((pParamInfo = ::lscp_get_audio_driver_param_info(client(),
560     m_sDriverName.latin1(), sParam.latin1(), pDepends)) == NULL)
561     appendMessagesClient("lscp_get_audio_driver_param_info");
562 capela 467 break;
563     case qsamplerDevice::Midi:
564 capela 484 if ((pParamInfo = ::lscp_get_midi_driver_param_info(client(),
565     m_sDriverName.latin1(), sParam.latin1(), pDepends)) == NULL)
566     appendMessagesClient("lscp_get_midi_driver_param_info");
567 capela 467 break;
568     case qsamplerDevice::None:
569     break;
570     }
571     if (pParamInfo) {
572     param = qsamplerDeviceParam(pParamInfo, QString(param.value));
573     iRefresh++;
574     }
575 capela 468
576 capela 467 // Free used parameter array.
577     delete pDepends;
578    
579     // Return whether the parameters has been changed...
580     return iRefresh;
581     }
582    
583    
584 capela 484 // Redirected messages output methods.
585     void qsamplerDevice::appendMessages( const QString& s ) const
586     {
587     if (m_pMainForm)
588     m_pMainForm->appendMessages(deviceName() + ' ' + s);
589     }
590    
591     void qsamplerDevice::appendMessagesColor( const QString& s,
592     const QString& c ) const
593     {
594     if (m_pMainForm)
595     m_pMainForm->appendMessagesColor(deviceName() + ' ' + s, c);
596     }
597    
598     void qsamplerDevice::appendMessagesText( const QString& s ) const
599     {
600     if (m_pMainForm)
601     m_pMainForm->appendMessagesText(deviceName() + ' ' + s);
602     }
603    
604     void qsamplerDevice::appendMessagesError( const QString& s ) const
605     {
606     if (m_pMainForm)
607     m_pMainForm->appendMessagesError(deviceName() + "\n\n" + s);
608     }
609    
610     void qsamplerDevice::appendMessagesClient( const QString& s ) const
611     {
612     if (m_pMainForm)
613     m_pMainForm->appendMessagesClient(deviceName() + ' ' + s);
614     }
615    
616    
617 capela 430 // Device ids enumerator.
618 capela 429 int *qsamplerDevice::getDevices ( lscp_client_t *pClient,
619     qsamplerDeviceType deviceType )
620     {
621     int *piDeviceIDs = NULL;
622     switch (deviceType) {
623 capela 431 case qsamplerDevice::Audio:
624     piDeviceIDs = ::lscp_list_audio_devices(pClient);
625 capela 429 break;
626 capela 431 case qsamplerDevice::Midi:
627     piDeviceIDs = ::lscp_list_midi_devices(pClient);
628     break;
629 capela 436 case qsamplerDevice::None:
630     break;
631 capela 429 }
632     return piDeviceIDs;
633     }
634    
635 capela 430
636     // Driver names enumerator.
637     QStringList qsamplerDevice::getDrivers ( lscp_client_t *pClient,
638     qsamplerDeviceType deviceType )
639     {
640     QStringList drivers;
641 capela 490
642 capela 430 const char **ppszDrivers = NULL;
643     switch (deviceType) {
644 capela 431 case qsamplerDevice::Audio:
645 capela 525 ppszDrivers = ::lscp_list_available_audio_drivers(pClient);
646 capela 430 break;
647 capela 431 case qsamplerDevice::Midi:
648 capela 525 ppszDrivers = ::lscp_list_available_midi_drivers(pClient);
649 capela 431 break;
650 capela 436 case qsamplerDevice::None:
651     break;
652 capela 430 }
653 capela 490
654 capela 431 for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)
655     drivers.append(ppszDrivers[iDriver]);
656 capela 430
657     return drivers;
658     }
659    
660    
661 capela 429 //-------------------------------------------------------------------------
662 capela 462 // qsamplerDevicePort - MIDI/Audio Device port/channel structure.
663     //
664    
665     // Constructor.
666 capela 484 qsamplerDevicePort::qsamplerDevicePort ( qsamplerDevice& device,
667     int iPortID ) : m_device(device)
668 capela 462 {
669 capela 484 setDevicePort(iPortID);
670 capela 462 }
671    
672     // Default destructor.
673     qsamplerDevicePort::~qsamplerDevicePort (void)
674     {
675     }
676    
677    
678     // Initializer.
679 capela 484 void qsamplerDevicePort::setDevicePort ( int iPortID )
680 capela 462 {
681     // Device port id should be always set.
682     m_iPortID = iPortID;
683    
684 capela 463 // Reset port parameters anyway.
685 capela 467 m_params.clear();
686 capela 463
687 capela 462 // Retrieve device port/channel info, if any.
688     lscp_device_port_info_t *pPortInfo = NULL;
689 capela 484 switch (m_device.deviceType()) {
690 capela 462 case qsamplerDevice::Audio:
691 capela 484 if ((pPortInfo = ::lscp_get_audio_channel_info(m_device.client(),
692     m_device.deviceID(), m_iPortID)) == NULL)
693     m_device.appendMessagesClient("lscp_get_audio_channel_info");
694 capela 462 break;
695     case qsamplerDevice::Midi:
696 capela 484 if ((pPortInfo = ::lscp_get_midi_port_info(m_device.client(),
697     m_device.deviceID(), m_iPortID)) == NULL)
698     m_device.appendMessagesClient("lscp_get_midi_port_info");
699 capela 462 break;
700     case qsamplerDevice::None:
701     break;
702     }
703    
704     // If we're bogus, bail out...
705     if (pPortInfo == NULL) {
706     m_sPortName = QString::null;
707     return;
708     }
709    
710     // Set device port/channel properties...
711 capela 484 m_sPortName = pPortInfo->name;
712 capela 462
713     // Grab device port/channel parameters...
714     m_params.clear();
715     for (int i = 0; pPortInfo->params && pPortInfo->params[i].key; i++) {
716 capela 463 const QString sParam = pPortInfo->params[i].key;
717 capela 462 lscp_param_info_t *pParamInfo = NULL;
718 capela 484 switch (m_device.deviceType()) {
719 capela 462 case qsamplerDevice::Audio:
720 capela 484 if ((pParamInfo = ::lscp_get_audio_channel_param_info(
721     m_device.client(), m_device.deviceID(),
722     m_iPortID, sParam.latin1())) == NULL)
723     m_device.appendMessagesClient("lscp_get_audio_channel_param_info");
724 capela 462 break;
725     case qsamplerDevice::Midi:
726 capela 484 if ((pParamInfo = ::lscp_get_midi_port_param_info(
727     m_device.client(), m_device.deviceID(),
728     m_iPortID, sParam.latin1())) == NULL)
729     m_device.appendMessagesClient("lscp_get_midi_port_param_info");
730 capela 462 break;
731     case qsamplerDevice::None:
732     break;
733     }
734     if (pParamInfo) {
735 capela 463 m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
736 capela 462 pPortInfo->params[i].value);
737     }
738     }
739     }
740    
741    
742     // Device port/channel property accessors.
743     int qsamplerDevicePort::portID (void) const
744     {
745     return m_iPortID;
746     }
747    
748     const QString& qsamplerDevicePort::portName (void) const
749     {
750     return m_sPortName;
751     }
752    
753     // Device port/channel parameter accessor.
754     const qsamplerDeviceParamMap& qsamplerDevicePort::params (void) const
755     {
756     return m_params;
757     }
758    
759    
760     // Set the proper device port/channel parameter value.
761 capela 484 bool qsamplerDevicePort::setParam ( const QString& sParam,
762 capela 462 const QString& sValue )
763     {
764 capela 484 // Set proper port/channel parameter.
765 capela 463 m_params[sParam.upper()].value = sValue;
766 capela 484
767     // If the device already exists, things get immediate...
768     int iRefresh = 0;
769     if (m_device.deviceID() >= 0 && m_iPortID >= 0) {
770     // Prepare parameter struct.
771     lscp_param_t param;
772     param.key = (char *) sParam.latin1();
773     param.value = (char *) sValue.latin1();
774     // Now it depends on the device type...
775     lscp_status_t ret = LSCP_FAILED;
776     switch (m_device.deviceType()) {
777     case qsamplerDevice::Audio:
778     if ((ret = ::lscp_set_audio_channel_param(m_device.client(),
779     m_device.deviceID(), m_iPortID, &param)) != LSCP_OK)
780     m_device.appendMessagesClient("lscp_set_audio_channel_param");
781     break;
782     case qsamplerDevice::Midi:
783     if ((ret = ::lscp_set_midi_port_param(m_device.client(),
784     m_device.deviceID(), m_iPortID, &param)) != LSCP_OK)
785     m_device.appendMessagesClient("lscp_set_midi_port_param");
786     break;
787     case qsamplerDevice::None:
788     break;
789     }
790     // Show result.
791     if (ret == LSCP_OK) {
792     m_device.appendMessages(m_sPortName
793     + ' ' + QString("%1: %2.").arg(sParam).arg(sValue));
794     iRefresh++;
795     } else {
796     m_device.appendMessagesError(
797     QObject::tr("Could not set %1 parameter value.\n\n"
798     "Sorry.").arg(m_sPortName));
799     }
800     }
801    
802     // Return whether we're need a view refresh.
803     return (iRefresh > 0);
804 capela 462 }
805    
806    
807     //-------------------------------------------------------------------------
808 capela 429 // qsamplerDeviceItem - QListView device item.
809     //
810    
811     // Constructors.
812 capela 433 qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView,
813 capela 484 qsamplerMainForm *pMainForm, qsamplerDevice::qsamplerDeviceType deviceType )
814     : QListViewItem(pListView), m_device(pMainForm, deviceType)
815 capela 429 {
816     switch(m_device.deviceType()) {
817 capela 431 case qsamplerDevice::Audio:
818 capela 429 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio1.png"));
819 capela 471 QListViewItem::setText(0, QObject::tr("Audio Devices"));
820 capela 429 break;
821 capela 431 case qsamplerDevice::Midi:
822 capela 429 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));
823 capela 471 QListViewItem::setText(0, QObject::tr("MIDI Devices"));
824 capela 429 break;
825 capela 436 case qsamplerDevice::None:
826     break;
827 capela 429 }
828     }
829    
830 capela 433 qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem,
831 capela 484 qsamplerMainForm *pMainForm, qsamplerDevice::qsamplerDeviceType deviceType,
832 capela 433 int iDeviceID )
833 capela 484 : QListViewItem(pItem), m_device(pMainForm, deviceType, iDeviceID)
834 capela 429 {
835     switch(m_device.deviceType()) {
836 capela 431 case qsamplerDevice::Audio:
837 capela 429 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio2.png"));
838     break;
839 capela 431 case qsamplerDevice::Midi:
840 capela 429 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));
841     break;
842 capela 436 case qsamplerDevice::None:
843     break;
844 capela 429 }
845    
846     QListViewItem::setText(0, m_device.deviceName());
847     }
848    
849     // Default destructor.
850     qsamplerDeviceItem::~qsamplerDeviceItem (void)
851     {
852     }
853    
854     // Instance accessors.
855 capela 431 qsamplerDevice& qsamplerDeviceItem::device (void)
856 capela 429 {
857     return m_device;
858     }
859    
860     // To virtually distinguish between list view items.
861     int qsamplerDeviceItem::rtti() const
862     {
863     return QSAMPLER_DEVICE_ITEM;
864     }
865    
866    
867    
868     //-------------------------------------------------------------------------
869     // qsamplerDeviceParamTable - Device parameter view table.
870     //
871    
872     // Constructor.
873 capela 433 qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent,
874     const char *pszName )
875 capela 426 : QTable(pParent, pszName)
876     {
877 capela 428 // Set fixed number of columns.
878 capela 429 QTable::setNumCols(3);
879 capela 428 QTable::setShowGrid(false);
880     QTable::setSorting(false);
881     QTable::setFocusStyle(QTable::FollowStyle);
882     QTable::setSelectionMode(QTable::NoSelection);
883     // No vertical header.
884     QTable::verticalHeader()->hide();
885     QTable::setLeftMargin(0);
886     // Initialize the fixed table column headings.
887     QHeader *pHeader = QTable::horizontalHeader();
888 capela 436 pHeader->setLabel(0, tr("Parameter"));
889     pHeader->setLabel(1, tr("Description"));
890     pHeader->setLabel(2, tr("Value"));
891 capela 428 // Set read-onlyness of each column
892     QTable::setColumnReadOnly(0, true);
893 capela 436 QTable::setColumnReadOnly(1, true);
894 capela 468 // QTable::setColumnReadOnly(2, false); -- of course not.
895 capela 436 QTable::setColumnStretchable(1, true);
896 capela 426 }
897    
898     // Default destructor.
899 capela 429 qsamplerDeviceParamTable::~qsamplerDeviceParamTable (void)
900 capela 426 {
901     }
902    
903    
904 capela 462 // Common parameter table renderer.
905     void qsamplerDeviceParamTable::refresh ( const qsamplerDeviceParamMap& params,
906     bool bEditable )
907 capela 429 {
908     // Always (re)start it empty.
909 capela 433 QTable::setUpdatesEnabled(false);
910 capela 429 QTable::setNumRows(0);
911    
912 capela 462 // Fill the parameter table...
913 capela 429 QTable::insertRows(0, params.count());
914     int iRow = 0;
915 capela 431 qsamplerDeviceParamMap::ConstIterator iter;
916 capela 429 for (iter = params.begin(); iter != params.end(); ++iter) {
917 capela 432 const qsamplerDeviceParam& param = iter.data();
918 capela 462 bool bEnabled = (bEditable || !param.fix);
919 capela 436 QTable::setText(iRow, 0, iter.key());
920     QTable::setText(iRow, 1, param.description);
921 capela 462 if (param.type == LSCP_TYPE_BOOL) {
922 capela 432 QStringList opts;
923 capela 463 opts.append(tr("false"));
924     opts.append(tr("true"));
925 capela 432 QComboTableItem *pComboItem = new QComboTableItem(this, opts);
926 capela 448 pComboItem->setCurrentItem(param.value.lower() == "true" ? 1 : 0);
927     pComboItem->setEnabled(bEnabled);
928 capela 436 QTable::setItem(iRow, 2, pComboItem);
929 capela 451 } else if (param.possibilities.count() > 0 && bEnabled) {
930 capela 492 QStringList opts = param.possibilities;
931     if (param.multiplicity)
932     opts.prepend(tr("(none)"));
933     QComboTableItem *pComboItem = new QComboTableItem(this, opts);
934     if (param.value.isEmpty())
935     pComboItem->setCurrentItem(0);
936     else
937     pComboItem->setCurrentItem(param.value);
938 capela 448 pComboItem->setEnabled(bEnabled);
939 capela 436 QTable::setItem(iRow, 2, pComboItem);
940 capela 451 } else if (param.type == LSCP_TYPE_INT && bEnabled
941 capela 448 && !param.range_min.isEmpty()
942     && !param.range_max.isEmpty()) {
943     qsamplerDeviceParamTableSpinBox *pSpinItem =
944 capela 442 new qsamplerDeviceParamTableSpinBox(this,
945 capela 448 bEnabled ? QTableItem::OnTyping : QTableItem::Never,
946 capela 447 param.value);
947 capela 448 pSpinItem->setMinValue(param.range_min.toInt());
948     pSpinItem->setMaxValue(param.range_max.toInt());
949 capela 442 QTable::setItem(iRow, 2, pSpinItem);
950 capela 432 } else {
951 capela 448 qsamplerDeviceParamTableEditBox *pEditItem =
952 capela 442 new qsamplerDeviceParamTableEditBox(this,
953 capela 448 bEnabled ? QTableItem::OnTyping : QTableItem::Never,
954 capela 442 param.value);
955     QTable::setItem(iRow, 2, pEditItem);
956 capela 432 }
957 capela 431 ++iRow;
958 capela 429 }
959    
960 capela 433 // Adjust optimal column widths.
961 capela 436 QTable::adjustColumn(0);
962 capela 433 QTable::adjustColumn(2);
963 capela 436
964 capela 433 QTable::setUpdatesEnabled(true);
965     QTable::updateContents();
966 capela 429 }
967    
968    
969 capela 442 //-------------------------------------------------------------------------
970     // qsamplerDeviceParamTableSpinBox - Custom spin box for parameter table.
971     //
972    
973     // Constructor.
974     qsamplerDeviceParamTableSpinBox::qsamplerDeviceParamTableSpinBox (
975 capela 447 QTable *pTable, EditType editType, const QString& sText )
976     : QTableItem(pTable, editType, sText)
977 capela 442 {
978 capela 448 m_iValue = sText.toInt();
979     m_iMinValue = m_iMaxValue = 0;
980 capela 442 }
981    
982     // Public accessors.
983     void qsamplerDeviceParamTableSpinBox::setValue ( int iValue )
984     {
985     m_iValue = iValue;
986     QTableItem::setText(QString::number(m_iValue));
987     }
988    
989     void qsamplerDeviceParamTableSpinBox::setMinValue ( int iMinValue )
990     {
991     m_iMinValue = iMinValue;
992     }
993    
994     void qsamplerDeviceParamTableSpinBox::setMaxValue ( int iMaxValue )
995     {
996     m_iMaxValue = iMaxValue;
997     }
998    
999     // Virtual implemetations.
1000     QWidget *qsamplerDeviceParamTableSpinBox::createEditor (void) const
1001     {
1002     QSpinBox *pSpinBox = new QSpinBox(QTableItem::table()->viewport());
1003     QObject::connect(pSpinBox, SIGNAL(valueChanged(int)),
1004     QTableItem::table(), SLOT(doValueChanged()));
1005     if (m_iValue >= m_iMinValue && m_iMaxValue >= m_iValue) {
1006     pSpinBox->setMinValue(m_iMinValue);
1007     pSpinBox->setMaxValue(m_iMaxValue);
1008     }
1009     pSpinBox->setValue(m_iValue);
1010     return pSpinBox;
1011     }
1012    
1013     void qsamplerDeviceParamTableSpinBox::setContentFromEditor ( QWidget *pWidget )
1014     {
1015     if (pWidget->inherits("QSpinBox"))
1016 capela 448 QTableItem::setText(QString::number(((QSpinBox *) pWidget)->value()));
1017 capela 442 else
1018 capela 448 QTableItem::setContentFromEditor(pWidget);
1019 capela 442 }
1020    
1021    
1022     //-------------------------------------------------------------------------
1023     // qsamplerDeviceParamTableEditBox - Custom edit box for parameter table.
1024     //
1025    
1026     // Constructor.
1027     qsamplerDeviceParamTableEditBox::qsamplerDeviceParamTableEditBox (
1028     QTable *pTable, EditType editType, const QString& sText )
1029     : QTableItem(pTable, editType, sText)
1030     {
1031     }
1032    
1033     // Virtual implemetations.
1034     QWidget *qsamplerDeviceParamTableEditBox::createEditor (void) const
1035     {
1036     QLineEdit *pEditBox = new QLineEdit(QTableItem::table()->viewport());
1037     QObject::connect(pEditBox, SIGNAL(returnPressed()),
1038     QTableItem::table(), SLOT(doValueChanged()));
1039     pEditBox->setText(QTableItem::text());
1040     return pEditBox;
1041     }
1042    
1043     void qsamplerDeviceParamTableEditBox::setContentFromEditor ( QWidget *pWidget )
1044     {
1045     if (pWidget->inherits("QLineEdit"))
1046 capela 448 QTableItem::setText(((QLineEdit *) pWidget)->text());
1047 capela 442 else
1048 capela 448 QTableItem::setContentFromEditor(pWidget);
1049 capela 442 }
1050    
1051    
1052 capela 426 // end of qsamplerDevice.cpp
1053 capela 492

  ViewVC Help
Powered by ViewVC