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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1366 - (show annotations) (download)
Mon Oct 1 18:26:06 2007 UTC (11 years, 2 months ago) by schoenebeck
File size: 27994 byte(s)
* Added new button "Edit" to the channel strips, which probably
  does exactly what you think it does: it opens an appropriate
  instrument editor application.

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 // Spawn instrument editor method.
677 bool qsamplerChannel::editChannel (void)
678 {
679 #ifdef CONFIG_EDIT_INSTRUMENT
680 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
681 if (pMainForm == NULL)
682 return false;
683 if (pMainForm->client() == NULL || m_iChannelID < 0)
684 return false;
685
686 if (::lscp_edit_instrument(pMainForm->client(), m_iChannelID) != LSCP_OK) {
687 appendMessagesClient("lscp_edit_instrument");
688 appendMessagesError(
689 "Could not launch an appropriate instrument editor for the\n"
690 "given instrument! Make sure you have an appropriate\n"
691 "instrument editor like 'gigedit' installed and that it placed\n"
692 "its mandatory DLL file into the sampler's plugin directory."
693 );
694 return false;
695 }
696
697 appendMessages(QObject::tr("edit instrument."));
698
699 return true;
700 #else
701 appendMessagesError(
702 "Sorry, QSampler was compiled for a version of liblscp which lacks\n"
703 "this feature. You may want to update liblscp and recompile\n"
704 "QSampler afterwards."
705 );
706 return false;
707 #endif
708 }
709
710
711 // Channel setup dialog form.
712 bool qsamplerChannel::channelSetup ( QWidget *pParent )
713 {
714 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
715 if (pMainForm == NULL)
716 return false;
717
718 bool bResult = false;
719
720 appendMessages(QObject::tr("setup..."));
721
722 qsamplerChannelForm *pChannelForm = new qsamplerChannelForm(pParent);
723 if (pChannelForm) {
724 pChannelForm->setup(this);
725 bResult = pChannelForm->exec();
726 delete pChannelForm;
727 }
728
729 return bResult;
730 }
731
732
733 // Redirected messages output methods.
734 void qsamplerChannel::appendMessages( const QString& s ) const
735 {
736 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
737 if (pMainForm)
738 pMainForm->appendMessages(channelName() + ' ' + s);
739 }
740
741 void qsamplerChannel::appendMessagesColor( const QString& s,
742 const QString& c ) const
743 {
744 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
745 if (pMainForm)
746 pMainForm->appendMessagesColor(channelName() + ' ' + s, c);
747 }
748
749 void qsamplerChannel::appendMessagesText( const QString& s ) const
750 {
751 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
752 if (pMainForm)
753 pMainForm->appendMessagesText(channelName() + ' ' + s);
754 }
755
756 void qsamplerChannel::appendMessagesError( const QString& s ) const
757 {
758 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
759 if (pMainForm)
760 pMainForm->appendMessagesError(channelName() + "\n\n" + s);
761 }
762
763 void qsamplerChannel::appendMessagesClient( const QString& s ) const
764 {
765 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
766 if (pMainForm)
767 pMainForm->appendMessagesClient(channelName() + ' ' + s);
768 }
769
770
771 // Context menu event handler.
772 void qsamplerChannel::contextMenuEvent( QContextMenuEvent *pEvent )
773 {
774 qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
775 if (pMainForm)
776 pMainForm->contextMenuEvent(pEvent);
777 }
778
779
780 // FIXME: Check whether a given file is an instrument file.
781 bool qsamplerChannel::isInstrumentFile ( const QString& sInstrumentFile )
782 {
783 bool bResult = false;
784
785 QFile file(sInstrumentFile);
786 if (file.open(IO_ReadOnly)) {
787 char achHeader[16];
788 if (file.readBlock(achHeader, 16)) {
789 bResult = (::memcmp(&achHeader[0], "RIFF", 4) == 0
790 && ::memcmp(&achHeader[8], "DLS LIST", 8) == 0);
791 }
792 file.close();
793 }
794
795 return bResult;
796 }
797
798
799 // Retrieve the instrument list of a instrument file (.gig).
800 QStringList qsamplerChannel::getInstrumentList( const QString& sInstrumentFile,
801 bool bInstrumentNames )
802 {
803 QString sInstrumentName = QFileInfo(sInstrumentFile).fileName();
804 QStringList instlist;
805
806 if (isInstrumentFile(sInstrumentFile)) {
807 #ifdef CONFIG_LIBGIG
808 if (bInstrumentNames) {
809 RIFF::File *pRiff = new RIFF::File(sInstrumentFile.latin1());
810 gig::File *pGig = new gig::File(pRiff);
811 gig::Instrument *pInstrument = pGig->GetFirstInstrument();
812 while (pInstrument) {
813 instlist.append((pInstrument->pInfo)->Name.c_str());
814 pInstrument = pGig->GetNextInstrument();
815 }
816 delete pGig;
817 delete pRiff;
818 }
819 else
820 #endif
821 for (int iInstrumentNr = 0; iInstrumentNr < QSAMPLER_INSTRUMENT_MAX; iInstrumentNr++)
822 instlist.append(sInstrumentName + " [" + QString::number(iInstrumentNr) + "]");
823 }
824 else instlist.append(noInstrumentName());
825
826 return instlist;
827 }
828
829
830 // Retrieve the spacific instrument name of a instrument file (.gig), given its index.
831 QString qsamplerChannel::getInstrumentName( const QString& sInstrumentFile,
832 int iInstrumentNr, bool bInstrumentNames )
833 {
834 QString sInstrumentName;
835
836 if (isInstrumentFile(sInstrumentFile)) {
837 sInstrumentName = QFileInfo(sInstrumentFile).fileName();
838 #ifdef CONFIG_LIBGIG
839 if (bInstrumentNames) {
840 RIFF::File *pRiff = new RIFF::File(sInstrumentFile.latin1());
841 gig::File *pGig = new gig::File(pRiff);
842 int iIndex = 0;
843 gig::Instrument *pInstrument = pGig->GetFirstInstrument();
844 while (pInstrument) {
845 if (iIndex == iInstrumentNr) {
846 sInstrumentName = (pInstrument->pInfo)->Name.c_str();
847 break;
848 }
849 iIndex++;
850 pInstrument = pGig->GetNextInstrument();
851 }
852 delete pGig;
853 delete pRiff;
854 }
855 else
856 #endif
857 sInstrumentName += " [" + QString::number(iInstrumentNr) + "]";
858 }
859 else sInstrumentName = noInstrumentName();
860
861 return sInstrumentName;
862 }
863
864
865 // Common invalid name-helpers.
866 QString qsamplerChannel::noEngineName (void)
867 {
868 return QObject::tr("(No engine)");
869 }
870
871 QString qsamplerChannel::noInstrumentName (void)
872 {
873 return QObject::tr("(No instrument)");
874 }
875
876 QString qsamplerChannel::loadingInstrument (void) {
877 return QObject::tr("(Loading instrument...)");
878 }
879
880
881
882 //-------------------------------------------------------------------------
883 // qsamplerChannelRoutingTable - Channel routing table.
884 //
885
886 // Constructor.
887 qsamplerChannelRoutingTable::qsamplerChannelRoutingTable (
888 QWidget *pParent, const char *pszName )
889 : QTable(pParent, pszName)
890 {
891 // Set fixed number of columns.
892 QTable::setNumCols(2);
893 QTable::setShowGrid(false);
894 QTable::setSorting(false);
895 QTable::setFocusStyle(QTable::FollowStyle);
896 QTable::setSelectionMode(QTable::NoSelection);
897 // No vertical header.
898 QTable::verticalHeader()->hide();
899 QTable::setLeftMargin(0);
900 // Initialize the fixed table column headings.
901 QHeader *pHeader = QTable::horizontalHeader();
902 pHeader->setLabel(0, tr("Sampler Channel"));
903 pHeader->setLabel(1, tr("Device Channel"));
904 // Set read-onlyness of each column
905 QTable::setColumnReadOnly(0, true);
906 // QTable::setColumnReadOnly(1, false); -- of course not.
907 QTable::setColumnStretchable(1, true);
908 }
909
910 // Default destructor.
911 qsamplerChannelRoutingTable::~qsamplerChannelRoutingTable (void)
912 {
913 }
914
915
916 // Routing map table renderer.
917 void qsamplerChannelRoutingTable::refresh ( qsamplerDevice *pDevice,
918 const qsamplerChannelRoutingMap& routing )
919 {
920 if (pDevice == NULL)
921 return;
922
923 // Always (re)start it empty.
924 QTable::setUpdatesEnabled(false);
925 QTable::setNumRows(0);
926
927 // The common device port item list.
928 QStringList opts;
929 qsamplerDevicePortList& ports = pDevice->ports();
930 qsamplerDevicePort *pPort;
931 for (pPort = ports.first(); pPort; pPort = ports.next()) {
932 opts.append(pDevice->deviceTypeName()
933 + ' ' + pDevice->driverName()
934 + ' ' + pPort->portName());
935 }
936
937 // Those items shall have a proper pixmap...
938 QPixmap pmChannel = QPixmap::fromMimeSource("qsamplerChannel.png");
939 QPixmap pmDevice;
940 switch (pDevice->deviceType()) {
941 case qsamplerDevice::Audio:
942 pmDevice = QPixmap::fromMimeSource("audio2.png");
943 break;
944 case qsamplerDevice::Midi:
945 pmDevice = QPixmap::fromMimeSource("midi2.png");
946 break;
947 case qsamplerDevice::None:
948 break;
949 }
950
951 // Fill the routing table...
952 QTable::insertRows(0, routing.count());
953 int iRow = 0;
954 qsamplerChannelRoutingMap::ConstIterator iter;
955 for (iter = routing.begin(); iter != routing.end(); ++iter) {
956 QTable::setPixmap(iRow, 0, pmChannel);
957 QTable::setText(iRow, 0, pDevice->deviceTypeName()
958 + ' ' + QString::number(iter.key()));
959 qsamplerChannelRoutingComboBox *pComboItem =
960 new qsamplerChannelRoutingComboBox(this, opts, pmDevice);
961 pComboItem->setCurrentItem(iter.data());
962 QTable::setItem(iRow, 1, pComboItem);
963 ++iRow;
964 }
965
966 // Adjust optimal column widths.
967 QTable::adjustColumn(0);
968 QTable::adjustColumn(1);
969
970 QTable::setUpdatesEnabled(true);
971 QTable::updateContents();
972 }
973
974
975 // Commit any pending editing.
976 void qsamplerChannelRoutingTable::flush (void)
977 {
978 if (QTable::isEditing())
979 QTable::endEdit(QTable::currEditRow(), QTable::currEditCol(), true, true);
980 }
981
982
983 //-------------------------------------------------------------------------
984 // qsamplerChannelRoutingComboBox - Custom combo box for routing table.
985 //
986
987 // Constructor.
988 qsamplerChannelRoutingComboBox::qsamplerChannelRoutingComboBox (
989 QTable *pTable, const QStringList& list, const QPixmap& pixmap )
990 : QTableItem(pTable, QTableItem::WhenCurrent, QString::null, pixmap),
991 m_list(list)
992 {
993 m_iCurrentItem = 0;
994 }
995
996 // Public accessors.
997 void qsamplerChannelRoutingComboBox::setCurrentItem ( int iCurrentItem )
998 {
999 m_iCurrentItem = iCurrentItem;
1000
1001 QTableItem::setText(m_list[iCurrentItem]);
1002 }
1003
1004 int qsamplerChannelRoutingComboBox::currentItem (void) const
1005 {
1006 return m_iCurrentItem;
1007 }
1008
1009 // Virtual implemetations.
1010 QWidget *qsamplerChannelRoutingComboBox::createEditor (void) const
1011 {
1012 QComboBox *pComboBox = new QComboBox(QTableItem::table()->viewport());
1013 QObject::connect(pComboBox, SIGNAL(activated(int)),
1014 QTableItem::table(), SLOT(doValueChanged()));
1015 for (QStringList::ConstIterator iter = m_list.begin();
1016 iter != m_list.end(); iter++) {
1017 pComboBox->insertItem(QTableItem::pixmap(), *iter);
1018 }
1019 pComboBox->setCurrentItem(m_iCurrentItem);
1020 return pComboBox;
1021 }
1022
1023 void qsamplerChannelRoutingComboBox::setContentFromEditor ( QWidget *pWidget )
1024 {
1025 if (pWidget->inherits("QComboBox")) {
1026 QComboBox *pComboBox = (QComboBox *) pWidget;
1027 m_iCurrentItem = pComboBox->currentItem();
1028 QTableItem::setText(pComboBox->currentText());
1029 }
1030 else QTableItem::setContentFromEditor(pWidget);
1031 }
1032
1033
1034 // end of qsamplerChannel.cpp

  ViewVC Help
Powered by ViewVC