trunk/src/qsamplerDeviceStatusForm.cpp

// qsamplerDeviceStatusForm.cpp
//
/****************************************************************************
   Copyright (C) 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

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

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

#include <QGridLayout>

#define MIDI_OFF_COLOR                  Qt::darkGreen
#define MIDI_ON_COLOR                   Qt::green

namespace QSampler {

MidiActivityLED::MidiActivityLED(QString text, QWidget* parent) : QLabel(text, parent) {
#if CONFIG_LSCP_DEVICE_MIDI
        setPalette(MIDI_OFF_COLOR);
        setAutoFillBackground(true);
#else
        setText("X");
        setTooltip("MIDI Activity Disabled");
#endif
        timer.setSingleShot(true);
        QObject::connect(
                &timer, SIGNAL(timeout()),
                this, SLOT(midiDataCeased())
        );
}

void MidiActivityLED::midiDataArrived() {
        setPalette(MIDI_ON_COLOR);
        timer.start(50);
}

void MidiActivityLED::midiDataCeased() {
        setPalette(MIDI_OFF_COLOR);
}


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

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

        if (!centralWidget()) setCentralWidget(new QWidget(this));

        QGridLayout* pLayout = new QGridLayout(centralWidget());
        for (int i = 0; i < ports.size(); ++i) {
                QLabel* pLabel =
                        new QLabel(QString("MIDI port \"") + ports[i]->portName() + "\": ");
                pLabel->setToolTip(QString("Device ID ") + QString::number(ports[i]->portID()));
                pLayout->addWidget(pLabel, i, 0, Qt::AlignLeft);
                MidiActivityLED* pLED = new MidiActivityLED();
                midiActivityLEDs.push_back(pLED);
                pLayout->addWidget(pLED, i, 1);
        }
        centralWidget()->setLayout(pLayout);

        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)),
                this, SLOT(setVisible(bool))
        );

        setWindowTitle(m_pDevice->deviceName() + " Status");
}

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

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

void DeviceStatusForm::closeEvent(QCloseEvent* event) {
        m_pVisibleAction->setChecked(false);
        event->accept();
}

void DeviceStatusForm::midiArrived(int iPort) {
        if (uint(iPort) >= midiActivityLEDs.size()) return;
        midiActivityLEDs[iPort]->midiDataArrived();
}

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

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

void DeviceStatusForm::onDevicesChanged() {
        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
                for (
                        std::map<int, DeviceStatusForm*>::iterator iter = instances.begin();
                        iter != instances.end(); ++iter
                ) {
                        if (deviceIDs.find(iter->first) == deviceIDs.end()) {
                                iter->second->hide();
                                delete iter->second;
                                instances.erase(iter);
                        }
                }
                // create status forms for new devices
                for (
                        std::set<int>::iterator iter = deviceIDs.begin();
                        iter != deviceIDs.end(); ++iter
                ) {
                        if (instances.find(*iter) == instances.end()) {
                                DeviceStatusForm* pStatusForm =
                                        new DeviceStatusForm(*iter, pMainForm);
                                instances[*iter] = pStatusForm;
                        }
                }
        }
}

} // namespace QSampler

// end of qsamplerDeviceStatusForm.cpp
1	// qsamplerDeviceStatusForm.cpp
2	//
3	/****************************************************************************
4	Copyright (C) 2008, Christian Schoenebeck
5
6	This program is free software; you can redistribute it and/or
7	modify it under the terms of the GNU General Public License
8	as published by the Free Software Foundation; either version 2
9	of the License, or (at your option) any later version.
10
11	This program is distributed in the hope that it will be useful,
12	but WITHOUT ANY WARRANTY; without even the implied warranty of
13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	GNU General Public License for more details.
15
16	You should have received a copy of the GNU General Public License
17	along with this program; if not, write to the Free Software
18	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19
20	*****************************************************************************/
21
22	#include "qsamplerAbout.h"
23	#include "qsamplerDeviceStatusForm.h"
24	#include "qsamplerMainForm.h"
25
26	#include <QGridLayout>
27
28	#define MIDI_OFF_COLOR Qt::darkGreen
29	#define MIDI_ON_COLOR Qt::green
30
31	namespace QSampler {
32
33	MidiActivityLED::MidiActivityLED(QString text, QWidget* parent) : QLabel(text, parent) {
34	#if CONFIG_LSCP_DEVICE_MIDI
35	setPalette(MIDI_OFF_COLOR);
36	setAutoFillBackground(true);
37	#else
38	setText("X");
39	setTooltip("MIDI Activity Disabled");
40	#endif
41	timer.setSingleShot(true);
42	QObject::connect(
43	&timer, SIGNAL(timeout()),
44	this, SLOT(midiDataCeased())
45	);
46	}
47
48	void MidiActivityLED::midiDataArrived() {
49	setPalette(MIDI_ON_COLOR);
50	timer.start(50);
51	}
52
53	void MidiActivityLED::midiDataCeased() {
54	setPalette(MIDI_OFF_COLOR);
55	}
56
57
58	std::map<int, DeviceStatusForm*> DeviceStatusForm::instances;
59
60	DeviceStatusForm::DeviceStatusForm (
61	int DeviceID, QWidget* pParent, Qt::WindowFlags wflags )
62	: QMainWindow(pParent, wflags)
63	{
64	m_pDevice = new Device(Device::Midi, DeviceID);
65	DevicePortList ports = m_pDevice->ports();
66
67	if (!centralWidget()) setCentralWidget(new QWidget(this));
68
69	QGridLayout* pLayout = new QGridLayout(centralWidget());
70	for (int i = 0; i < ports.size(); ++i) {
71	QLabel* pLabel =
72	new QLabel(QString("MIDI port \"") + ports[i]->portName() + "\": ");
73	pLabel->setToolTip(QString("Device ID ") + QString::number(ports[i]->portID()));
74	pLayout->addWidget(pLabel, i, 0, Qt::AlignLeft);
75	MidiActivityLED* pLED = new MidiActivityLED();
76	midiActivityLEDs.push_back(pLED);
77	pLayout->addWidget(pLED, i, 1);
78	}
79	centralWidget()->setLayout(pLayout);
80
81	m_pVisibleAction = new QAction(this);
82	m_pVisibleAction->setCheckable(true);
83	m_pVisibleAction->setChecked(false);
84	m_pVisibleAction->setText(m_pDevice->deviceName());
85	m_pVisibleAction->setToolTip(
86	QString("MIDI Device ID: ") +
87	QString::number(m_pDevice->deviceID())
88	);
89	QObject::connect(
90	m_pVisibleAction, SIGNAL(toggled(bool)),
91	this, SLOT(setVisible(bool))
92	);
93
94	setWindowTitle(m_pDevice->deviceName() + " Status");
95	}
96
97	DeviceStatusForm::~DeviceStatusForm() {
98	if (m_pDevice) delete m_pDevice;
99	}
100
101	QAction* DeviceStatusForm::visibleAction() {
102	return m_pVisibleAction;
103	}
104
105	void DeviceStatusForm::closeEvent(QCloseEvent* event) {
106	m_pVisibleAction->setChecked(false);
107	event->accept();
108	}
109
110	void DeviceStatusForm::midiArrived(int iPort) {
111	if (uint(iPort) >= midiActivityLEDs.size()) return;
112	midiActivityLEDs[iPort]->midiDataArrived();
113	}
114
115	DeviceStatusForm* DeviceStatusForm::getInstance(int iDeviceID) {
116	std::map<int, DeviceStatusForm*>::iterator iter =
117	instances.find(iDeviceID);
118	return (iter != instances.end()) ? iter->second : NULL;
119	}
120
121	const std::map<int, DeviceStatusForm*>& DeviceStatusForm::getInstances() {
122	return instances;
123	}
124
125	void DeviceStatusForm::onDevicesChanged() {
126	MainForm* pMainForm = MainForm::getInstance();
127	if (pMainForm && pMainForm->client()) {
128	std::set<int> deviceIDs =
129	Device::getDeviceIDs(pMainForm->client(), Device::Midi);
130	// hide and delete status forms whose device has been destroyed
131	for (
132	std::map<int, DeviceStatusForm*>::iterator iter = instances.begin();
133	iter != instances.end(); ++iter
134	) {
135	if (deviceIDs.find(iter->first) == deviceIDs.end()) {
136	iter->second->hide();
137	delete iter->second;
138	instances.erase(iter);
139	}
140	}
141	// create status forms for new devices
142	for (
143	std::set<int>::iterator iter = deviceIDs.begin();
144	iter != deviceIDs.end(); ++iter
145	) {
146	if (instances.find(*iter) == instances.end()) {
147	DeviceStatusForm* pStatusForm =
148	new DeviceStatusForm(*iter, pMainForm);
149	instances[*iter] = pStatusForm;
150	}
151	}
152	}
153	}
154
155	} // namespace QSampler
156
157	// end of qsamplerDeviceStatusForm.cpp