trunk/src/qsamplerChannelStrip.cpp

// qsamplerChannelStrip.cpp
//
/****************************************************************************
   Copyright (C) 2004-2007, rncbc aka Rui Nuno Capela. All rights reserved.
   Copyright (C) 2007, Christian Schoenebeck

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; either version 2
   of the License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License along
   with this program; if not, write to the Free Software Foundation, Inc.,
   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*****************************************************************************/

#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


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