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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1372 - (show annotations) (download)
Wed Oct 3 11:34:30 2007 UTC (16 years, 5 months ago) by capela
File size: 28035 byte(s)
* The new channel instrument editor tool is now also accessible
  from the main menu and toolbar.

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

  ViewVC Help
Powered by ViewVC