trunk/src/qsamplerChannelStrip.cpp

// qsamplerChannelStrip.cpp
//
/****************************************************************************
   Copyright (C) 2004-2012, rncbc aka Rui Nuno Capela. All rights reserved.
   Copyright (C) 2007, 2008 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 "qsamplerAbout.h"
#include "qsamplerChannelStrip.h"

#include "qsamplerMainForm.h"

#include "qsamplerChannelFxForm.h"

#include <QMessageBox>
#include <QDragEnterEvent>
#include <QFileInfo>
#include <QTimer>
#include <QUrl>

#if QT_VERSION >= 0x050000
#include <QMimeData>
#endif

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

// Needed for lroundf()
#include <math.h>

#ifndef CONFIG_ROUND
static inline long lroundf ( float x )
{
        if (x >= 0.0f)
                return long(x + 0.5f);
        else
                return long(x - 0.5f);
}
#endif


namespace QSampler {

//-------------------------------------------------------------------------
// QSampler::ChannelStrip -- Channel strip form implementation.
//

// MIDI activity pixmap common resources.
int      ChannelStrip::g_iMidiActivityRefCount = 0;
QPixmap *ChannelStrip::g_pMidiActivityLedOn    = NULL;
QPixmap *ChannelStrip::g_pMidiActivityLedOff   = NULL;

// Channel strip activation/selection.
ChannelStrip *ChannelStrip::g_pSelectedStrip = NULL;

ChannelStrip::ChannelStrip ( QWidget* pParent, Qt::WindowFlags wflags )
        : QWidget(pParent, wflags)
{
        m_ui.setupUi(this);

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

        if (++g_iMidiActivityRefCount == 1) {
                g_pMidiActivityLedOn  = new QPixmap(":/images/ledon1.png");
                g_pMidiActivityLedOff = new QPixmap(":/images/ledoff1.png");
        }

        m_ui.MidiActivityLabel->setPixmap(*g_pMidiActivityLedOff);

#ifndef CONFIG_EVENT_CHANNEL_MIDI
        m_ui.MidiActivityLabel->setToolTip("MIDI activity (disabled)");
#endif

        m_pMidiActivityTimer = new QTimer(this);
        m_pMidiActivityTimer->setSingleShot(true);

        QObject::connect(m_pMidiActivityTimer,
                SIGNAL(timeout()),
                SLOT(midiActivityLedOff())
        );

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

        QObject::connect(m_ui.ChannelSetupPushButton,
                SIGNAL(clicked()),
                SLOT(channelSetup()));
        QObject::connect(m_ui.ChannelMutePushButton,
                SIGNAL(toggled(bool)),
                SLOT(channelMute(bool)));
        QObject::connect(m_ui.ChannelSoloPushButton,
                SIGNAL(toggled(bool)),
                SLOT(channelSolo(bool)));
        QObject::connect(m_ui.VolumeSlider,
                SIGNAL(valueChanged(int)),
                SLOT(volumeChanged(int)));
        QObject::connect(m_ui.VolumeSpinBox,
                SIGNAL(valueChanged(int)),
                SLOT(volumeChanged(int)));
        QObject::connect(m_ui.ChannelEditPushButton,
                SIGNAL(clicked()),
                SLOT(channelEdit()));
        QObject::connect(m_ui.FxPushButton,
                SIGNAL(clicked()),
                SLOT(channelFxEdit()));

        setSelected(false);
}


ChannelStrip::~ChannelStrip (void)
{
        setSelected(false);

        // Destroy existing channel descriptor.
        if (m_pChannel)
                delete m_pChannel;
        m_pChannel = NULL;

        if (--g_iMidiActivityRefCount == 0) {
                if (g_pMidiActivityLedOn)
                        delete g_pMidiActivityLedOn;
                g_pMidiActivityLedOn = NULL;
                if (g_pMidiActivityLedOff)
                        delete g_pMidiActivityLedOff;
                g_pMidiActivityLedOff = NULL;
        }
}


// Window drag-n-drop event handlers.
void ChannelStrip::dragEnterEvent ( QDragEnterEvent* pDragEnterEvent )
{
        if (m_pChannel == NULL)
                return;

        bool bAccept = false;

        if (pDragEnterEvent->source() == NULL) {
                const QMimeData *pMimeData = pDragEnterEvent->mimeData();
                if (pMimeData && pMimeData->hasUrls()) {
                        QListIterator<QUrl> iter(pMimeData->urls());
                        while (iter.hasNext()) {
                                const QString& sFilename = iter.next().toLocalFile();
                                if (!sFilename.isEmpty()) {
                                //      bAccept = Channel::isDlsInstrumentFile(sFilename);
                                        bAccept = QFileInfo(sFilename).exists();
                                        break;
                                }
                        }
                }
        }

        if (bAccept)
                pDragEnterEvent->accept();
        else
                pDragEnterEvent->ignore();
}


void ChannelStrip::dropEvent ( QDropEvent* pDropEvent )
{
        if (m_pChannel == NULL)
                return;

        if (pDropEvent->source())
                return;

        const QMimeData *pMimeData = pDropEvent->mimeData();
        if (pMimeData && pMimeData->hasUrls()) {
                QStringList files;
                QListIterator<QUrl> iter(pMimeData->urls());
                while (iter.hasNext()) {
                        const QString& sFilename = iter.next().toLocalFile();
                        if (!sFilename.isEmpty()) {
                                // Go and set the dropped instrument filename...
                                m_pChannel->setInstrument(sFilename, 0);
                                // Open up the channel dialog.
                                channelSetup();
                                break;
                        }
                }
        }
}


// Channel strip setup formal initializer.
void ChannelStrip::setup ( Channel *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.
Channel *ChannelStrip::channel (void) const
{
        return m_pChannel;
}


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

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


// Channel display background effect.
void ChannelStrip::setDisplayEffect ( bool bDisplayEffect )
{
        QPalette pal;
        pal.setColor(QPalette::Foreground, Qt::yellow);
        m_ui.EngineNameTextLabel->setPalette(pal);
        m_ui.MidiPortChannelTextLabel->setPalette(pal);
        pal.setColor(QPalette::Foreground, Qt::green);
        if (bDisplayEffect) {
                QPixmap pm(":/images/displaybg1.png");
                pal.setBrush(QPalette::Background, QBrush(pm));
        } else {
                pal.setColor(QPalette::Background, Qt::black);
        }
        m_ui.ChannelInfoFrame->setPalette(pal);
        m_ui.InstrumentNameTextLabel->setPalette(pal);
        m_ui.StreamVoiceCountTextLabel->setPalette(pal);
}


// Maximum volume slider accessors.
void ChannelStrip::setMaxVolume ( int iMaxVolume )
{
        m_iDirtyChange++;
        m_ui.VolumeSlider->setRange(0, iMaxVolume);
        m_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();
}

bool ChannelStrip::channelFxEdit (void)
{
        MainForm *pMainForm = MainForm::getInstance();
        if (!pMainForm || !channel())
                return false;

        pMainForm->appendMessages(QObject::tr("channel fx sends..."));

        bool bResult = false;

#if CONFIG_FXSEND
        ChannelFxForm *pChannelFxForm =
                new ChannelFxForm(channel(), parentWidget());
        if (pChannelFxForm) {
                //pChannelForm->setup(this);
                bResult = pChannelFxForm->exec();
                delete pChannelFxForm;
        }
#else // CONFIG_FXSEND
        QMessageBox::critical(this,
                QSAMPLER_TITLE ": " + tr("Unavailable"),
                        tr("Sorry, QSampler was built without FX send support!\n\n"
                           "(Make sure you have a recent liblscp when recompiling QSampler)"));
#endif // CONFIG_FXSEND

        return bResult;
}

// 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) {
                        m_ui.InstrumentNameTextLabel->setText(
                                ' ' + Channel::loadingInstrument());
                } else {
                        m_ui.InstrumentNameTextLabel->setText(
                                ' ' + Channel::noInstrumentName());
                }
        } else {
                m_ui.InstrumentNameTextLabel->setText(
                        ' ' + m_pChannel->instrumentName());
        }

        return true;
}


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

        // Convert...
        int iVolume = ::lroundf(100.0f * m_pChannel->volume());
        // And clip...
        if (iVolume < 0)
                iVolume = 0;

        // Flag it here, to avoid infinite recursion.
        m_iDirtyChange++;
        m_ui.VolumeSlider->setValue(iVolume);
        m_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();
        setWindowTitle(sText);
        m_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()) {
                m_ui.EngineNameTextLabel->setText(
                        ' ' + Channel::noEngineName());
        } else {
                m_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);
        m_ui.MidiPortChannelTextLabel->setText(sMidiPortChannel);

        // Common palette...
        QPalette pal;
        const QColor& rgbFore = pal.color(QPalette::Foreground);

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

#ifdef CONFIG_MUTE_SOLO
        // Mute/Solo button state coloring...
        bool bMute = m_pChannel->channelMute();
        const QColor& rgbButton = pal.color(QPalette::Button);
        const QColor& rgbButtonText = pal.color(QPalette::ButtonText);
        pal.setColor(QPalette::Foreground, rgbFore);
        pal.setColor(QPalette::Button, bMute ? Qt::yellow : rgbButton);
        pal.setColor(QPalette::ButtonText, bMute ? Qt::darkYellow : rgbButtonText);
        m_ui.ChannelMutePushButton->setPalette(pal);
        m_ui.ChannelMutePushButton->setDown(bMute);
        bool bSolo = m_pChannel->channelSolo();
        pal.setColor(QPalette::Button, bSolo ? Qt::cyan : rgbButton);   
        pal.setColor(QPalette::ButtonText, bSolo ? Qt::darkCyan : rgbButtonText);
        m_ui.ChannelSoloPushButton->setPalette(pal);
        m_ui.ChannelSoloPushButton->setDown(bSolo);
#else
        m_ui.ChannelMutePushButton->setEnabled(false);
        m_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...
        m_ui.StreamUsageProgressBar->setValue(iStreamUsage);
        m_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.0f;
        if (fVolume < 0.001f)
                fVolume = 0.0f;

        // 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);
}


void ChannelStrip::midiActivityLedOn (void)
{
        m_ui.MidiActivityLabel->setPixmap(*g_pMidiActivityLedOn);
        m_pMidiActivityTimer->start(100);
}


void ChannelStrip::midiActivityLedOff (void)
{
        m_ui.MidiActivityLabel->setPixmap(*g_pMidiActivityLedOff);
}


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


// Channel strip activation/selection.
void ChannelStrip::setSelected ( bool bSelected )
{
        if (bSelected) {
                if (g_pSelectedStrip == this)
                        return;
                if (g_pSelectedStrip)
                        g_pSelectedStrip->setSelected(false);
                g_pSelectedStrip = this;
        } else {
                if (g_pSelectedStrip == this)
                        g_pSelectedStrip = NULL;
        }

        QPalette pal;
        if (bSelected) {
                const QColor& color = pal.midlight().color();
                pal.setColor(QPalette::Background, color.dark(150));
                pal.setColor(QPalette::Foreground, color.light(150));
        }
        QWidget::setPalette(pal);
}


bool ChannelStrip::isSelected (void) const
{
        return (this == g_pSelectedStrip);
}


} // namespace QSampler


// end of qsamplerChannelStrip.cpp
1	capela	1464	// qsamplerChannelStrip.cpp
2			//
3			/****************************************************************************
4	capela	2387	Copyright (C) 2004-2012, rncbc aka Rui Nuno Capela. All rights reserved.
5	schoenebeck	1667	Copyright (C) 2007, 2008 Christian Schoenebeck
6	capela	1464
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	capela	1499	#include "qsamplerAbout.h"
24	schoenebeck	1461	#include "qsamplerChannelStrip.h"
25
26			#include "qsamplerMainForm.h"
27
28	schoenebeck	1667	#include "qsamplerChannelFxForm.h"
29
30			#include <QMessageBox>
31	capela	1499	#include <QDragEnterEvent>
32	capela	2108	#include <QFileInfo>
33	capela	2036	#include <QTimer>
34	schoenebeck	1461	#include <QUrl>
35
36	capela	2387	#if QT_VERSION >= 0x050000
37			#include <QMimeData>
38			#endif
39	schoenebeck	1691
40	schoenebeck	1461	// Channel status/usage usage limit control.
41			#define QSAMPLER_ERROR_LIMIT 3
42
43	capela	1510	// Needed for lroundf()
44			#include <math.h>
45
46			#ifndef CONFIG_ROUND
47			static inline long lroundf ( float x )
48			{
49			if (x >= 0.0f)
50			return long(x + 0.5f);
51			else
52			return long(x - 0.5f);
53			}
54			#endif
55
56	capela	1514
57			namespace QSampler {
58
59	capela	1558	//-------------------------------------------------------------------------
60			// QSampler::ChannelStrip -- Channel strip form implementation.
61			//
62
63	capela	2036	// MIDI activity pixmap common resources.
64			int ChannelStrip::g_iMidiActivityRefCount = 0;
65			QPixmap *ChannelStrip::g_pMidiActivityLedOn = NULL;
66			QPixmap *ChannelStrip::g_pMidiActivityLedOff = NULL;
67
68	capela	1514	// Channel strip activation/selection.
69			ChannelStrip *ChannelStrip::g_pSelectedStrip = NULL;
70
71	capela	1509	ChannelStrip::ChannelStrip ( QWidget* pParent, Qt::WindowFlags wflags )
72			: QWidget(pParent, wflags)
73			{
74	capela	1510	m_ui.setupUi(this);
75	schoenebeck	1461
76	capela	1510	// Initialize locals.
77			m_pChannel = NULL;
78			m_iDirtyChange = 0;
79			m_iErrorCount = 0;
80	schoenebeck	1461
81	capela	2036	if (++g_iMidiActivityRefCount == 1) {
82	capela	2074	g_pMidiActivityLedOn = new QPixmap(":/images/ledon1.png");
83			g_pMidiActivityLedOff = new QPixmap(":/images/ledoff1.png");
84	capela	2036	}
85
86			m_ui.MidiActivityLabel->setPixmap(*g_pMidiActivityLedOff);
87
88			#ifndef CONFIG_EVENT_CHANNEL_MIDI
89			m_ui.MidiActivityLabel->setToolTip("MIDI activity (disabled)");
90			#endif
91
92			m_pMidiActivityTimer = new QTimer(this);
93			m_pMidiActivityTimer->setSingleShot(true);
94
95			QObject::connect(m_pMidiActivityTimer,
96			SIGNAL(timeout()),
97			SLOT(midiActivityLedOff())
98			);
99
100	capela	1510	// Try to restore normal window positioning.
101			adjustSize();
102	capela	1466
103	capela	1509	QObject::connect(m_ui.ChannelSetupPushButton,
104	capela	1466	SIGNAL(clicked()),
105			SLOT(channelSetup()));
106	capela	1509	QObject::connect(m_ui.ChannelMutePushButton,
107	capela	1466	SIGNAL(toggled(bool)),
108			SLOT(channelMute(bool)));
109	capela	1509	QObject::connect(m_ui.ChannelSoloPushButton,
110	capela	1466	SIGNAL(toggled(bool)),
111			SLOT(channelSolo(bool)));
112	capela	1509	QObject::connect(m_ui.VolumeSlider,
113	capela	1466	SIGNAL(valueChanged(int)),
114			SLOT(volumeChanged(int)));
115	capela	1509	QObject::connect(m_ui.VolumeSpinBox,
116	capela	1466	SIGNAL(valueChanged(int)),
117			SLOT(volumeChanged(int)));
118	capela	1509	QObject::connect(m_ui.ChannelEditPushButton,
119	capela	1466	SIGNAL(clicked()),
120			SLOT(channelEdit()));
121	schoenebeck	1667	QObject::connect(m_ui.FxPushButton,
122			SIGNAL(clicked()),
123			SLOT(channelFxEdit()));
124	capela	1515
125			setSelected(false);
126	schoenebeck	1461	}
127
128	capela	1513
129			ChannelStrip::~ChannelStrip (void)
130			{
131	capela	1515	setSelected(false);
132
133	capela	1510	// Destroy existing channel descriptor.
134			if (m_pChannel)
135			delete m_pChannel;
136			m_pChannel = NULL;
137	capela	2036
138			if (--g_iMidiActivityRefCount == 0) {
139			if (g_pMidiActivityLedOn)
140			delete g_pMidiActivityLedOn;
141			g_pMidiActivityLedOn = NULL;
142			if (g_pMidiActivityLedOff)
143			delete g_pMidiActivityLedOff;
144			g_pMidiActivityLedOff = NULL;
145			}
146	schoenebeck	1461	}
147
148
149	capela	1499	// Window drag-n-drop event handlers.
150			void ChannelStrip::dragEnterEvent ( QDragEnterEvent* pDragEnterEvent )
151	schoenebeck	1461	{
152			if (m_pChannel == NULL)
153	capela	1499	return;
154
155			bool bAccept = false;
156
157			if (pDragEnterEvent->source() == NULL) {
158			const QMimeData *pMimeData = pDragEnterEvent->mimeData();
159			if (pMimeData && pMimeData->hasUrls()) {
160			QListIterator<QUrl> iter(pMimeData->urls());
161			while (iter.hasNext()) {
162			const QString& sFilename = iter.next().toLocalFile();
163			if (!sFilename.isEmpty()) {
164	capela	2108	// bAccept = Channel::isDlsInstrumentFile(sFilename);
165			bAccept = QFileInfo(sFilename).exists();
166	capela	1499	break;
167	schoenebeck	1461	}
168			}
169			}
170			}
171
172	capela	1499	if (bAccept)
173			pDragEnterEvent->accept();
174			else
175			pDragEnterEvent->ignore();
176	schoenebeck	1461	}
177
178
179			void ChannelStrip::dropEvent ( QDropEvent* pDropEvent )
180			{
181	capela	1499	if (m_pChannel == NULL)
182			return;
183	schoenebeck	1461
184	capela	1499	if (pDropEvent->source())
185			return;
186
187			const QMimeData *pMimeData = pDropEvent->mimeData();
188			if (pMimeData && pMimeData->hasUrls()) {
189			QStringList files;
190			QListIterator<QUrl> iter(pMimeData->urls());
191			while (iter.hasNext()) {
192			const QString& sFilename = iter.next().toLocalFile();
193			if (!sFilename.isEmpty()) {
194			// Go and set the dropped instrument filename...
195			m_pChannel->setInstrument(sFilename, 0);
196			// Open up the channel dialog.
197			channelSetup();
198			break;
199			}
200			}
201	schoenebeck	1461	}
202			}
203
204
205			// Channel strip setup formal initializer.
206	capela	1558	void ChannelStrip::setup ( Channel *pChannel )
207	schoenebeck	1461	{
208	capela	1510	// Destroy any previous channel descriptor;
209			// (remember that once setup we own it!)
210			if (m_pChannel)
211			delete m_pChannel;
212	schoenebeck	1461
213	capela	1510	// Set the new one...
214			m_pChannel = pChannel;
215	schoenebeck	1461
216	capela	1510	// Stabilize this around.
217			updateChannelInfo();
218	schoenebeck	1461
219			// We'll accept drops from now on...
220			if (m_pChannel)
221			setAcceptDrops(true);
222			}
223
224	capela	1513
225	schoenebeck	1461	// Channel secriptor accessor.
226	capela	1558	Channel *ChannelStrip::channel (void) const
227	schoenebeck	1461	{
228	capela	1510	return m_pChannel;
229	schoenebeck	1461	}
230
231
232			// Messages view font accessors.
233	capela	1509	QFont ChannelStrip::displayFont (void) const
234	schoenebeck	1461	{
235	capela	1510	return m_ui.EngineNameTextLabel->font();
236	schoenebeck	1461	}
237
238			void ChannelStrip::setDisplayFont ( const QFont & font )
239			{
240	capela	1510	m_ui.EngineNameTextLabel->setFont(font);
241			m_ui.MidiPortChannelTextLabel->setFont(font);
242			m_ui.InstrumentNameTextLabel->setFont(font);
243			m_ui.InstrumentStatusTextLabel->setFont(font);
244	schoenebeck	1461	}
245
246
247			// Channel display background effect.
248			void ChannelStrip::setDisplayEffect ( bool bDisplayEffect )
249			{
250	capela	1499	QPalette pal;
251	capela	1507	pal.setColor(QPalette::Foreground, Qt::yellow);
252	capela	1509	m_ui.EngineNameTextLabel->setPalette(pal);
253			m_ui.MidiPortChannelTextLabel->setPalette(pal);
254	capela	1499	pal.setColor(QPalette::Foreground, Qt::green);
255			if (bDisplayEffect) {
256	capela	2074	QPixmap pm(":/images/displaybg1.png");
257	capela	1499	pal.setBrush(QPalette::Background, QBrush(pm));
258			} else {
259			pal.setColor(QPalette::Background, Qt::black);
260			}
261	capela	1509	m_ui.ChannelInfoFrame->setPalette(pal);
262	capela	1637	m_ui.InstrumentNameTextLabel->setPalette(pal);
263	capela	1509	m_ui.StreamVoiceCountTextLabel->setPalette(pal);
264	schoenebeck	1461	}
265
266
267			// Maximum volume slider accessors.
268			void ChannelStrip::setMaxVolume ( int iMaxVolume )
269			{
270	capela	1510	m_iDirtyChange++;
271			m_ui.VolumeSlider->setRange(0, iMaxVolume);
272			m_ui.VolumeSpinBox->setRange(0, iMaxVolume);
273			m_iDirtyChange--;
274	schoenebeck	1461	}
275
276
277			// Channel setup dialog slot.
278			bool ChannelStrip::channelSetup (void)
279			{
280			if (m_pChannel == NULL)
281			return false;
282
283			// Invoke the channel setup dialog.
284			bool bResult = m_pChannel->channelSetup(this);
285			// Notify that this channel has changed.
286			if (bResult)
287			emit channelChanged(this);
288
289			return bResult;
290			}
291
292
293			// Channel mute slot.
294			bool ChannelStrip::channelMute ( bool bMute )
295			{
296			if (m_pChannel == NULL)
297			return false;
298
299			// Invoke the channel mute method.
300			bool bResult = m_pChannel->setChannelMute(bMute);
301			// Notify that this channel has changed.
302			if (bResult)
303			emit channelChanged(this);
304
305			return bResult;
306			}
307
308
309			// Channel solo slot.
310			bool ChannelStrip::channelSolo ( bool bSolo )
311			{
312			if (m_pChannel == NULL)
313			return false;
314
315			// Invoke the channel solo method.
316			bool bResult = m_pChannel->setChannelSolo(bSolo);
317			// Notify that this channel has changed.
318			if (bResult)
319			emit channelChanged(this);
320
321			return bResult;
322			}
323
324
325			// Channel edit slot.
326			void ChannelStrip::channelEdit (void)
327			{
328			if (m_pChannel == NULL)
329			return;
330
331			m_pChannel->editChannel();
332			}
333
334	schoenebeck	1667	bool ChannelStrip::channelFxEdit (void)
335			{
336			MainForm *pMainForm = MainForm::getInstance();
337			if (!pMainForm \|\| !channel())
338			return false;
339	schoenebeck	1461
340	schoenebeck	1667	pMainForm->appendMessages(QObject::tr("channel fx sends..."));
341
342			bool bResult = false;
343
344			#if CONFIG_FXSEND
345			ChannelFxForm *pChannelFxForm =
346	schoenebeck	1668	new ChannelFxForm(channel(), parentWidget());
347	schoenebeck	1667	if (pChannelFxForm) {
348			//pChannelForm->setup(this);
349			bResult = pChannelFxForm->exec();
350			delete pChannelFxForm;
351			}
352			#else // CONFIG_FXSEND
353			QMessageBox::critical(this,
354			QSAMPLER_TITLE ": " + tr("Unavailable"),
355			tr("Sorry, QSampler was built without FX send support!\n\n"
356			"(Make sure you have a recent liblscp when recompiling QSampler)"));
357			#endif // CONFIG_FXSEND
358
359			return bResult;
360			}
361
362	schoenebeck	1461	// Channel reset slot.
363			bool ChannelStrip::channelReset (void)
364			{
365			if (m_pChannel == NULL)
366			return false;
367
368			// Invoke the channel reset method.
369			bool bResult = m_pChannel->channelReset();
370			// Notify that this channel has changed.
371			if (bResult)
372			emit channelChanged(this);
373
374			return bResult;
375			}
376
377
378			// Update the channel instrument name.
379			bool ChannelStrip::updateInstrumentName ( bool bForce )
380			{
381			if (m_pChannel == NULL)
382			return false;
383
384			// Do we refresh the actual name?
385			if (bForce)
386			m_pChannel->updateInstrumentName();
387
388			// Instrument name...
389			if (m_pChannel->instrumentName().isEmpty()) {
390	capela	1513	if (m_pChannel->instrumentStatus() >= 0) {
391			m_ui.InstrumentNameTextLabel->setText(
392	capela	1558	' ' + Channel::loadingInstrument());
393	capela	1513	} else {
394			m_ui.InstrumentNameTextLabel->setText(
395	capela	1558	' ' + Channel::noInstrumentName());
396	capela	1513	}
397			} else {
398			m_ui.InstrumentNameTextLabel->setText(
399			' ' + m_pChannel->instrumentName());
400			}
401	schoenebeck	1461
402			return true;
403			}
404
405
406			// Do the dirty volume change.
407			bool ChannelStrip::updateChannelVolume (void)
408			{
409	capela	1510	if (m_pChannel == NULL)
410			return false;
411	schoenebeck	1461
412	capela	1510	// Convert...
413			int iVolume = ::lroundf(100.0f * m_pChannel->volume());
414			// And clip...
415			if (iVolume < 0)
416			iVolume = 0;
417	schoenebeck	1461
418	capela	1510	// Flag it here, to avoid infinite recursion.
419			m_iDirtyChange++;
420			m_ui.VolumeSlider->setValue(iVolume);
421			m_ui.VolumeSpinBox->setValue(iVolume);
422			m_iDirtyChange--;
423	schoenebeck	1461
424	capela	1510	return true;
425	schoenebeck	1461	}
426
427
428			// Update whole channel info state.
429			bool ChannelStrip::updateChannelInfo (void)
430			{
431	capela	1510	if (m_pChannel == NULL)
432			return false;
433	schoenebeck	1461
434			// Check for error limit/recycle...
435			if (m_iErrorCount > QSAMPLER_ERROR_LIMIT)
436			return true;
437
438	capela	1510	// Update strip caption.
439			QString sText = m_pChannel->channelName();
440			setWindowTitle(sText);
441	capela	1513	m_ui.ChannelSetupPushButton->setText('&' + sText);
442	schoenebeck	1461
443	capela	1510	// Check if we're up and connected.
444	schoenebeck	1461	MainForm* pMainForm = MainForm::getInstance();
445			if (pMainForm->client() == NULL)
446			return false;
447
448	capela	1510	// Read actual channel information.
449			m_pChannel->updateChannelInfo();
450	schoenebeck	1461
451	capela	1510	// Engine name...
452	capela	1513	if (m_pChannel->engineName().isEmpty()) {
453			m_ui.EngineNameTextLabel->setText(
454	capela	1558	' ' + Channel::noEngineName());
455	capela	1513	} else {
456			m_ui.EngineNameTextLabel->setText(
457			' ' + m_pChannel->engineName());
458			}
459	schoenebeck	1461
460			// Instrument name...
461			updateInstrumentName(false);
462
463	capela	1510	// MIDI Port/Channel...
464	schoenebeck	1461	QString sMidiPortChannel = QString::number(m_pChannel->midiPort()) + " / ";
465			if (m_pChannel->midiChannel() == LSCP_MIDI_CHANNEL_ALL)
466			sMidiPortChannel += tr("All");
467			else
468			sMidiPortChannel += QString::number(m_pChannel->midiChannel() + 1);
469	capela	1509	m_ui.MidiPortChannelTextLabel->setText(sMidiPortChannel);
470	schoenebeck	1461
471	capela	1499	// Common palette...
472			QPalette pal;
473			const QColor& rgbFore = pal.color(QPalette::Foreground);
474
475	capela	1510	// Instrument status...
476			int iInstrumentStatus = m_pChannel->instrumentStatus();
477			if (iInstrumentStatus < 0) {
478	capela	1499	pal.setColor(QPalette::Foreground, Qt::red);
479	capela	1509	m_ui.InstrumentStatusTextLabel->setPalette(pal);
480	capela	1513	m_ui.InstrumentStatusTextLabel->setText(
481			tr("ERR%1").arg(iInstrumentStatus));
482	capela	1510	m_iErrorCount++;
483			return false;
484			}
485			// All seems normal...
486	capela	1499	pal.setColor(QPalette::Foreground,
487			iInstrumentStatus < 100 ? Qt::yellow : Qt::green);
488	capela	1510	m_ui.InstrumentStatusTextLabel->setPalette(pal);
489	capela	1513	m_ui.InstrumentStatusTextLabel->setText(
490			QString::number(iInstrumentStatus) + '%');
491	capela	1510	m_iErrorCount = 0;
492	schoenebeck	1461
493			#ifdef CONFIG_MUTE_SOLO
494	capela	1510	// Mute/Solo button state coloring...
495			bool bMute = m_pChannel->channelMute();
496	capela	1499	const QColor& rgbButton = pal.color(QPalette::Button);
497	capela	2068	const QColor& rgbButtonText = pal.color(QPalette::ButtonText);
498	capela	1499	pal.setColor(QPalette::Foreground, rgbFore);
499			pal.setColor(QPalette::Button, bMute ? Qt::yellow : rgbButton);
500	capela	2068	pal.setColor(QPalette::ButtonText, bMute ? Qt::darkYellow : rgbButtonText);
501	capela	1509	m_ui.ChannelMutePushButton->setPalette(pal);
502			m_ui.ChannelMutePushButton->setDown(bMute);
503	capela	1510	bool bSolo = m_pChannel->channelSolo();
504	capela	1499	pal.setColor(QPalette::Button, bSolo ? Qt::cyan : rgbButton);
505	capela	2068	pal.setColor(QPalette::ButtonText, bSolo ? Qt::darkCyan : rgbButtonText);
506	capela	1509	m_ui.ChannelSoloPushButton->setPalette(pal);
507			m_ui.ChannelSoloPushButton->setDown(bSolo);
508	schoenebeck	1461	#else
509	capela	1509	m_ui.ChannelMutePushButton->setEnabled(false);
510			m_ui.ChannelSoloPushButton->setEnabled(false);
511	schoenebeck	1461	#endif
512
513	capela	1510	// And update the both GUI volume elements;
514			// return success if, and only if, intrument is fully loaded...
515			return updateChannelVolume() && (iInstrumentStatus == 100);
516	schoenebeck	1461	}
517
518
519			// Update whole channel usage state.
520			bool ChannelStrip::updateChannelUsage (void)
521			{
522	capela	1510	if (m_pChannel == NULL)
523			return false;
524	schoenebeck	1461
525			MainForm *pMainForm = MainForm::getInstance();
526			if (pMainForm->client() == NULL)
527			return false;
528
529			// This only makes sense on fully loaded channels...
530			if (m_pChannel->instrumentStatus() < 100)
531	capela	1510	return false;
532	schoenebeck	1461
533	capela	1510	// Get current channel voice count.
534	capela	1513	int iVoiceCount = ::lscp_get_channel_voice_count(
535			pMainForm->client(), m_pChannel->channelID());
536	capela	1510	// Get current stream count.
537	capela	1513	int iStreamCount = ::lscp_get_channel_stream_count(
538			pMainForm->client(), m_pChannel->channelID());
539	capela	1510	// Get current channel buffer fill usage.
540			// As benno has suggested this is the percentage usage
541			// of the least filled buffer stream...
542	capela	1513	int iStreamUsage = ::lscp_get_channel_stream_usage(
543			pMainForm->client(), m_pChannel->channelID());;
544	schoenebeck	1461
545	capela	1510	// Update the GUI elements...
546			m_ui.StreamUsageProgressBar->setValue(iStreamUsage);
547	capela	1513	m_ui.StreamVoiceCountTextLabel->setText(
548			QString("%1 / %2").arg(iStreamCount).arg(iVoiceCount));
549	schoenebeck	1461
550	capela	1510	// We're clean.
551			return true;
552	schoenebeck	1461	}
553
554
555			// Volume change slot.
556			void ChannelStrip::volumeChanged ( int iVolume )
557			{
558	capela	1510	if (m_pChannel == NULL)
559			return;
560	schoenebeck	1461
561	capela	1510	// Avoid recursion.
562			if (m_iDirtyChange > 0)
563			return;
564	schoenebeck	1461
565	capela	1510	// Convert and clip.
566			float fVolume = (float) iVolume / 100.0f;
567			if (fVolume < 0.001f)
568			fVolume = 0.0f;
569	schoenebeck	1461
570	capela	1510	// Update the GUI elements.
571			if (m_pChannel->setVolume(fVolume)) {
572			updateChannelVolume();
573			emit channelChanged(this);
574			}
575	schoenebeck	1461	}
576
577
578			// Context menu event handler.
579			void ChannelStrip::contextMenuEvent( QContextMenuEvent *pEvent )
580			{
581	capela	1510	if (m_pChannel == NULL)
582			return;
583	schoenebeck	1461
584	capela	1510	// We'll just show up the main form's edit menu (thru qsamplerChannel).
585			m_pChannel->contextMenuEvent(pEvent);
586	schoenebeck	1461	}
587
588	capela	2036
589			void ChannelStrip::midiActivityLedOn (void)
590			{
591			m_ui.MidiActivityLabel->setPixmap(*g_pMidiActivityLedOn);
592	capela	2038	m_pMidiActivityTimer->start(100);
593	schoenebeck	1691	}
594	schoenebeck	1461
595	capela	2036
596			void ChannelStrip::midiActivityLedOff (void)
597			{
598			m_ui.MidiActivityLabel->setPixmap(*g_pMidiActivityLedOff);
599			}
600
601
602	schoenebeck	1461	// Error count hackish accessors.
603			void ChannelStrip::resetErrorCount (void)
604			{
605			m_iErrorCount = 0;
606			}
607
608	capela	1514
609			// Channel strip activation/selection.
610			void ChannelStrip::setSelected ( bool bSelected )
611			{
612			if (bSelected) {
613			if (g_pSelectedStrip == this)
614			return;
615			if (g_pSelectedStrip)
616			g_pSelectedStrip->setSelected(false);
617			g_pSelectedStrip = this;
618			} else {
619			if (g_pSelectedStrip == this)
620			g_pSelectedStrip = NULL;
621			}
622
623			QPalette pal;
624			if (bSelected) {
625			const QColor& color = pal.midlight().color();
626			pal.setColor(QPalette::Background, color.dark(150));
627			pal.setColor(QPalette::Foreground, color.light(150));
628			}
629			QWidget::setPalette(pal);
630			}
631
632
633			bool ChannelStrip::isSelected (void) const
634			{
635			return (this == g_pSelectedStrip);
636			}
637
638
639	schoenebeck	1461	} // namespace QSampler
640	capela	1464
641
642			// end of qsamplerChannelStrip.cpp