());
releaseKb();
shcutDlg.exec();
grabKb();
#endif
}
void VPiano::slotBankNext()
{
int index = m_comboBank->currentIndex();
if (index < m_comboBank->count()-1) {
m_comboBank->setCurrentIndex(++index);
slotComboBankActivated(index);
}
}
void VPiano::slotBankPrev()
{
int index = m_comboBank->currentIndex();
if (index > 0) {
m_comboBank->setCurrentIndex(--index);
slotComboBankActivated(index);
}
}
void VPiano::slotProgramNext()
{
int index = m_comboProg->currentIndex();
if (index < m_comboProg->count()-1) {
m_comboProg->setCurrentIndex(++index);
slotComboProgActivated(index);
}
}
void VPiano::slotProgramPrev()
{
int index = m_comboProg->currentIndex();
if (index > 0) {
m_comboProg->setCurrentIndex(--index);
slotComboProgActivated(index);
}
}
void VPiano::slotControllerNext()
{
int index = m_comboControl->currentIndex();
if (index < m_comboControl->count()-1)
m_comboControl->setCurrentIndex(++index);
}
void VPiano::slotControllerPrev()
{
int index = m_comboControl->currentIndex();
if (index > 0)
m_comboControl->setCurrentIndex(--index);
}
void VPiano::slotVelocityUp()
{
m_Velocity->triggerAction(Knob::SliderPageStepAdd);
}
void VPiano::slotVelocityDown()
{
m_Velocity->triggerAction(Knob::SliderPageStepSub);
}
void VPiano::slotControllerUp()
{
m_Control->triggerAction(Knob::SliderPageStepAdd);
slotControlSliderMoved(m_Control->value());
}
void VPiano::slotControllerDown()
{
m_Control->triggerAction(Knob::SliderPageStepSub);
slotControlSliderMoved(m_Control->value());
}
QString VPiano::configuredLanguage()
{
if (m_language.isEmpty()) {
QSettings settings;
QString defLang = QLocale::system().name();
settings.beginGroup(QSTR_PREFERENCES);
m_language = settings.value(QSTR_LANGUAGE, defLang).toString();
settings.endGroup();
//qDebug() << Q_FUNC_INFO << m_language;
}
return m_language;
}
void VPiano::slotSwitchLanguage(QAction *action)
{
QString lang = action->data().toString();
if ( QMessageBox::question (this, tr("Language Changed"),
tr("The language for this application is going to change to %1. "
"Do you want to continue?").arg(m_supportedLangs[lang]),
QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes )
{
m_language = lang;
retranslateUi();
} else {
m_currentLang->setChecked(true);
}
}
void VPiano::createLanguageMenu()
{
QString currentLang = configuredLanguage();
QActionGroup *languageGroup = new QActionGroup(this);
connect(languageGroup, SIGNAL(triggered(QAction *)),
SLOT(slotSwitchLanguage(QAction *)));
QDir dir(VPiano::localeDirectory());
QStringList fileNames = dir.entryList(QStringList(QSTR_VMPKPX + "*.qm"));
QStringList locales;
locales << "en";
foreach (const QString& fileName, fileNames) {
QString locale = fileName;
locale.remove(0, locale.indexOf('_') + 1);
locale.truncate(locale.lastIndexOf('.'));
locales << locale;
}
locales.sort();
foreach (const QString& loc, locales) {
QAction *action = new QAction(m_supportedLangs.value(loc), this);
action->setCheckable(true);
action->setData(loc);
ui.menuLanguage->addAction(action);
languageGroup->addAction(action);
if (currentLang.startsWith(loc)) {
action->setChecked(true);
m_currentLang = action;
}
}
}
void VPiano::slotAboutTranslation()
{
QString common = tr("VMPK is developed and translated thanks to the "
"volunteer work of many people from around the world. If you want to "
"join the team or have any question, please visit the forums at "
"SourceForge"
"
");
QString currentLang = configuredLanguage();
bool supported(false);
if (!currentLang.startsWith("en")) {
QMapIterator it(m_supportedLangs);
while (it.hasNext()) {
it.next();
if (currentLang.startsWith(it.key())) {
supported = true;
break;
}
}
}
if (supported)
QMessageBox::information(this, tr("Translation"),
tr("Translation by TRANSLATOR_NAME_AND_EMAIL
%1").arg(common));
else
QMessageBox::information(this, tr("Translation Information"), common);
}
void VPiano::retranslateUi()
{
m_trq->load( QSTR_QTPX + configuredLanguage(),
QLibraryInfo::location(QLibraryInfo::TranslationsPath) );
m_trp->load( QSTR_VMPKPX + configuredLanguage(),
VPiano::localeDirectory() );
ui.retranslateUi(this);
ui.pianokeybd->retranslate();
initLanguages();
ui.menuLanguage->clear();
createLanguageMenu();
retranslateToolbars();
if (m_dlgAbout != 0)
m_dlgAbout->retranslateUi();
if (m_dlgPreferences != 0)
m_dlgPreferences->retranslateUi();
if (m_dlgMidiSetup != 0)
m_dlgMidiSetup->retranslateUi();
#if !defined(SMALL_SCREEN)
if (m_dlgKeyMap != 0)
m_dlgKeyMap->retranslateUi();
#endif
if (m_dlgExtra != 0)
m_dlgExtra->retranslateUi();
if (m_dlgRiffImport != 0)
m_dlgRiffImport->retranslateUi();
}
void VPiano::initLanguages()
{
m_supportedLangs.clear();
m_supportedLangs.insert(QLatin1String("cs"), tr("Czech"));
m_supportedLangs.insert(QLatin1String("de"), tr("German"));
m_supportedLangs.insert(QLatin1String("en"), tr("English"));
m_supportedLangs.insert(QLatin1String("es"), tr("Spanish"));
m_supportedLangs.insert(QLatin1String("fr"), tr("French"));
m_supportedLangs.insert(QLatin1String("nl"), tr("Dutch"));
m_supportedLangs.insert(QLatin1String("ru"), tr("Russian"));
m_supportedLangs.insert(QLatin1String("sv"), tr("Swedish"));
m_supportedLangs.insert(QLatin1String("zh_CN"), tr("Chinese"));
}
void VPiano::retranslateToolbars()
{
m_lblChannel->setText(
#if defined(SMALL_SCREEN)
tr("Chan:")
#else
tr("Channel:")
#endif
);
m_lblBaseOctave->setText(
#if defined(SMALL_SCREEN)
tr("Oct:")
#else
tr("Base Octave:")
#endif
);
m_lblTranspose->setText(
#if defined(SMALL_SCREEN)
tr("Trans:")
#else
tr("Transpose:")
#endif
);
m_lblVelocity->setText(
#if defined(SMALL_SCREEN)
tr("Vel:")
#else
tr("Velocity:")
#endif
);
m_lblBank->setText(tr("Bank:"));
m_lblBender->setText(tr("Bender:"));
m_lblControl->setText(tr("Control:"));
m_lblProgram->setText(tr("Program:"));
m_lblValue->setText(tr("Value:"));
}
QMenu * VPiano::createPopupMenu ()
{
#if defined(SMALL_SCREEN)
return 0;
#else
return QMainWindow::createPopupMenu();
#endif
}
vmpk-0.4.0/src/keyboardmap.cpp 0000644 0001750 0000144 00000011256 11572642326 015326 0 ustar pedro users /*
MIDI Virtual Piano Keyboard
Copyright (C) 2008-2011, Pedro Lopez-Cabanillas
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 3 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, see .
*/
#include "keyboardmap.h"
#include
#include
#include
#include
#include
void KeyboardMap::loadFromXMLFile(const QString fileName)
{
QFile f(fileName);
if (f.open(QFile::ReadOnly | QFile::Text)) {
initializeFromXML(&f);
f.close();
m_fileName = fileName;
//qDebug() << "Loaded Map: " << fileName;
}
if (f.error() != QFile::NoError) {
reportError(fileName, tr("Error loading a file"), f.errorString());
}
}
void KeyboardMap::saveToXMLFile(const QString fileName)
{
QFile f(fileName);
if (f.open(QFile::WriteOnly | QFile::Text)) {
serializeToXML(&f);
f.close();
m_fileName = fileName;
//qDebug() << "Saved Map: " << fileName;
}
if (f.error() != QFile::NoError) {
reportError(fileName, tr("Error saving a file"), f.errorString());
}
}
void KeyboardMap::initializeFromXML(QIODevice *dev)
{
QXmlStreamReader reader(dev);
clear();
while (!reader.atEnd()) {
reader.readNext();
if (reader.isStartElement()) {
if (reader.name() == (m_rawMode?"rawkeymap":"keyboardmap")) {
reader.readNext();
while (reader.isWhitespace())
reader.readNext();
while (reader.isStartElement()) {
if (reader.name() == "mapping") {
QString key = reader.attributes().value(m_rawMode?"keycode":"key").toString();
QString sn = reader.attributes().value("note").toString();
bool ok = false;
int note = sn.toInt(&ok);
if (ok) {
if (m_rawMode) {
int keycode = key.toInt(&ok);
if (ok) insert(keycode, note);
} else {
QKeySequence ks(key);
insert(ks[0], note);
}
}
}
reader.readNext();
while (reader.isWhitespace() || reader.isEndElement())
reader.readNext();
}
} else {
reader.readNext();
}
}
}
if (reader.hasError()) {
reportError(QString(), tr("Error reading XML"), reader.errorString() );
}
}
void KeyboardMap::serializeToXML(QIODevice *dev)
{
QXmlStreamWriter writer(dev);
writer.setAutoFormatting(true);
//writer.setCodec("UTF-8");
writer.writeStartDocument();
writer.writeDTD(m_rawMode?"":"");
writer.writeStartElement(m_rawMode ? "rawkeymap" : "keyboardmap");
writer.writeAttribute("version", "1.0");
foreach(int key, keys()) {
writer.writeEmptyElement("mapping");
if (m_rawMode)
writer.writeAttribute("keycode", QString::number(key));
else {
QKeySequence ks(key);
writer.writeAttribute("key", ks.toString(QKeySequence::PortableText));
}
writer.writeAttribute("note", QString::number(value(key)));
}
writer.writeEndElement();
writer.writeEndDocument();
}
void KeyboardMap::copyFrom(const KeyboardMap* other)
{
m_fileName = other->getFileName();
m_rawMode = other->getRawMode();
clear();
KeyboardMap::ConstIterator it;
for(it = other->begin(); it != other->end(); ++it)
insert(it.key(), it.value());
}
void KeyboardMap::reportError( const QString filename,
const QString title,
const QString err )
{
QMessageBox::warning(0, title, tr("File: %1\n%2").arg(filename).arg(err));
}
vmpk-0.4.0/src/preferences.cpp 0000644 0001750 0000144 00000021554 11572642326 015333 0 ustar pedro users /*
MIDI Virtual Piano Keyboard
Copyright (C) 2008-2011, Pedro Lopez-Cabanillas
This library 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 3 of the License, or
(at your option) any later version.
This library 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, see .
*/
#include "preferences.h"
#include "constants.h"
#include "vpiano.h"
#include
#include
#include
#include
#include
Preferences::Preferences(QWidget *parent)
: QDialog(parent),
m_numOctaves(DEFAULTNUMBEROFOCTAVES),
m_drumsChannel(MIDIGMDRUMSCHANNEL),
m_networkPort(NETWORKPORTNUMBER),
m_grabKb(false),
m_styledKnobs(true),
m_alwaysOnTop(false),
m_rawKeyboard(false),
m_velocityColor(true)
{
ui.setupUi( this );
ui.txtFileInstrument->setText(QSTR_DEFAULT);
ui.txtFileKmap->setText(QSTR_DEFAULT);
ui.txtFileRawKmap->setText(QSTR_DEFAULT);
m_keymap.setRawMode(false);
m_rawmap.setRawMode(true);
restoreDefaults();
connect(ui.btnInstrument, SIGNAL(clicked()), SLOT(slotOpenInstrumentFile()));
connect(ui.btnColor, SIGNAL(clicked()), SLOT(slotSelectColor()));
connect(ui.btnKmap, SIGNAL(clicked()), SLOT(slotOpenKeymapFile()));
connect(ui.btnRawKmap, SIGNAL(clicked()), SLOT(slotOpenRawKeymapFile()));
QPushButton *btnDefaults = ui.buttonBox->button(QDialogButtonBox::RestoreDefaults);
connect(btnDefaults, SIGNAL(clicked()), SLOT(slotRestoreDefaults()));
#if !defined(RAWKBD_SUPPORT)
ui.chkRawKeyboard->setVisible(false);
ui.lblRawKmap->setVisible(false);
ui.txtFileRawKmap->setVisible(false);
ui.btnRawKmap->setVisible(false);
#endif
#if !defined(NETWORK_MIDI)
ui.lblNetworkPort->setVisible(false);
ui.txtNetworkPort->setVisible(false);
#endif
#if defined(SMALL_SCREEN)
ui.chkRawKeyboard->setVisible(false);
ui.lblRawKmap->setVisible(false);
ui.txtFileRawKmap->setVisible(false);
ui.btnRawKmap->setVisible(false);
ui.lblKmap->setVisible(false);
ui.txtFileKmap->setVisible(false);
ui.btnKmap->setVisible(false);
ui.chkAlwaysOnTop->setVisible(false);
ui.chkGrabKb->setVisible(false);
setWindowState(Qt::WindowActive | Qt::WindowMaximized);
#else
setMinimumSize(480,320);
adjustSize();
#endif
}
void Preferences::showEvent ( QShowEvent *event )
{
if (event->type() == QEvent::Show) {
ui.spinNumOctaves->setValue( m_numOctaves );
ui.cboDrumsChannel->setCurrentIndex(m_drumsChannel+1);
ui.chkGrabKb->setChecked( m_grabKb );
ui.chkStyledKnobs->setChecked( m_styledKnobs );
ui.chkAlwaysOnTop->setChecked( m_alwaysOnTop );
ui.chkRawKeyboard->setChecked( m_rawKeyboard );
ui.chkVelocityColor->setChecked( m_velocityColor );
ui.txtNetworkPort->setText( QString::number( m_networkPort ));
if (!m_keyPressedColor.isValid()) {
setKeyPressedColor(QApplication::palette().highlight().color());
}
}
}
void Preferences::apply()
{
m_numOctaves = ui.spinNumOctaves->value();
m_keyPressedColor = QColor(ui.lblColorName->text());
m_grabKb = ui.chkGrabKb->isChecked();
m_styledKnobs = ui.chkStyledKnobs->isChecked();
m_alwaysOnTop = ui.chkAlwaysOnTop->isChecked();
m_rawKeyboard = ui.chkRawKeyboard->isChecked();
m_velocityColor = ui.chkVelocityColor->isChecked();
if ( ui.txtFileRawKmap->text().isEmpty() ||
ui.txtFileRawKmap->text() == QSTR_DEFAULT)
m_rawmap.setFileName(QSTR_DEFAULT);
if ( ui.txtFileKmap->text().isEmpty() ||
ui.txtFileKmap->text() == QSTR_DEFAULT)
m_keymap.setFileName(QSTR_DEFAULT);
if ( ui.txtFileInstrument->text().isEmpty() ||
ui.txtFileInstrument->text() == QSTR_DEFAULT )
m_insFileName = QSTR_DEFAULT;
m_drumsChannel = ui.cboDrumsChannel->currentIndex() - 1;
m_networkPort = ui.txtNetworkPort->text().toInt();
}
void Preferences::accept()
{
apply();
QDialog::accept();
}
void Preferences::slotOpenInstrumentFile()
{
QString fileName = QFileDialog::getOpenFileName(this,
tr("Open instruments definition"),
VPiano::dataDirectory(),
tr("Instrument definitions (*.ins)"));
if (!fileName.isEmpty()) {
setInstrumentsFileName(fileName);
}
}
void Preferences::slotSelectColor()
{
QColor color = QColorDialog::getColor(m_keyPressedColor, this);
setKeyPressedColor(color);
}
Instrument* Preferences::getInstrument()
{
QString key = ui.cboInstrument->currentText();
if (key.isEmpty())
return NULL;
if (!m_ins.contains(key))
return NULL;
return &m_ins[key];
}
Instrument* Preferences::getDrumsInstrument()
{
QString key = ui.cboInstrument->currentText();
if (key.isEmpty())
return NULL;
key.append(" Drums");
if (!m_ins.contains(key))
return NULL;
return &m_ins[key];
}
void Preferences::setInstrumentsFileName( const QString fileName )
{
QFileInfo f(fileName);
if (f.isReadable()) {
m_ins.clear();
ui.cboInstrument->clear();
if (m_ins.load(fileName)) {
ui.txtFileInstrument->setText(f.fileName());
InstrumentList::ConstIterator it;
for(it = m_ins.constBegin(); it != m_ins.constEnd(); ++it) {
if(!it.key().endsWith(QLatin1String("Drums"), Qt::CaseInsensitive))
ui.cboInstrument->addItem(it.key());
}
ui.cboInstrument->setCurrentIndex(-1);
m_insFileName = fileName;
} else {
m_insFileName.clear();
ui.txtFileInstrument->setText(m_insFileName);
}
} else {
qDebug() << "file" << fileName << "not readable.";
}
}
QString Preferences::getInstrumentsFileName()
{
return m_insFileName;
}
void Preferences::setInstrumentName( const QString name )
{
int index = ui.cboInstrument->findText( name );
ui.cboInstrument->setCurrentIndex( index );
}
QString Preferences::getInstrumentName()
{
return ui.cboInstrument->currentText();
}
void Preferences::setKeyPressedColor(QColor value)
{
if (m_keyPressedColor != value && value.isValid()) {
m_keyPressedColor = value;
ui.lblColorName->setText(value.name());
ui.lblColorName->setPalette(QPalette(value));
ui.lblColorName->setAutoFillBackground(true);
}
}
void Preferences::slotOpenKeymapFile()
{
QString fileName = QFileDialog::getOpenFileName(0,
tr("Open keyboard map definition"),
VPiano::dataDirectory(),
tr("Keyboard map (*.xml)"));
if (!fileName.isEmpty()) {
setKeyMapFileName(fileName);
}
}
void Preferences::slotOpenRawKeymapFile()
{
QString fileName = QFileDialog::getOpenFileName(0,
tr("Open keyboard map definition"),
VPiano::dataDirectory(),
tr("Keyboard map (*.xml)"));
if (!fileName.isEmpty()) {
setRawKeyMapFileName(fileName);
}
}
void Preferences::setRawKeyMapFileName( const QString fileName )
{
QFileInfo f(fileName);
if (f.isReadable()) {
m_rawmap.loadFromXMLFile(fileName);
ui.txtFileRawKmap->setText(f.fileName());
} else {
m_rawmap.clear();
m_rawmap.setFileName(QSTR_DEFAULT);
}
}
void Preferences::setKeyMapFileName( const QString fileName )
{
QFileInfo f(fileName);
if (f.isReadable()) {
m_keymap.loadFromXMLFile(fileName);
ui.txtFileKmap->setText(f.fileName());
} else {
m_keymap.clear();
m_keymap.setFileName(QSTR_DEFAULT);
}
}
void Preferences::restoreDefaults()
{
ui.chkAlwaysOnTop->setChecked(false);
ui.chkGrabKb->setChecked(false);
ui.chkRawKeyboard->setChecked(false);
ui.chkStyledKnobs->setChecked(true);
ui.spinNumOctaves->setValue(DEFAULTNUMBEROFOCTAVES);
ui.txtFileKmap->setText(QSTR_DEFAULT);
ui.txtFileRawKmap->setText(QSTR_DEFAULT);
ui.chkVelocityColor->setChecked(true);
setInstrumentsFileName(VPiano::dataDirectory() + QSTR_DEFAULTINS);
ui.cboInstrument->setCurrentIndex(0);
ui.txtNetworkPort->setText(QString::number(NETWORKPORTNUMBER));
}
void Preferences::slotRestoreDefaults()
{
restoreDefaults();
setKeyPressedColor(QApplication::palette().highlight().color());
}
void Preferences::retranslateUi()
{
ui.retranslateUi(this);
}
vmpk-0.4.0/src/instrument.h 0000644 0001750 0000144 00000022272 11572642326 014705 0 ustar pedro users /*
MIDI Virtual Piano Keyboard
Copyright (C) 2008-2011, Pedro Lopez-Cabanillas
For this file, the following copyright notice is also applicable:
Copyright (C) 2005-2011, rncbc aka Rui Nuno Capela. All rights reserved.
See http://qtractor.sourceforge.net
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 3 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, see .
*/
/* Library of compatible instrument definitions:
ftp://ftp.cakewalk.com/pub/InstrumentDefinitions/ */
#ifndef __instrument_h
#define __instrument_h
#include
#include
// Forward declarations.
class QTextStream;
//----------------------------------------------------------------------
// class InstrumentData -- instrument definition data classes.
//
class InstrumentData
{
public:
typedef QMap DataMap;
// Constructor.
InstrumentData()
: m_pData(new DataRef()) {}
// Copy constructor.
InstrumentData(const InstrumentData& data)
{ attach(data); }
// Destructor.
~InstrumentData()
{ detach(); }
// Assignment operator.
InstrumentData& operator= (const InstrumentData& data)
{
if (m_pData != data.m_pData) {
detach();
attach(data);
}
return *this;
}
// Accessor operator.
QString& operator[] (int iIndex) const
{ return m_pData->map[iIndex]; }
// Property accessors.
void setName(const QString& sName)
{ m_pData->name = sName; }
const QString& name() const { return m_pData->name; }
void setBasedOn(const QString& sBasedOn)
{ m_pData->basedOn = sBasedOn; }
const QString& basedOn() const { return m_pData->basedOn; }
// Indirect iterator stuff.
typedef DataMap::Iterator Iterator;
Iterator begin() { return m_pData->map.begin(); }
Iterator end() { return m_pData->map.end(); }
typedef DataMap::ConstIterator ConstIterator;
ConstIterator constBegin() const { return m_pData->map.constBegin(); }
ConstIterator constEnd() const { return m_pData->map.constEnd(); }
unsigned int count() const { return m_pData->map.count(); }
bool contains(int iKey) const
{ return m_pData->map.contains(iKey); }
protected:
// Copy/clone method.
void attach(const InstrumentData& data)
{ m_pData = data.m_pData; m_pData->refCount++; }
// Destroy method.
void detach()
{ if (--(m_pData->refCount) == 0) delete m_pData; }
private:
// The ref-counted data.
struct DataRef
{
// Default payload constructor.
DataRef() : refCount(1) {};
// Payload members.
int refCount;
QString name;
QString basedOn;
DataMap map;
} * m_pData;
};
class InstrumentDataList
: public QMap {};
class InstrumentPatches
: public QMap {};
class InstrumentNotes
: public QMap {};
class InstrumentKeys
: public QMap {};
class InstrumentDrumFlags
: public QMap {};
class InstrumentDrums
: public QMap {};
//----------------------------------------------------------------------
// class Instrument -- instrument definition instance class.
//
class Instrument
{
public:
// Constructor.
Instrument()
: m_pData(new DataRef()) {}
// Copy constructor.
Instrument(const Instrument& instr)
{ attach(instr); }
// Destructor.
~Instrument()
{ detach(); }
// Assignment operator.
Instrument& operator= (const Instrument& instr)
{
if (m_pData != instr.m_pData) {
detach();
attach(instr);
}
return *this;
}
// Instrument title property accessors.
void setInstrumentName(const QString& sInstrumentName)
{ m_pData->instrumentName = sInstrumentName; }
const QString& instrumentName() const
{ return m_pData->instrumentName; }
// BankSelMethod accessors.
void setBankSelMethod(int iBankSelMethod)
{ m_pData->bankSelMethod = iBankSelMethod; }
int bankSelMethod() const { return m_pData->bankSelMethod; }
void setUsesNotesAsControllers(bool bUsesNotesAsControllers)
{ m_pData->usesNotesAsControllers = bUsesNotesAsControllers; }
bool usesNotesAsControllers() const
{ return m_pData->usesNotesAsControllers; }
// Patch banks accessors.
const InstrumentPatches& patches() const
{ return m_pData->patches; }
const InstrumentData& patch(int iBank) const;
void setPatch(int iBank, const InstrumentData& patch)
{ m_pData->patches[iBank] = patch; }
// Control names accessors.
void setControlName(const QString& sControlName)
{ m_pData->control.setName(sControlName); }
const QString& controlName() const
{ return m_pData->control.name(); }
void setControl(const InstrumentData& control)
{ m_pData->control = control; }
const InstrumentData& control() const
{ return m_pData->control; }
// RPN names accessors.
void setRpnName(const QString& sRpnName)
{ m_pData->rpn.setName(sRpnName); }
const QString& rpnName() const
{ return m_pData->rpn.name(); }
void setRpn(const InstrumentData& rpn)
{ m_pData->rpn = rpn; }
const InstrumentData& rpn() const
{ return m_pData->rpn; }
// NRPN names accessors.
void setNrpnName(const QString& sNrpnName)
{ m_pData->nrpn.setName(sNrpnName); }
const QString& nrpnName() const
{ return m_pData->nrpn.name(); }
void setNrpn(const InstrumentData& nrpn)
{ m_pData->nrpn = nrpn; }
const InstrumentData& nrpn() const
{ return m_pData->nrpn; }
// Keys banks accessors.
const InstrumentData& notes(int iBank, int iProg) const;
void setNotes(int iBank, int iProg, const InstrumentData& notes)
{ m_pData->keys[iBank][iProg] = notes; }
const InstrumentKeys& keys() const
{ return m_pData->keys; }
// Drumflags banks accessors.
bool isDrum(int iBank, int iProg) const;
void setDrum(int iBank, int iProg, bool bDrum)
{ m_pData->drums[iBank][iProg] = (int) bDrum; }
const InstrumentDrums& drums() const
{ return m_pData->drums; }
protected:
// Copy/clone method.
void attach(const Instrument& instr)
{ m_pData = instr.m_pData; m_pData->refCount++; }
// Destroy method.
void detach()
{ if (--(m_pData->refCount) == 0) delete m_pData; }
private:
// The ref-counted data.
struct DataRef
{
// Default payload constructor.
DataRef() : refCount(1),
bankSelMethod(0), usesNotesAsControllers(false) {};
// Payload members.
int refCount;
int bankSelMethod;
bool usesNotesAsControllers;
QString instrumentName;
InstrumentPatches patches;
InstrumentData control;
InstrumentData rpn;
InstrumentData nrpn;
InstrumentKeys keys;
InstrumentDrums drums;
} * m_pData;
};
//----------------------------------------------------------------------
// class InstrumentList -- A Cakewalk .ins file container class.
//
class InstrumentList : public QMap
{
public:
// Open file methods.
bool load(const QString& sFilename);
bool save(const QString& sFilename);
// The official loaded file list.
const QStringList& files() const;
// Manage a file list (out of sync)
void appendFile(const QString& sFilename)
{ m_files.append(sFilename); }
void removeFile(const QString& sFilename)
{
int iFile = m_files.indexOf(sFilename);
if (iFile >= 0)
m_files.removeAt(iFile);
}
// Patch Names definition accessors.
const InstrumentDataList& patches() const
{ return m_patches; }
const InstrumentData& patch(const QString& sName)
{ return m_patches[sName]; }
// Note Names definition accessors.
const InstrumentDataList& notes() const
{ return m_notes; }
InstrumentData& note(const QString& sName)
{ return m_notes[sName]; }
// Controller Names definition accessors.
const InstrumentDataList& controllers() const
{ return m_controllers; }
InstrumentData& controller(const QString& sName)
{ return m_controllers[sName]; }
// RPN Names definition accessors.
const InstrumentDataList& rpns() const
{ return m_rpns; }
InstrumentData& rpn(const QString& sName)
{ return m_rpns[sName]; }
// NRPN Names definition accessors.
const InstrumentDataList& nrpns() const
{ return m_nrpns; }
InstrumentData& nrpn(const QString& sName)
{ return m_nrpns[sName]; }
// Clear all contents.
void clearAll();
// Special instrument list merge method.
void merge(const InstrumentList& instruments);
protected:
// Internal instrument data list save method helpers.
void saveDataList(QTextStream& ts, const InstrumentDataList& list);
void saveData(QTextStream& ts, const InstrumentData& data);
// Special instrument data list merge method.
void mergeDataList(InstrumentDataList& dst,
const InstrumentDataList& src);
private:
// To hold the names definition lists.
InstrumentDataList m_patches;
InstrumentDataList m_notes;
InstrumentDataList m_controllers;
InstrumentDataList m_rpns;
InstrumentDataList m_nrpns;
// To old the official file list.
QStringList m_files;
};
#endif // __instrument_h
vmpk-0.4.0/src/events.h 0000644 0001750 0000144 00000007051 11572642326 013777 0 ustar pedro users /*
MIDI Virtual Piano Keyboard
Copyright (C) 2008-2011, Pedro Lopez-Cabanillas
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 3 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, see .
*/
#ifndef EVENTS_H
#define EVENTS_H
#include "mididefs.h"
#include
const QEvent::Type NoteOffEventType = QEvent::Type(
QEvent::registerEventType( QEvent::User + STATUS_NOTEOFF ) );
const QEvent::Type NoteOnEventType = QEvent::Type(
QEvent::registerEventType( QEvent::User + STATUS_NOTEON ) );
const QEvent::Type PolyKeyPressEventType = QEvent::Type(
QEvent::registerEventType( QEvent::User + STATUS_POLYAFT ) );
const QEvent::Type ControlChangeEventType = QEvent::Type(
QEvent::registerEventType( QEvent::User + STATUS_CTLCHG ) );
const QEvent::Type ProgramChangeEventType = QEvent::Type(
QEvent::registerEventType( QEvent::User + STATUS_PROGRAM ) );
const QEvent::Type ChannelKeyPressEventType = QEvent::Type(
QEvent::registerEventType( QEvent::User + STATUS_CHANAFT ) );
const QEvent::Type PitchWheelEventType = QEvent::Type(
QEvent::registerEventType( QEvent::User + STATUS_BENDER) );
class NoteEvent : public QEvent
{
public:
NoteEvent(unsigned char note, unsigned char val, QEvent::Type type)
: QEvent(type), m_note(note), m_value(val) { }
unsigned char getNote() const { return m_note; }
unsigned char getValue() const { return m_value; }
protected:
unsigned char m_note;
unsigned char m_value;
};
class NoteOffEvent : public NoteEvent
{
public:
NoteOffEvent(unsigned char note, unsigned char vel)
: NoteEvent(note, vel, NoteOffEventType) { }
};
class NoteOnEvent : public NoteEvent
{
public:
NoteOnEvent(unsigned char note, unsigned char vel)
: NoteEvent(note, vel, NoteOnEventType) { }
};
class PolyKeyPressEvent : public NoteEvent
{
public:
PolyKeyPressEvent(unsigned char note, unsigned char value)
: NoteEvent(note, value, PolyKeyPressEventType) { }
};
class ControlChangeEvent : public QEvent
{
public:
ControlChangeEvent(unsigned char ctl, unsigned char value)
: QEvent(ControlChangeEventType), m_ctl(ctl), m_value(value) { }
unsigned char getController() const { return m_ctl; }
unsigned char getValue() const { return m_value; }
private:
unsigned char m_ctl;
unsigned char m_value;
};
class ValueEvent : public QEvent
{
public:
ValueEvent(int value, QEvent::Type type)
: QEvent(type), m_value(value) { }
int getValue() const { return m_value; }
private:
int m_value;
};
class ProgramChangeEvent : public ValueEvent
{
public:
ProgramChangeEvent(unsigned char value)
: ValueEvent(value, ProgramChangeEventType) { }
};
class ChannelKeyPressEvent : public ValueEvent
{
public:
ChannelKeyPressEvent(unsigned char value)
: ValueEvent(value, ChannelKeyPressEventType) { }
};
class PitchWheelEvent : public ValueEvent
{
public:
PitchWheelEvent(int value)
: ValueEvent(value, PitchWheelEventType) { }
};
#endif /* EVENTS_H */
vmpk-0.4.0/src/vpiano.ui 0000644 0001750 0000144 00000054357 11572642326 014170 0 ustar pedro users
MIDI Virtual Piano Keyboard
Copyright (C) 2008-2011, Pedro Lopez-Cabanillas
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 3 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, see http://www.gnu.org/licenses/
VPiano
0
0
573
223
Virtual MIDI Piano Keyboard
:/vpiano/vmpk_32x32.png:/vpiano/vmpk_32x32.png
0
-
true
0
0
&Notes
Qt::ToolButtonTextOnly
TopToolBarArea
false
0
0
&Controllers
Qt::ToolButtonTextOnly
TopToolBarArea
true
0
0
Pitch &Bender
Qt::ToolButtonTextOnly
TopToolBarArea
true
0
0
&Programs
Qt::ToolButtonTextOnly
TopToolBarArea
true
0
0
&Extra Controls
Qt::ToolButtonTextOnly
TopToolBarArea
true
&Quit
Exit the program
&Preferences
Edit the program settings
&Connections
Edit the MIDI connections
&About
Show the About box
About &Qt
Show the Qt about box
true
&Notes
Show or hide the Notes toolbar
true
&Controllers
Show or hide the Controller toolbar
true
Pitch &Bender
Show or hide the Pitch Bender toolbar
true
&Programs
Show or hide the Programs toolbar
true
true
&Status Bar
Show or hide the Status Bar
Panic
Stops all active notes
Esc
Reset All
Resets all the controllers
Reset
Resets the Bender value
&Keyboard Map
Edit the current keyboard layout
&Contents
Open the index of the help document
F1
VMPK &Web site
Open the VMPK web site address using a web browser
&Import SoundFont...
Import SoundFont
true
&Extra Controls
Show or hide the Extra Controls toolbar
Edit
Open the Extra Controls editor
false
Edit
Open the Banks/Programs editor
false
false
&Extra Controllers
Open the Extra Controls editor
true
N&ote Names
Show or hide the note names
&Shortcuts
Open the Shortcuts editor
Octave Up
Play one octave higher
Right
Octave Down
Play one octave lower
Left
Transpose Up
Transpose one semitone higher
Ctrl+Right
Transpose Down
Transpose one semitone lower
Ctrl+Left
Next Channel
Play and listen next channel
Up
Previous Channel
Play and listen previous channel
Down
Next Controller
Select the next controller
Ctrl++
Previous Controller
Select the previous controller
Ctrl+-
Controller Up
Increment the controller value
+
Controller Down
Decrement the controller value
-
Next Bank
Select the next instrument bank
Ctrl+PgUp
Previous Bank
Select the previous instrument bank
Ctrl+PgDown
Next Program
Select the next instrument program
PgUp
Previous Program
Select the previous instrument program
PgDown
Velocity Up
Increment note velocity
End
Velocity Down
Decrement note velocity
Home
About &Translation
Show information about the program language translation
PianoKeybd
QGraphicsView
actionExit
triggered()
VPiano
close()
-1
-1
335
260
actionNotes
toggled(bool)
toolBarNotes
setVisible(bool)
-1
-1
37
38
actionControllers
toggled(bool)
toolBarControllers
setVisible(bool)
-1
-1
120
69
actionBender
toggled(bool)
toolBarBender
setVisible(bool)
-1
-1
205
92
actionPrograms
toggled(bool)
toolBarPrograms
setVisible(bool)
-1
-1
457
102
actionStatusBar
toggled(bool)
statusBar
setVisible(bool)
-1
-1
335
266
actionExtraControls
toggled(bool)
toolBarExtra
setVisible(bool)
-1
-1
338
125
vmpk-0.4.0/src/riffimportdlg.h 0000644 0001750 0000144 00000003241 11572642326 015340 0 ustar pedro users /*
MIDI Virtual Piano Keyboard
Copyright (C) 2008-2011, Pedro Lopez-Cabanillas
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 3 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, see .
*/
#ifndef RIFFIMPORTDLG_H
#define RIFFIMPORTDLG_H
#include
#include
#include "riff.h"
namespace Ui
{
class RiffImportDlg;
}
typedef QMap Bank;
class RiffImportDlg : public QDialog
{
Q_OBJECT
public:
RiffImportDlg(QWidget *parent = 0);
~RiffImportDlg();
void setInput(QString fileName);
void setOutput(QString fileName);
QString getOutput() { return m_output; }
QString getInput() { return m_input; }
QString getName() { return m_name; }
void save();
void retranslateUi();
protected slots:
void slotInstrument(int bank, int pc, QString name);
void slotCompleted(QString name, QString version, QString copyright);
void openInput();
void openOutput();
private:
Ui::RiffImportDlg *ui;
Riff* m_riff;
QMap m_ins;
QString m_input;
QString m_output;
QString m_name;
};
#endif // RIFFIMPORTDLG_H
vmpk-0.4.0/src/knob.h 0000644 0001750 0000144 00000005025 11572642326 013423 0 ustar pedro users /*
MIDI Virtual Piano Keyboard
Copyright (C) 2008-2011, Pedro Lopez-Cabanillas
For this file, the following copyright notice is also applicable:
Copyright (C) 2005-2011, rncbc aka Rui Nuno Capela. All rights reserved.
See http://qsynth.sourceforge.net
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 3 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, see .
*/
#ifndef KNOB_H
#define KNOB_H
#include
//-------------------------------------------------------------------------
// Knob - A better QDial
class Knob : public QDial
{
Q_OBJECT
Q_PROPERTY( int defaultValue READ getDefaultValue WRITE setDefaultValue )
Q_PROPERTY( DialMode dialMode READ getDialMode WRITE setDialMode )
Q_ENUMS(DialMode)
public:
// Constructor.
Knob(QWidget *pParent = 0);
// Destructor.
~Knob() {}
int getDefaultValue() const { return m_iDefaultValue; }
// Knob dial mode behavior:
// QDialMode - Old QDial behavior.
// AngularMode - Angularly relative to widget center.
// LinearMode - Proportionally to distance in one orthogonal axis.
enum DialMode { QDialMode, AngularMode, LinearMode };
DialMode getDialMode() const { return m_dialMode; }
public slots:
// Set default (mid) value.
void setDefaultValue(int iDefaultValue);
// Set knob dial mode behavior.
void setDialMode(DialMode dialMode);
protected:
// Mouse angle determination.
float mouseAngle(const QPoint& pos);
// Alternate mouse behavior event handlers.
virtual void mousePressEvent(QMouseEvent *pMouseEvent);
virtual void mouseMoveEvent(QMouseEvent *pMouseEvent);
virtual void mouseReleaseEvent(QMouseEvent *pMouseEvent);
virtual void wheelEvent(QWheelEvent *pWheelEvent);
private:
void updatePosition(int val);
// Default (mid) value.
int m_iDefaultValue;
// Knob dial mode behavior.
DialMode m_dialMode;
// Alternate mouse behavior tracking.
bool m_bMousePressed;
QPoint m_posMouse;
// Just for more precision on the movement
float m_lastDragValue;
};
#endif // KNOB_H
vmpk-0.4.0/src/qticonloader.h 0000644 0001750 0000144 00000004156 11572642326 015162 0 ustar pedro users /****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** Contact: Qt Software Information (qt-info@nokia.com)
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** Commercial Usage
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain
** additional rights. These rights are described in the Nokia Qt LGPL
** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
** package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at qt-sales@nokia.com.
**
****************************************************************************/
#ifndef QTICONLOADER_H
#define QTICONLOADER_H
#include
// This is the QtIconLoader
// Version 0.1
//
class QtIconLoader
{
public:
static QIcon icon(const QString &name, const QIcon &fallback = QIcon());
};
#endif // QTICONLOADER_H
vmpk-0.4.0/src/extracontrols.ui 0000644 0001750 0000144 00000043775 11572642326 015605 0 ustar pedro users
MIDI Virtual Piano Keyboard
Copyright (C) 2008-2011, Pedro Lopez-Cabanillas
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 3 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, see http://www.gnu.org/licenses/
DialogExtraControls
0
0
376
267
Extra Controls Editor
:/vpiano/vmpk_32x32.png:/vpiano/vmpk_32x32.png
-
100
0
-
false
QFrame::StyledPanel
QFrame::Raised
-
Label:
txtLabel
-
-
MIDI Controller:
spinController
-
127
-
QFrame::NoFrame
-
Add
:/vpiano/list-add.svg:/vpiano/list-add.svg
-
false
Remove
:/vpiano/list-remove.svg:/vpiano/list-remove.svg
-
false
Up
-
false
Down
-
Qt::Vertical
20
40
-
false
-
Switch
-
Knob
-
Spin box
-
Slider
-
Button Ctl
-
Button SysEx
-
false
QFrame::StyledPanel
QFrame::Raised
0
-
Default ON
-
value ON:
spinValueOn
-
127
-
value OFF:
spinValueOff
-
127
-
Min. value:
spinKnobMin
-
127
-
Max. value:
spinKnobMax
-
127
-
Default value:
spinKnobDef
-
127
-
Min. value:
spinSpinMin
-
127
-
Max. value:
spinSpinMax
-
127
-
Default value:
spinSpinDef
-
127
-
Display size:
spinSliderSize
-
9999
-
Min. value:
spinSliderMin
-
127
-
Max. value:
spinSliderMax
-
127
-
Default value:
spinSliderDef
-
127
-
value:
spinValueOn
-
127
-
Qt::Vertical
20
40
-
File name:
Qt::AlignBottom|Qt::AlignLeading|Qt::AlignLeft
-
true
-
...
-
Qt::Vertical
20
40
-
Qt::Horizontal
QDialogButtonBox::Cancel|QDialogButtonBox::Ok
extraList
txtLabel
spinController
chkSwitchDefOn
spinValueOn
spinValueOff
spinKnobMin
spinKnobMax
spinKnobDef
spinSpinMin
spinSpinMax
spinSpinDef
spinSliderSize
spinSliderMin
spinSliderMax
spinSliderDef
btnAdd
btnRemove
btnUp
btnDown
buttonBox
buttonBox
accepted()
DialogExtraControls
accept()
254
298
157
274
buttonBox
rejected()
DialogExtraControls
reject()
322
298
286
274
cboControlType
currentIndexChanged(int)
stackedPanel
setCurrentIndex(int)
231
89
273
113
stackedPanel
currentChanged(int)
cboControlType
setCurrentIndex(int)
134
111
164
89
vmpk-0.4.0/src/instrument.cpp 0000644 0001750 0000144 00000035426 11572642326 015245 0 ustar pedro users /*
MIDI Virtual Piano Keyboard
Copyright (C) 2008-2011, Pedro Lopez-Cabanillas
For this file, the following copyright notice is also applicable:
Copyright (C) 2005-2011, rncbc aka Rui Nuno Capela. All rights reserved.
See http://qtractor.sourceforge.net
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 3 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, see .
*/
#include "instrument.h"
#include
#include
#include
#include
#include
//----------------------------------------------------------------------
// class Instrument -- instrument definition instance class.
//
// Retrieve patch/program list for given bank address.
const InstrumentData& Instrument::patch ( int iBank ) const
{
if (m_pData->patches.contains(iBank))
return m_pData->patches[iBank];
return m_pData->patches[-1];
}
// Retrieve key/notes list for given (bank, prog) pair.
const InstrumentData& Instrument::notes ( int iBank, int iProg ) const
{
if (m_pData->keys.contains(iBank)) {
if (m_pData->keys[iBank].contains(iProg)) {
return m_pData->keys[iBank][iProg];
} else {
return m_pData->keys[iBank][-1];
}
}
else if (iBank >= 0)
return notes(-1, iProg);
return m_pData->keys[-1][-1];
}
// Check if given (bank, prog) pair is a drum patch.
bool Instrument::isDrum ( int iBank, int iProg ) const
{
if (m_pData->drums.contains(iBank)) {
if (m_pData->drums[iBank].contains(iProg)) {
return (bool) m_pData->drums[iBank][iProg];
} else {
return (bool) m_pData->drums[iBank][-1];
}
}
else if (iBank >= 0)
return isDrum(-1, iProg);
return false;
return isDrum(-1, iProg);
}
//----------------------------------------------------------------------
// class InstrumentList -- A Cakewalk .ins file container class.
//
// Clear all contents.
void InstrumentList::clearAll (void)
{
clear();
m_patches.clear();
m_notes.clear();
m_controllers.clear();
m_rpns.clear();
m_nrpns.clear();
m_files.clear();
}
// Special list merge method.
void InstrumentList::merge ( const InstrumentList& instruments )
{
// Maybe its better not merging to itself.
if (this == &instruments)
return;
// Names data lists merge...
mergeDataList(m_patches, instruments.patches());
mergeDataList(m_notes, instruments.notes());
mergeDataList(m_controllers, instruments.controllers());
mergeDataList(m_rpns, instruments.rpns());
mergeDataList(m_nrpns, instruments.nrpns());
// Instrument merge...
InstrumentList::ConstIterator it;
for (it = instruments.begin(); it != instruments.end(); ++it) {
Instrument& instr = (*this)[it.key()];
instr = it.value();
}
}
// Special instrument data list merge method.
void InstrumentList::mergeDataList (
InstrumentDataList& dst, const InstrumentDataList& src )
{
InstrumentDataList::ConstIterator it;
for (it = src.begin(); it != src.end(); ++it)
dst[it.key()] = it.value();
}
// The official loaded file list.
const QStringList& InstrumentList::files (void) const
{
return m_files;
}
// File load method.
bool InstrumentList::load ( const QString& sFilename )
{
// Open and read from real file.
QFile file(sFilename);
if (!file.open(QIODevice::ReadOnly))
return false;
enum FileSection {
None = 0,
PatchNames = 1,
NoteNames = 2,
ControlNames = 3,
RpnNames = 4,
NrpnNames = 5,
InstrDefs = 6
} sect = None;
Instrument *pInstrument = NULL;
InstrumentData *pData = NULL;
QRegExp rxTitle ("^\\[([^\\]]+)\\]$");
QRegExp rxData ("^([0-9]+)=(.*)$");
QRegExp rxBasedOn ("^BasedOn=(.+)$");
QRegExp rxBankSel ("^BankSelMethod=(0|1|2|3)$");
QRegExp rxUseNotes("^UsesNotesAsControllers=(0|1)$");
QRegExp rxControl ("^Control=(.+)$");
QRegExp rxRpn ("^RPN=(.+)$");
QRegExp rxNrpn ("^NRPN=(.+)$");
QRegExp rxPatch ("^Patch\\[([0-9]+|\\*)\\]=(.+)$");
QRegExp rxKey ("^Key\\[([0-9]+|\\*),([0-9]+|\\*)\\]=(.+)$");
QRegExp rxDrum ("^Drum\\[([0-9]+|\\*),([0-9]+|\\*)\\]=(0|1)$");
const QString s0_127 = "0..127";
const QString s1_128 = "1..128";
const QString s0_16383 = "0..16383";
const QString sAsterisk = "*";
// Read the file.
unsigned int iLine = 0;
QTextStream ts(&file);
while (!ts.atEnd()) {
// Read the line.
iLine++;
QString sLine = ts.readLine().simplified();
// If not empty, nor a comment, call the server...
if (sLine.isEmpty() || sLine[0] == ';')
continue;
// Check for section intro line...
if (sLine[0] == '.') {
if (sLine == ".Patch Names") {
sect = PatchNames;
// m_patches.clear();
m_patches[s0_127].setName(s0_127);
m_patches[s1_128].setName(s1_128);
}
else if (sLine == ".Note Names") {
sect = NoteNames;
// m_notes.clear();
m_notes[s0_127].setName(s0_127);
}
else if (sLine == ".Controller Names") {
sect = ControlNames;
// m_controllers.clear();
m_controllers[s0_127].setName(s0_127);
}
else if (sLine == ".RPN Names") {
sect = RpnNames;
// m_rpns.clear();
m_rpns[s0_16383].setName(s0_16383);
}
else if (sLine == ".NRPN Names") {
sect = NrpnNames;
// m_nrpns.clear();
m_nrpns[s0_16383].setName(s0_16383);
}
else if (sLine == ".Instrument Definitions") {
sect = InstrDefs;
// clear();
}
else {
// Unknown section found...
qWarning("%s(%d): %s: Unknown section.",
sFilename.toUtf8().constData(), iLine, sLine.toUtf8().constData());
}
// Go on...
continue;
}
// Now it depends on the section...
switch (sect) {
case PatchNames: {
if (rxTitle.exactMatch(sLine)) {
// New patch name...
const QString& sTitle = rxTitle.cap(1);
pData = &(m_patches[sTitle]);
pData->setName(sTitle);
} else if (rxBasedOn.exactMatch(sLine)) {
pData->setBasedOn(rxBasedOn.cap(1));
} else if (rxData.exactMatch(sLine)) {
(*pData)[rxData.cap(1).toInt()] = rxData.cap(2);
} else {
qWarning("%s(%d): %s: Unknown .Patch Names entry.",
sFilename.toUtf8().constData(), iLine, sLine.toUtf8().constData());
}
break;
}
case NoteNames: {
if (rxTitle.exactMatch(sLine)) {
// New note name...
const QString& sTitle = rxTitle.cap(1);
pData = &(m_notes[sTitle]);
pData->setName(sTitle);
} else if (rxBasedOn.exactMatch(sLine)) {
pData->setBasedOn(rxBasedOn.cap(1));
} else if (rxData.exactMatch(sLine)) {
(*pData)[rxData.cap(1).toInt()] = rxData.cap(2);
} else {
qWarning("%s(%d): %s: Unknown .Note Names entry.",
sFilename.toUtf8().constData(), iLine, sLine.toUtf8().constData());
}
break;
}
case ControlNames: {
if (rxTitle.exactMatch(sLine)) {
// New controller name...
const QString& sTitle = rxTitle.cap(1);
pData = &(m_controllers[sTitle]);
pData->setName(sTitle);
} else if (rxBasedOn.exactMatch(sLine)) {
pData->setBasedOn(rxBasedOn.cap(1));
} else if (rxData.exactMatch(sLine)) {
(*pData)[rxData.cap(1).toInt()] = rxData.cap(2);
} else {
qWarning("%s(%d): %s: Unknown .Controller Names entry.",
sFilename.toUtf8().constData(), iLine, sLine.toUtf8().constData());
}
break;
}
case RpnNames: {
if (rxTitle.exactMatch(sLine)) {
// New RPN name...
const QString& sTitle = rxTitle.cap(1);
pData = &(m_rpns[sTitle]);
pData->setName(sTitle);
} else if (rxBasedOn.exactMatch(sLine)) {
pData->setBasedOn(rxBasedOn.cap(1));
} else if (rxData.exactMatch(sLine)) {
(*pData)[rxData.cap(1).toInt()] = rxData.cap(2);
} else {
qWarning("%s(%d): %s: Unknown .RPN Names entry.",
sFilename.toUtf8().constData(), iLine, sLine.toUtf8().constData());
}
break;
}
case NrpnNames: {
if (rxTitle.exactMatch(sLine)) {
// New NRPN name...
const QString& sTitle = rxTitle.cap(1);
pData = &(m_nrpns[sTitle]);
pData->setName(sTitle);
} else if (rxBasedOn.exactMatch(sLine)) {
pData->setBasedOn(rxBasedOn.cap(1));
} else if (rxData.exactMatch(sLine)) {
(*pData)[rxData.cap(1).toInt()] = rxData.cap(2);
} else {
qWarning("%s(%d): %s: Unknown .NRPN Names entry.",
sFilename.toUtf8().constData(), iLine, sLine.toUtf8().constData());
}
break;
}
case InstrDefs: {
if (rxTitle.exactMatch(sLine)) {
// New instrument definition...
const QString& sTitle = rxTitle.cap(1);
pInstrument = &((*this)[sTitle]);
pInstrument->setInstrumentName(sTitle);
} else if (rxBankSel.exactMatch(sLine)) {
pInstrument->setBankSelMethod(
rxBankSel.cap(1).toInt());
} else if (rxUseNotes.exactMatch(sLine)) {
pInstrument->setUsesNotesAsControllers(
(bool) rxBankSel.cap(1).toInt());
} else if (rxPatch.exactMatch(sLine)) {
int iBank = (rxPatch.cap(1) == sAsterisk
? -1 : rxPatch.cap(1).toInt());
pInstrument->setPatch(iBank, m_patches[rxPatch.cap(2)]);
} else if (rxControl.exactMatch(sLine)) {
pInstrument->setControl(m_controllers[rxControl.cap(1)]);
} else if (rxRpn.exactMatch(sLine)) {
pInstrument->setRpn(m_rpns[rxRpn.cap(1)]);
} else if (rxNrpn.exactMatch(sLine)) {
pInstrument->setNrpn(m_nrpns[rxNrpn.cap(1)]);
} else if (rxKey.exactMatch(sLine)) {
int iBank = (rxKey.cap(1) == sAsterisk
? -1 : rxKey.cap(1).toInt());
int iProg = (rxKey.cap(2) == sAsterisk
? -1 : rxKey.cap(2).toInt());
pInstrument->setNotes(iBank, iProg, m_notes[rxKey.cap(3)]);
} else if (rxDrum.exactMatch(sLine)) {
int iBank = (rxDrum.cap(1) == sAsterisk
? -1 : rxDrum.cap(1).toInt());
int iProg = (rxDrum.cap(2) == sAsterisk
? -1 : rxKey.cap(2).toInt());
pInstrument->setDrum(iBank, iProg,
(bool) rxDrum.cap(3).toInt());
} else {
qWarning("%s(%d): %s: Unknown .Instrument Definitions entry.",
sFilename.toUtf8().constData(), iLine, sLine.toUtf8().constData());
}
break;
}
default:
break;
}
}
// Ok. We've read it all.
file.close();
// We're in business...
appendFile(sFilename);
return true;
}
// File save method.
bool InstrumentList::save ( const QString& sFilename )
{
// Open and write into real file.
QFile file(sFilename);
if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate))
return false;
// A visula separator line.
const QString sepl = "; -----------------------------"
"------------------------------------------------";
// Write the file.
QTextStream ts(&file);
ts << sepl << endl;
ts << "; " << QObject::tr("Cakewalk Instrument Definition File") << endl;
/*
ts << ";" << endl;
ts << "; " << _TITLE " - " << QObject::tr(_SUBTITLE) << endl;
ts << "; " << QObject::tr("Version")
<< ": " _VERSION << endl;
ts << "; " << QObject::tr("Build")
<< ": " __DATE__ " " __TIME__ << endl;
*/
ts << ";" << endl;
ts << "; " << QObject::tr("File")
<< ": " << QFileInfo(sFilename).fileName() << endl;
ts << "; " << QObject::tr("Date")
<< ": " << QDate::currentDate().toString("MMM dd yyyy")
<< " " << QTime::currentTime().toString("hh:mm:ss") << endl;
ts << ";" << endl;
// - Patch Names...
ts << sepl << endl << endl;
ts << ".Patch Names" << endl;
saveDataList(ts, m_patches);
// - Note Names...
ts << sepl << endl << endl;
ts << ".Note Names" << endl;
saveDataList(ts, m_notes);
// - Controller Names...
ts << sepl << endl << endl;
ts << ".Controller Names" << endl;
saveDataList(ts, m_controllers);
// - RPN Names...
ts << sepl << endl << endl;
ts << ".RPN Names" << endl;
saveDataList(ts, m_rpns);
// - NRPN Names...
ts << sepl << endl << endl;
ts << ".NRPN Names" << endl;
saveDataList(ts, m_nrpns);
// - Instrument Definitions...
ts << sepl << endl << endl;
ts << ".Instrument Definitions" << endl;
ts << endl;
InstrumentList::Iterator iter;
for (iter = begin(); iter != end(); ++iter) {
Instrument& instr = *iter;
ts << "[" << instr.instrumentName() << "]" << endl;
if (instr.bankSelMethod() > 0)
ts << "BankSelMethod=" << instr.bankSelMethod() << endl;
if (!instr.control().name().isEmpty())
ts << "Control=" << instr.control().name() << endl;
if (!instr.rpn().name().isEmpty())
ts << "RPN=" << instr.rpn().name() << endl;
if (!instr.nrpn().name().isEmpty())
ts << "NRPN=" << instr.nrpn().name() << endl;
// - Patches...
InstrumentPatches::ConstIterator pit;
for (pit = instr.patches().begin();
pit != instr.patches().end(); ++pit) {
int iBank = pit.key();
const QString sBank = (iBank < 0
? QString("*") : QString::number(iBank));
ts << "Patch[" << sBank << "]=" << pit.value().name() << endl;
}
// - Keys...
InstrumentKeys::ConstIterator kit;
for (kit = instr.keys().begin(); kit != instr.keys().end(); ++kit) {
int iBank = kit.key();
const QString sBank = (iBank < 0
? QString("*") : QString::number(iBank));
const InstrumentNotes& notes = kit.value();
InstrumentNotes::ConstIterator nit;
for (nit = notes.begin(); nit != notes.end(); ++nit) {
int iProg = nit.key();
const QString sProg = (iProg < 0
? QString("*") : QString::number(iProg));
ts << "Key[" << sBank << "," << sProg << "]="
<< nit.value().name() << endl;
}
}
// - Drums...
InstrumentDrums::ConstIterator dit;
for (dit = instr.drums().begin(); dit != instr.drums().end(); ++dit) {
int iBank = dit.key();
const QString sBank = (iBank < 0
? QString("*") : QString::number(iBank));
const InstrumentDrumFlags& flags = dit.value();
InstrumentDrumFlags::ConstIterator fit;
for (fit = flags.begin(); fit != flags.end(); ++fit) {
int iProg = fit.key();
const QString sProg = (iProg < 0
? QString("*") : QString::number(iProg));
ts << "Drum[" << sBank << "," << sProg << "]="
<< fit.value() << endl;
}
}
ts << endl;
}
// Done.
file.close();
return true;
}
void InstrumentList::saveDataList ( QTextStream& ts,
const InstrumentDataList& list )
{
ts << endl;
InstrumentDataList::ConstIterator it;
for (it = list.begin(); it != list.end(); ++it) {
ts << "[" << it.value().name() << "]" << endl;
saveData(ts, it.value());
}
}
void InstrumentList::saveData ( QTextStream& ts,
const InstrumentData& data )
{
if (!data.basedOn().isEmpty())
ts << "BasedOn=" << data.basedOn() << endl;
InstrumentData::ConstIterator it;
for (it = data.constBegin(); it != data.constEnd(); ++it)
ts << it.key() << "=" << it.value() << endl;
ts << endl;
}
vmpk-0.4.0/src/kmapdialog.h 0000644 0001750 0000144 00000002553 11572642326 014605 0 ustar pedro users /*
MIDI Virtual Piano Keyboard
Copyright (C) 2008-2011, Pedro Lopez-Cabanillas
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 3 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, see .
*/
#ifndef KMAPDIALOG_H
#define KMAPDIALOG_H
#include "ui_kmapdialog.h"
#include "keyboardmap.h"
#include
class KMapDialog : public QDialog
{
Q_OBJECT
public:
KMapDialog(QWidget *parent = 0);
void load(const QString fileName);
void save(const QString fileName);
void displayMap(const KeyboardMap* map);
void getMap(KeyboardMap* map);
void retranslateUi();
public slots:
void slotOpen();
void slotSave();
private:
void updateMap();
QPushButton* m_btnOpen;
QPushButton* m_btnSave;
KeyboardMap m_map;
Ui::KMapDialogClass ui;
};
#endif // KMAPDIALOG_H
vmpk-0.4.0/src/RtMidi.h 0000644 0001750 0000144 00000025214 11572642326 013664 0 ustar pedro users /**********************************************************************/
/*! \class RtMidi
\brief An abstract base class for realtime MIDI input/output.
This class implements some common functionality for the realtime
MIDI input/output subclasses RtMidiIn and RtMidiOut.
RtMidi WWW site: http://music.mcgill.ca/~gary/rtmidi/
RtMidi: realtime MIDI i/o C++ classes
Copyright (c) 2003-2011 Gary P. Scavone
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation files
(the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of the Software,
and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
Any person wishing to distribute modifications to the Software is
requested to send the modifications to the original developer so that
they can be incorporated into the canonical version.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/**********************************************************************/
// RtMidi: Version 1.0.14
#ifndef RTMIDI_H
#define RTMIDI_H
#include "RtError.h"
#include
class RtMidi
{
public:
//! Pure virtual openPort() function.
virtual void openPort( unsigned int portNumber = 0, const std::string portName = std::string( "RtMidi" ) ) = 0;
//! Pure virtual openVirtualPort() function.
virtual void openVirtualPort( const std::string portName = std::string( "RtMidi" ) ) = 0;
//! Pure virtual getPortCount() function.
virtual unsigned int getPortCount() = 0;
//! Pure virtual getPortName() function.
virtual std::string getPortName( unsigned int portNumber = 0 ) = 0;
//! Pure virtual closePort() function.
virtual void closePort( void ) = 0;
protected:
RtMidi();
virtual ~RtMidi() {};
// A basic error reporting function for internal use in the RtMidi
// subclasses. The behavior of this function can be modified to
// suit specific needs.
void error( RtError::Type type );
void *apiData_;
bool connected_;
std::string errorString_;
};
/**********************************************************************/
/*! \class RtMidiIn
\brief A realtime MIDI input class.
This class provides a common, platform-independent API for
realtime MIDI input. It allows access to a single MIDI input
port. Incoming MIDI messages are either saved to a queue for
retrieval using the getMessage() function or immediately passed to
a user-specified callback function. Create multiple instances of
this class to connect to more than one MIDI device at the same
time. With the OS-X and Linux ALSA MIDI APIs, it is also possible
to open a virtual input port to which other MIDI software clients
can connect.
by Gary P. Scavone, 2003-2008.
*/
/**********************************************************************/
#include
#include
class RtMidiIn : public RtMidi
{
public:
//! User callback function type definition.
typedef void (*RtMidiCallback)( double timeStamp, std::vector *message, void *userData);
//! Default constructor that allows an optional client name.
/*!
An exception will be thrown if a MIDI system initialization error occurs.
*/
RtMidiIn( const std::string clientName = std::string( "RtMidi Input Client") );
//! If a MIDI connection is still open, it will be closed by the destructor.
~RtMidiIn();
//! Open a MIDI input connection.
/*!
An optional port number greater than 0 can be specified.
Otherwise, the default or first port found is opened.
*/
void openPort( unsigned int portNumber = 0, const std::string Portname = std::string( "RtMidi Input" ) );
//! Create a virtual input port, with optional name, to allow software connections (OS X and ALSA only).
/*!
This function creates a virtual MIDI input port to which other
software applications can connect. This type of functionality
is currently only supported by the Macintosh OS-X and Linux ALSA
APIs (the function does nothing for the other APIs).
*/
void openVirtualPort( const std::string portName = std::string( "RtMidi Input" ) );
//! Set a callback function to be invoked for incoming MIDI messages.
/*!
The callback function will be called whenever an incoming MIDI
message is received. While not absolutely necessary, it is best
to set the callback function before opening a MIDI port to avoid
leaving some messages in the queue.
*/
void setCallback( RtMidiCallback callback, void *userData = 0 );
//! Cancel use of the current callback function (if one exists).
/*!
Subsequent incoming MIDI messages will be written to the queue
and can be retrieved with the \e getMessage function.
*/
void cancelCallback();
//! Close an open MIDI connection (if one exists).
void closePort( void );
//! Return the number of available MIDI input ports.
unsigned int getPortCount();
//! Return a string identifier for the specified MIDI input port number.
/*!
An empty string is returned if an invalid port specifier is provided.
*/
std::string getPortName( unsigned int portNumber = 0 );
//! Set the maximum number of MIDI messages to be saved in the queue.
/*!
If the queue size limit is reached, incoming messages will be
ignored. The default limit is 1024.
*/
void setQueueSizeLimit( unsigned int queueSize );
//! Specify whether certain MIDI message types should be queued or ignored during input.
/*!
By default, MIDI timing and active sensing messages are ignored
during message input because of their relative high data rates.
MIDI sysex messages are ignored by default as well. Variable
values of "true" imply that the respective message type will be
ignored.
*/
void ignoreTypes( bool midiSysex = true, bool midiTime = true, bool midiSense = true );
//! Fill the user-provided vector with the data bytes for the next available MIDI message in the input queue and return the event delta-time in seconds.
/*!
This function returns immediately whether a new message is
available or not. A valid message is indicated by a non-zero
vector size. An exception is thrown if an error occurs during
message retrieval or an input connection was not previously
established.
*/
double getMessage( std::vector *message );
// A MIDI structure used internally by the class to store incoming
// messages. Each message represents one and only one MIDI message.
struct MidiMessage {
std::vector bytes;
double timeStamp;
// Default constructor.
MidiMessage()
:bytes(3), timeStamp(0.0) {}
};
// The RtMidiInData structure is used to pass private class data to
// the MIDI input handling function or thread.
struct RtMidiInData {
std::queue queue;
MidiMessage message;
unsigned int queueLimit;
unsigned char ignoreFlags;
bool doInput;
bool firstMessage;
void *apiData;
bool usingCallback;
void *userCallback;
void *userData;
bool continueSysex;
// Default constructor.
RtMidiInData()
: queueLimit(1024), ignoreFlags(7), doInput(false), firstMessage(true),
apiData(0), usingCallback(false), userCallback(0), userData(0),
continueSysex(false) {}
};
private:
void initialize( const std::string& clientName );
RtMidiInData inputData_;
};
/**********************************************************************/
/*! \class RtMidiOut
\brief A realtime MIDI output class.
This class provides a common, platform-independent API for MIDI
output. It allows one to probe available MIDI output ports, to
connect to one such port, and to send MIDI bytes immediately over
the connection. Create multiple instances of this class to
connect to more than one MIDI device at the same time.
by Gary P. Scavone, 2003-2008.
*/
/**********************************************************************/
class RtMidiOut : public RtMidi
{
public:
//! Default constructor that allows an optional client name.
/*!
An exception will be thrown if a MIDI system initialization error occurs.
*/
RtMidiOut( const std::string clientName = std::string( "RtMidi Output Client" ) );
//! The destructor closes any open MIDI connections.
~RtMidiOut();
//! Open a MIDI output connection.
/*!
An optional port number greater than 0 can be specified.
Otherwise, the default or first port found is opened. An
exception is thrown if an error occurs while attempting to make
the port connection.
*/
void openPort( unsigned int portNumber = 0, const std::string portName = std::string( "RtMidi Output" ) );
//! Close an open MIDI connection (if one exists).
void closePort();
//! Create a virtual output port, with optional name, to allow software connections (OS X and ALSA only).
/*!
This function creates a virtual MIDI output port to which other
software applications can connect. This type of functionality
is currently only supported by the Macintosh OS-X and Linux ALSA
APIs (the function does nothing with the other APIs). An
exception is thrown if an error occurs while attempting to create
the virtual port.
*/
void openVirtualPort( const std::string portName = std::string( "RtMidi Output" ) );
//! Return the number of available MIDI output ports.
unsigned int getPortCount();
//! Return a string identifier for the specified MIDI port type and number.
/*!
An empty string is returned if an invalid port specifier is provided.
*/
std::string getPortName( unsigned int portNumber = 0 );
//! Immediately send a single message out an open MIDI output port.
/*!
An exception is thrown if an error occurs during output or an
output connection was not previously established.
*/
void sendMessage( std::vector *message );
private:
void initialize( const std::string& clientName );
};
#endif
vmpk-0.4.0/src/udpmidi.cpp 0000644 0001750 0000144 00000022121 11572642326 014454 0 ustar pedro users /*
MIDI Virtual Piano Keyboard
Copyright (C) 2008-2011, Pedro Lopez-Cabanillas
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 3 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, see .
*/
/*
* This code is based on Qmidinet, by Rui Nuno Capela: http://qmidinet.sf.net
*/
#if defined(NETWORK_MIDI)
#include
#include
#if defined(__SYMBIAN32__)
#include
#include
#include
#include
#include
#else
#if defined(WIN32)
#include
#include
#else
#include
#include
#include
#endif
#endif
#include
#include
#include "RtMidi.h"
#include "preferences.h"
int g_iUdpPort = NETWORKPORTNUMBER;
struct NetworkMidiData {
NetworkMidiData(): socket(0), thread(0) { }
int socket;
struct sockaddr_in sockaddr;
class UdpDeviceThread *thread;
};
#if defined(WIN32)
static WSADATA g_wsaData;
typedef int socklen_t;
static void __attribute__((constructor)) startup()
{
qDebug() << "startup";
WSAStartup(MAKEWORD(1, 1), &g_wsaData);
}
static void __attribute__((destructor)) cleanup()
{
qDebug() << "cleanup";
WSACleanup();
}
#endif
/* RtMidiIn */
class UdpDeviceThread : public QThread
{
public:
UdpDeviceThread(RtMidiIn::RtMidiInData *data)
: QThread(), m_data(data)
{ }
protected:
void run();
private:
RtMidiIn::RtMidiInData *m_data;
};
void UdpDeviceThread::run (void)
{
NetworkMidiData *apiData = static_cast (m_data->apiData);
RtMidiIn::MidiMessage message;
qDebug() << "running!";
while (m_data->doInput) {
fd_set fds;
FD_ZERO(&fds);
FD_SET(apiData->socket, &fds);
int fdmax = apiData->socket;
struct timeval tv;
tv.tv_sec = 1; // timeout period (1 second)...
tv.tv_usec = 0;
int s = ::select(fdmax + 1, &fds, NULL, NULL, &tv);
if (s < 0) {
qDebug() << "RtMidiIn: select = " << s << ": " << ::strerror(s);
break;
}
if (s == 0) {
//qDebug() << "\nRtMidiIn: timeout";
continue;
}
// A Network event
if (FD_ISSET(apiData->socket, &fds)) {
// Read from network...
unsigned char buf[1024];
struct sockaddr_in sender;
socklen_t slen = sizeof(sender);
int r = ::recvfrom(apiData->socket, (char *) buf, sizeof(buf),
0, (struct sockaddr *) &sender, &slen);
if (r > 0) {
message.timeStamp = 0;
message.bytes.clear();
for ( int i = 0; i < r; ++i ) {
message.bytes.push_back( buf[i] );
}
if ( m_data->usingCallback ) {
RtMidiIn::RtMidiCallback callback =
(RtMidiIn::RtMidiCallback) m_data->userCallback;
callback(message.timeStamp, &message.bytes, m_data->userData);
} else {
if ( m_data->queueLimit > m_data->queue.size() ) {
m_data->queue.push( message );
} else {
qDebug() << "RtMidiIn: message queue limit reached!!\n\n";
}
}
} else if (r < 0) {
qDebug() << "RtMidiIn: recvfrom=" << r;
}
}
}
}
void RtMidiIn :: initialize( const std::string& /*clientName*/ )
{
NetworkMidiData *data = new NetworkMidiData;
apiData_ = (void *) data;
inputData_.apiData = (void *) data;
}
RtMidiIn :: ~RtMidiIn()
{
// Close a connection if it exists.
closePort();
// Cleanup.
NetworkMidiData *data = (NetworkMidiData *) inputData_.apiData ;
delete data;
}
void RtMidiIn :: openPort( unsigned int /*portNumber*/, const std::string /*portName*/ )
{
NetworkMidiData *data = static_cast (apiData_);
// Setup network protocol...
data->socket = ::socket(PF_INET, SOCK_DGRAM, 0);
if (data->socket < 0) {
qDebug() << "socket(in)";
return;
}
struct sockaddr_in addrin;
::memset(&addrin, 0, sizeof(addrin));
addrin.sin_family = AF_INET;
addrin.sin_addr.s_addr = htonl(INADDR_ANY);
addrin.sin_port = htons(g_iUdpPort);
if (::bind(data->socket, (struct sockaddr *) (&addrin), sizeof(addrin)) < 0) {
qDebug() << "bind";
return;
}
// Will Hall, 2007
// INADDR_ANY will bind to default interface,
struct in_addr if_addr_in;
if_addr_in.s_addr = htonl(INADDR_ANY);
struct ip_mreq mreq;
mreq.imr_multiaddr.s_addr = ::inet_addr("225.0.0.37");
mreq.imr_interface.s_addr = if_addr_in.s_addr;
if (::setsockopt (data->socket, IPPROTO_IP, IP_ADD_MEMBERSHIP,
(char *) &mreq, sizeof(mreq)) < 0) {
qDebug() << "setsockopt(IP_ADD_MEMBERSHIP)";
errorString_ = "RtMidiIn::openPort: OS is probably missing multicast support.";
error( RtError::SYSTEM_ERROR );
}
// start the input thread
data->thread = new UdpDeviceThread(&inputData_);
inputData_.doInput = true;
data->thread->start();
if (data->thread == 0 || !data->thread->isRunning()) {
inputData_.doInput = false;
errorString_ = "RtMidiIn::openPort: error starting MIDI input thread!";
error( RtError::THREAD_ERROR );
}
}
void RtMidiIn :: openVirtualPort( const std::string /*portName*/ )
{
errorString_ = "RtMidiIn::openVirtualPort: cannot be implemented in UDP!";
error( RtError::WARNING );
}
unsigned int RtMidiIn :: getPortCount()
{
return 1;
}
std::string RtMidiIn :: getPortName( unsigned int /*portNumber*/ )
{
std::ostringstream ost;
ost << "UDP/" << g_iUdpPort;
return ost.str();
}
void RtMidiIn :: closePort()
{
NetworkMidiData *data = static_cast (apiData_);
// Shutdown the input thread.
if (data->thread != 0) {
if (data->thread->isRunning()) {
inputData_.doInput = false;
data->thread->wait(1200); // Timeout>1sec.
}
delete data->thread;
data->thread = 0;
}
// close socket
if (data->socket >= 0) {
#if defined(WIN32)
::closesocket(data->socket);
#else
::close(data->socket);
#endif
data->socket = 0;
}
}
/* RtMidiOut */
void RtMidiOut :: initialize( const std::string& /*clientName*/ )
{
NetworkMidiData *data = new NetworkMidiData;
apiData_ = (void *) data;
}
RtMidiOut :: ~RtMidiOut()
{
// Close a connection if it exists.
closePort();
// Cleanup.
NetworkMidiData *data = (NetworkMidiData *) apiData_;
delete data;
}
void RtMidiOut :: openPort( unsigned int /*portNumber*/, const std::string /*portName*/ )
{
NetworkMidiData *data = static_cast (apiData_);
data->socket = ::socket(AF_INET, SOCK_DGRAM, 0);
if (data->socket < 0) {
errorString_ = "RtMidiOut::openPort: error creating a socket";
error( RtError::SYSTEM_ERROR );
}
::memset(&data->sockaddr, 0, sizeof(data->sockaddr));
data->sockaddr.sin_family = AF_INET;
data->sockaddr.sin_addr.s_addr = ::inet_addr("225.0.0.37");
data->sockaddr.sin_port = htons(g_iUdpPort);
// Turn off loopback...
int loop = 0;
if (::setsockopt(data->socket, IPPROTO_IP, IP_MULTICAST_LOOP,
(char *) &loop, sizeof (loop)) < 0) {
qDebug() << "setsockopt(IP_MULTICAST_LOOP)";
return;
}
}
void RtMidiOut :: openVirtualPort( const std::string /*portName*/ )
{
errorString_ = "RtMidiOut::openVirtualPort: cannot be implemented in UDP!";
error( RtError::WARNING );
}
unsigned int RtMidiOut :: getPortCount()
{
return 1;
}
std::string RtMidiOut :: getPortName( unsigned int /*portNumber*/ )
{
std::ostringstream ost;
ost << "UDP/" << g_iUdpPort;
return ost.str();
}
void RtMidiOut :: closePort()
{
NetworkMidiData *data = static_cast (apiData_);
if (data->socket >= 0) {
#if defined(WIN32)
::closesocket(data->socket);
#else
::close(data->socket);
#endif
data->socket = 0;
}
}
void RtMidiOut :: sendMessage( std::vector