trunk/src/qsamplerDeviceStatusForm.cpp

// qsamplerDeviceStatusForm.cpp
//
/****************************************************************************
   Copyright (C) 2008, Christian Schoenebeck
   Copyright (C) 2010, rncbc aka Rui Nuno Capela. All rights reserved.

   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

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

#include "qsamplerAbout.h"
#include "qsamplerDeviceStatusForm.h"

#include "qsamplerMainForm.h"

#include <QGridLayout>


namespace QSampler {

//-------------------------------------------------------------------------
// QSampler::MidiActivityLED -- Graphical indicator for MIDI activity.
//

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


MidiActivityLED::MidiActivityLED ( QString sText, QWidget *pParent )
        : QLabel(sText, pParent)
{
        if (++g_iMidiActivityRefCount == 1) {
                g_pMidiActivityLedOn  = new QPixmap(":/icons/ledon1.png");
                g_pMidiActivityLedOff = new QPixmap(":/icons/ledoff1.png");
        }

        setPixmap(*g_pMidiActivityLedOff);
#ifndef CONFIG_EVENT_DEVICE_MIDI
        setToolTip("MIDI Activity disabled");
#endif
        m_timer.setSingleShot(true);

        QObject::connect(&m_timer,
                SIGNAL(timeout()),
                SLOT(midiActivityLedOff())
        );
}

MidiActivityLED::~MidiActivityLED (void)
{
        if (--g_iMidiActivityRefCount == 0) {
                if (g_pMidiActivityLedOn)
                        delete g_pMidiActivityLedOn;
                g_pMidiActivityLedOn = NULL;
                if (g_pMidiActivityLedOff)
                        delete g_pMidiActivityLedOff;
                g_pMidiActivityLedOff = NULL;
        }
}


void MidiActivityLED::midiActivityLedOn (void)
{
        setPixmap(*g_pMidiActivityLedOn);
        m_timer.start(100);
}


void MidiActivityLED::midiActivityLedOff (void)
{
        setPixmap(*g_pMidiActivityLedOff);
}


//-------------------------------------------------------------------------
// QSampler::DeviceStatusForm -- Device status informations window.
//

std::map<int, DeviceStatusForm *> DeviceStatusForm::g_instances;


DeviceStatusForm::DeviceStatusForm (
        int DeviceID, QWidget *pParent, Qt::WindowFlags wflags )
        : QWidget(pParent, wflags)
{
        m_pDevice = new Device(Device::Midi, DeviceID);

        setLayout(new QGridLayout(/*this*/));
        updateGUIPorts(); // build the GUI

        m_pVisibleAction = new QAction(this);
        m_pVisibleAction->setCheckable(true);
        m_pVisibleAction->setChecked(false);
        m_pVisibleAction->setText(m_pDevice->deviceName());
        m_pVisibleAction->setToolTip(
                QString("MIDI Device ID: ") +
                QString::number(m_pDevice->deviceID())
        );

        QObject::connect(m_pVisibleAction,
                SIGNAL(toggled(bool)),
                SLOT(setVisible(bool))
        );

        setWindowTitle(tr("%1 Status").arg(m_pDevice->deviceName()));
}


void DeviceStatusForm::updateGUIPorts (void)
{
        // refresh device informations
        m_pDevice->setDevice(m_pDevice->deviceType(), m_pDevice->deviceID());
        DevicePortList ports = m_pDevice->ports();

        // clear the GUI
        QGridLayout *pLayout = static_cast<QGridLayout *> (layout());
        for (int i = pLayout->count() - 1; i >= 0; --i) {
                QLayoutItem *pItem = pLayout->itemAt(i);
                if (pItem) {
                        pLayout->removeItem(pItem);
                        if (pItem->widget())
                                delete pItem->widget();
                        delete pItem;
                }
        }

        m_midiActivityLEDs.clear();

        // rebuild the GUI
        for (int i = 0; i < ports.size(); ++i) {
                QLabel *pLabel
                        = new QLabel(tr("MIDI port %1").arg(ports[i]->portName()));
                pLabel->setToolTip(tr("Device ID %1").arg(ports[i]->portID()));
                pLayout->addWidget(pLabel, i, 0, Qt::AlignLeft);
                MidiActivityLED *pLED = new MidiActivityLED();
                m_midiActivityLEDs.push_back(pLED);
                pLayout->addWidget(pLED, i, 1);
        }
}


DeviceStatusForm::~DeviceStatusForm (void)
{
        if (m_pDevice) delete m_pDevice;
}


QAction* DeviceStatusForm::visibleAction (void)
{
        return m_pVisibleAction;
}

void DeviceStatusForm::closeEvent ( QCloseEvent *pCloseEvent )
{
        m_pVisibleAction->setChecked(false);

        pCloseEvent->accept();
}


void DeviceStatusForm::midiArrived ( int iPort )
{
        if (uint(iPort) >= m_midiActivityLEDs.size())
                return;

        m_midiActivityLEDs[iPort]->midiActivityLedOn();
}


DeviceStatusForm *DeviceStatusForm::getInstance ( int iDeviceID )
{
        std::map<int, DeviceStatusForm *>::iterator iter
                = g_instances.find(iDeviceID);
        return ((iter != g_instances.end()) ? iter->second : NULL);
}


const std::map<int, DeviceStatusForm *>& DeviceStatusForm::getInstances (void)
{
        return g_instances;
}

void DeviceStatusForm::deleteAllInstances (void)
{
        std::map<int, DeviceStatusForm *>::iterator iter = g_instances.begin();
        for ( ; iter != g_instances.end(); ++iter) {
                iter->second->hide();
                delete iter->second;
        }

        g_instances.clear();
}


void DeviceStatusForm::onDevicesChanged (void)
{
        MainForm* pMainForm = MainForm::getInstance();
        if (pMainForm && pMainForm->client()) {
                std::set<int> deviceIDs
                        = Device::getDeviceIDs(pMainForm->client(), Device::Midi);
                // hide and delete status forms whose device has been destroyed
                std::map<int, DeviceStatusForm *>::iterator iter = g_instances.begin();
                for ( ; iter != g_instances.end(); ++iter) {
                        if (deviceIDs.find(iter->first) == deviceIDs.end()) {
                                iter->second->hide();
                                delete iter->second;
                                g_instances.erase(iter);
                        }
                }
                // create status forms for new devices
                std::set<int>::iterator it = deviceIDs.begin();
                for ( ; it != deviceIDs.end(); ++iter) {
                        if (g_instances.find(*it) == g_instances.end()) {
                                // What style do we create these forms?
                                Qt::WindowFlags wflags = Qt::Window
                                        | Qt::CustomizeWindowHint
                                        | Qt::WindowTitleHint
                                        | Qt::WindowSystemMenuHint
                                        | Qt::WindowMinMaxButtonsHint
                                        | Qt::WindowCloseButtonHint;
                                Options *pOptions = pMainForm->options();
                                if (pOptions && pOptions->bKeepOnTop)
                                        wflags |= Qt::Tool;
                                // Create the form, giving it the device id.
                                DeviceStatusForm *pStatusForm
                                        = new DeviceStatusForm(*it, NULL, wflags);
                                g_instances[*it] = pStatusForm;
                        }
                }
        }
}


void DeviceStatusForm::onDeviceChanged ( int iDeviceID )
{
        DeviceStatusForm *pStatusForm
                = DeviceStatusForm::getInstance(iDeviceID);
        if (pStatusForm)
                pStatusForm->updateGUIPorts();
}


} // namespace QSampler

// end of qsamplerDeviceStatusForm.cpp
1	schoenebeck	1698	// qsamplerDeviceStatusForm.cpp
2			//
3			/****************************************************************************
4			Copyright (C) 2008, Christian Schoenebeck
5	capela	2038	Copyright (C) 2010, rncbc aka Rui Nuno Capela. All rights reserved.
6	schoenebeck	1698
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
18			along with this program; if not, write to the Free Software
19			Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20
21			*****************************************************************************/
22
23			#include "qsamplerAbout.h"
24			#include "qsamplerDeviceStatusForm.h"
25	capela	2038
26	schoenebeck	1698	#include "qsamplerMainForm.h"
27
28			#include <QGridLayout>
29
30
31			namespace QSampler {
32
33	schoenebeck	1699	//-------------------------------------------------------------------------
34			// QSampler::MidiActivityLED -- Graphical indicator for MIDI activity.
35			//
36
37	capela	2038	// MIDI activity pixmap common resources.
38			int MidiActivityLED::g_iMidiActivityRefCount = 0;
39			QPixmap *MidiActivityLED::g_pMidiActivityLedOn = NULL;
40			QPixmap *MidiActivityLED::g_pMidiActivityLedOff = NULL;
41
42
43			MidiActivityLED::MidiActivityLED ( QString sText, QWidget *pParent )
44			: QLabel(sText, pParent)
45			{
46			if (++g_iMidiActivityRefCount == 1) {
47			g_pMidiActivityLedOn = new QPixmap(":/icons/ledon1.png");
48			g_pMidiActivityLedOff = new QPixmap(":/icons/ledoff1.png");
49			}
50
51			setPixmap(*g_pMidiActivityLedOff);
52			#ifndef CONFIG_EVENT_DEVICE_MIDI
53			setToolTip("MIDI Activity disabled");
54	schoenebeck	1698	#endif
55	capela	2038	m_timer.setSingleShot(true);
56
57			QObject::connect(&m_timer,
58			SIGNAL(timeout()),
59			SLOT(midiActivityLedOff())
60	schoenebeck	1698	);
61			}
62
63	capela	2038	MidiActivityLED::~MidiActivityLED (void)
64			{
65			if (--g_iMidiActivityRefCount == 0) {
66			if (g_pMidiActivityLedOn)
67			delete g_pMidiActivityLedOn;
68			g_pMidiActivityLedOn = NULL;
69			if (g_pMidiActivityLedOff)
70			delete g_pMidiActivityLedOff;
71			g_pMidiActivityLedOff = NULL;
72			}
73	schoenebeck	1698	}
74
75	capela	2038
76			void MidiActivityLED::midiActivityLedOn (void)
77			{
78			setPixmap(*g_pMidiActivityLedOn);
79			m_timer.start(100);
80	schoenebeck	1698	}
81
82	capela	2038
83			void MidiActivityLED::midiActivityLedOff (void)
84			{
85			setPixmap(*g_pMidiActivityLedOff);
86			}
87
88
89	schoenebeck	1699	//-------------------------------------------------------------------------
90			// QSampler::DeviceStatusForm -- Device status informations window.
91			//
92	schoenebeck	1698
93	capela	2038	std::map<int, DeviceStatusForm *> DeviceStatusForm::g_instances;
94	schoenebeck	1698
95	capela	2038
96	schoenebeck	1698	DeviceStatusForm::DeviceStatusForm (
97	capela	2038	int DeviceID, QWidget *pParent, Qt::WindowFlags wflags )
98			: QWidget(pParent, wflags)
99	schoenebeck	1698	{
100			m_pDevice = new Device(Device::Midi, DeviceID);
101
102	capela	2038	setLayout(new QGridLayout(/this/));
103	schoenebeck	1699	updateGUIPorts(); // build the GUI
104	schoenebeck	1698
105			m_pVisibleAction = new QAction(this);
106			m_pVisibleAction->setCheckable(true);
107			m_pVisibleAction->setChecked(false);
108			m_pVisibleAction->setText(m_pDevice->deviceName());
109			m_pVisibleAction->setToolTip(
110			QString("MIDI Device ID: ") +
111			QString::number(m_pDevice->deviceID())
112			);
113	capela	2038
114			QObject::connect(m_pVisibleAction,
115			SIGNAL(toggled(bool)),
116			SLOT(setVisible(bool))
117	schoenebeck	1698	);
118
119	capela	2038	setWindowTitle(tr("%1 Status").arg(m_pDevice->deviceName()));
120	schoenebeck	1698	}
121
122	capela	2038
123			void DeviceStatusForm::updateGUIPorts (void)
124			{
125	schoenebeck	1699	// refresh device informations
126			m_pDevice->setDevice(m_pDevice->deviceType(), m_pDevice->deviceID());
127			DevicePortList ports = m_pDevice->ports();
128
129			// clear the GUI
130	capela	2038	QGridLayout pLayout = static_cast<QGridLayout > (layout());
131	schoenebeck	1699	for (int i = pLayout->count() - 1; i >= 0; --i) {
132	capela	2038	QLayoutItem *pItem = pLayout->itemAt(i);
133			if (pItem) {
134			pLayout->removeItem(pItem);
135			if (pItem->widget())
136			delete pItem->widget();
137			delete pItem;
138			}
139	schoenebeck	1699	}
140
141	capela	2038	m_midiActivityLEDs.clear();
142
143	schoenebeck	1699	// rebuild the GUI
144			for (int i = 0; i < ports.size(); ++i) {
145	capela	2038	QLabel *pLabel
146			= new QLabel(tr("MIDI port %1").arg(ports[i]->portName()));
147			pLabel->setToolTip(tr("Device ID %1").arg(ports[i]->portID()));
148	schoenebeck	1699	pLayout->addWidget(pLabel, i, 0, Qt::AlignLeft);
149	capela	2038	MidiActivityLED *pLED = new MidiActivityLED();
150			m_midiActivityLEDs.push_back(pLED);
151	schoenebeck	1699	pLayout->addWidget(pLED, i, 1);
152			}
153			}
154
155	capela	2038
156			DeviceStatusForm::~DeviceStatusForm (void)
157			{
158	schoenebeck	1698	if (m_pDevice) delete m_pDevice;
159			}
160
161	capela	2038
162			QAction* DeviceStatusForm::visibleAction (void)
163			{
164	schoenebeck	1698	return m_pVisibleAction;
165			}
166
167	capela	2038	void DeviceStatusForm::closeEvent ( QCloseEvent *pCloseEvent )
168			{
169	schoenebeck	1698	m_pVisibleAction->setChecked(false);
170	capela	2038
171			pCloseEvent->accept();
172	schoenebeck	1698	}
173
174	capela	2038
175			void DeviceStatusForm::midiArrived ( int iPort )
176			{
177			if (uint(iPort) >= m_midiActivityLEDs.size())
178			return;
179
180			m_midiActivityLEDs[iPort]->midiActivityLedOn();
181	schoenebeck	1698	}
182
183	capela	2038
184			DeviceStatusForm *DeviceStatusForm::getInstance ( int iDeviceID )
185			{
186			std::map<int, DeviceStatusForm *>::iterator iter
187			= g_instances.find(iDeviceID);
188			return ((iter != g_instances.end()) ? iter->second : NULL);
189	schoenebeck	1698	}
190
191	capela	2038
192			const std::map<int, DeviceStatusForm *>& DeviceStatusForm::getInstances (void)
193			{
194			return g_instances;
195	schoenebeck	1698	}
196
197	capela	2038	void DeviceStatusForm::deleteAllInstances (void)
198			{
199			std::map<int, DeviceStatusForm *>::iterator iter = g_instances.begin();
200			for ( ; iter != g_instances.end(); ++iter) {
201	schoenebeck	1699	iter->second->hide();
202			delete iter->second;
203			}
204	capela	2038
205			g_instances.clear();
206	schoenebeck	1699	}
207
208	capela	2038
209			void DeviceStatusForm::onDevicesChanged (void)
210			{
211	schoenebeck	1698	MainForm* pMainForm = MainForm::getInstance();
212			if (pMainForm && pMainForm->client()) {
213	capela	2038	std::set<int> deviceIDs
214			= Device::getDeviceIDs(pMainForm->client(), Device::Midi);
215	schoenebeck	1698	// hide and delete status forms whose device has been destroyed
216	capela	2038	std::map<int, DeviceStatusForm *>::iterator iter = g_instances.begin();
217			for ( ; iter != g_instances.end(); ++iter) {
218	schoenebeck	1698	if (deviceIDs.find(iter->first) == deviceIDs.end()) {
219			iter->second->hide();
220			delete iter->second;
221	capela	2038	g_instances.erase(iter);
222	schoenebeck	1698	}
223			}
224			// create status forms for new devices
225	capela	2038	std::set<int>::iterator it = deviceIDs.begin();
226			for ( ; it != deviceIDs.end(); ++iter) {
227			if (g_instances.find(*it) == g_instances.end()) {
228			// What style do we create these forms?
229			Qt::WindowFlags wflags = Qt::Window
230			\| Qt::CustomizeWindowHint
231			\| Qt::WindowTitleHint
232			\| Qt::WindowSystemMenuHint
233			\| Qt::WindowMinMaxButtonsHint
234			\| Qt::WindowCloseButtonHint;
235			Options *pOptions = pMainForm->options();
236			if (pOptions && pOptions->bKeepOnTop)
237			wflags \|= Qt::Tool;
238			// Create the form, giving it the device id.
239			DeviceStatusForm *pStatusForm
240			= new DeviceStatusForm(*it, NULL, wflags);
241			g_instances[*it] = pStatusForm;
242	schoenebeck	1698	}
243			}
244			}
245			}
246
247	capela	2038
248			void DeviceStatusForm::onDeviceChanged ( int iDeviceID )
249			{
250			DeviceStatusForm *pStatusForm
251			= DeviceStatusForm::getInstance(iDeviceID);
252			if (pStatusForm)
253			pStatusForm->updateGUIPorts();
254	schoenebeck	1699	}
255
256	capela	2038
257	schoenebeck	1698	} // namespace QSampler
258
259			// end of qsamplerDeviceStatusForm.cpp