trunk/src/qsamplerChannelStrip.cpp

// qsamplerChannelStrip.cpp
//
/****************************************************************************
   Copyright (C) 2004-2010, 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 <QTimer>
#include <QUrl>


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