trunk/src/qsamplerChannelStrip.cpp

#include "qsamplerChannelStrip.h"

#include "qsamplerMainForm.h"

#include <q3dragobject.h>

#include <QUrl>

#include <math.h>

// Channel status/usage usage limit control.
#define QSAMPLER_ERROR_LIMIT    3

namespace QSampler {

ChannelStrip::ChannelStrip(QWidget* parent, Qt::WFlags f) : QWidget(parent, f) {
    ui.setupUi(this);

    // Initialize locals.
    m_pChannel     = NULL;
    m_iDirtyChange = 0;
    m_iErrorCount  = 0;

    // Try to restore normal window positioning.
    adjustSize();
}

ChannelStrip::~ChannelStrip() {
    // Destroy existing channel descriptor.
    if (m_pChannel)
        delete m_pChannel;
    m_pChannel = NULL;
}


// Drag'n'drop file handler.
bool ChannelStrip::decodeDragFile ( const QMimeSource *pEvent, QString& sInstrumentFile )
{
        if (m_pChannel == NULL)
                return false;
        if (Q3TextDrag::canDecode(pEvent)) {
                QString sText;
                if (Q3TextDrag::decode(pEvent, sText)) {
                        QStringList files = QStringList::split('\n', sText);
                        for (QStringList::Iterator iter = files.begin(); iter != files.end(); iter++) {
                                *iter = QUrl((*iter).stripWhiteSpace().replace(QRegExp("^file:"), QString::null)).path();
                                if (qsamplerChannel::isInstrumentFile(*iter)) {
                                        sInstrumentFile = *iter;
                                        return true;
                                }
                        }
                }
        }
        // Fail.
        return false;
}


// Window drag-n-drop event handlers.
void ChannelStrip::dragEnterEvent ( QDragEnterEvent* pDragEnterEvent )
{
        QString sInstrumentFile;
        pDragEnterEvent->accept(decodeDragFile(pDragEnterEvent, sInstrumentFile));
}


void ChannelStrip::dropEvent ( QDropEvent* pDropEvent )
{
        QString sInstrumentFile;

        if (decodeDragFile(pDropEvent, sInstrumentFile)) {
                // Go and set the dropped instrument filename...
                m_pChannel->setInstrument(sInstrumentFile, 0);
                // Open up the channel dialog.
                channelSetup();
        }
}


// Channel strip setup formal initializer.
void ChannelStrip::setup ( qsamplerChannel *pChannel )
{
    // Destroy any previous channel descriptor;
    // (remember that once setup we own it!)
    if (m_pChannel)
        delete m_pChannel;

    // Set the new one...
    m_pChannel = pChannel;

    // Stabilize this around.
    updateChannelInfo();

        // We'll accept drops from now on...
        if (m_pChannel)
                setAcceptDrops(true);
}

// Channel secriptor accessor.
qsamplerChannel *ChannelStrip::channel (void)
{
    return m_pChannel;
}


// Messages view font accessors.
QFont ChannelStrip::displayFont (void)
{
    return ui.EngineNameTextLabel->font();
}

void ChannelStrip::setDisplayFont ( const QFont & font )
{
    ui.EngineNameTextLabel->setFont(font);
    ui.MidiPortChannelTextLabel->setFont(font);
    ui.InstrumentNameTextLabel->setFont(font);
    ui.InstrumentStatusTextLabel->setFont(font);
}


// Channel display background effect.
void ChannelStrip::setDisplayEffect ( bool bDisplayEffect )
{
    QPixmap pm =
        (bDisplayEffect) ?
            QPixmap(":/qsampler/pixmaps/displaybg1.png") : QPixmap();
    setDisplayBackground(pm);
}


// Update main display background pixmap.
void ChannelStrip::setDisplayBackground ( const QPixmap& pm )
{
    // Set the main origin...
    ui.ChannelInfoFrame->setPaletteBackgroundPixmap(pm);

    // Iterate for every child text label...
    QList<QObject*> list = ui.ChannelInfoFrame->queryList("QLabel");
    for (QList<QObject*>::iterator iter = list.begin(); iter != list.end(); iter++) {
        static_cast<QLabel*>(*iter)->setPaletteBackgroundPixmap(pm);
    }

    // And this standalone too.
    ui.StreamVoiceCountTextLabel->setPaletteBackgroundPixmap(pm);
}


// Maximum volume slider accessors.
void ChannelStrip::setMaxVolume ( int iMaxVolume )
{
    m_iDirtyChange++;
    ui.VolumeSlider->setRange(0, iMaxVolume);
    ui.VolumeSpinBox->setRange(0, iMaxVolume);
    m_iDirtyChange--;
}


// Channel setup dialog slot.
bool ChannelStrip::channelSetup (void)
{
        if (m_pChannel == NULL)
                return false;

        // Invoke the channel setup dialog.
        bool bResult = m_pChannel->channelSetup(this);
        // Notify that this channel has changed.
        if (bResult)
                emit channelChanged(this);

        return bResult;
}


// Channel mute slot.
bool ChannelStrip::channelMute ( bool bMute )
{
        if (m_pChannel == NULL)
                return false;

        // Invoke the channel mute method.
        bool bResult = m_pChannel->setChannelMute(bMute);
        // Notify that this channel has changed.
        if (bResult)
                emit channelChanged(this);

        return bResult;
}


// Channel solo slot.
bool ChannelStrip::channelSolo ( bool bSolo )
{
        if (m_pChannel == NULL)
                return false;

        // Invoke the channel solo method.
        bool bResult = m_pChannel->setChannelSolo(bSolo);
        // Notify that this channel has changed.
        if (bResult)
                emit channelChanged(this);

        return bResult;
}


// Channel edit slot.
void ChannelStrip::channelEdit (void)
{
        if (m_pChannel == NULL)
                return;

        m_pChannel->editChannel();
}


// Channel reset slot.
bool ChannelStrip::channelReset (void)
{
        if (m_pChannel == NULL)
                return false;

        // Invoke the channel reset method.
        bool bResult = m_pChannel->channelReset();
        // Notify that this channel has changed.
        if (bResult)
                emit channelChanged(this);

        return bResult;
}


// Update the channel instrument name.
bool ChannelStrip::updateInstrumentName ( bool bForce )
{
        if (m_pChannel == NULL)
                return false;

        // Do we refresh the actual name?
        if (bForce)
                m_pChannel->updateInstrumentName();

        // Instrument name...
        if (m_pChannel->instrumentName().isEmpty()) {
                if (m_pChannel->instrumentStatus() >= 0)
                        ui.InstrumentNameTextLabel->setText(' ' + qsamplerChannel::loadingInstrument());
                else
                        ui.InstrumentNameTextLabel->setText(' ' + qsamplerChannel::noInstrumentName());
        } else
                ui.InstrumentNameTextLabel->setText(' ' + m_pChannel->instrumentName());

        return true;
}


// Do the dirty volume change.
bool ChannelStrip::updateChannelVolume (void)
{
    if (m_pChannel == NULL)
        return false;

    // Convert...
#ifdef CONFIG_ROUND
    int iVolume = (int) ::round(100.0 * m_pChannel->volume());
#else
    double fIPart = 0.0;
    double fFPart = ::modf(100.0 * m_pChannel->volume(), &fIPart);
    int iVolume = (int) fIPart;
    if (fFPart >= +0.5)
        iVolume++;
    else
    if (fFPart <= -0.5)
        iVolume--;
#endif

    // And clip...
    if (iVolume < 0)
        iVolume = 0;

    // Flag it here, to avoid infinite recursion.
    m_iDirtyChange++;
    ui.VolumeSlider->setValue(iVolume);
    ui.VolumeSpinBox->setValue(iVolume);
    m_iDirtyChange--;

    return true;
}


// Update whole channel info state.
bool ChannelStrip::updateChannelInfo (void)
{
    if (m_pChannel == NULL)
        return false;

        // Check for error limit/recycle...
        if (m_iErrorCount > QSAMPLER_ERROR_LIMIT)
                return true;

    // Update strip caption.
    QString sText = m_pChannel->channelName();
    setCaption(sText);
    ui.ChannelSetupPushButton->setText(sText);

    // Check if we're up and connected.
        MainForm* pMainForm = MainForm::getInstance();
        if (pMainForm->client() == NULL)
                return false;

    // Read actual channel information.
    m_pChannel->updateChannelInfo();

    // Engine name...
    if (m_pChannel->engineName().isEmpty())
        ui.EngineNameTextLabel->setText(' ' + qsamplerChannel::noEngineName());
    else
        ui.EngineNameTextLabel->setText(' ' + m_pChannel->engineName());

        // Instrument name...
        updateInstrumentName(false);

    // MIDI Port/Channel...
        QString sMidiPortChannel = QString::number(m_pChannel->midiPort()) + " / ";
        if (m_pChannel->midiChannel() == LSCP_MIDI_CHANNEL_ALL)
                sMidiPortChannel += tr("All");
        else
                sMidiPortChannel += QString::number(m_pChannel->midiChannel() + 1);
        ui.MidiPortChannelTextLabel->setText(sMidiPortChannel);

    // Instrument status...
    int iInstrumentStatus = m_pChannel->instrumentStatus();
    if (iInstrumentStatus < 0) {
        ui.InstrumentStatusTextLabel->setPaletteForegroundColor(Qt::red);
        ui.InstrumentStatusTextLabel->setText(tr("ERR%1").arg(iInstrumentStatus));
        m_iErrorCount++;
        return false;
    }
    // All seems normal...
    ui.InstrumentStatusTextLabel->setPaletteForegroundColor(iInstrumentStatus < 100 ? Qt::yellow : Qt::green);
    ui.InstrumentStatusTextLabel->setText(QString::number(iInstrumentStatus) + '%');
    m_iErrorCount = 0;

#ifdef CONFIG_MUTE_SOLO
    // Mute/Solo button state coloring...
    const QColor& rgbNormal = ChannelSetupPushButton->paletteBackgroundColor();
    bool bMute = m_pChannel->channelMute();
    ChannelMutePushButton->setPaletteBackgroundColor(bMute ? Qt::yellow : rgbNormal);
    ChannelMutePushButton->setDown(bMute);
    bool bSolo = m_pChannel->channelSolo();
    ChannelSoloPushButton->setPaletteBackgroundColor(bSolo ? Qt::cyan : rgbNormal);
    ChannelSoloPushButton->setDown(bSolo);
#else
        ui.ChannelMutePushButton->setEnabled(false);
        ui.ChannelSoloPushButton->setEnabled(false);
#endif

    // And update the both GUI volume elements;
    // return success if, and only if, intrument is fully loaded...
    return updateChannelVolume() && (iInstrumentStatus == 100);
}


// Update whole channel usage state.
bool ChannelStrip::updateChannelUsage (void)
{
    if (m_pChannel == NULL)
        return false;

        MainForm *pMainForm = MainForm::getInstance();
        if (pMainForm->client() == NULL)
                return false;

        // This only makes sense on fully loaded channels...
        if (m_pChannel->instrumentStatus() < 100)
            return false;

    // Get current channel voice count.
    int iVoiceCount  = ::lscp_get_channel_voice_count(pMainForm->client(), m_pChannel->channelID());
    // Get current stream count.
    int iStreamCount = ::lscp_get_channel_stream_count(pMainForm->client(), m_pChannel->channelID());
    // Get current channel buffer fill usage.
    // As benno has suggested this is the percentage usage
    // of the least filled buffer stream...
    int iStreamUsage = ::lscp_get_channel_stream_usage(pMainForm->client(), m_pChannel->channelID());;

    // Update the GUI elements...
    ui.StreamUsageProgressBar->setValue(iStreamUsage);
    ui.StreamVoiceCountTextLabel->setText(QString("%1 / %2").arg(iStreamCount).arg(iVoiceCount));

    // We're clean.
    return true;
}


// Volume change slot.
void ChannelStrip::volumeChanged ( int iVolume )
{
    if (m_pChannel == NULL)
        return;

    // Avoid recursion.
    if (m_iDirtyChange > 0)
        return;

    // Convert and clip.
    float fVolume = (float) iVolume / 100.0;
    if (fVolume < 0.001)
        fVolume = 0.0;

    // Update the GUI elements.
    if (m_pChannel->setVolume(fVolume)) {
        updateChannelVolume();
        emit channelChanged(this);
    }
}


// Context menu event handler.
void ChannelStrip::contextMenuEvent( QContextMenuEvent *pEvent )
{
    if (m_pChannel == NULL)
        return;

    // We'll just show up the main form's edit menu (thru qsamplerChannel).
    m_pChannel->contextMenuEvent(pEvent);
}


// Error count hackish accessors.
void ChannelStrip::resetErrorCount (void)
{
        m_iErrorCount = 0;
}

} // namespace QSampler
1	#include "qsamplerChannelStrip.h"
2
3	#include "qsamplerMainForm.h"
4
5	#include <q3dragobject.h>
6
7	#include <QUrl>
8
9	#include <math.h>
10
11	// Channel status/usage usage limit control.
12	#define QSAMPLER_ERROR_LIMIT 3
13
14	namespace QSampler {
15
16	ChannelStrip::ChannelStrip(QWidget* parent, Qt::WFlags f) : QWidget(parent, f) {
17	ui.setupUi(this);
18
19	// Initialize locals.
20	m_pChannel = NULL;
21	m_iDirtyChange = 0;
22	m_iErrorCount = 0;
23
24	// Try to restore normal window positioning.
25	adjustSize();
26	}
27
28	ChannelStrip::~ChannelStrip() {
29	// Destroy existing channel descriptor.
30	if (m_pChannel)
31	delete m_pChannel;
32	m_pChannel = NULL;
33	}
34
35
36	// Drag'n'drop file handler.
37	bool ChannelStrip::decodeDragFile ( const QMimeSource *pEvent, QString& sInstrumentFile )
38	{
39	if (m_pChannel == NULL)
40	return false;
41	if (Q3TextDrag::canDecode(pEvent)) {
42	QString sText;
43	if (Q3TextDrag::decode(pEvent, sText)) {
44	QStringList files = QStringList::split('\n', sText);
45	for (QStringList::Iterator iter = files.begin(); iter != files.end(); iter++) {
46	iter = QUrl((iter).stripWhiteSpace().replace(QRegExp("^file:"), QString::null)).path();
47	if (qsamplerChannel::isInstrumentFile(*iter)) {
48	sInstrumentFile = *iter;
49	return true;
50	}
51	}
52	}
53	}
54	// Fail.
55	return false;
56	}
57
58
59	// Window drag-n-drop event handlers.
60	void ChannelStrip::dragEnterEvent ( QDragEnterEvent* pDragEnterEvent )
61	{
62	QString sInstrumentFile;
63	pDragEnterEvent->accept(decodeDragFile(pDragEnterEvent, sInstrumentFile));
64	}
65
66
67	void ChannelStrip::dropEvent ( QDropEvent* pDropEvent )
68	{
69	QString sInstrumentFile;
70
71	if (decodeDragFile(pDropEvent, sInstrumentFile)) {
72	// Go and set the dropped instrument filename...
73	m_pChannel->setInstrument(sInstrumentFile, 0);
74	// Open up the channel dialog.
75	channelSetup();
76	}
77	}
78
79
80	// Channel strip setup formal initializer.
81	void ChannelStrip::setup ( qsamplerChannel *pChannel )
82	{
83	// Destroy any previous channel descriptor;
84	// (remember that once setup we own it!)
85	if (m_pChannel)
86	delete m_pChannel;
87
88	// Set the new one...
89	m_pChannel = pChannel;
90
91	// Stabilize this around.
92	updateChannelInfo();
93
94	// We'll accept drops from now on...
95	if (m_pChannel)
96	setAcceptDrops(true);
97	}
98
99	// Channel secriptor accessor.
100	qsamplerChannel *ChannelStrip::channel (void)
101	{
102	return m_pChannel;
103	}
104
105
106	// Messages view font accessors.
107	QFont ChannelStrip::displayFont (void)
108	{
109	return ui.EngineNameTextLabel->font();
110	}
111
112	void ChannelStrip::setDisplayFont ( const QFont & font )
113	{
114	ui.EngineNameTextLabel->setFont(font);
115	ui.MidiPortChannelTextLabel->setFont(font);
116	ui.InstrumentNameTextLabel->setFont(font);
117	ui.InstrumentStatusTextLabel->setFont(font);
118	}
119
120
121	// Channel display background effect.
122	void ChannelStrip::setDisplayEffect ( bool bDisplayEffect )
123	{
124	QPixmap pm =
125	(bDisplayEffect) ?
126	QPixmap(":/qsampler/pixmaps/displaybg1.png") : QPixmap();
127	setDisplayBackground(pm);
128	}
129
130
131	// Update main display background pixmap.
132	void ChannelStrip::setDisplayBackground ( const QPixmap& pm )
133	{
134	// Set the main origin...
135	ui.ChannelInfoFrame->setPaletteBackgroundPixmap(pm);
136
137	// Iterate for every child text label...
138	QList<QObject*> list = ui.ChannelInfoFrame->queryList("QLabel");
139	for (QList<QObject*>::iterator iter = list.begin(); iter != list.end(); iter++) {
140	static_cast<QLabel>(iter)->setPaletteBackgroundPixmap(pm);
141	}
142
143	// And this standalone too.
144	ui.StreamVoiceCountTextLabel->setPaletteBackgroundPixmap(pm);
145	}
146
147
148	// Maximum volume slider accessors.
149	void ChannelStrip::setMaxVolume ( int iMaxVolume )
150	{
151	m_iDirtyChange++;
152	ui.VolumeSlider->setRange(0, iMaxVolume);
153	ui.VolumeSpinBox->setRange(0, iMaxVolume);
154	m_iDirtyChange--;
155	}
156
157
158	// Channel setup dialog slot.
159	bool ChannelStrip::channelSetup (void)
160	{
161	if (m_pChannel == NULL)
162	return false;
163
164	// Invoke the channel setup dialog.
165	bool bResult = m_pChannel->channelSetup(this);
166	// Notify that this channel has changed.
167	if (bResult)
168	emit channelChanged(this);
169
170	return bResult;
171	}
172
173
174	// Channel mute slot.
175	bool ChannelStrip::channelMute ( bool bMute )
176	{
177	if (m_pChannel == NULL)
178	return false;
179
180	// Invoke the channel mute method.
181	bool bResult = m_pChannel->setChannelMute(bMute);
182	// Notify that this channel has changed.
183	if (bResult)
184	emit channelChanged(this);
185
186	return bResult;
187	}
188
189
190	// Channel solo slot.
191	bool ChannelStrip::channelSolo ( bool bSolo )
192	{
193	if (m_pChannel == NULL)
194	return false;
195
196	// Invoke the channel solo method.
197	bool bResult = m_pChannel->setChannelSolo(bSolo);
198	// Notify that this channel has changed.
199	if (bResult)
200	emit channelChanged(this);
201
202	return bResult;
203	}
204
205
206	// Channel edit slot.
207	void ChannelStrip::channelEdit (void)
208	{
209	if (m_pChannel == NULL)
210	return;
211
212	m_pChannel->editChannel();
213	}
214
215
216	// Channel reset slot.
217	bool ChannelStrip::channelReset (void)
218	{
219	if (m_pChannel == NULL)
220	return false;
221
222	// Invoke the channel reset method.
223	bool bResult = m_pChannel->channelReset();
224	// Notify that this channel has changed.
225	if (bResult)
226	emit channelChanged(this);
227
228	return bResult;
229	}
230
231
232	// Update the channel instrument name.
233	bool ChannelStrip::updateInstrumentName ( bool bForce )
234	{
235	if (m_pChannel == NULL)
236	return false;
237
238	// Do we refresh the actual name?
239	if (bForce)
240	m_pChannel->updateInstrumentName();
241
242	// Instrument name...
243	if (m_pChannel->instrumentName().isEmpty()) {
244	if (m_pChannel->instrumentStatus() >= 0)
245	ui.InstrumentNameTextLabel->setText(' ' + qsamplerChannel::loadingInstrument());
246	else
247	ui.InstrumentNameTextLabel->setText(' ' + qsamplerChannel::noInstrumentName());
248	} else
249	ui.InstrumentNameTextLabel->setText(' ' + m_pChannel->instrumentName());
250
251	return true;
252	}
253
254
255	// Do the dirty volume change.
256	bool ChannelStrip::updateChannelVolume (void)
257	{
258	if (m_pChannel == NULL)
259	return false;
260
261	// Convert...
262	#ifdef CONFIG_ROUND
263	int iVolume = (int) ::round(100.0 * m_pChannel->volume());
264	#else
265	double fIPart = 0.0;
266	double fFPart = ::modf(100.0 * m_pChannel->volume(), &fIPart);
267	int iVolume = (int) fIPart;
268	if (fFPart >= +0.5)
269	iVolume++;
270	else
271	if (fFPart <= -0.5)
272	iVolume--;
273	#endif
274
275	// And clip...
276	if (iVolume < 0)
277	iVolume = 0;
278
279	// Flag it here, to avoid infinite recursion.
280	m_iDirtyChange++;
281	ui.VolumeSlider->setValue(iVolume);
282	ui.VolumeSpinBox->setValue(iVolume);
283	m_iDirtyChange--;
284
285	return true;
286	}
287
288
289	// Update whole channel info state.
290	bool ChannelStrip::updateChannelInfo (void)
291	{
292	if (m_pChannel == NULL)
293	return false;
294
295	// Check for error limit/recycle...
296	if (m_iErrorCount > QSAMPLER_ERROR_LIMIT)
297	return true;
298
299	// Update strip caption.
300	QString sText = m_pChannel->channelName();
301	setCaption(sText);
302	ui.ChannelSetupPushButton->setText(sText);
303
304	// Check if we're up and connected.
305	MainForm* pMainForm = MainForm::getInstance();
306	if (pMainForm->client() == NULL)
307	return false;
308
309	// Read actual channel information.
310	m_pChannel->updateChannelInfo();
311
312	// Engine name...
313	if (m_pChannel->engineName().isEmpty())
314	ui.EngineNameTextLabel->setText(' ' + qsamplerChannel::noEngineName());
315	else
316	ui.EngineNameTextLabel->setText(' ' + m_pChannel->engineName());
317
318	// Instrument name...
319	updateInstrumentName(false);
320
321	// MIDI Port/Channel...
322	QString sMidiPortChannel = QString::number(m_pChannel->midiPort()) + " / ";
323	if (m_pChannel->midiChannel() == LSCP_MIDI_CHANNEL_ALL)
324	sMidiPortChannel += tr("All");
325	else
326	sMidiPortChannel += QString::number(m_pChannel->midiChannel() + 1);
327	ui.MidiPortChannelTextLabel->setText(sMidiPortChannel);
328
329	// Instrument status...
330	int iInstrumentStatus = m_pChannel->instrumentStatus();
331	if (iInstrumentStatus < 0) {
332	ui.InstrumentStatusTextLabel->setPaletteForegroundColor(Qt::red);
333	ui.InstrumentStatusTextLabel->setText(tr("ERR%1").arg(iInstrumentStatus));
334	m_iErrorCount++;
335	return false;
336	}
337	// All seems normal...
338	ui.InstrumentStatusTextLabel->setPaletteForegroundColor(iInstrumentStatus < 100 ? Qt::yellow : Qt::green);
339	ui.InstrumentStatusTextLabel->setText(QString::number(iInstrumentStatus) + '%');
340	m_iErrorCount = 0;
341
342	#ifdef CONFIG_MUTE_SOLO
343	// Mute/Solo button state coloring...
344	const QColor& rgbNormal = ChannelSetupPushButton->paletteBackgroundColor();
345	bool bMute = m_pChannel->channelMute();
346	ChannelMutePushButton->setPaletteBackgroundColor(bMute ? Qt::yellow : rgbNormal);
347	ChannelMutePushButton->setDown(bMute);
348	bool bSolo = m_pChannel->channelSolo();
349	ChannelSoloPushButton->setPaletteBackgroundColor(bSolo ? Qt::cyan : rgbNormal);
350	ChannelSoloPushButton->setDown(bSolo);
351	#else
352	ui.ChannelMutePushButton->setEnabled(false);
353	ui.ChannelSoloPushButton->setEnabled(false);
354	#endif
355
356	// And update the both GUI volume elements;
357	// return success if, and only if, intrument is fully loaded...
358	return updateChannelVolume() && (iInstrumentStatus == 100);
359	}
360
361
362	// Update whole channel usage state.
363	bool ChannelStrip::updateChannelUsage (void)
364	{
365	if (m_pChannel == NULL)
366	return false;
367
368	MainForm *pMainForm = MainForm::getInstance();
369	if (pMainForm->client() == NULL)
370	return false;
371
372	// This only makes sense on fully loaded channels...
373	if (m_pChannel->instrumentStatus() < 100)
374	return false;
375
376	// Get current channel voice count.
377	int iVoiceCount = ::lscp_get_channel_voice_count(pMainForm->client(), m_pChannel->channelID());
378	// Get current stream count.
379	int iStreamCount = ::lscp_get_channel_stream_count(pMainForm->client(), m_pChannel->channelID());
380	// Get current channel buffer fill usage.
381	// As benno has suggested this is the percentage usage
382	// of the least filled buffer stream...
383	int iStreamUsage = ::lscp_get_channel_stream_usage(pMainForm->client(), m_pChannel->channelID());;
384
385	// Update the GUI elements...
386	ui.StreamUsageProgressBar->setValue(iStreamUsage);
387	ui.StreamVoiceCountTextLabel->setText(QString("%1 / %2").arg(iStreamCount).arg(iVoiceCount));
388
389	// We're clean.
390	return true;
391	}
392
393
394	// Volume change slot.
395	void ChannelStrip::volumeChanged ( int iVolume )
396	{
397	if (m_pChannel == NULL)
398	return;
399
400	// Avoid recursion.
401	if (m_iDirtyChange > 0)
402	return;
403
404	// Convert and clip.
405	float fVolume = (float) iVolume / 100.0;
406	if (fVolume < 0.001)
407	fVolume = 0.0;
408
409	// Update the GUI elements.
410	if (m_pChannel->setVolume(fVolume)) {
411	updateChannelVolume();
412	emit channelChanged(this);
413	}
414	}
415
416
417	// Context menu event handler.
418	void ChannelStrip::contextMenuEvent( QContextMenuEvent *pEvent )
419	{
420	if (m_pChannel == NULL)
421	return;
422
423	// We'll just show up the main form's edit menu (thru qsamplerChannel).
424	m_pChannel->contextMenuEvent(pEvent);
425	}
426
427
428	// Error count hackish accessors.
429	void ChannelStrip::resetErrorCount (void)
430	{
431	m_iErrorCount = 0;
432	}
433
434	} // namespace QSampler