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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 824 - (hide annotations) (download)
Fri Dec 23 01:40:56 2005 UTC (18 years, 3 months ago) by capela
File size: 23990 byte(s)
* Whenever the listing of actual instrument names is not an
  option (e.g. due to lack of libgig support), the whole
  number of selectable Instrument items is now being graciously
  increased from just the bare 8 (eight) right up through 100
  (one hundred), on the sampler channel setup dialog.

* The selection buttons, on the right of the Instrument, Audio
  and MIDI devices combo-boxes, on the sampler channel dialog,
  are now expected to be a little better looking than it was
  before, at least for those Mac OS X eyes.

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

  ViewVC Help
Powered by ViewVC