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