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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1558 - (hide annotations) (download)
Thu Dec 6 09:35:33 2007 UTC (16 years, 4 months ago) by capela
File size: 33261 byte(s)
* Qt4 migration: complete QSampler namespace overhaul.

1 capela 426 // qsamplerDevice.cpp
2     //
3     /****************************************************************************
4 schoenebeck 1461 Copyright (C) 2004-2007, rncbc aka Rui Nuno Capela. All rights reserved.
5 capela 1464 Copyright (C) 2007, Christian Schoenebeck
6 capela 426
7     This program is free software; you can redistribute it and/or
8     modify it under the terms of the GNU General Public License
9     as published by the Free Software Foundation; either version 2
10     of the License, or (at your option) any later version.
11    
12     This program is distributed in the hope that it will be useful,
13     but WITHOUT ANY WARRANTY; without even the implied warranty of
14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15     GNU General Public License for more details.
16    
17 capela 920 You should have received a copy of the GNU General Public License along
18     with this program; if not, write to the Free Software Foundation, Inc.,
19     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 capela 426
21     *****************************************************************************/
22    
23 capela 759 #include "qsamplerAbout.h"
24 capela 426 #include "qsamplerDevice.h"
25    
26     #include "qsamplerMainForm.h"
27     #include "qsamplerDeviceForm.h"
28    
29 capela 1499 #include <QCheckBox>
30     #include <QSpinBox>
31     #include <QLineEdit>
32 capela 426
33 capela 1499
34 capela 1558 namespace QSampler {
35 capela 426
36     //-------------------------------------------------------------------------
37 capela 1558 // QSampler::DeviceParam - MIDI/Audio Device parameter structure.
38 capela 426 //
39    
40 capela 429 // Constructors.
41 capela 1558 DeviceParam::DeviceParam ( lscp_param_info_t *pParamInfo,
42 capela 429 const char *pszValue )
43     {
44     setParam(pParamInfo, pszValue);
45     }
46    
47    
48     // Default destructor.
49 capela 1558 DeviceParam::~DeviceParam (void)
50 capela 429 {
51     }
52    
53    
54     // Initializer.
55 capela 1558 void DeviceParam::setParam ( lscp_param_info_t *pParamInfo,
56 capela 429 const char *pszValue )
57     {
58     if (pParamInfo == NULL)
59 capela 431 return;
60 capela 490
61 capela 431 // Info structure field members.
62 capela 490
63 capela 429 type = pParamInfo->type;
64 capela 490
65 capela 429 if (pParamInfo->description)
66     description = pParamInfo->description;
67     else
68     description = QString::null;
69 capela 490
70 capela 482 mandatory = (bool) pParamInfo->mandatory;
71 capela 431 fix = (bool) pParamInfo->fix;
72     multiplicity = (bool) pParamInfo->multiplicity;
73 capela 490
74 capela 431 depends.clear();
75     for (int i = 0; pParamInfo->depends && pParamInfo->depends[i]; i++)
76     depends.append(pParamInfo->depends[i]);
77 capela 490
78 capela 429 if (pParamInfo->defaultv)
79     defaultv = pParamInfo->defaultv;
80     else
81     defaultv = QString::null;
82 capela 490
83 capela 429 if (pParamInfo->range_min)
84 capela 431 range_min = pParamInfo->range_min;
85 capela 429 else
86     range_min = QString::null;
87 capela 490
88 capela 429 if (pParamInfo->range_max)
89 capela 431 range_max = pParamInfo->range_max;
90 capela 429 else
91     range_max = QString::null;
92 capela 490
93 capela 429 possibilities.clear();
94 capela 431 for (int i = 0; pParamInfo->possibilities && pParamInfo->possibilities[i]; i++)
95     possibilities.append(pParamInfo->possibilities[i]);
96 capela 490
97 capela 431 // The current parameter value.
98 capela 429 if (pszValue)
99 capela 431 value = pszValue;
100 capela 429 else
101     value = QString::null;
102     }
103    
104    
105     //-------------------------------------------------------------------------
106 capela 1558 // QSampler::Device - MIDI/Audio Device structure.
107 capela 429 //
108    
109 capela 426 // Constructor.
110 capela 1558 Device::Device ( DeviceType deviceType, int iDeviceID )
111 capela 429 {
112 capela 1499 // m_ports.setAutoDelete(true);
113 capela 490
114 capela 484 setDevice(deviceType, iDeviceID);
115 capela 429 }
116    
117     // Default destructor.
118 capela 1558 Device::~Device (void)
119 capela 429 {
120 capela 1499 qDeleteAll(m_ports);
121     m_ports.clear();
122 capela 429 }
123    
124 capela 484 // Copy constructor.
125 capela 1558 Device::Device ( const Device& device )
126 capela 1499 : m_params(device.m_params), m_ports(device.m_ports)
127 capela 484 {
128     m_iDeviceID = device.m_iDeviceID;
129     m_deviceType = device.m_deviceType;
130     m_sDeviceType = device.m_sDeviceType;
131     m_sDriverName = device.m_sDriverName;
132     m_sDeviceName = device.m_sDeviceName;
133     }
134 capela 429
135 capela 484
136 capela 429 // Initializer.
137 capela 1558 void Device::setDevice ( DeviceType deviceType, int iDeviceID )
138 capela 429 {
139 schoenebeck 1461 MainForm *pMainForm = MainForm::getInstance();
140 capela 961 if (pMainForm == NULL)
141     return;
142     if (pMainForm->client() == NULL)
143     return;
144    
145 capela 430 // Device id and type should be always set.
146 capela 462 m_iDeviceID = iDeviceID;
147     m_deviceType = deviceType;
148 capela 490
149 capela 463 // Reset device parameters and ports anyway.
150 capela 467 m_params.clear();
151 capela 1499 qDeleteAll(m_ports);
152 capela 467 m_ports.clear();
153 capela 430
154     // Retrieve device info, if any.
155 capela 429 lscp_device_info_t *pDeviceInfo = NULL;
156     switch (deviceType) {
157 capela 1558 case Device::Audio:
158 capela 433 m_sDeviceType = QObject::tr("Audio");
159 capela 484 if (m_iDeviceID >= 0 && (pDeviceInfo = ::lscp_get_audio_device_info(
160 capela 961 pMainForm->client(), m_iDeviceID)) == NULL)
161 capela 484 appendMessagesClient("lscp_get_audio_device_info");
162 capela 431 break;
163 capela 1558 case Device::Midi:
164 capela 433 m_sDeviceType = QObject::tr("MIDI");
165 capela 484 if (m_iDeviceID >= 0 && (pDeviceInfo = ::lscp_get_midi_device_info(
166 capela 961 pMainForm->client(), m_iDeviceID)) == NULL)
167 capela 484 appendMessagesClient("lscp_get_midi_device_info");
168 capela 429 break;
169 capela 1558 case Device::None:
170 capela 433 m_sDeviceType = QString::null;
171     break;
172 capela 429 }
173 capela 430 // If we're bogus, bail out...
174     if (pDeviceInfo == NULL) {
175     m_sDriverName = QString::null;
176 capela 452 m_sDeviceName = QObject::tr("New %1 device").arg(m_sDeviceType);
177 capela 431 return;
178 capela 430 }
179 capela 431
180 capela 430 // Other device properties...
181 capela 429 m_sDriverName = pDeviceInfo->driver;
182 capela 430 m_sDeviceName = m_sDriverName + ' '
183     + QObject::tr("Device %1").arg(m_iDeviceID);
184 capela 429
185 capela 431 // Grab device parameters...
186 capela 429 for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {
187 capela 463 const QString sParam = pDeviceInfo->params[i].key;
188 capela 429 lscp_param_info_t *pParamInfo = NULL;
189     switch (deviceType) {
190 capela 1558 case Device::Audio:
191 capela 1499 if ((pParamInfo = ::lscp_get_audio_driver_param_info(
192     pMainForm->client(), m_sDriverName.toUtf8().constData(),
193     sParam.toUtf8().constData(), NULL)) == NULL)
194 capela 484 appendMessagesClient("lscp_get_audio_driver_param_info");
195 capela 431 break;
196 capela 1558 case Device::Midi:
197 capela 1499 if ((pParamInfo = ::lscp_get_midi_driver_param_info(
198     pMainForm->client(), m_sDriverName.toUtf8().constData(),
199     sParam.toUtf8().constData(), NULL)) == NULL)
200 capela 484 appendMessagesClient("lscp_get_midi_driver_param_info");
201 capela 429 break;
202 capela 1558 case Device::None:
203 capela 436 break;
204 capela 429 }
205 capela 436 if (pParamInfo) {
206 capela 1558 m_params[sParam.toUpper()] = DeviceParam(pParamInfo,
207 capela 433 pDeviceInfo->params[i].value);
208 capela 436 }
209 capela 429 }
210 capela 463
211 capela 467 // Refresh parameter dependencies...
212 capela 484 refreshParams();
213 capela 467 // Set port/channel list...
214 capela 484 refreshPorts();
215 capela 429 }
216    
217    
218 capela 462 // Driver name initializer/settler.
219 capela 1558 void Device::setDriver ( const QString& sDriverName )
220 capela 431 {
221 schoenebeck 1461 MainForm *pMainForm = MainForm::getInstance();
222 capela 961 if (pMainForm == NULL)
223     return;
224     if (pMainForm->client() == NULL)
225     return;
226    
227 capela 431 // Valid only for scratch devices.
228     if (m_sDriverName == sDriverName)
229     return;
230    
231 capela 463 // Reset device parameters and ports anyway.
232 capela 467 m_params.clear();
233 capela 1499 qDeleteAll(m_ports);
234 capela 467 m_ports.clear();
235 capela 463
236 capela 431 // Retrieve driver info, if any.
237     lscp_driver_info_t *pDriverInfo = NULL;
238     switch (m_deviceType) {
239 capela 1558 case Device::Audio:
240 capela 961 if ((pDriverInfo = ::lscp_get_audio_driver_info(pMainForm->client(),
241 capela 1499 sDriverName.toUtf8().constData())) == NULL)
242 capela 484 appendMessagesClient("lscp_get_audio_driver_info");
243 capela 431 break;
244 capela 1558 case Device::Midi:
245 capela 961 if ((pDriverInfo = ::lscp_get_midi_driver_info(pMainForm->client(),
246 capela 1499 sDriverName.toUtf8().constData())) == NULL)
247 capela 484 appendMessagesClient("lscp_get_midi_driver_info");
248 capela 431 break;
249 capela 1558 case Device::None:
250 capela 436 break;
251 capela 431 }
252    
253     // If we're bogus, bail out...
254     if (pDriverInfo == NULL)
255     return;
256    
257     // Remember device parameters...
258     m_sDriverName = sDriverName;
259    
260     // Grab driver parameters...
261     for (int i = 0; pDriverInfo->parameters && pDriverInfo->parameters[i]; i++) {
262 capela 463 const QString sParam = pDriverInfo->parameters[i];
263 capela 431 lscp_param_info_t *pParamInfo = NULL;
264     switch (m_deviceType) {
265 capela 1558 case Device::Audio:
266 capela 1499 if ((pParamInfo = ::lscp_get_audio_driver_param_info(
267     pMainForm->client(), sDriverName.toUtf8().constData(),
268     sParam.toUtf8().constData(), NULL)) == NULL)
269 capela 484 appendMessagesClient("lscp_get_audio_driver_param_info");
270 capela 431 break;
271 capela 1558 case Device::Midi:
272 capela 1499 if ((pParamInfo = ::lscp_get_midi_driver_param_info(
273     pMainForm->client(), sDriverName.toUtf8().constData(),
274     sParam.toUtf8().constData(), NULL)) == NULL)
275 capela 484 appendMessagesClient("lscp_get_midi_driver_param_info");
276 capela 431 break;
277 capela 1558 case Device::None:
278 capela 436 break;
279 capela 431 }
280 capela 463 if (pParamInfo) {
281 capela 1558 m_params[sParam.toUpper()] = DeviceParam(pParamInfo,
282 capela 463 pParamInfo->defaultv);
283     }
284 capela 431 }
285 capela 467
286     // Refresh parameter dependencies...
287 capela 484 refreshParams();
288 capela 467 // Set port/channel list...
289 capela 484 refreshPorts();
290 capela 431 }
291    
292    
293 capela 429 // Device property accessors.
294 capela 1558 int Device::deviceID (void) const
295 capela 429 {
296     return m_iDeviceID;
297     }
298    
299 capela 1558 Device::DeviceType Device::deviceType (void) const
300 capela 429 {
301     return m_deviceType;
302     }
303    
304 capela 1558 const QString& Device::deviceTypeName (void) const
305 capela 433 {
306     return m_sDeviceType;
307     }
308    
309 capela 1558 const QString& Device::driverName (void) const
310 capela 429 {
311     return m_sDriverName;
312     }
313    
314 capela 484 // Special device name formatter.
315 capela 1558 QString Device::deviceName (void) const
316 capela 429 {
317 capela 484 QString sPrefix;
318     if (m_iDeviceID >= 0)
319 capela 1509 sPrefix += m_sDeviceType + ' ';
320 capela 484 return sPrefix + m_sDeviceName;
321 capela 429 }
322    
323 capela 463
324     // Set the proper device parameter value.
325 capela 1558 bool Device::setParam ( const QString& sParam,
326 capela 463 const QString& sValue )
327     {
328 schoenebeck 1461 MainForm *pMainForm = MainForm::getInstance();
329 capela 961 if (pMainForm == NULL)
330     return false;
331     if (pMainForm->client() == NULL)
332     return false;
333    
334 capela 484 // Set proper device parameter.
335 capela 1499 m_params[sParam.toUpper()].value = sValue;
336 capela 490
337 capela 484 // If the device already exists, things get immediate...
338     int iRefresh = 0;
339 schoenebeck 1486 if (m_iDeviceID >= 0 && sValue != QString::null) {
340 schoenebeck 1508
341     // we need temporary byte arrrays with the final strings, because
342     // i.e. QString::toUtf8() only returns a temporary object and the
343     // C-style char* pointers for liblscp would immediately be invalidated
344     QByteArray finalParamKey = sParam.toUtf8();
345     QByteArray finalParamVal = sValue.toUtf8();
346    
347 capela 484 // Prepare parameter struct.
348     lscp_param_t param;
349 schoenebeck 1508 param.key = (char *) finalParamKey.constData();
350     param.value = (char *) finalParamVal.constData();
351 capela 484 // Now it depends on the device type...
352     lscp_status_t ret = LSCP_FAILED;
353     switch (m_deviceType) {
354 capela 1558 case Device::Audio:
355 capela 1509 if (sParam == "CHANNELS") iRefresh++;
356 capela 961 if ((ret = ::lscp_set_audio_device_param(pMainForm->client(),
357 capela 484 m_iDeviceID, &param)) != LSCP_OK)
358     appendMessagesClient("lscp_set_audio_device_param");
359     break;
360 capela 1558 case Device::Midi:
361 capela 1509 if (sParam == "PORTS") iRefresh++;
362 capela 961 if ((ret = ::lscp_set_midi_device_param(pMainForm->client(),
363 capela 484 m_iDeviceID, &param)) != LSCP_OK)
364     appendMessagesClient("lscp_set_midi_device_param");
365     break;
366 capela 1558 case Device::None:
367 capela 484 break;
368     }
369     // Show result.
370     if (ret == LSCP_OK) {
371     appendMessages(QString("%1: %2.").arg(sParam).arg(sValue));
372     // Special care for specific parameter changes...
373     if (iRefresh > 0)
374     iRefresh += refreshPorts();
375     iRefresh += refreshDepends(sParam);
376     } else {
377     // Oops...
378     appendMessagesError(
379     QObject::tr("Could not set device parameter value.\n\nSorry."));
380     }
381     }
382 capela 490
383 capela 484 // Return whether we're need a view refresh.
384     return (iRefresh > 0);
385 capela 463 }
386    
387    
388 capela 429 // Device parameter accessor.
389 capela 1558 const DeviceParamMap& Device::params (void) const
390 capela 429 {
391     return m_params;
392     }
393    
394    
395 capela 463 // Device port/channel list accessor.
396 capela 1558 DevicePortList& Device::ports (void)
397 capela 429 {
398 capela 463 return m_ports;
399 capela 429 }
400    
401 capela 462
402 capela 484 // Create a new device, as a copy of this current one.
403 capela 1558 bool Device::createDevice (void)
404 capela 484 {
405 schoenebeck 1461 MainForm *pMainForm = MainForm::getInstance();
406 capela 961 if (pMainForm == NULL)
407 capela 484 return false;
408 capela 961 if (pMainForm->client() == NULL)
409     return false;
410 capela 484
411 schoenebeck 1508 // we need temporary lists with the final strings, because i.e.
412     // QString::toUtf8() only returns a temporary object and the
413     // C-style char* pointers for liblscp would immediately be invalidated
414     QList<QByteArray> finalKeys;
415     QList<QByteArray> finalVals;
416    
417 capela 1558 DeviceParamMap::ConstIterator iter;
418 capela 484 for (iter = m_params.begin(); iter != m_params.end(); ++iter) {
419 capela 1499 if (iter.value().value == QString::null) continue;
420 schoenebeck 1508 finalKeys.push_back(iter.key().toUtf8());
421     finalVals.push_back(iter.value().value.toUtf8());
422 capela 484 }
423 schoenebeck 1508
424     // yeah, we DO HAVE to do the two loops separately !
425    
426     // Build the parameter list...
427     lscp_param_t *pParams = new lscp_param_t [finalKeys.count() + 1];
428     int iParam;
429     for (iParam = 0; iParam < finalKeys.count(); iParam++) {
430     pParams[iParam].key = (char *) finalKeys[iParam].constData();
431     pParams[iParam].value = (char *) finalVals[iParam].constData();
432     }
433 capela 484 // Null terminated.
434     pParams[iParam].key = NULL;
435     pParams[iParam].value = NULL;
436    
437     // Now it depends on the device type...
438     switch (m_deviceType) {
439 capela 1558 case Device::Audio:
440 capela 961 if ((m_iDeviceID = ::lscp_create_audio_device(pMainForm->client(),
441 capela 1499 m_sDriverName.toUtf8().constData(), pParams)) < 0)
442 capela 484 appendMessagesClient("lscp_create_audio_device");
443     break;
444 capela 1558 case Device::Midi:
445 capela 961 if ((m_iDeviceID = ::lscp_create_midi_device(pMainForm->client(),
446 capela 1499 m_sDriverName.toUtf8().constData(), pParams)) < 0)
447 capela 484 appendMessagesClient("lscp_create_midi_device");
448     break;
449 capela 1558 case Device::None:
450 capela 484 break;
451     }
452    
453     // Free used parameter array.
454     delete pParams;
455    
456     // Show result.
457     if (m_iDeviceID >= 0) {
458 capela 490 // Refresh our own stuff...
459     setDevice(m_deviceType, m_iDeviceID);
460 capela 484 appendMessages(QObject::tr("created."));
461     } else {
462     appendMessagesError(QObject::tr("Could not create device.\n\nSorry."));
463     }
464 capela 490
465 capela 484 // Return whether we're a valid device...
466     return (m_iDeviceID >= 0);
467     }
468    
469    
470     // Destroy existing device.
471 capela 1558 bool Device::deleteDevice (void)
472 capela 484 {
473 schoenebeck 1461 MainForm *pMainForm = MainForm::getInstance();
474 capela 961 if (pMainForm == NULL)
475     return false;
476     if (pMainForm->client() == NULL)
477     return false;
478    
479 capela 484 // Now it depends on the device type...
480     lscp_status_t ret = LSCP_FAILED;
481     switch (m_deviceType) {
482 capela 1558 case Device::Audio:
483 capela 961 if ((ret = ::lscp_destroy_audio_device(pMainForm->client(),
484 capela 484 m_iDeviceID)) != LSCP_OK)
485     appendMessagesClient("lscp_destroy_audio_device");
486     break;
487 capela 1558 case Device::Midi:
488 capela 961 if ((ret = ::lscp_destroy_midi_device(pMainForm->client(),
489 capela 484 m_iDeviceID)) != LSCP_OK)
490     appendMessagesClient("lscp_destroy_midi_device");
491     break;
492 capela 1558 case Device::None:
493 capela 484 break;
494     }
495    
496     // Show result.
497     if (ret == LSCP_OK) {
498     appendMessages(QObject::tr("deleted."));
499     m_iDeviceID = -1;
500     } else {
501     appendMessagesError(QObject::tr("Could not delete device.\n\nSorry."));
502     }
503 capela 490
504 capela 484 // Return whether we've done it..
505     return (ret == LSCP_OK);
506     }
507    
508    
509 capela 467 // Device parameter dependencies refreshner.
510 capela 1558 int Device::refreshParams (void)
511 capela 467 {
512 capela 468 // This should only make sense for scratch devices...
513     if (m_iDeviceID >= 0)
514 capela 1509 return 0;
515 capela 467 // Refresh all parameters that have dependencies...
516     int iParams = 0;
517 capela 1558 DeviceParamMap::ConstIterator iter;
518 capela 467 for (iter = m_params.begin(); iter != m_params.end(); ++iter)
519 capela 484 iParams += refreshParam(iter.key());
520 capela 467 // Return how many parameters have been refreshed...
521     return iParams;
522     }
523    
524    
525 capela 463 // Device port/channel list refreshner.
526 capela 1558 int Device::refreshPorts (void)
527 capela 463 {
528 capela 468 // This should only make sense for actual devices...
529     if (m_iDeviceID < 0)
530 capela 1509 return 0;
531 capela 463 // Port/channel count determination...
532     int iPorts = 0;
533     switch (m_deviceType) {
534 capela 1558 case Device::Audio:
535 capela 463 iPorts = m_params["CHANNELS"].value.toInt();
536     break;
537 capela 1558 case Device::Midi:
538 capela 463 iPorts = m_params["PORTS"].value.toInt();
539     break;
540 capela 1558 case Device::None:
541 capela 463 break;
542     }
543     // Retrieve port/channel information...
544 capela 1499 qDeleteAll(m_ports);
545 capela 463 m_ports.clear();
546     for (int iPort = 0; iPort < iPorts; iPort++)
547 capela 1558 m_ports.append(new DevicePort(*this, iPort));
548 capela 467 // Return how many ports have been refreshed...
549     return iPorts;
550 capela 463 }
551    
552    
553 capela 467 // Refresh/set dependencies given that some parameter has changed.
554 capela 1558 int Device::refreshDepends ( const QString& sParam )
555 capela 467 {
556 capela 468 // This should only make sense for scratch devices...
557     if (m_iDeviceID >= 0)
558 capela 1509 return 0;
559 capela 467 // Refresh all parameters that depend on this one...
560     int iDepends = 0;
561 capela 1558 DeviceParamMap::ConstIterator iter;
562 capela 467 for (iter = m_params.begin(); iter != m_params.end(); ++iter) {
563 capela 1499 const QStringList& depends = iter.value().depends;
564     if (depends.indexOf(sParam) >= 0)
565 capela 484 iDepends += refreshParam(iter.key());
566 capela 467 }
567     // Return how many dependencies have been refreshed...
568     return iDepends;
569     }
570    
571    
572     // Refresh/set given parameter based on driver supplied dependencies.
573 capela 1558 int Device::refreshParam ( const QString& sParam )
574 capela 467 {
575 schoenebeck 1461 MainForm *pMainForm = MainForm::getInstance();
576 capela 961 if (pMainForm == NULL)
577     return 0;
578     if (pMainForm->client() == NULL)
579     return 0;
580    
581 capela 467 // Check if we have dependencies...
582 capela 1558 DeviceParam& param = m_params[sParam.toUpper()];
583 capela 467 if (param.depends.isEmpty())
584     return 0;
585    
586     int iRefresh = 0;
587    
588     // Build dependency list...
589     lscp_param_t *pDepends = new lscp_param_t [param.depends.count() + 1];
590     int iDepend = 0;
591 schoenebeck 1508
592     // we need temporary lists with the final strings, because i.e.
593     // QString::toUtf8() only returns a temporary object and the
594     // C-style char* pointers for liblscp would immediately be invalidated
595     QList<QByteArray> finalKeys;
596     QList<QByteArray> finalVals;
597     for (int i = 0; i < param.depends.count(); i++) {
598     const QString& sDepend = param.depends[i];
599     finalKeys.push_back(sDepend.toUtf8());
600     finalVals.push_back(m_params[sDepend.toUpper()].value.toUtf8());
601     }
602     // yeah, we DO HAVE to do those two loops separately !
603     for (int i = 0; i < param.depends.count(); i++) {
604     pDepends[iDepend].key = (char *) finalKeys[i].constData();
605     pDepends[iDepend].value = (char *) finalVals[i].constData();
606 capela 467 ++iDepend;
607     }
608     // Null terminated.
609     pDepends[iDepend].key = NULL;
610     pDepends[iDepend].value = NULL;
611    
612     // FIXME: Some parameter dependencies (e.g.ALSA CARD)
613 capela 468 // are blocking for no reason, causing potential timeout-crashes.
614     // hopefully this gets mitigated if this dependency hell is only
615     // carried out for scratch devices...
616 capela 467
617     // Retrieve some modern parameters...
618     lscp_param_info_t *pParamInfo = NULL;
619     switch (m_deviceType) {
620 capela 1558 case Device::Audio:
621 capela 1499 if ((pParamInfo = ::lscp_get_audio_driver_param_info(
622     pMainForm->client(), m_sDriverName.toUtf8().constData(),
623     sParam.toUtf8().constData(), pDepends)) == NULL)
624 capela 484 appendMessagesClient("lscp_get_audio_driver_param_info");
625 capela 467 break;
626 capela 1558 case Device::Midi:
627 capela 1499 if ((pParamInfo = ::lscp_get_midi_driver_param_info(
628     pMainForm->client(), m_sDriverName.toUtf8().constData(),
629     sParam.toUtf8().constData(), pDepends)) == NULL)
630 capela 484 appendMessagesClient("lscp_get_midi_driver_param_info");
631 capela 467 break;
632 capela 1558 case Device::None:
633 capela 467 break;
634     }
635     if (pParamInfo) {
636 capela 1558 param = DeviceParam(pParamInfo,
637 capela 1499 param.value.isEmpty() ? NULL : param.value.toUtf8().constData());
638 capela 467 iRefresh++;
639     }
640 capela 468
641 capela 467 // Free used parameter array.
642     delete pDepends;
643    
644     // Return whether the parameters has been changed...
645     return iRefresh;
646     }
647    
648    
649 capela 484 // Redirected messages output methods.
650 capela 1558 void Device::appendMessages( const QString& s ) const
651 capela 484 {
652 schoenebeck 1461 MainForm *pMainForm = MainForm::getInstance();
653 capela 961 if (pMainForm)
654     pMainForm->appendMessages(deviceName() + ' ' + s);
655 capela 484 }
656    
657 capela 1558 void Device::appendMessagesColor( const QString& s,
658 capela 484 const QString& c ) const
659     {
660 schoenebeck 1461 MainForm *pMainForm = MainForm::getInstance();
661 capela 961 if (pMainForm)
662     pMainForm->appendMessagesColor(deviceName() + ' ' + s, c);
663 capela 484 }
664    
665 capela 1558 void Device::appendMessagesText( const QString& s ) const
666 capela 484 {
667 schoenebeck 1461 MainForm *pMainForm = MainForm::getInstance();
668 capela 961 if (pMainForm)
669     pMainForm->appendMessagesText(deviceName() + ' ' + s);
670 capela 484 }
671    
672 capela 1558 void Device::appendMessagesError( const QString& s ) const
673 capela 484 {
674 schoenebeck 1461 MainForm *pMainForm = MainForm::getInstance();
675 capela 961 if (pMainForm)
676     pMainForm->appendMessagesError(deviceName() + "\n\n" + s);
677 capela 484 }
678    
679 capela 1558 void Device::appendMessagesClient( const QString& s ) const
680 capela 484 {
681 schoenebeck 1461 MainForm *pMainForm = MainForm::getInstance();
682 capela 961 if (pMainForm)
683     pMainForm->appendMessagesClient(deviceName() + ' ' + s);
684 capela 484 }
685    
686    
687 capela 430 // Device ids enumerator.
688 capela 1558 int *Device::getDevices ( lscp_client_t *pClient,
689 capela 1509 DeviceType deviceType )
690 capela 429 {
691     int *piDeviceIDs = NULL;
692     switch (deviceType) {
693 capela 1558 case Device::Audio:
694 capela 431 piDeviceIDs = ::lscp_list_audio_devices(pClient);
695 capela 429 break;
696 capela 1558 case Device::Midi:
697 capela 431 piDeviceIDs = ::lscp_list_midi_devices(pClient);
698     break;
699 capela 1558 case Device::None:
700 capela 436 break;
701 capela 429 }
702     return piDeviceIDs;
703     }
704    
705 capela 430
706     // Driver names enumerator.
707 capela 1558 QStringList Device::getDrivers ( lscp_client_t *pClient,
708 capela 1509 DeviceType deviceType )
709 capela 430 {
710     QStringList drivers;
711 capela 490
712 capela 430 const char **ppszDrivers = NULL;
713     switch (deviceType) {
714 capela 1558 case Device::Audio:
715 capela 525 ppszDrivers = ::lscp_list_available_audio_drivers(pClient);
716 capela 430 break;
717 capela 1558 case Device::Midi:
718 capela 525 ppszDrivers = ::lscp_list_available_midi_drivers(pClient);
719 capela 431 break;
720 capela 1558 case Device::None:
721 capela 436 break;
722 capela 430 }
723 capela 490
724 capela 980 for (int iDriver = 0; ppszDrivers && ppszDrivers[iDriver]; iDriver++)
725 capela 431 drivers.append(ppszDrivers[iDriver]);
726 capela 430
727     return drivers;
728     }
729    
730    
731 capela 429 //-------------------------------------------------------------------------
732 capela 1558 // QSampler::DevicePort - MIDI/Audio Device port/channel structure.
733 capela 462 //
734    
735     // Constructor.
736 capela 1558 DevicePort::DevicePort ( Device& device,
737 capela 484 int iPortID ) : m_device(device)
738 capela 462 {
739 capela 484 setDevicePort(iPortID);
740 capela 462 }
741    
742     // Default destructor.
743 capela 1558 DevicePort::~DevicePort (void)
744 capela 462 {
745     }
746    
747    
748     // Initializer.
749 capela 1558 void DevicePort::setDevicePort ( int iPortID )
750 capela 462 {
751 schoenebeck 1461 MainForm *pMainForm = MainForm::getInstance();
752 capela 961 if (pMainForm == NULL)
753     return;
754     if (pMainForm->client() == NULL)
755     return;
756    
757 capela 462 // Device port id should be always set.
758     m_iPortID = iPortID;
759    
760 capela 463 // Reset port parameters anyway.
761 capela 467 m_params.clear();
762 capela 463
763 capela 462 // Retrieve device port/channel info, if any.
764     lscp_device_port_info_t *pPortInfo = NULL;
765 capela 484 switch (m_device.deviceType()) {
766 capela 1558 case Device::Audio:
767 capela 961 if ((pPortInfo = ::lscp_get_audio_channel_info(pMainForm->client(),
768 capela 484 m_device.deviceID(), m_iPortID)) == NULL)
769     m_device.appendMessagesClient("lscp_get_audio_channel_info");
770 capela 462 break;
771 capela 1558 case Device::Midi:
772 capela 961 if ((pPortInfo = ::lscp_get_midi_port_info(pMainForm->client(),
773 capela 484 m_device.deviceID(), m_iPortID)) == NULL)
774     m_device.appendMessagesClient("lscp_get_midi_port_info");
775 capela 462 break;
776 capela 1558 case Device::None:
777 capela 462 break;
778     }
779    
780     // If we're bogus, bail out...
781     if (pPortInfo == NULL) {
782     m_sPortName = QString::null;
783     return;
784     }
785    
786     // Set device port/channel properties...
787 capela 484 m_sPortName = pPortInfo->name;
788 capela 462
789     // Grab device port/channel parameters...
790     m_params.clear();
791     for (int i = 0; pPortInfo->params && pPortInfo->params[i].key; i++) {
792 capela 463 const QString sParam = pPortInfo->params[i].key;
793 capela 462 lscp_param_info_t *pParamInfo = NULL;
794 capela 484 switch (m_device.deviceType()) {
795 capela 1558 case Device::Audio:
796 capela 484 if ((pParamInfo = ::lscp_get_audio_channel_param_info(
797 capela 961 pMainForm->client(), m_device.deviceID(),
798 capela 1499 m_iPortID, sParam.toUtf8().constData())) == NULL)
799 capela 484 m_device.appendMessagesClient("lscp_get_audio_channel_param_info");
800 capela 462 break;
801 capela 1558 case Device::Midi:
802 capela 484 if ((pParamInfo = ::lscp_get_midi_port_param_info(
803 capela 961 pMainForm->client(), m_device.deviceID(),
804 capela 1499 m_iPortID, sParam.toUtf8().constData())) == NULL)
805 capela 484 m_device.appendMessagesClient("lscp_get_midi_port_param_info");
806 capela 462 break;
807 capela 1558 case Device::None:
808 capela 462 break;
809     }
810     if (pParamInfo) {
811 capela 1558 m_params[sParam.toUpper()] = DeviceParam(pParamInfo,
812 capela 462 pPortInfo->params[i].value);
813     }
814     }
815     }
816    
817    
818     // Device port/channel property accessors.
819 capela 1558 int DevicePort::portID (void) const
820 capela 462 {
821     return m_iPortID;
822     }
823    
824 capela 1558 const QString& DevicePort::portName (void) const
825 capela 462 {
826     return m_sPortName;
827     }
828    
829     // Device port/channel parameter accessor.
830 capela 1558 const DeviceParamMap& DevicePort::params (void) const
831 capela 462 {
832     return m_params;
833     }
834    
835    
836     // Set the proper device port/channel parameter value.
837 capela 1558 bool DevicePort::setParam ( const QString& sParam,
838 capela 462 const QString& sValue )
839     {
840 schoenebeck 1461 MainForm *pMainForm = MainForm::getInstance();
841 capela 961 if (pMainForm == NULL)
842     return false;
843     if (pMainForm->client() == NULL)
844     return false;
845    
846 capela 484 // Set proper port/channel parameter.
847 capela 1499 m_params[sParam.toUpper()].value = sValue;
848 capela 484
849     // If the device already exists, things get immediate...
850     int iRefresh = 0;
851     if (m_device.deviceID() >= 0 && m_iPortID >= 0) {
852 schoenebeck 1508
853     // we need temporary byte arrrays with the final strings, because
854     // i.e. QString::toUtf8() only returns a temporary object and the
855     // C-style char* pointers for liblscp would immediately be invalidated
856     QByteArray finalParamKey = sParam.toUtf8();
857     QByteArray finalParamVal = sValue.toUtf8();
858    
859 capela 484 // Prepare parameter struct.
860     lscp_param_t param;
861 schoenebeck 1508 param.key = (char *) finalParamKey.constData();
862     param.value = (char *) finalParamVal.constData();
863 capela 484 // Now it depends on the device type...
864     lscp_status_t ret = LSCP_FAILED;
865     switch (m_device.deviceType()) {
866 capela 1558 case Device::Audio:
867 capela 961 if ((ret = ::lscp_set_audio_channel_param(pMainForm->client(),
868 capela 484 m_device.deviceID(), m_iPortID, &param)) != LSCP_OK)
869     m_device.appendMessagesClient("lscp_set_audio_channel_param");
870     break;
871 capela 1558 case Device::Midi:
872 capela 961 if ((ret = ::lscp_set_midi_port_param(pMainForm->client(),
873 capela 484 m_device.deviceID(), m_iPortID, &param)) != LSCP_OK)
874     m_device.appendMessagesClient("lscp_set_midi_port_param");
875     break;
876 capela 1558 case Device::None:
877 capela 484 break;
878     }
879     // Show result.
880     if (ret == LSCP_OK) {
881     m_device.appendMessages(m_sPortName
882     + ' ' + QString("%1: %2.").arg(sParam).arg(sValue));
883     iRefresh++;
884     } else {
885     m_device.appendMessagesError(
886     QObject::tr("Could not set %1 parameter value.\n\n"
887     "Sorry.").arg(m_sPortName));
888     }
889     }
890    
891     // Return whether we're need a view refresh.
892     return (iRefresh > 0);
893 capela 462 }
894    
895    
896     //-------------------------------------------------------------------------
897 capela 1558 // QSampler::DeviceItem - QTreeWidget device item.
898 capela 429 //
899    
900     // Constructors.
901 capela 1558 DeviceItem::DeviceItem ( QTreeWidget* pTreeWidget,
902     Device::DeviceType deviceType )
903 schoenebeck 1461 : QTreeWidgetItem(pTreeWidget, QSAMPLER_DEVICE_ITEM),
904 capela 1509 m_device(deviceType)
905 capela 429 {
906     switch(m_device.deviceType()) {
907 capela 1558 case Device::Audio:
908 schoenebeck 1477 setIcon(0, QPixmap(":/icons/audio1.png"));
909     setText(0, QObject::tr("Audio Devices"));
910 capela 429 break;
911 capela 1558 case Device::Midi:
912 schoenebeck 1477 setIcon(0, QPixmap(":/icons/midi1.png"));
913     setText(0, QObject::tr("MIDI Devices"));
914 capela 429 break;
915 capela 1558 case Device::None:
916 capela 436 break;
917 capela 429 }
918 capela 1558
919     // Root items are not selectable...
920     setFlags(flags() & ~Qt::ItemIsSelectable);
921 capela 429 }
922    
923 capela 1558 DeviceItem::DeviceItem ( QTreeWidgetItem* pItem,
924     Device::DeviceType deviceType,
925 capela 433 int iDeviceID )
926 schoenebeck 1461 : QTreeWidgetItem(pItem, QSAMPLER_DEVICE_ITEM),
927 capela 1509 m_device(deviceType, iDeviceID)
928 capela 429 {
929     switch(m_device.deviceType()) {
930 capela 1558 case Device::Audio:
931 schoenebeck 1477 setIcon(0, QPixmap(":/icons/audio2.png"));
932 capela 429 break;
933 capela 1558 case Device::Midi:
934 schoenebeck 1477 setIcon(0, QPixmap(":/icons/midi2.png"));
935 capela 429 break;
936 capela 1558 case Device::None:
937 capela 436 break;
938 capela 429 }
939    
940 schoenebeck 1486 setText(0, m_device.deviceName());
941 capela 429 }
942    
943     // Default destructor.
944 capela 1558 DeviceItem::~DeviceItem ()
945 capela 429 {
946     }
947    
948     // Instance accessors.
949 capela 1558 Device& DeviceItem::device ()
950 capela 429 {
951     return m_device;
952     }
953    
954    
955     //-------------------------------------------------------------------------
956 capela 1558 // QSampler::AbstractDeviceParamModel - data model base class for device parameters
957 capela 429 //
958 capela 426
959 capela 1509 AbstractDeviceParamModel::AbstractDeviceParamModel ( QObject* pParent )
960     : QAbstractTableModel(pParent), m_bEditable(false)
961     {
962 capela 1510 m_pParams = NULL;
963 capela 426 }
964    
965 capela 1509
966     int AbstractDeviceParamModel::rowCount ( const QModelIndex& /*parent*/) const
967     {
968     //std::cout << "model size=" << params.size() << "\n" << std::flush;
969 capela 1510 return (m_pParams ? m_pParams->size() : 0);
970 capela 429 }
971    
972 capela 1509
973     int AbstractDeviceParamModel::columnCount ( const QModelIndex& /*parent*/) const
974     {
975     return 3;
976 schoenebeck 1461 }
977 capela 429
978 capela 1509
979     Qt::ItemFlags AbstractDeviceParamModel::flags ( const QModelIndex& /*index*/) const
980     {
981 schoenebeck 1518 return Qt::ItemIsEditable | Qt::ItemIsEnabled;
982 schoenebeck 1461 }
983    
984    
985 capela 1509 QVariant AbstractDeviceParamModel::headerData (
986     int section, Qt::Orientation orientation, int role) const
987     {
988     if (role != Qt::DisplayRole)
989     return QVariant();
990 schoenebeck 1461
991 capela 1509 if (orientation == Qt::Horizontal) {
992     switch (section) {
993     case 0: return tr("Parameter");
994     case 1: return tr("Value");
995     case 2: return tr("Description");
996     default: return QVariant();
997     }
998     }
999    
1000     return QVariant();
1001 schoenebeck 1461 }
1002    
1003 capela 1509
1004     void AbstractDeviceParamModel::refresh (
1005 capela 1558 const DeviceParamMap* pParams, bool bEditable )
1006 capela 1509 {
1007 capela 1510 m_pParams = pParams;
1008 capela 1509 m_bEditable = bEditable;
1009     // inform the outer world (QTableView) that our data changed
1010     QAbstractTableModel::reset();
1011 schoenebeck 1461 }
1012    
1013 capela 1509
1014     void AbstractDeviceParamModel::clear (void)
1015     {
1016 capela 1510 m_pParams = NULL;
1017 capela 1509 // inform the outer world (QTableView) that our data changed
1018     QAbstractTableModel::reset();
1019 schoenebeck 1486 }
1020    
1021    
1022     //-------------------------------------------------------------------------
1023 capela 1558 // QSampler::DeviceParamModel - data model for device parameters
1024     // (used for QTableView)
1025 schoenebeck 1486
1026 capela 1509 DeviceParamModel::DeviceParamModel ( QObject *pParent )
1027     : AbstractDeviceParamModel(pParent)
1028     {
1029 capela 1510 m_pDevice = NULL;
1030 schoenebeck 1486 }
1031    
1032 capela 1509 QVariant DeviceParamModel::data (
1033     const QModelIndex &index, int role) const
1034     {
1035     if (!index.isValid())
1036     return QVariant();
1037 schoenebeck 1508
1038 capela 1509 if (role != Qt::DisplayRole)
1039     return QVariant();
1040 schoenebeck 1508
1041 capela 1509 DeviceParameterRow item;
1042 capela 1510 item.name = m_pParams->keys()[index.row()];
1043     item.param = (*m_pParams)[item.name];
1044     item.alive = (m_pDevice && m_pDevice->deviceID() >= 0);
1045 capela 1509
1046     return QVariant::fromValue(item);
1047 schoenebeck 1508 }
1048    
1049 capela 1509
1050     bool DeviceParamModel::setData (
1051     const QModelIndex& index, const QVariant& value, int /*role*/)
1052     {
1053     if (!index.isValid())
1054     return false;
1055    
1056 capela 1510 QString key = m_pParams->keys()[index.row()];
1057     //m_pParams[key].value = value.toString();
1058     m_pDevice->setParam(key, value.toString());
1059 capela 1509 emit dataChanged(index, index);
1060     return true;
1061 schoenebeck 1486 }
1062    
1063 capela 1509
1064 capela 1558 void DeviceParamModel::refresh ( Device* pDevice, bool bEditable )
1065 capela 1509 {
1066 capela 1510 m_pDevice = pDevice;
1067 capela 1509 AbstractDeviceParamModel::refresh(&pDevice->params(), bEditable);
1068 schoenebeck 1486 }
1069    
1070 capela 1509
1071     void DeviceParamModel::clear (void)
1072     {
1073     AbstractDeviceParamModel::clear();
1074 capela 1510 m_pDevice = NULL;
1075 schoenebeck 1461 }
1076    
1077    
1078 schoenebeck 1486 //-------------------------------------------------------------------------
1079 capela 1558 // QSampler::PortParamModel - data model for port parameters
1080     // (used for QTableView)
1081 schoenebeck 1486
1082 capela 1509 PortParamModel::PortParamModel ( QObject *pParent)
1083     : AbstractDeviceParamModel(pParent)
1084     {
1085 capela 1510 m_pPort = NULL;
1086 schoenebeck 1486 }
1087    
1088 capela 1509 QVariant PortParamModel::data ( const QModelIndex &index, int role ) const
1089     {
1090     if (!index.isValid())
1091     return QVariant();
1092 schoenebeck 1508
1093 capela 1509 if (role != Qt::DisplayRole)
1094     return QVariant();
1095 schoenebeck 1508
1096 capela 1509 DeviceParameterRow item;
1097 capela 1510 item.name = m_pParams->keys()[index.row()];
1098     item.param = (*m_pParams)[item.name];
1099     item.alive = (m_pPort && m_pPort->portID() >= 0);
1100 capela 1509
1101     return QVariant::fromValue(item);
1102 schoenebeck 1508 }
1103    
1104 capela 1509
1105     bool PortParamModel::setData (
1106     const QModelIndex& index, const QVariant& value, int /*role*/)
1107     {
1108     if (!index.isValid())
1109     return false;
1110    
1111 capela 1510 QString key = m_pParams->keys()[index.row()];
1112 capela 1509 //params[key].value = value.toString();
1113 capela 1510 m_pPort->setParam(key, value.toString());
1114 capela 1509 emit dataChanged(index, index);
1115     return true;
1116 schoenebeck 1486 }
1117    
1118 capela 1509
1119 capela 1558 void PortParamModel::refresh ( DevicePort* pPort, bool bEditable )
1120 capela 1509 {
1121 capela 1510 m_pPort = pPort;
1122     AbstractDeviceParamModel::refresh(&pPort->params(), bEditable);
1123 schoenebeck 1486 }
1124    
1125 capela 1509
1126     void PortParamModel::clear (void)
1127     {
1128     AbstractDeviceParamModel::clear();
1129 capela 1510 m_pPort = NULL;
1130 schoenebeck 1486 }
1131    
1132    
1133     //-------------------------------------------------------------------------
1134 capela 1558 // QSampler::DeviceParamDelegate - table cell renderer for device/port parameters
1135 schoenebeck 1486 //
1136    
1137 capela 1509 DeviceParamDelegate::DeviceParamDelegate ( QObject *pParent)
1138     : QItemDelegate(pParent)
1139     {
1140 schoenebeck 1461 }
1141    
1142 capela 1509
1143     QWidget* DeviceParamDelegate::createEditor ( QWidget *pParent,
1144     const QStyleOptionViewItem& /* option */, const QModelIndex& index ) const
1145 schoenebeck 1461 {
1146 capela 1509 if (!index.isValid())
1147     return NULL;
1148 schoenebeck 1486
1149 capela 1509 DeviceParameterRow r = index.model()->data(index,
1150     Qt::DisplayRole).value<DeviceParameterRow>();
1151 schoenebeck 1461
1152 capela 1509 const bool bEnabled = (r.alive) ? !r.param.fix : true;
1153 schoenebeck 1461
1154 capela 1509 QString val = (r.alive) ? r.param.value : r.param.defaultv;
1155 schoenebeck 1508
1156 capela 1509 switch (index.column()) {
1157     case 0:
1158     return new QLabel(r.name, pParent);
1159     case 1: {
1160     if (r.param.type == LSCP_TYPE_BOOL) {
1161 capela 1510 QCheckBox *pCheckBox = new QCheckBox(pParent);
1162 capela 1509 if (val != QString::null)
1163     pCheckBox->setChecked(val.toLower() == "true");
1164     pCheckBox->setEnabled(bEnabled);
1165     return pCheckBox;
1166     } else if (r.param.possibilities.count() > 0) {
1167     QStringList opts = r.param.possibilities;
1168     if (r.param.multiplicity)
1169     opts.prepend(tr("(none)"));
1170 capela 1510 QComboBox *pComboBox = new QComboBox(pParent);
1171 capela 1509 pComboBox->addItems(opts);
1172     if (r.param.value.isEmpty())
1173     pComboBox->setCurrentIndex(0);
1174     else
1175     pComboBox->setCurrentIndex(pComboBox->findText(val));
1176     pComboBox->setEnabled(bEnabled);
1177     return pComboBox;
1178     } else if (r.param.type == LSCP_TYPE_INT && bEnabled) {
1179 capela 1510 QSpinBox *pSpinBox = new QSpinBox(pParent);
1180 capela 1509 pSpinBox->setMinimum(
1181     (!r.param.range_min.isEmpty()) ?
1182     r.param.range_min.toInt() : 0 // or better a negative default min value ?
1183     );
1184     pSpinBox->setMaximum(
1185     (!r.param.range_max.isEmpty()) ?
1186     r.param.range_max.toInt() : (1 << 16) // or better a nigher default max value ?
1187     );
1188     pSpinBox->setValue(val.toInt());
1189     return pSpinBox;
1190     } else if (bEnabled) {
1191 capela 1510 QLineEdit *pLineEdit = new QLineEdit(val, pParent);
1192 capela 1509 return pLineEdit;
1193     } else {
1194 capela 1510 QLabel *pLabel = new QLabel(val, pParent);
1195 capela 1509 return pLabel;
1196     }
1197     }
1198     case 2:
1199     return new QLabel(r.param.description, pParent);
1200     default:
1201     return NULL;
1202     }
1203 schoenebeck 1461 }
1204    
1205 capela 1509
1206     void DeviceParamDelegate::setEditorData (
1207     QWidget* /*pEditor*/, const QModelIndex& /*index*/) const
1208     {
1209     // Unused, since we set the editor data already in createEditor()
1210 schoenebeck 1461 }
1211    
1212 capela 1509
1213     void DeviceParamDelegate::setModelData ( QWidget *pEditor,
1214 capela 1510 QAbstractItemModel *pModel, const QModelIndex& index ) const
1215 capela 1509 {
1216     if (index.column() == 1) {
1217     DeviceParameterRow r = index.model()->data(index,
1218     Qt::DisplayRole).value<DeviceParameterRow> ();
1219 schoenebeck 1511 if (pEditor->metaObject()->className() == QString("QCheckBox")) {
1220 capela 1509 QCheckBox* pCheckBox = static_cast<QCheckBox*> (pEditor);
1221 capela 1510 pModel->setData(index, QVariant(pCheckBox->checkState() == Qt::Checked));
1222 schoenebeck 1511 } else if (pEditor->metaObject()->className() == QString("QComboBox")) {
1223 capela 1509 QComboBox* pComboBox = static_cast<QComboBox*> (pEditor);
1224 capela 1510 pModel->setData(index, pComboBox->currentText());
1225 schoenebeck 1511 } else if (pEditor->metaObject()->className() == QString("QSpinBox")) {
1226 capela 1509 QSpinBox* pSpinBox = static_cast<QSpinBox*> (pEditor);
1227 capela 1510 pModel->setData(index, pSpinBox->value());
1228 schoenebeck 1511 } else if (pEditor->metaObject()->className() == QString("QLineEdit")) {
1229 capela 1509 QLineEdit* pLineEdit = static_cast<QLineEdit*> (pEditor);
1230 capela 1510 pModel->setData(index, pLineEdit->text());
1231 schoenebeck 1511 } else if (pEditor->metaObject()->className() == QString("QLabel")) {
1232 capela 1509 QLabel* pLabel = static_cast<QLabel*> (pEditor);
1233 capela 1510 pModel->setData(index, pLabel->text());
1234 capela 1509 }
1235     }
1236 schoenebeck 1461 }
1237    
1238 capela 1509 void DeviceParamDelegate::updateEditorGeometry ( QWidget *pEditor,
1239 schoenebeck 1461 const QStyleOptionViewItem &option, const QModelIndex &/* index */) const
1240     {
1241 capela 1509 if (pEditor)
1242     pEditor->setGeometry(option.rect);
1243 schoenebeck 1461 }
1244    
1245 capela 1558 } // namespace QSampler
1246    
1247 capela 426 // end of qsamplerDevice.cpp

  ViewVC Help
Powered by ViewVC