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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 525 - (hide annotations) (download)
Mon May 9 10:21:41 2005 UTC (18 years, 10 months ago) by capela
File size: 28970 byte(s)
* [bug #9] Fixed for a LSCP command syntax convention
consistency, regarding the enumeration of available
sampler engines, Audio and MIDI drivers.
* [bug #13] Update instrument names list when a new
instrument file is select on the channel setup dialog.

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

  ViewVC Help
Powered by ViewVC