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