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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1490 - (show annotations) (download)
Mon Nov 19 04:09:30 2007 UTC (16 years, 3 months ago) by schoenebeck
File size: 27497 byte(s)
- minor cosmetics (show unicode right arrow instead of "->")

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

  ViewVC Help
Powered by ViewVC