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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1022 - (show annotations) (download)
Thu Jan 11 16:14:31 2007 UTC (13 years, 2 months ago) by capela
File size: 26995 byte(s)
- Prepared and settled for liblscp 0.5.2 compliance release.

1 // qsamplerChannel.cpp
2 //
3 /****************************************************************************
4 Copyright (C) 2004-2007, rncbc aka Rui Nuno Capela. All rights reserved.
5
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License
8 as published by the Free Software Foundation; either version 2
9 of the License, or (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License 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
20 *****************************************************************************/
21
22 #include "qsamplerAbout.h"
23 #include "qsamplerChannel.h"
24
25 #include "qsamplerMainForm.h"
26 #include "qsamplerChannelForm.h"
27
28 #include <qfileinfo.h>
29 #include <qcombobox.h>
30
31 #ifdef CONFIG_LIBGIG
32 #include "gig.h"
33 #endif
34
35 #define QSAMPLER_INSTRUMENT_MAX 100
36
37
38 //-------------------------------------------------------------------------
39 // qsamplerChannel - Sampler channel structure.
40 //
41
42 // Constructor.
43 qsamplerChannel::qsamplerChannel ( int iChannelID )
44 {
45 m_iChannelID = iChannelID;
46
47 // m_sEngineName = noEngineName();
48 // m_sInstrumentName = noInstrumentName();
49 // m_sInstrumentFile = m_sInstrumentName;
50 m_iInstrumentNr = -1;
51 m_iInstrumentStatus = -1;
52 m_sMidiDriver = "ALSA";
53 m_iMidiDevice = -1;
54 m_iMidiPort = -1;
55 m_iMidiChannel = -1;
56 m_iMidiMap = -1;
57 m_sAudioDriver = "ALSA";
58 m_iAudioDevice = -1;
59 m_fVolume = 0.0;
60 m_bMute = false;
61 m_bSolo = false;
62 }
63
64 // Default destructor.
65 qsamplerChannel::~qsamplerChannel (void)
66 {
67 }
68
69
70 // Create a new sampler channel, if not already.
71 bool qsamplerChannel::addChannel (void)
72 {
73 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
74 if (pMainForm == NULL)
75 return false;
76 if (pMainForm->client() == NULL)
77 return false;
78
79 // Are we a new channel?
80 if (m_iChannelID < 0) {
81 m_iChannelID = ::lscp_add_channel(pMainForm->client());
82 if (m_iChannelID < 0) {
83 appendMessagesClient("lscp_add_channel");
84 appendMessagesError(
85 QObject::tr("Could not add channel.\n\nSorry."));
86 } // Otherwise it's created...
87 else appendMessages(QObject::tr("added."));
88 }
89
90 // Return whether we're a valid channel...
91 return (m_iChannelID >= 0);
92 }
93
94
95 // Remove sampler channel.
96 bool qsamplerChannel::removeChannel (void)
97 {
98 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
99 if (pMainForm == NULL)
100 return false;
101 if (pMainForm->client() == NULL)
102 return false;
103
104 // Are we an existing channel?
105 if (m_iChannelID >= 0) {
106 if (::lscp_remove_channel(pMainForm->client(), m_iChannelID) != LSCP_OK) {
107 appendMessagesClient("lscp_remove_channel");
108 appendMessagesError(QObject::tr("Could not remove channel.\n\nSorry."));
109 } else {
110 // Otherwise it's removed.
111 appendMessages(QObject::tr("removed."));
112 m_iChannelID = -1;
113 }
114 }
115
116 // Return whether we've removed the channel...
117 return (m_iChannelID < 0);
118 }
119
120
121 // Channel-ID (aka Sammpler-Channel) accessors.
122 int qsamplerChannel::channelID (void) const
123 {
124 return m_iChannelID;
125 }
126
127 void qsamplerChannel::setChannelID ( int iChannelID )
128 {
129 m_iChannelID = iChannelID;
130 }
131
132
133 // Readable channel name.
134 QString qsamplerChannel::channelName (void) const
135 {
136 return (m_iChannelID < 0 ? QObject::tr("New Channel") : QObject::tr("Channel %1").arg(m_iChannelID));
137 }
138
139
140 // Engine name accessors.
141 const QString& qsamplerChannel::engineName (void) const
142 {
143 return m_sEngineName;
144 }
145
146 bool qsamplerChannel::loadEngine ( const QString& sEngineName )
147 {
148 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
149 if (pMainForm == NULL)
150 return false;
151 if (pMainForm->client() == NULL || m_iChannelID < 0)
152 return false;
153 if (m_iInstrumentStatus == 100 && m_sEngineName == sEngineName)
154 return true;
155
156 if (::lscp_load_engine(pMainForm->client(), sEngineName.latin1(), m_iChannelID) != LSCP_OK) {
157 appendMessagesClient("lscp_load_engine");
158 return false;
159 }
160
161 appendMessages(QObject::tr("Engine: %1.").arg(sEngineName));
162
163 m_sEngineName = sEngineName;
164 return true;
165 }
166
167
168 // Instrument filename accessor.
169 const QString& qsamplerChannel::instrumentFile (void) const
170 {
171 return m_sInstrumentFile;
172 }
173
174 // Instrument index accessor.
175 int qsamplerChannel::instrumentNr (void) const
176 {
177 return m_iInstrumentNr;
178 }
179
180 // Instrument name accessor.
181 const QString& qsamplerChannel::instrumentName (void) const
182 {
183 return m_sInstrumentName;
184 }
185
186 // Instrument status accessor.
187 int qsamplerChannel::instrumentStatus (void) const
188 {
189 return m_iInstrumentStatus;
190 }
191
192 // Instrument file loader.
193 bool qsamplerChannel::loadInstrument ( const QString& sInstrumentFile, int iInstrumentNr )
194 {
195 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
196 if (pMainForm == NULL)
197 return false;
198 if (pMainForm->client() == NULL || m_iChannelID < 0)
199 return false;
200 if (!isInstrumentFile(sInstrumentFile))
201 return false;
202 if (m_iInstrumentStatus == 100 && m_sInstrumentFile == sInstrumentFile && m_iInstrumentNr == iInstrumentNr)
203 return true;
204
205 if (::lscp_load_instrument_non_modal(pMainForm->client(), sInstrumentFile.latin1(), iInstrumentNr, m_iChannelID) != LSCP_OK) {
206 appendMessagesClient("lscp_load_instrument");
207 return false;
208 }
209
210 appendMessages(QObject::tr("Instrument: \"%1\" (%2).")
211 .arg(sInstrumentFile).arg(iInstrumentNr));
212
213 return setInstrument(sInstrumentFile, iInstrumentNr);
214 }
215
216
217 // Special instrument file/name/number settler.
218 bool qsamplerChannel::setInstrument ( const QString& sInstrumentFile, int iInstrumentNr )
219 {
220 m_sInstrumentFile = sInstrumentFile;
221 m_iInstrumentNr = iInstrumentNr;
222 #ifdef CONFIG_INSTRUMENT_NAME
223 m_sInstrumentName = QString::null; // We'll get it, maybe later, on channel_info...
224 #else
225 m_sInstrumentName = getInstrumentName(sInstrumentFile, iInstrumentNr, true);
226 #endif
227 m_iInstrumentStatus = 0;
228
229 return true;
230 }
231
232
233 // MIDI driver type accessors (DEPRECATED).
234 const QString& qsamplerChannel::midiDriver (void) const
235 {
236 return m_sMidiDriver;
237 }
238
239 bool qsamplerChannel::setMidiDriver ( const QString& sMidiDriver )
240 {
241 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
242 if (pMainForm == NULL)
243 return false;
244 if (pMainForm->client() == NULL || m_iChannelID < 0)
245 return false;
246 if (m_iInstrumentStatus == 100 && m_sMidiDriver == sMidiDriver)
247 return true;
248
249 if (::lscp_set_channel_midi_type(pMainForm->client(), m_iChannelID, sMidiDriver.latin1()) != LSCP_OK) {
250 appendMessagesClient("lscp_set_channel_midi_type");
251 return false;
252 }
253
254 appendMessages(QObject::tr("MIDI driver: %1.").arg(sMidiDriver));
255
256 m_sMidiDriver = sMidiDriver;
257 return true;
258 }
259
260
261 // MIDI device accessors.
262 int qsamplerChannel::midiDevice (void) const
263 {
264 return m_iMidiDevice;
265 }
266
267 bool qsamplerChannel::setMidiDevice ( int iMidiDevice )
268 {
269 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
270 if (pMainForm == NULL)
271 return false;
272 if (pMainForm->client() == NULL || m_iChannelID < 0)
273 return false;
274 if (m_iInstrumentStatus == 100 && m_iMidiDevice == iMidiDevice)
275 return true;
276
277 if (::lscp_set_channel_midi_device(pMainForm->client(), m_iChannelID, iMidiDevice) != LSCP_OK) {
278 appendMessagesClient("lscp_set_channel_midi_device");
279 return false;
280 }
281
282 appendMessages(QObject::tr("MIDI device: %1.").arg(iMidiDevice));
283
284 m_iMidiDevice = iMidiDevice;
285 return true;
286 }
287
288
289 // MIDI port number accessor.
290 int qsamplerChannel::midiPort (void) const
291 {
292 return m_iMidiPort;
293 }
294
295 bool qsamplerChannel::setMidiPort ( int iMidiPort )
296 {
297 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
298 if (pMainForm == NULL)
299 return false;
300 if (pMainForm->client() == NULL || m_iChannelID < 0)
301 return false;
302 if (m_iInstrumentStatus == 100 && m_iMidiPort == iMidiPort)
303 return true;
304
305 if (::lscp_set_channel_midi_port(pMainForm->client(), m_iChannelID, iMidiPort) != LSCP_OK) {
306 appendMessagesClient("lscp_set_channel_midi_port");
307 return false;
308 }
309
310 appendMessages(QObject::tr("MIDI port: %1.").arg(iMidiPort));
311
312 m_iMidiPort = iMidiPort;
313 return true;
314 }
315
316
317 // MIDI channel accessor.
318 int qsamplerChannel::midiChannel (void) const
319 {
320 return m_iMidiChannel;
321 }
322
323 bool qsamplerChannel::setMidiChannel ( int iMidiChannel )
324 {
325 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
326 if (pMainForm == NULL)
327 return false;
328 if (pMainForm->client() == NULL || m_iChannelID < 0)
329 return false;
330 if (m_iInstrumentStatus == 100 && m_iMidiChannel == iMidiChannel)
331 return true;
332
333 if (::lscp_set_channel_midi_channel(pMainForm->client(), m_iChannelID, iMidiChannel) != LSCP_OK) {
334 appendMessagesClient("lscp_set_channel_midi_channel");
335 return false;
336 }
337
338 appendMessages(QObject::tr("MIDI channel: %1.").arg(iMidiChannel));
339
340 m_iMidiChannel = iMidiChannel;
341 return true;
342 }
343
344
345 // MIDI instrument map accessor.
346 int qsamplerChannel::midiMap (void) const
347 {
348 return m_iMidiMap;
349 }
350
351 bool qsamplerChannel::setMidiMap ( int iMidiMap )
352 {
353 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
354 if (pMainForm == NULL)
355 return false;
356 if (pMainForm->client() == NULL || m_iChannelID < 0)
357 return false;
358 if (m_iInstrumentStatus == 100 && m_iMidiMap == iMidiMap)
359 return true;
360 #ifdef CONFIG_MIDI_INSTRUMENT
361 if (::lscp_set_channel_midi_map(pMainForm->client(), m_iChannelID, iMidiMap) != LSCP_OK) {
362 appendMessagesClient("lscp_set_channel_midi_map");
363 return false;
364 }
365 #endif
366 appendMessages(QObject::tr("MIDI map: %1.").arg(iMidiMap));
367
368 m_iMidiMap = iMidiMap;
369 return true;
370 }
371
372
373 // Audio device accessor.
374 int qsamplerChannel::audioDevice (void) const
375 {
376 return m_iAudioDevice;
377 }
378
379 bool qsamplerChannel::setAudioDevice ( int iAudioDevice )
380 {
381 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
382 if (pMainForm == NULL)
383 return false;
384 if (pMainForm->client() == NULL || m_iChannelID < 0)
385 return false;
386 if (m_iInstrumentStatus == 100 && m_iAudioDevice == iAudioDevice)
387 return true;
388
389 if (::lscp_set_channel_audio_device(pMainForm->client(), m_iChannelID, iAudioDevice) != LSCP_OK) {
390 appendMessagesClient("lscp_set_channel_audio_device");
391 return false;
392 }
393
394 appendMessages(QObject::tr("Audio device: %1.").arg(iAudioDevice));
395
396 m_iAudioDevice = iAudioDevice;
397 return true;
398 }
399
400
401 // Audio driver type accessors (DEPRECATED).
402 const QString& qsamplerChannel::audioDriver (void) const
403 {
404 return m_sAudioDriver;
405 }
406
407 bool qsamplerChannel::setAudioDriver ( const QString& sAudioDriver )
408 {
409 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
410 if (pMainForm == NULL)
411 return false;
412 if (pMainForm->client() == NULL || m_iChannelID < 0)
413 return false;
414 if (m_iInstrumentStatus == 100 && m_sAudioDriver == sAudioDriver)
415 return true;
416
417 if (::lscp_set_channel_audio_type(pMainForm->client(), m_iChannelID, sAudioDriver.latin1()) != LSCP_OK) {
418 appendMessagesClient("lscp_set_channel_audio_type");
419 return false;
420 }
421
422 appendMessages(QObject::tr("Audio driver: %1.").arg(sAudioDriver));
423
424 m_sAudioDriver = sAudioDriver;
425 return true;
426 }
427
428
429 // Channel volume accessors.
430 float qsamplerChannel::volume (void) const
431 {
432 return m_fVolume;
433 }
434
435 bool qsamplerChannel::setVolume ( float fVolume )
436 {
437 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
438 if (pMainForm == NULL)
439 return false;
440 if (pMainForm->client() == NULL || m_iChannelID < 0)
441 return false;
442 if (m_iInstrumentStatus == 100 && m_fVolume == fVolume)
443 return true;
444
445 if (::lscp_set_channel_volume(pMainForm->client(), m_iChannelID, fVolume) != LSCP_OK) {
446 appendMessagesClient("lscp_set_channel_volume");
447 return false;
448 }
449
450 appendMessages(QObject::tr("Volume: %1.").arg(fVolume));
451
452 m_fVolume = fVolume;
453 return true;
454 }
455
456
457 // Sampler channel mute state.
458 bool qsamplerChannel::channelMute (void) const
459 {
460 return m_bMute;
461 }
462
463 bool qsamplerChannel::setChannelMute ( bool bMute )
464 {
465 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
466 if (pMainForm == NULL)
467 return false;
468 if (pMainForm->client() == NULL || m_iChannelID < 0)
469 return false;
470 if (m_iInstrumentStatus == 100 && ((m_bMute && bMute) || (!m_bMute && !bMute)))
471 return true;
472
473 #ifdef CONFIG_MUTE_SOLO
474 if (::lscp_set_channel_mute(pMainForm->client(), m_iChannelID, bMute) != LSCP_OK) {
475 appendMessagesClient("lscp_set_channel_mute");
476 return false;
477 }
478 appendMessages(QObject::tr("Mute: %1.").arg((int) bMute));
479 m_bMute = bMute;
480 return true;
481 #else
482 return false;
483 #endif
484 }
485
486
487 // Sampler channel solo state.
488 bool qsamplerChannel::channelSolo (void) const
489 {
490 return m_bSolo;
491 }
492
493 bool qsamplerChannel::setChannelSolo ( bool bSolo )
494 {
495 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
496 if (pMainForm == NULL)
497 return false;
498 if (pMainForm->client() == NULL || m_iChannelID < 0)
499 return false;
500 if (m_iInstrumentStatus == 100 && ((m_bSolo && bSolo) || (!m_bSolo && !bSolo)))
501 return true;
502
503 #ifdef CONFIG_MUTE_SOLO
504 if (::lscp_set_channel_solo(pMainForm->client(), m_iChannelID, bSolo) != LSCP_OK) {
505 appendMessagesClient("lscp_set_channel_solo");
506 return false;
507 }
508 appendMessages(QObject::tr("Solo: %1.").arg((int) bSolo));
509 m_bSolo = bSolo;
510 return true;
511 #else
512 return false;
513 #endif
514 }
515
516
517 // Audio routing accessors.
518 int qsamplerChannel::audioChannel ( int iAudioOut ) const
519 {
520 return m_audioRouting[iAudioOut];
521 }
522
523 bool qsamplerChannel::setAudioChannel ( int iAudioOut, int iAudioIn )
524 {
525 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
526 if (pMainForm == NULL)
527 return false;
528 if (pMainForm->client() == NULL || m_iChannelID < 0)
529 return false;
530 if (m_iInstrumentStatus == 100 &&
531 m_audioRouting[iAudioOut] == iAudioIn)
532 return true;
533
534 if (::lscp_set_channel_audio_channel(pMainForm->client(),
535 m_iChannelID, iAudioOut, iAudioIn) != LSCP_OK) {
536 appendMessagesClient("lscp_set_channel_audio_channel");
537 return false;
538 }
539
540 appendMessages(QObject::tr("Audio Channel: %1 -> %2.")
541 .arg(iAudioOut).arg(iAudioIn));
542
543 m_audioRouting[iAudioOut] = iAudioIn;
544 return true;
545 }
546
547 // The audio routing map itself.
548 const qsamplerChannelRoutingMap& qsamplerChannel::audioRouting (void) const
549 {
550 return m_audioRouting;
551 }
552
553
554 // Istrument name remapper.
555 void qsamplerChannel::updateInstrumentName (void)
556 {
557 #ifndef CONFIG_INSTRUMENT_NAME
558 m_sInstrumentName = getInstrumentName(m_sInstrumentFile,
559 m_iInstrumentNr, (options() && options()->bInstrumentNames));
560 #endif
561 }
562
563
564 // Update whole channel info state.
565 bool qsamplerChannel::updateChannelInfo (void)
566 {
567 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
568 if (pMainForm == NULL)
569 return false;
570 if (pMainForm->client() == NULL || m_iChannelID < 0)
571 return false;
572
573 // Read channel information.
574 lscp_channel_info_t *pChannelInfo = ::lscp_get_channel_info(pMainForm->client(), m_iChannelID);
575 if (pChannelInfo == NULL) {
576 appendMessagesClient("lscp_get_channel_info");
577 appendMessagesError(QObject::tr("Could not get channel information.\n\nSorry."));
578 return false;
579 }
580
581 #ifdef CONFIG_INSTRUMENT_NAME
582 // We got all actual instrument datum...
583 m_sInstrumentFile = pChannelInfo->instrument_file;
584 m_iInstrumentNr = pChannelInfo->instrument_nr;
585 m_sInstrumentName = pChannelInfo->instrument_name;
586 #else
587 // First, check if intrument name has changed,
588 // taking care that instrument name lookup might be expensive,
589 // so we better make it only once and when really needed...
590 if ((m_sInstrumentFile != pChannelInfo->instrument_file) ||
591 (m_iInstrumentNr != pChannelInfo->instrument_nr)) {
592 m_sInstrumentFile = pChannelInfo->instrument_file;
593 m_iInstrumentNr = pChannelInfo->instrument_nr;
594 updateInstrumentName();
595 }
596 #endif
597 // Cache in other channel information.
598 m_sEngineName = pChannelInfo->engine_name;
599 m_iInstrumentStatus = pChannelInfo->instrument_status;
600 m_iMidiDevice = pChannelInfo->midi_device;
601 m_iMidiPort = pChannelInfo->midi_port;
602 m_iMidiChannel = pChannelInfo->midi_channel;
603 #ifdef CONFIG_MIDI_INSTRUMENT
604 m_iMidiMap = pChannelInfo->midi_map;
605 #endif
606 m_iAudioDevice = pChannelInfo->audio_device;
607 m_fVolume = pChannelInfo->volume;
608 #ifdef CONFIG_MUTE_SOLO
609 m_bMute = pChannelInfo->mute;
610 m_bSolo = pChannelInfo->solo;
611 #endif
612 // Some sanity checks.
613 if (m_sEngineName == "NONE" || m_sEngineName.isEmpty())
614 m_sEngineName = QString::null;
615 if (m_sInstrumentFile == "NONE" || m_sInstrumentFile.isEmpty()) {
616 m_sInstrumentFile = QString::null;
617 m_sInstrumentName = QString::null;
618 }
619
620 // Time for device info grabbing...
621 lscp_device_info_t *pDeviceInfo;
622 const QString sNone = QObject::tr("(none)");
623 // Audio device driver type.
624 pDeviceInfo = ::lscp_get_audio_device_info(pMainForm->client(), m_iAudioDevice);
625 if (pDeviceInfo == NULL) {
626 appendMessagesClient("lscp_get_audio_device_info");
627 m_sAudioDriver = sNone;
628 } else {
629 m_sAudioDriver = pDeviceInfo->driver;
630 }
631 // MIDI device driver type.
632 pDeviceInfo = ::lscp_get_midi_device_info(pMainForm->client(), m_iMidiDevice);
633 if (pDeviceInfo == NULL) {
634 appendMessagesClient("lscp_get_midi_device_info");
635 m_sMidiDriver = sNone;
636 } else {
637 m_sMidiDriver = pDeviceInfo->driver;
638 }
639
640 // Set the audio routing map.
641 m_audioRouting.clear();
642 #ifdef CONFIG_AUDIO_ROUTING
643 int *piAudioRouting = pChannelInfo->audio_routing;
644 for (int i = 0; piAudioRouting && piAudioRouting[i] >= 0; i++)
645 m_audioRouting[i] = piAudioRouting[i];
646 #else
647 char **ppszAudioRouting = pChannelInfo->audio_routing;
648 for (int i = 0; ppszAudioRouting && ppszAudioRouting[i]; i++)
649 m_audioRouting[i] = ::atoi(ppszAudioRouting[i]);
650 #endif
651
652 return true;
653 }
654
655
656 // Reset channel method.
657 bool qsamplerChannel::channelReset (void)
658 {
659 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
660 if (pMainForm == NULL)
661 return false;
662 if (pMainForm->client() == NULL || m_iChannelID < 0)
663 return false;
664
665 if (::lscp_reset_channel(pMainForm->client(), m_iChannelID) != LSCP_OK) {
666 appendMessagesClient("lscp_reset_channel");
667 return false;
668 }
669
670 appendMessages(QObject::tr("reset."));
671
672 return true;
673 }
674
675
676 // Channel setup dialog form.
677 bool qsamplerChannel::channelSetup ( QWidget *pParent )
678 {
679 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
680 if (pMainForm == NULL)
681 return false;
682
683 bool bResult = false;
684
685 appendMessages(QObject::tr("setup..."));
686
687 qsamplerChannelForm *pChannelForm = new qsamplerChannelForm(pParent);
688 if (pChannelForm) {
689 pChannelForm->setup(this);
690 bResult = pChannelForm->exec();
691 delete pChannelForm;
692 }
693
694 return bResult;
695 }
696
697
698 // Redirected messages output methods.
699 void qsamplerChannel::appendMessages( const QString& s ) const
700 {
701 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
702 if (pMainForm)
703 pMainForm->appendMessages(channelName() + ' ' + s);
704 }
705
706 void qsamplerChannel::appendMessagesColor( const QString& s,
707 const QString& c ) const
708 {
709 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
710 if (pMainForm)
711 pMainForm->appendMessagesColor(channelName() + ' ' + s, c);
712 }
713
714 void qsamplerChannel::appendMessagesText( const QString& s ) const
715 {
716 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
717 if (pMainForm)
718 pMainForm->appendMessagesText(channelName() + ' ' + s);
719 }
720
721 void qsamplerChannel::appendMessagesError( const QString& s ) const
722 {
723 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
724 if (pMainForm)
725 pMainForm->appendMessagesError(channelName() + "\n\n" + s);
726 }
727
728 void qsamplerChannel::appendMessagesClient( const QString& s ) const
729 {
730 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
731 if (pMainForm)
732 pMainForm->appendMessagesClient(channelName() + ' ' + s);
733 }
734
735
736 // Context menu event handler.
737 void qsamplerChannel::contextMenuEvent( QContextMenuEvent *pEvent )
738 {
739 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
740 if (pMainForm)
741 pMainForm->contextMenuEvent(pEvent);
742 }
743
744
745 // FIXME: Check whether a given file is an instrument file.
746 bool qsamplerChannel::isInstrumentFile ( const QString& sInstrumentFile )
747 {
748 bool bResult = false;
749
750 QFile file(sInstrumentFile);
751 if (file.open(IO_ReadOnly)) {
752 char achHeader[16];
753 if (file.readBlock(achHeader, 16)) {
754 bResult = (::memcmp(&achHeader[0], "RIFF", 4) == 0
755 && ::memcmp(&achHeader[8], "DLS LIST", 8) == 0);
756 }
757 file.close();
758 }
759
760 return bResult;
761 }
762
763
764 // Retrieve the instrument list of a instrument file (.gig).
765 QStringList qsamplerChannel::getInstrumentList( const QString& sInstrumentFile,
766 bool bInstrumentNames )
767 {
768 QString sInstrumentName = QFileInfo(sInstrumentFile).fileName();
769 QStringList instlist;
770
771 if (isInstrumentFile(sInstrumentFile)) {
772 #ifdef CONFIG_LIBGIG
773 if (bInstrumentNames) {
774 RIFF::File *pRiff = new RIFF::File(sInstrumentFile.latin1());
775 gig::File *pGig = new gig::File(pRiff);
776 gig::Instrument *pInstrument = pGig->GetFirstInstrument();
777 while (pInstrument) {
778 instlist.append((pInstrument->pInfo)->Name.c_str());
779 pInstrument = pGig->GetNextInstrument();
780 }
781 delete pGig;
782 delete pRiff;
783 }
784 else
785 #endif
786 for (int iInstrumentNr = 0; iInstrumentNr < QSAMPLER_INSTRUMENT_MAX; iInstrumentNr++)
787 instlist.append(sInstrumentName + " [" + QString::number(iInstrumentNr) + "]");
788 }
789 else instlist.append(noInstrumentName());
790
791 return instlist;
792 }
793
794
795 // Retrieve the spacific instrument name of a instrument file (.gig), given its index.
796 QString qsamplerChannel::getInstrumentName( const QString& sInstrumentFile,
797 int iInstrumentNr, bool bInstrumentNames )
798 {
799 QString sInstrumentName;
800
801 if (isInstrumentFile(sInstrumentFile)) {
802 sInstrumentName = QFileInfo(sInstrumentFile).fileName();
803 #ifdef CONFIG_LIBGIG
804 if (bInstrumentNames) {
805 RIFF::File *pRiff = new RIFF::File(sInstrumentFile.latin1());
806 gig::File *pGig = new gig::File(pRiff);
807 int iIndex = 0;
808 gig::Instrument *pInstrument = pGig->GetFirstInstrument();
809 while (pInstrument) {
810 if (iIndex == iInstrumentNr) {
811 sInstrumentName = (pInstrument->pInfo)->Name.c_str();
812 break;
813 }
814 iIndex++;
815 pInstrument = pGig->GetNextInstrument();
816 }
817 delete pGig;
818 delete pRiff;
819 }
820 else
821 #endif
822 sInstrumentName += " [" + QString::number(iInstrumentNr) + "]";
823 }
824 else sInstrumentName = noInstrumentName();
825
826 return sInstrumentName;
827 }
828
829
830 // Common invalid name-helpers.
831 QString qsamplerChannel::noEngineName (void)
832 {
833 return QObject::tr("(No engine)");
834 }
835
836 QString qsamplerChannel::noInstrumentName (void)
837 {
838 return QObject::tr("(No instrument)");
839 }
840
841 QString qsamplerChannel::loadingInstrument (void) {
842 return QObject::tr("(Loading instrument...)");
843 }
844
845
846
847 //-------------------------------------------------------------------------
848 // qsamplerChannelRoutingTable - Channel routing table.
849 //
850
851 // Constructor.
852 qsamplerChannelRoutingTable::qsamplerChannelRoutingTable (
853 QWidget *pParent, const char *pszName )
854 : QTable(pParent, pszName)
855 {
856 // Set fixed number of columns.
857 QTable::setNumCols(2);
858 QTable::setShowGrid(false);
859 QTable::setSorting(false);
860 QTable::setFocusStyle(QTable::FollowStyle);
861 QTable::setSelectionMode(QTable::NoSelection);
862 // No vertical header.
863 QTable::verticalHeader()->hide();
864 QTable::setLeftMargin(0);
865 // Initialize the fixed table column headings.
866 QHeader *pHeader = QTable::horizontalHeader();
867 pHeader->setLabel(0, tr("Sampler Channel"));
868 pHeader->setLabel(1, tr("Device Channel"));
869 // Set read-onlyness of each column
870 QTable::setColumnReadOnly(0, true);
871 // QTable::setColumnReadOnly(1, false); -- of course not.
872 QTable::setColumnStretchable(1, true);
873 }
874
875 // Default destructor.
876 qsamplerChannelRoutingTable::~qsamplerChannelRoutingTable (void)
877 {
878 }
879
880
881 // Routing map table renderer.
882 void qsamplerChannelRoutingTable::refresh ( qsamplerDevice *pDevice,
883 const qsamplerChannelRoutingMap& routing )
884 {
885 if (pDevice == NULL)
886 return;
887
888 // Always (re)start it empty.
889 QTable::setUpdatesEnabled(false);
890 QTable::setNumRows(0);
891
892 // The common device port item list.
893 QStringList opts;
894 qsamplerDevicePortList& ports = pDevice->ports();
895 qsamplerDevicePort *pPort;
896 for (pPort = ports.first(); pPort; pPort = ports.next()) {
897 opts.append(pDevice->deviceTypeName()
898 + ' ' + pDevice->driverName()
899 + ' ' + pPort->portName());
900 }
901
902 // Those items shall have a proper pixmap...
903 QPixmap pmChannel = QPixmap::fromMimeSource("qsamplerChannel.png");
904 QPixmap pmDevice;
905 switch (pDevice->deviceType()) {
906 case qsamplerDevice::Audio:
907 pmDevice = QPixmap::fromMimeSource("audio2.png");
908 break;
909 case qsamplerDevice::Midi:
910 pmDevice = QPixmap::fromMimeSource("midi2.png");
911 break;
912 case qsamplerDevice::None:
913 break;
914 }
915
916 // Fill the routing table...
917 QTable::insertRows(0, routing.count());
918 int iRow = 0;
919 qsamplerChannelRoutingMap::ConstIterator iter;
920 for (iter = routing.begin(); iter != routing.end(); ++iter) {
921 QTable::setPixmap(iRow, 0, pmChannel);
922 QTable::setText(iRow, 0, pDevice->deviceTypeName()
923 + ' ' + QString::number(iter.key()));
924 qsamplerChannelRoutingComboBox *pComboItem =
925 new qsamplerChannelRoutingComboBox(this, opts, pmDevice);
926 pComboItem->setCurrentItem(iter.data());
927 QTable::setItem(iRow, 1, pComboItem);
928 ++iRow;
929 }
930
931 // Adjust optimal column widths.
932 QTable::adjustColumn(0);
933 QTable::adjustColumn(1);
934
935 QTable::setUpdatesEnabled(true);
936 QTable::updateContents();
937 }
938
939
940 // Commit any pending editing.
941 void qsamplerChannelRoutingTable::flush (void)
942 {
943 if (QTable::isEditing())
944 QTable::endEdit(QTable::currEditRow(), QTable::currEditCol(), true, true);
945 }
946
947
948 //-------------------------------------------------------------------------
949 // qsamplerChannelRoutingComboBox - Custom combo box for routing table.
950 //
951
952 // Constructor.
953 qsamplerChannelRoutingComboBox::qsamplerChannelRoutingComboBox (
954 QTable *pTable, const QStringList& list, const QPixmap& pixmap )
955 : QTableItem(pTable, QTableItem::WhenCurrent, QString::null, pixmap),
956 m_list(list)
957 {
958 m_iCurrentItem = 0;
959 }
960
961 // Public accessors.
962 void qsamplerChannelRoutingComboBox::setCurrentItem ( int iCurrentItem )
963 {
964 m_iCurrentItem = iCurrentItem;
965
966 QTableItem::setText(m_list[iCurrentItem]);
967 }
968
969 int qsamplerChannelRoutingComboBox::currentItem (void) const
970 {
971 return m_iCurrentItem;
972 }
973
974 // Virtual implemetations.
975 QWidget *qsamplerChannelRoutingComboBox::createEditor (void) const
976 {
977 QComboBox *pComboBox = new QComboBox(QTableItem::table()->viewport());
978 QObject::connect(pComboBox, SIGNAL(activated(int)),
979 QTableItem::table(), SLOT(doValueChanged()));
980 for (QStringList::ConstIterator iter = m_list.begin();
981 iter != m_list.end(); iter++) {
982 pComboBox->insertItem(QTableItem::pixmap(), *iter);
983 }
984 pComboBox->setCurrentItem(m_iCurrentItem);
985 return pComboBox;
986 }
987
988 void qsamplerChannelRoutingComboBox::setContentFromEditor ( QWidget *pWidget )
989 {
990 if (pWidget->inherits("QComboBox")) {
991 QComboBox *pComboBox = (QComboBox *) pWidget;
992 m_iCurrentItem = pComboBox->currentItem();
993 QTableItem::setText(pComboBox->currentText());
994 }
995 else QTableItem::setContentFromEditor(pWidget);
996 }
997
998
999 // end of qsamplerChannel.cpp

  ViewVC Help
Powered by ViewVC