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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1461 by schoenebeck, Sun Oct 28 23:30:36 2007 UTC revision 2563 by capela, Tue May 20 10:59:37 2014 UTC
# Line 1  Line 1 
1  // qsamplerChannel.cpp  // qsamplerChannel.cpp
2  //  //
3  /****************************************************************************  /****************************************************************************
4     Copyright (C) 2004-2007, rncbc aka Rui Nuno Capela. All rights reserved.     Copyright (C) 2004-2014, rncbc aka Rui Nuno Capela. All rights reserved.
5       Copyright (C) 2007, 2008 Christian Schoenebeck
6    
7     This program is free software; you can redistribute it and/or     This program is free software; you can redistribute it and/or
8     modify it under the terms of the GNU General Public License     modify it under the terms of the GNU General Public License
# Line 19  Line 20 
20    
21  *****************************************************************************/  *****************************************************************************/
22    
 #include "qsamplerUtilities.h"  
23  #include "qsamplerAbout.h"  #include "qsamplerAbout.h"
24  #include "qsamplerChannel.h"  #include "qsamplerChannel.h"
25    #include "qsamplerUtilities.h"
26    
27  #include "qsamplerMainForm.h"  #include "qsamplerMainForm.h"
28  #include "qsamplerChannelForm.h"  #include "qsamplerChannelForm.h"
29    
30  #include <qfileinfo.h>  #include <QFileInfo>
31  #include <qcombobox.h>  #include <QComboBox>
32    
33  #ifdef CONFIG_LIBGIG  #ifdef CONFIG_LIBGIG
34  #include "gig.h"  #include "gig.h"
35    #include "SF.h"
36  #endif  #endif
37    
38  #define QSAMPLER_INSTRUMENT_MAX 100  namespace QSampler {
39    
40    #define QSAMPLER_INSTRUMENT_MAX 128
41    
42    #define UNICODE_RIGHT_ARROW     QChar(char(0x92), char(0x21))
43    
 using namespace QSampler;  
44    
45  //-------------------------------------------------------------------------  //-------------------------------------------------------------------------
46  // qsamplerChannel - Sampler channel structure.  // QSampler::Channel - Sampler channel structure.
47  //  //
48    
49  // Constructor.  // Constructor.
50  qsamplerChannel::qsamplerChannel ( int iChannelID )  Channel::Channel ( int iChannelID )
51  {  {
52          m_iChannelID = iChannelID;          m_iChannelID = iChannelID;
53    
# Line 58  qsamplerChannel::qsamplerChannel ( int i Line 63  qsamplerChannel::qsamplerChannel ( int i
63          m_iMidiMap          = -1;          m_iMidiMap          = -1;
64          m_sAudioDriver      = "ALSA";          m_sAudioDriver      = "ALSA";
65          m_iAudioDevice      = -1;          m_iAudioDevice      = -1;
66          m_fVolume           = 0.0;          m_fVolume           = 0.0f;
67          m_bMute             = false;          m_bMute             = false;
68          m_bSolo             = false;          m_bSolo             = false;
69  }  }
70    
71  // Default destructor.  // Default destructor.
72  qsamplerChannel::~qsamplerChannel (void)  Channel::~Channel (void)
73  {  {
74  }  }
75    
76    
77  // Create a new sampler channel, if not already.  // Create a new sampler channel, if not already.
78  bool qsamplerChannel::addChannel (void)  bool Channel::addChannel (void)
79  {  {
80          MainForm* pMainForm = MainForm::getInstance();          MainForm* pMainForm = MainForm::getInstance();
81          if (pMainForm == NULL)          if (pMainForm == NULL)
# Line 95  bool qsamplerChannel::addChannel (void) Line 100  bool qsamplerChannel::addChannel (void)
100    
101    
102  // Remove sampler channel.  // Remove sampler channel.
103  bool qsamplerChannel::removeChannel (void)  bool Channel::removeChannel (void)
104  {  {
105          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
106          if (pMainForm == NULL)          if (pMainForm == NULL)
# Line 121  bool qsamplerChannel::removeChannel (voi Line 126  bool qsamplerChannel::removeChannel (voi
126    
127    
128  // Channel-ID (aka Sammpler-Channel) accessors.  // Channel-ID (aka Sammpler-Channel) accessors.
129  int qsamplerChannel::channelID (void) const  int Channel::channelID (void) const
130  {  {
131          return m_iChannelID;          return m_iChannelID;
132  }  }
133    
134  void qsamplerChannel::setChannelID ( int iChannelID )  void Channel::setChannelID ( int iChannelID )
135  {  {
136          m_iChannelID = iChannelID;          m_iChannelID = iChannelID;
137  }  }
138    
139    
140  // Readable channel name.  // Readable channel name.
141  QString qsamplerChannel::channelName (void) const  QString Channel::channelName (void) const
142  {  {
143          return (m_iChannelID < 0 ? QObject::tr("New Channel") : QObject::tr("Channel %1").arg(m_iChannelID));          return (m_iChannelID < 0 ? QObject::tr("New Channel") : QObject::tr("Channel %1").arg(m_iChannelID));
144  }  }
145    
146    
147  // Engine name accessors.  // Engine name accessors.
148  const QString& qsamplerChannel::engineName (void) const  const QString& Channel::engineName (void) const
149  {  {
150          return m_sEngineName;          return m_sEngineName;
151  }  }
152    
153  bool qsamplerChannel::loadEngine ( const QString& sEngineName )  bool Channel::loadEngine ( const QString& sEngineName )
154  {  {
155          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
156          if (pMainForm == NULL)          if (pMainForm == NULL)
# Line 155  bool qsamplerChannel::loadEngine ( const Line 160  bool qsamplerChannel::loadEngine ( const
160          if (m_iInstrumentStatus == 100 && m_sEngineName == sEngineName)          if (m_iInstrumentStatus == 100 && m_sEngineName == sEngineName)
161                  return true;                  return true;
162    
163          if (::lscp_load_engine(pMainForm->client(), sEngineName.latin1(), m_iChannelID) != LSCP_OK) {          if (::lscp_load_engine(pMainForm->client(),
164                            sEngineName.toUtf8().constData(), m_iChannelID) != LSCP_OK) {
165                  appendMessagesClient("lscp_load_engine");                  appendMessagesClient("lscp_load_engine");
166                  return false;                  return false;
167          }          }
# Line 168  bool qsamplerChannel::loadEngine ( const Line 174  bool qsamplerChannel::loadEngine ( const
174    
175    
176  // Instrument filename accessor.  // Instrument filename accessor.
177  const QString& qsamplerChannel::instrumentFile (void) const  const QString& Channel::instrumentFile (void) const
178  {  {
179          return m_sInstrumentFile;          return m_sInstrumentFile;
180  }  }
181    
182  // Instrument index accessor.  // Instrument index accessor.
183  int qsamplerChannel::instrumentNr (void) const  int Channel::instrumentNr (void) const
184  {  {
185          return m_iInstrumentNr;          return m_iInstrumentNr;
186  }  }
187    
188  // Instrument name accessor.  // Instrument name accessor.
189  const QString& qsamplerChannel::instrumentName (void) const  const QString& Channel::instrumentName (void) const
190  {  {
191          return m_sInstrumentName;          return m_sInstrumentName;
192  }  }
193    
194  // Instrument status accessor.  // Instrument status accessor.
195  int qsamplerChannel::instrumentStatus (void) const  int Channel::instrumentStatus (void) const
196  {  {
197          return m_iInstrumentStatus;          return m_iInstrumentStatus;
198  }  }
199    
200  // Instrument file loader.  // Instrument file loader.
201  bool qsamplerChannel::loadInstrument ( const QString& sInstrumentFile, int iInstrumentNr )  bool Channel::loadInstrument ( const QString& sInstrumentFile, int iInstrumentNr )
202  {  {
203          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
204          if (pMainForm == NULL)          if (pMainForm == NULL)
205                  return false;                  return false;
206          if (pMainForm->client() == NULL || m_iChannelID < 0)          if (pMainForm->client() == NULL || m_iChannelID < 0)
207                  return false;                  return false;
208          if (!isInstrumentFile(sInstrumentFile))          if (!QFileInfo(sInstrumentFile).exists())
209                  return false;                  return false;
210          if (m_iInstrumentStatus == 100 && m_sInstrumentFile == sInstrumentFile && m_iInstrumentNr == iInstrumentNr)          if (m_iInstrumentStatus == 100
211                    && m_sInstrumentFile == sInstrumentFile
212                    && m_iInstrumentNr == iInstrumentNr)
213                  return true;                  return true;
214    
215          if (          if (::lscp_load_instrument_non_modal(
                 ::lscp_load_instrument_non_modal(  
216                          pMainForm->client(),                          pMainForm->client(),
217                          qsamplerUtilities::lscpEscapePath(sInstrumentFile).latin1(),                          qsamplerUtilities::lscpEscapePath(
218                                    sInstrumentFile).toUtf8().constData(),
219                          iInstrumentNr, m_iChannelID                          iInstrumentNr, m_iChannelID
220                  ) != LSCP_OK                  ) != LSCP_OK) {
         ) {  
221                  appendMessagesClient("lscp_load_instrument");                  appendMessagesClient("lscp_load_instrument");
222                  return false;                  return false;
223          }          }
# Line 223  bool qsamplerChannel::loadInstrument ( c Line 230  bool qsamplerChannel::loadInstrument ( c
230    
231    
232  // Special instrument file/name/number settler.  // Special instrument file/name/number settler.
233  bool qsamplerChannel::setInstrument ( const QString& sInstrumentFile, int iInstrumentNr )  bool Channel::setInstrument ( const QString& sInstrumentFile, int iInstrumentNr )
234  {  {
235          m_sInstrumentFile = sInstrumentFile;          m_sInstrumentFile = sInstrumentFile;
236          m_iInstrumentNr = iInstrumentNr;          m_iInstrumentNr = iInstrumentNr;
# Line 239  bool qsamplerChannel::setInstrument ( co Line 246  bool qsamplerChannel::setInstrument ( co
246    
247    
248  // MIDI driver type accessors (DEPRECATED).  // MIDI driver type accessors (DEPRECATED).
249  const QString& qsamplerChannel::midiDriver (void) const  const QString& Channel::midiDriver (void) const
250  {  {
251          return m_sMidiDriver;          return m_sMidiDriver;
252  }  }
253    
254  bool qsamplerChannel::setMidiDriver ( const QString& sMidiDriver )  bool Channel::setMidiDriver ( const QString& sMidiDriver )
255  {  {
256          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
257          if (pMainForm == NULL)          if (pMainForm == NULL)
# Line 254  bool qsamplerChannel::setMidiDriver ( co Line 261  bool qsamplerChannel::setMidiDriver ( co
261          if (m_iInstrumentStatus == 100 && m_sMidiDriver == sMidiDriver)          if (m_iInstrumentStatus == 100 && m_sMidiDriver == sMidiDriver)
262                  return true;                  return true;
263    
264          if (::lscp_set_channel_midi_type(pMainForm->client(), m_iChannelID, sMidiDriver.latin1()) != LSCP_OK) {          if (::lscp_set_channel_midi_type(pMainForm->client(),
265                            m_iChannelID, sMidiDriver.toUtf8().constData()) != LSCP_OK) {
266                  appendMessagesClient("lscp_set_channel_midi_type");                  appendMessagesClient("lscp_set_channel_midi_type");
267                  return false;                  return false;
268          }          }
# Line 267  bool qsamplerChannel::setMidiDriver ( co Line 275  bool qsamplerChannel::setMidiDriver ( co
275    
276    
277  // MIDI device accessors.  // MIDI device accessors.
278  int qsamplerChannel::midiDevice (void) const  int Channel::midiDevice (void) const
279  {  {
280          return m_iMidiDevice;          return m_iMidiDevice;
281  }  }
282    
283  bool qsamplerChannel::setMidiDevice ( int iMidiDevice )  bool Channel::setMidiDevice ( int iMidiDevice )
284  {  {
285          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
286          if (pMainForm == NULL)          if (pMainForm == NULL)
# Line 295  bool qsamplerChannel::setMidiDevice ( in Line 303  bool qsamplerChannel::setMidiDevice ( in
303    
304    
305  // MIDI port number accessor.  // MIDI port number accessor.
306  int qsamplerChannel::midiPort (void) const  int Channel::midiPort (void) const
307  {  {
308          return m_iMidiPort;          return m_iMidiPort;
309  }  }
310    
311  bool qsamplerChannel::setMidiPort ( int iMidiPort )  bool Channel::setMidiPort ( int iMidiPort )
312  {  {
313          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
314          if (pMainForm == NULL)          if (pMainForm == NULL)
# Line 323  bool qsamplerChannel::setMidiPort ( int Line 331  bool qsamplerChannel::setMidiPort ( int
331    
332    
333  // MIDI channel accessor.  // MIDI channel accessor.
334  int qsamplerChannel::midiChannel (void) const  int Channel::midiChannel (void) const
335  {  {
336          return m_iMidiChannel;          return m_iMidiChannel;
337  }  }
338    
339  bool qsamplerChannel::setMidiChannel ( int iMidiChannel )  bool Channel::setMidiChannel ( int iMidiChannel )
340  {  {
341          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
342          if (pMainForm == NULL)          if (pMainForm == NULL)
# Line 351  bool qsamplerChannel::setMidiChannel ( i Line 359  bool qsamplerChannel::setMidiChannel ( i
359    
360    
361  // MIDI instrument map accessor.  // MIDI instrument map accessor.
362  int qsamplerChannel::midiMap (void) const  int Channel::midiMap (void) const
363  {  {
364          return m_iMidiMap;          return m_iMidiMap;
365  }  }
366    
367  bool qsamplerChannel::setMidiMap ( int iMidiMap )  bool Channel::setMidiMap ( int iMidiMap )
368  {  {
369          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
370          if (pMainForm == NULL)          if (pMainForm == NULL)
# Line 379  bool qsamplerChannel::setMidiMap ( int i Line 387  bool qsamplerChannel::setMidiMap ( int i
387    
388    
389  // Audio device accessor.  // Audio device accessor.
390  int qsamplerChannel::audioDevice (void) const  int Channel::audioDevice (void) const
391  {  {
392          return m_iAudioDevice;          return m_iAudioDevice;
393  }  }
394    
395  bool qsamplerChannel::setAudioDevice ( int iAudioDevice )  bool Channel::setAudioDevice ( int iAudioDevice )
396  {  {
397          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
398          if (pMainForm == NULL)          if (pMainForm == NULL)
# Line 407  bool qsamplerChannel::setAudioDevice ( i Line 415  bool qsamplerChannel::setAudioDevice ( i
415    
416    
417  // Audio driver type accessors (DEPRECATED).  // Audio driver type accessors (DEPRECATED).
418  const QString& qsamplerChannel::audioDriver (void) const  const QString& Channel::audioDriver (void) const
419  {  {
420          return m_sAudioDriver;          return m_sAudioDriver;
421  }  }
422    
423  bool qsamplerChannel::setAudioDriver ( const QString& sAudioDriver )  bool Channel::setAudioDriver ( const QString& sAudioDriver )
424  {  {
425          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
426          if (pMainForm == NULL)          if (pMainForm == NULL)
# Line 422  bool qsamplerChannel::setAudioDriver ( c Line 430  bool qsamplerChannel::setAudioDriver ( c
430          if (m_iInstrumentStatus == 100 && m_sAudioDriver == sAudioDriver)          if (m_iInstrumentStatus == 100 && m_sAudioDriver == sAudioDriver)
431                  return true;                  return true;
432    
433          if (::lscp_set_channel_audio_type(pMainForm->client(), m_iChannelID, sAudioDriver.latin1()) != LSCP_OK) {          if (::lscp_set_channel_audio_type(pMainForm->client(),
434                            m_iChannelID, sAudioDriver.toUtf8().constData()) != LSCP_OK) {
435                  appendMessagesClient("lscp_set_channel_audio_type");                  appendMessagesClient("lscp_set_channel_audio_type");
436                  return false;                  return false;
437          }          }
# Line 435  bool qsamplerChannel::setAudioDriver ( c Line 444  bool qsamplerChannel::setAudioDriver ( c
444    
445    
446  // Channel volume accessors.  // Channel volume accessors.
447  float qsamplerChannel::volume (void) const  float Channel::volume (void) const
448  {  {
449          return m_fVolume;          return m_fVolume;
450  }  }
451    
452  bool qsamplerChannel::setVolume ( float fVolume )  bool Channel::setVolume ( float fVolume )
453  {  {
454          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
455          if (pMainForm == NULL)          if (pMainForm == NULL)
# Line 463  bool qsamplerChannel::setVolume ( float Line 472  bool qsamplerChannel::setVolume ( float
472    
473    
474  // Sampler channel mute state.  // Sampler channel mute state.
475  bool qsamplerChannel::channelMute (void) const  bool Channel::channelMute (void) const
476  {  {
477          return m_bMute;          return m_bMute;
478  }  }
479    
480  bool qsamplerChannel::setChannelMute ( bool bMute )  bool Channel::setChannelMute ( bool bMute )
481  {  {
482          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
483          if (pMainForm == NULL)          if (pMainForm == NULL)
# Line 493  bool qsamplerChannel::setChannelMute ( b Line 502  bool qsamplerChannel::setChannelMute ( b
502    
503    
504  // Sampler channel solo state.  // Sampler channel solo state.
505  bool qsamplerChannel::channelSolo (void) const  bool Channel::channelSolo (void) const
506  {  {
507          return m_bSolo;          return m_bSolo;
508  }  }
509    
510  bool qsamplerChannel::setChannelSolo ( bool bSolo )  bool Channel::setChannelSolo ( bool bSolo )
511  {  {
512          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
513          if (pMainForm == NULL)          if (pMainForm == NULL)
# Line 523  bool qsamplerChannel::setChannelSolo ( b Line 532  bool qsamplerChannel::setChannelSolo ( b
532    
533    
534  // Audio routing accessors.  // Audio routing accessors.
535  int qsamplerChannel::audioChannel ( int iAudioOut ) const  int Channel::audioChannel ( int iAudioOut ) const
536  {  {
537          return m_audioRouting[iAudioOut];          return m_audioRouting[iAudioOut];
538  }  }
539    
540  bool qsamplerChannel::setAudioChannel ( int iAudioOut, int iAudioIn )  bool Channel::setAudioChannel ( int iAudioOut, int iAudioIn )
541  {  {
542          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
543          if (pMainForm == NULL)          if (pMainForm == NULL)
# Line 553  bool qsamplerChannel::setAudioChannel ( Line 562  bool qsamplerChannel::setAudioChannel (
562  }  }
563    
564  // The audio routing map itself.  // The audio routing map itself.
565  const qsamplerChannelRoutingMap& qsamplerChannel::audioRouting (void) const  const ChannelRoutingMap& Channel::audioRouting (void) const
566  {  {
567          return m_audioRouting;          return m_audioRouting;
568  }  }
569    
570    
571  // Istrument name remapper.  // Istrument name remapper.
572  void qsamplerChannel::updateInstrumentName (void)  void Channel::updateInstrumentName (void)
573  {  {
574  #ifndef CONFIG_INSTRUMENT_NAME  #ifndef CONFIG_INSTRUMENT_NAME
575          m_sInstrumentName = getInstrumentName(m_sInstrumentFile,          m_sInstrumentName = getInstrumentName(m_sInstrumentFile,
# Line 570  void qsamplerChannel::updateInstrumentNa Line 579  void qsamplerChannel::updateInstrumentNa
579    
580    
581  // Update whole channel info state.  // Update whole channel info state.
582  bool qsamplerChannel::updateChannelInfo (void)  bool Channel::updateChannelInfo (void)
583  {  {
584          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
585          if (pMainForm == NULL)          if (pMainForm == NULL)
# Line 664  bool qsamplerChannel::updateChannelInfo Line 673  bool qsamplerChannel::updateChannelInfo
673    
674    
675  // Reset channel method.  // Reset channel method.
676  bool qsamplerChannel::channelReset (void)  bool Channel::channelReset (void)
677  {  {
678          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
679          if (pMainForm == NULL)          if (pMainForm == NULL)
# Line 684  bool qsamplerChannel::channelReset (void Line 693  bool qsamplerChannel::channelReset (void
693    
694    
695  // Spawn instrument editor method.  // Spawn instrument editor method.
696  bool qsamplerChannel::editChannel (void)  bool Channel::editChannel (void)
697  {  {
698  #ifdef CONFIG_EDIT_INSTRUMENT  #ifdef CONFIG_EDIT_INSTRUMENT
699    
# Line 699  bool qsamplerChannel::editChannel (void) Line 708  bool qsamplerChannel::editChannel (void)
708                  appendMessagesClient("lscp_edit_channel_instrument");                  appendMessagesClient("lscp_edit_channel_instrument");
709                  appendMessagesError(QObject::tr(                  appendMessagesError(QObject::tr(
710                          "Could not launch an appropriate instrument editor "                          "Could not launch an appropriate instrument editor "
711                          "for the given instrument!\n"                          "for the given instrument!\n\n"
712                          "Make sure you have an appropriate "                          "Make sure you have an appropriate "
713                          "instrument editor like 'gigedit' installed\n"                          "instrument editor like 'gigedit' installed "
714                          "and that it placed its mandatory DLL file "                          "and that it placed its mandatory DLL file "
715                          "into the sampler's plugin directory.")                          "into the sampler's plugin directory.")
716                  );                  );
# Line 716  bool qsamplerChannel::editChannel (void) Line 725  bool qsamplerChannel::editChannel (void)
725    
726          appendMessagesError(QObject::tr(          appendMessagesError(QObject::tr(
727                  "Sorry, QSampler was compiled for a version of liblscp "                  "Sorry, QSampler was compiled for a version of liblscp "
728                  "which lacks this feature.\n"                  "which lacks this feature.\n\n"
729                  "You may want to update liblscp and recompile QSampler afterwards.")                  "You may want to update liblscp and recompile QSampler afterwards.")
730          );          );
731    
# Line 727  bool qsamplerChannel::editChannel (void) Line 736  bool qsamplerChannel::editChannel (void)
736    
737    
738  // Channel setup dialog form.  // Channel setup dialog form.
739  bool qsamplerChannel::channelSetup ( QWidget *pParent )  bool Channel::channelSetup ( QWidget *pParent )
740  {  {
741          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
742          if (pMainForm == NULL)          if (pMainForm == NULL)
# Line 749  bool qsamplerChannel::channelSetup ( QWi Line 758  bool qsamplerChannel::channelSetup ( QWi
758    
759    
760  // Redirected messages output methods.  // Redirected messages output methods.
761  void qsamplerChannel::appendMessages( const QString& s ) const  void Channel::appendMessages( const QString& s ) const
762  {  {
763          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
764          if (pMainForm)          if (pMainForm)
765                  pMainForm->appendMessages(channelName() + ' ' + s);                  pMainForm->appendMessages(channelName() + ' ' + s);
766  }  }
767    
768  void qsamplerChannel::appendMessagesColor( const QString& s,  void Channel::appendMessagesColor( const QString& s,
769          const QString& c ) const          const QString& c ) const
770  {  {
771          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
# Line 764  void qsamplerChannel::appendMessagesColo Line 773  void qsamplerChannel::appendMessagesColo
773                  pMainForm->appendMessagesColor(channelName() + ' ' + s, c);                  pMainForm->appendMessagesColor(channelName() + ' ' + s, c);
774  }  }
775    
776  void qsamplerChannel::appendMessagesText( const QString& s ) const  void Channel::appendMessagesText( const QString& s ) const
777  {  {
778          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
779          if (pMainForm)          if (pMainForm)
780                  pMainForm->appendMessagesText(channelName() + ' ' + s);                  pMainForm->appendMessagesText(channelName() + ' ' + s);
781  }  }
782    
783  void qsamplerChannel::appendMessagesError( const QString& s ) const  void Channel::appendMessagesError( const QString& s ) const
784  {  {
785          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
786          if (pMainForm)          if (pMainForm)
787                  pMainForm->appendMessagesError(channelName() + "\n\n" + s);                  pMainForm->appendMessagesError(channelName() + "\n\n" + s);
788  }  }
789    
790  void qsamplerChannel::appendMessagesClient( const QString& s ) const  void Channel::appendMessagesClient( const QString& s ) const
791  {  {
792          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
793          if (pMainForm)          if (pMainForm)
# Line 787  void qsamplerChannel::appendMessagesClie Line 796  void qsamplerChannel::appendMessagesClie
796    
797    
798  // Context menu event handler.  // Context menu event handler.
799  void qsamplerChannel::contextMenuEvent( QContextMenuEvent *pEvent )  void Channel::contextMenuEvent( QContextMenuEvent *pEvent )
800  {  {
801          MainForm *pMainForm = MainForm::getInstance();          MainForm *pMainForm = MainForm::getInstance();
802          if (pMainForm)          if (pMainForm)
# Line 795  void qsamplerChannel::contextMenuEvent( Line 804  void qsamplerChannel::contextMenuEvent(
804  }  }
805    
806    
807  // FIXME: Check whether a given file is an instrument file.  // FIXME: Check whether a given file is an instrument file (DLS only).
808  bool qsamplerChannel::isInstrumentFile ( const QString& sInstrumentFile )  bool Channel::isDlsInstrumentFile ( const QString& sInstrumentFile )
809  {  {
810          bool bResult = false;          bool bResult = false;
811    
812          QFile file(sInstrumentFile);          QFile file(sInstrumentFile);
813          if (file.open(IO_ReadOnly)) {          if (file.open(QIODevice::ReadOnly)) {
814                  char achHeader[16];                  char achHeader[16];
815                  if (file.readBlock(achHeader, 16)) {                  if (file.read(achHeader, 16) > 0) {
816                          bResult = (::memcmp(&achHeader[0], "RIFF", 4)     == 0                          bResult = (::memcmp(&achHeader[0], "RIFF", 4)     == 0
817                                          && ::memcmp(&achHeader[8], "DLS LIST", 8) == 0);                                          && ::memcmp(&achHeader[8], "DLS LIST", 8) == 0);
818                  }                  }
# Line 814  bool qsamplerChannel::isInstrumentFile ( Line 823  bool qsamplerChannel::isInstrumentFile (
823  }  }
824    
825    
826    // FIXME: Check whether a given file is an instrument file (SF2 only).
827    bool Channel::isSf2InstrumentFile ( const QString& sInstrumentFile )
828    {
829            bool bResult = false;
830    
831            QFile file(sInstrumentFile);
832            if (file.open(QIODevice::ReadOnly)) {
833                    char achHeader[8];
834                    if (file.read(achHeader, 8) > 0) {
835                            bResult = (::memcmp(&achHeader[0], "RIFF", 4) == 0
836                                            && ::memcmp(&achHeader[4], "sfbk", 4) == 0);
837                    }
838                    file.close();
839            }
840    
841            return bResult;
842    }
843    
844    
845  // Retrieve the instrument list of a instrument file (.gig).  // Retrieve the instrument list of a instrument file (.gig).
846  QStringList qsamplerChannel::getInstrumentList( const QString& sInstrumentFile,  QStringList Channel::getInstrumentList(
847          bool bInstrumentNames )          const QString& sInstrumentFile, bool bInstrumentNames )
848  {  {
         QString sInstrumentName = QFileInfo(sInstrumentFile).fileName();  
849          QStringList instlist;          QStringList instlist;
850    
851          if (isInstrumentFile(sInstrumentFile)) {          const QFileInfo fi(sInstrumentFile);
852            if (!fi.exists()) {
853                    instlist.append(noInstrumentName());
854                    return instlist;
855            }
856    
857  #ifdef CONFIG_LIBGIG  #ifdef CONFIG_LIBGIG
858                  if (bInstrumentNames) {          if (bInstrumentNames) {
859                          RIFF::File *pRiff = new RIFF::File(sInstrumentFile.latin1());                  if (isDlsInstrumentFile(sInstrumentFile)) {
860                            RIFF::File *pRiff
861                                    = new RIFF::File(sInstrumentFile.toUtf8().constData());
862                          gig::File  *pGig  = new gig::File(pRiff);                          gig::File  *pGig  = new gig::File(pRiff);
863                    #if HAVE_LIBGIG_SETAUTOLOAD
864                            // prevent sleepy response time on large .gig files
865                            pGig->SetAutoLoad(false);
866                    #endif
867                          gig::Instrument *pInstrument = pGig->GetFirstInstrument();                          gig::Instrument *pInstrument = pGig->GetFirstInstrument();
868                          while (pInstrument) {                          while (pInstrument) {
869                                  instlist.append((pInstrument->pInfo)->Name.c_str());                                  instlist.append((pInstrument->pInfo)->Name.c_str());
# Line 835  QStringList qsamplerChannel::getInstrume Line 873  QStringList qsamplerChannel::getInstrume
873                          delete pRiff;                          delete pRiff;
874                  }                  }
875                  else                  else
876                    if (isSf2InstrumentFile(sInstrumentFile)) {
877                            RIFF::File *pRiff
878                                    = new RIFF::File(sInstrumentFile.toUtf8().constData());
879                            sf2::File *pSf2 = new sf2::File(pRiff);
880                            const int iPresetCount = pSf2->GetPresetCount();
881                            for (int iIndex = 0; iIndex < iPresetCount; ++iIndex) {
882                                    sf2::Preset *pPreset = pSf2->GetPreset(iIndex);
883                                    if (pPreset) {
884                                            instlist.append(pPreset->Name.c_str());
885                                    } else {
886                                            instlist.append(fi.fileName()
887                                                    + " [" + QString::number(iIndex) + "]");
888                                    }
889                            }
890                            delete pSf2;
891                            delete pRiff;
892                    }
893            }
894  #endif  #endif
895                  for (int iInstrumentNr = 0; iInstrumentNr < QSAMPLER_INSTRUMENT_MAX; iInstrumentNr++)  
896                          instlist.append(sInstrumentName + " [" + QString::number(iInstrumentNr) + "]");          if (instlist.isEmpty()) {
897                    for (int iIndex = 0; iIndex < QSAMPLER_INSTRUMENT_MAX; ++iIndex) {
898                            instlist.append(fi.fileName()
899                                    + " [" + QString::number(iIndex) + "]");
900                    }
901          }          }
         else instlist.append(noInstrumentName());  
902    
903          return instlist;          return instlist;
904  }  }
905    
906    
907  // Retrieve the spacific instrument name of a instrument file (.gig), given its index.  // Retrieve the spacific instrument name of a instrument file (.gig), given its index.
908  QString qsamplerChannel::getInstrumentName( const QString& sInstrumentFile,  QString Channel::getInstrumentName (
909          int iInstrumentNr, bool bInstrumentNames )          const QString& sInstrumentFile, int iInstrumentNr, bool bInstrumentNames )
910  {  {
911            const QFileInfo fi(sInstrumentFile);
912            if (!fi.exists())
913                    return noInstrumentName();
914    
915          QString sInstrumentName;          QString sInstrumentName;
916    
         if (isInstrumentFile(sInstrumentFile)) {  
                 sInstrumentName = QFileInfo(sInstrumentFile).fileName();  
917  #ifdef CONFIG_LIBGIG  #ifdef CONFIG_LIBGIG
918                  if (bInstrumentNames) {          if (bInstrumentNames) {
919                          RIFF::File *pRiff = new RIFF::File(sInstrumentFile.latin1());                  if (isDlsInstrumentFile(sInstrumentFile)) {
920                          gig::File  *pGig  = new gig::File(pRiff);                          RIFF::File *pRiff
921                                    = new RIFF::File(sInstrumentFile.toUtf8().constData());
922                            gig::File *pGig = new gig::File(pRiff);
923                    #if HAVE_LIBGIG_SETAUTOLOAD
924                            // prevent sleepy response time on large .gig files
925                            pGig->SetAutoLoad(false);
926                    #endif
927                          int iIndex = 0;                          int iIndex = 0;
928                          gig::Instrument *pInstrument = pGig->GetFirstInstrument();                          gig::Instrument *pInstrument = pGig->GetFirstInstrument();
929                          while (pInstrument) {                          while (pInstrument) {
# Line 871  QString qsamplerChannel::getInstrumentNa Line 938  QString qsamplerChannel::getInstrumentNa
938                          delete pRiff;                          delete pRiff;
939                  }                  }
940                  else                  else
941                    if (isSf2InstrumentFile(sInstrumentFile)) {
942                            RIFF::File *pRiff
943                                    = new RIFF::File(sInstrumentFile.toUtf8().constData());
944                            sf2::File *pSf2 = new sf2::File(pRiff);
945                            sf2::Preset *pPreset = pSf2->GetPreset(iInstrumentNr);
946                            if (pPreset)
947                                    sInstrumentName = pPreset->Name.c_str();
948                            delete pSf2;
949                            delete pRiff;
950                    }
951            }
952  #endif  #endif
953    
954            if (sInstrumentName.isEmpty()) {
955                    sInstrumentName  = fi.fileName();
956                  sInstrumentName += " [" + QString::number(iInstrumentNr) + "]";                  sInstrumentName += " [" + QString::number(iInstrumentNr) + "]";
957          }          }
         else sInstrumentName = noInstrumentName();  
958    
959          return sInstrumentName;          return sInstrumentName;
960  }  }
961    
962    
963  // Common invalid name-helpers.  // Common invalid name-helpers.
964  QString qsamplerChannel::noEngineName (void)  QString Channel::noEngineName (void)
965  {  {
966          return QObject::tr("(No engine)");          return QObject::tr("(No engine)");
967  }  }
968    
969  QString qsamplerChannel::noInstrumentName (void)  QString Channel::noInstrumentName (void)
970  {  {
971          return QObject::tr("(No instrument)");          return QObject::tr("(No instrument)");
972  }  }
973    
974  QString qsamplerChannel::loadingInstrument (void) {  QString Channel::loadingInstrument (void) {
975          return QObject::tr("(Loading instrument...)");          return QObject::tr("(Loading instrument...)");
976  }  }
977    
978    
   
979  //-------------------------------------------------------------------------  //-------------------------------------------------------------------------
980  // qsamplerChannelRoutingTable - Channel routing table.  // QSampler::ChannelRoutingModel - data model for audio routing
981  //  //                                 (used for QTableView)
 #if 0  
 // Constructor.  
 qsamplerChannelRoutingTable::qsamplerChannelRoutingTable (  
         QWidget *pParent, const char *pszName )  
         : QTable(pParent, pszName)  
 {  
         // Set fixed number of columns.  
         QTable::setNumCols(2);  
         QTable::setShowGrid(false);  
         QTable::setSorting(false);  
         QTable::setFocusStyle(QTable::FollowStyle);  
         QTable::setSelectionMode(QTable::NoSelection);  
         // No vertical header.  
         QTable::verticalHeader()->hide();  
         QTable::setLeftMargin(0);  
         // Initialize the fixed table column headings.  
         QHeader *pHeader = QTable::horizontalHeader();  
         pHeader->setLabel(0, tr("Sampler Channel"));  
         pHeader->setLabel(1, tr("Device Channel"));  
         // Set read-onlyness of each column  
         QTable::setColumnReadOnly(0, true);  
 //      QTable::setColumnReadOnly(1, false); -- of course not.  
         QTable::setColumnStretchable(1, true);  
 }  
982    
983  // Default destructor.  ChannelRoutingModel::ChannelRoutingModel ( QObject *pParent )
984  qsamplerChannelRoutingTable::~qsamplerChannelRoutingTable (void)          : QAbstractTableModel(pParent), m_pDevice(NULL)
985  {  {
986  }  }
987    
988    
989  // Routing map table renderer.  int ChannelRoutingModel::rowCount ( const QModelIndex& /*parent*/) const
 void qsamplerChannelRoutingTable::refresh ( qsamplerDevice *pDevice,  
         const qsamplerChannelRoutingMap& routing )  
990  {  {
991          if (pDevice == NULL)          return (m_pDevice) ? m_routing.size() : 0;
                 return;  
   
         // Always (re)start it empty.  
         QTable::setUpdatesEnabled(false);  
         QTable::setNumRows(0);  
   
         // The common device port item list.  
         QStringList opts;  
         qsamplerDevicePortList& ports = pDevice->ports();  
         qsamplerDevicePort *pPort;  
         for (pPort = ports.first(); pPort; pPort = ports.next()) {  
                 opts.append(pDevice->deviceTypeName()  
                         + ' ' + pDevice->driverName()  
                         + ' ' + pPort->portName());  
         }  
   
         // Those items shall have a proper pixmap...  
         QPixmap pmChannel = QPixmap::fromMimeSource("qsamplerChannel.png");  
         QPixmap pmDevice;  
         switch (pDevice->deviceType()) {  
         case qsamplerDevice::Audio:  
                 pmDevice = QPixmap::fromMimeSource("audio2.png");  
                 break;  
         case qsamplerDevice::Midi:  
                 pmDevice = QPixmap::fromMimeSource("midi2.png");  
                 break;  
         case qsamplerDevice::None:  
                 break;  
         }  
   
         // Fill the routing table...  
         QTable::insertRows(0, routing.count());  
         int iRow = 0;  
         qsamplerChannelRoutingMap::ConstIterator iter;  
         for (iter = routing.begin(); iter != routing.end(); ++iter) {  
                 QTable::setPixmap(iRow, 0, pmChannel);  
                 QTable::setText(iRow, 0, pDevice->deviceTypeName()  
                         + ' ' + QString::number(iter.key()));  
                 qsamplerChannelRoutingComboBox *pComboItem =  
                         new qsamplerChannelRoutingComboBox(this, opts, pmDevice);  
                 pComboItem->setCurrentItem(iter.data());  
                 QTable::setItem(iRow, 1, pComboItem);  
                 ++iRow;  
         }  
   
         // Adjust optimal column widths.  
         QTable::adjustColumn(0);  
         QTable::adjustColumn(1);  
   
         QTable::setUpdatesEnabled(true);  
         QTable::updateContents();  
992  }  }
993    
994    
995  // Commit any pending editing.  int ChannelRoutingModel::columnCount ( const QModelIndex& /*parent*/) const
 void qsamplerChannelRoutingTable::flush (void)  
996  {  {
997          if (QTable::isEditing())          return 1;
             QTable::endEdit(QTable::currEditRow(), QTable::currEditCol(), true, true);  
998  }  }
 #endif  
999    
 ChannelRoutingModel::ChannelRoutingModel(QObject* parent) : QAbstractTableModel(parent), pDevice(NULL) {  
 }  
1000    
1001  int ChannelRoutingModel::rowCount(const QModelIndex& /*parent*/) const {  Qt::ItemFlags ChannelRoutingModel::flags ( const QModelIndex& /*index*/) const
1002      return routing.size();  {
1003  }          return Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsEnabled;
   
 int ChannelRoutingModel::columnCount(const QModelIndex& /*parent*/) const {  
     return 1;  
1004  }  }
1005    
 QVariant ChannelRoutingModel::data(const QModelIndex &index, int role) const {  
     if (!index.isValid())  
         return QVariant();  
     if (role != Qt::DisplayRole)  
         return QVariant();  
1006    
1007      ChannelRoutingItem item;  bool ChannelRoutingModel::setData ( const QModelIndex& index,
1008            const QVariant& value, int /*role*/)
1009      // The common device port item list.  {
1010      qsamplerDevicePortList& ports = pDevice->ports();          if (!index.isValid())
1011      qsamplerDevicePort* pPort;                  return false;
     for (pPort = ports.first(); pPort; pPort = ports.next()) {  
         item.options.append(  
             pDevice->deviceTypeName()  
             + ' ' + pDevice->driverName()  
             + ' ' + pPort->portName()  
         );  
     }  
1012    
1013      item.selection = routing[index.column()];          m_routing[index.row()] = value.toInt();
1014    
1015      return QVariant::fromValue(item);          emit dataChanged(index, index);
1016            return true;
1017  }  }
1018    
 QVariant ChannelRoutingModel::headerData(int section, Qt::Orientation orientation, int role) const {  
     if (role != Qt::DisplayRole) return QVariant();  
   
     if (orientation == Qt::Horizontal)  
         return QObject::tr("Device Channel");  
1019    
1020      if (orientation == Qt::Vertical)  QVariant ChannelRoutingModel::data ( const QModelIndex &index, int role ) const
         return QObject::tr("Sampler Channel Output ") +  
                QString(section);  
   
     return QVariant();  
 }  
   
 void ChannelRoutingModel::refresh ( qsamplerDevice *pDevice,  
         const qsamplerChannelRoutingMap& routing )  
1021  {  {
1022      this->pDevice = pDevice;          if (!index.isValid())
1023      this->routing = routing;                  return QVariant();
1024  }          if (role != Qt::DisplayRole)
1025                    return QVariant();
1026            if (index.column() != 0)
1027                    return QVariant();
1028    
1029            ChannelRoutingItem item;
1030    
1031            // The common device port item list.
1032            DevicePortList& ports = m_pDevice->ports();
1033            QListIterator<DevicePort *> iter(ports);
1034            while (iter.hasNext()) {
1035                    DevicePort *pPort = iter.next();
1036                    item.options.append(
1037                            m_pDevice->deviceTypeName()
1038                            + ' ' + m_pDevice->driverName()
1039                            + ' ' + pPort->portName()
1040                    );
1041            }
1042    
1043            item.selection = m_routing[index.row()];
1044    
1045  ChannelRoutingDelegate::ChannelRoutingDelegate(QObject *parent) : QItemDelegate(parent) {          return QVariant::fromValue(item);
1046  }  }
1047    
 QWidget* ChannelRoutingDelegate::createEditor(QWidget *parent,  
         const QStyleOptionViewItem &/* option */,  
         const QModelIndex& index) const  
 {  
     ChannelRoutingItem item = index.model()->data(index, Qt::DisplayRole).value<ChannelRoutingItem>();  
1048    
1049      QComboBox* editor = new QComboBox(parent);  QVariant ChannelRoutingModel::headerData ( int section,
1050      editor->addItems(item.options);          Qt::Orientation orientation, int role) const
1051      editor->setCurrentIndex(item.selection);  {
1052      editor->installEventFilter(const_cast<ChannelRoutingDelegate*>(this));          if (role != Qt::DisplayRole)
1053      return editor;                  return QVariant();
 }  
1054    
1055  void ChannelRoutingDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const {          switch (orientation) {
1056      ChannelRoutingItem item = index.model()->data(index, Qt::DisplayRole).value<ChannelRoutingItem>();                  case Qt::Horizontal:
1057      QComboBox* comboBox = static_cast<QComboBox*>(editor);                          return UNICODE_RIGHT_ARROW + QObject::tr(" Device Channel");
1058      comboBox->setCurrentIndex(item.selection);                  case Qt::Vertical:
1059                            return QObject::tr("Audio Channel ") +
1060                                    QString::number(section) + " " + UNICODE_RIGHT_ARROW;
1061                    default:
1062                            return QVariant();
1063            }
1064  }  }
1065    
 void ChannelRoutingDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const {  
     QComboBox* comboBox = static_cast<QComboBox*>(editor);  
     model->setData(index, comboBox->currentIndex());  
 }  
1066    
1067  void ChannelRoutingDelegate::updateEditorGeometry(QWidget *editor,  void ChannelRoutingModel::refresh ( Device *pDevice,
1068          const QStyleOptionViewItem &option, const QModelIndex &/* index */) const          const ChannelRoutingMap& routing )
1069  {  {
1070      editor->setGeometry(option.rect);          m_pDevice = pDevice;
1071            m_routing = routing;
1072            // inform the outer world (QTableView) that our data changed
1073    #if QT_VERSION < 0x050000
1074            QAbstractTableModel::reset();
1075    #else
1076            QAbstractTableModel::beginResetModel();
1077            QAbstractTableModel::endResetModel();
1078    #endif
1079  }  }
1080    
1081    
   
1082  //-------------------------------------------------------------------------  //-------------------------------------------------------------------------
1083  // qsamplerChannelRoutingComboBox - Custom combo box for routing table.  // QSampler::ChannelRoutingDelegate - table cell renderer for audio routing
1084  //  //
1085    
1086  #if 0  ChannelRoutingDelegate::ChannelRoutingDelegate ( QObject *pParent )
1087  // Constructor.          : QItemDelegate(pParent)
 qsamplerChannelRoutingComboBox::qsamplerChannelRoutingComboBox (  
         QTable *pTable, const QStringList& list, const QPixmap& pixmap )  
         : QTableItem(pTable, QTableItem::WhenCurrent, QString::null, pixmap),  
         m_list(list)  
1088  {  {
         m_iCurrentItem = 0;  
1089  }  }
1090    
1091  // Public accessors.  
1092  void qsamplerChannelRoutingComboBox::setCurrentItem ( int iCurrentItem )  QWidget* ChannelRoutingDelegate::createEditor ( QWidget *pParent,
1093            const QStyleOptionViewItem & option, const QModelIndex& index ) const
1094  {  {
1095          m_iCurrentItem = iCurrentItem;          if (!index.isValid())
1096                    return NULL;
1097    
1098            if (index.column() != 0)
1099                    return NULL;
1100    
1101          QTableItem::setText(m_list[iCurrentItem]);          ChannelRoutingItem item = index.model()->data(index, Qt::DisplayRole).value<ChannelRoutingItem>();
1102    
1103            QComboBox* pComboBox = new QComboBox(pParent);
1104            pComboBox->addItems(item.options);
1105            pComboBox->setCurrentIndex(item.selection);
1106            pComboBox->setEnabled(true);
1107            pComboBox->setGeometry(option.rect);
1108            return pComboBox;
1109  }  }
1110    
1111  int qsamplerChannelRoutingComboBox::currentItem (void) const  
1112    void ChannelRoutingDelegate::setEditorData ( QWidget *pEditor,
1113            const QModelIndex &index) const
1114  {  {
1115          return m_iCurrentItem;          ChannelRoutingItem item = index.model()->data(index,
1116                    Qt::DisplayRole).value<ChannelRoutingItem> ();
1117            QComboBox* pComboBox = static_cast<QComboBox*> (pEditor);
1118            pComboBox->setCurrentIndex(item.selection);
1119  }  }
1120    
1121  // Virtual implemetations.  
1122  QWidget *qsamplerChannelRoutingComboBox::createEditor (void) const  void ChannelRoutingDelegate::setModelData ( QWidget* pEditor,
1123            QAbstractItemModel *pModel, const QModelIndex& index ) const
1124  {  {
1125          QComboBox *pComboBox = new QComboBox(QTableItem::table()->viewport());          QComboBox *pComboBox = static_cast<QComboBox*> (pEditor);
1126          QObject::connect(pComboBox, SIGNAL(activated(int)),          pModel->setData(index, pComboBox->currentIndex());
                 QTableItem::table(), SLOT(doValueChanged()));  
         for (QStringList::ConstIterator iter = m_list.begin();  
                         iter != m_list.end(); iter++) {  
                 pComboBox->insertItem(QTableItem::pixmap(), *iter);  
         }  
         pComboBox->setCurrentItem(m_iCurrentItem);  
         return pComboBox;  
1127  }  }
1128    
1129  void qsamplerChannelRoutingComboBox::setContentFromEditor ( QWidget *pWidget )  
1130    void ChannelRoutingDelegate::updateEditorGeometry ( QWidget *pEditor,
1131            const QStyleOptionViewItem& option, const QModelIndex &/* index */) const
1132  {  {
1133          if (pWidget->inherits("QComboBox")) {          pEditor->setGeometry(option.rect);
                 QComboBox *pComboBox = (QComboBox *) pWidget;  
                 m_iCurrentItem = pComboBox->currentItem();  
                 QTableItem::setText(pComboBox->currentText());  
         }  
         else QTableItem::setContentFromEditor(pWidget);  
1134  }  }
1135    
1136  #endif  } // namespace QSampler
1137    
1138    
1139    // end of qsamplerChannel.cpp
Legend:
Removed from v.1461  
changed lines
  Added in v.2563
  ViewVC Help
Powered by ViewVC