void MidiPort::subscribeWritablePort( const QString& port, bool subscribe )
{
m_writablePorts[port] = subscribe;
// make sure, MIDI-port is configured for output
if( subscribe == true && !isOutputEnabled() )
{
m_writableModel.setValue( true );
}
m_midiClient->subscribeWritablePort( this, port, subscribe );
}
void MidiPort::saveSettings( QDomDocument& doc, QDomElement& thisElement )
{
m_inputChannelModel.saveSettings( doc, thisElement, "inputchannel" );
m_outputChannelModel.saveSettings( doc, thisElement, "outputchannel" );
m_inputControllerModel.saveSettings( doc, thisElement, "inputcontroller" );
m_outputControllerModel.saveSettings( doc, thisElement, "outputcontroller" );
m_fixedInputVelocityModel.saveSettings( doc, thisElement, "fixedinputvelocity" );
m_fixedOutputVelocityModel.saveSettings( doc, thisElement, "fixedoutputvelocity" );
m_fixedOutputNoteModel.saveSettings( doc, thisElement, "fixedoutputnote" );
m_outputProgramModel.saveSettings( doc, thisElement, "outputprogram" );
m_baseVelocityModel.saveSettings( doc, thisElement, "basevelocity" );
m_readableModel.saveSettings( doc, thisElement, "readable" );
m_writableModel.saveSettings( doc, thisElement, "writable" );
if( isInputEnabled() )
{
QString rp;
for( Map::ConstIterator it = m_readablePorts.begin(); it != m_readablePorts.end(); ++it )
{
if( it.value() )
{
rp += it.key() + ",";
}
}
// cut off comma
if( rp.length() > 0 )
{
rp.truncate( rp.length() - 1 );
}
thisElement.setAttribute( "inports", rp );
}
if( isOutputEnabled() )
{
QString wp;
for( Map::ConstIterator it = m_writablePorts.begin(); it != m_writablePorts.end(); ++it )
{
if( it.value() )
{
wp += it.key() + ",";
}
}
// cut off comma
if( wp.length() > 0 )
{
wp.truncate( wp.length() - 1 );
}
thisElement.setAttribute( "outports", wp );
}
}
void MidiPort::loadSettings( const QDomElement& thisElement )
{
m_inputChannelModel.loadSettings( thisElement, "inputchannel" );
m_outputChannelModel.loadSettings( thisElement, "outputchannel" );
m_inputControllerModel.loadSettings( thisElement, "inputcontroller" );
m_outputControllerModel.loadSettings( thisElement, "outputcontroller" );
m_fixedInputVelocityModel.loadSettings( thisElement, "fixedinputvelocity" );
m_fixedOutputVelocityModel.loadSettings( thisElement, "fixedoutputvelocity" );
m_outputProgramModel.loadSettings( thisElement, "outputprogram" );
m_baseVelocityModel.loadSettings( thisElement, "basevelocity" );
m_readableModel.loadSettings( thisElement, "readable" );
m_writableModel.loadSettings( thisElement, "writable" );
// restore connections
if( isInputEnabled() )
{
QStringList rp = thisElement.attribute( "inports" ).split( ',' );
for( Map::ConstIterator it = m_readablePorts.begin(); it != m_readablePorts.end(); ++it )
{
if( it.value() != ( rp.indexOf( it.key() ) != -1 ) )
{
subscribeReadablePort( it.key() );
}
}
emit readablePortsChanged();
}
if( isOutputEnabled() )
{
QStringList wp = thisElement.attribute( "outports" ).split( ',' );
for( Map::ConstIterator it = m_writablePorts.begin(); it != m_writablePorts.end(); ++it )
{
if( it.value() != ( wp.indexOf( it.key() ) != -1 ) )
{
subscribeWritablePort( it.key() );
}
}
emit writablePortsChanged();
}
if( thisElement.hasAttribute( "basevelocity" ) == false )
{
// for projects created by LMMS < 0.9.92 there's no value for the base
// velocity and for compat reasons we have to stick with maximum velocity
// which did not allow note volumes > 100%
m_baseVelocityModel.setValue( MidiMaxVelocity );
}
}
void MidiPort::processOutEvent( const MidiEvent& event, const MidiTime& time )
{
// mask event
if( isOutputEnabled() && realOutputChannel() == event.channel() )
{
MidiEvent outEvent = event;
if( fixedOutputVelocity() >= 0 && event.velocity() > 0 &&
( event.type() == MidiNoteOn || event.type() == MidiKeyPressure ) )
{
outEvent.setVelocity( fixedOutputVelocity() );
}
m_midiClient->processOutEvent( outEvent, time, this );
}
}
void MidiPort::updateMidiPortMode()
{
// this small lookup-table makes everything easier
static const Modes modeTable[2][2] =
{
{ Disabled, Output },
{ Input, Duplex }
} ;
setMode( modeTable[m_readableModel.value()][m_writableModel.value()] );
// check whether we have to dis-check items in connection-menu
if( !isInputEnabled() )
{
for( Map::ConstIterator it = m_readablePorts.begin(); it != m_readablePorts.end(); ++it )
{
// subscribed?
if( it.value() )
{
subscribeReadablePort( it.key(), false );
}
}
}
if( !isOutputEnabled() )
{
for( Map::ConstIterator it = m_writablePorts.begin(); it != m_writablePorts.end(); ++it )
{
// subscribed?
if( it.value() )
{
subscribeWritablePort( it.key(), false );
}
}
}
emit readablePortsChanged();
emit writablePortsChanged();
emit modeChanged();
if( Engine::getSong() )
{
Engine::getSong()->setModified();
}
}
//------------------------------------------------------------------------------
// publishAndSubscribe()
//------------------------------------------------------------------------------
bool NetIO::publishAndSubscribeMunitionDetonation()
{
RTI::RTIambassador* p = getRTIambassador();
bool ok = true;
// ----------
// Get handles to the class, attributes and parameters
// ----------
try {
// ---
// Munition detonation Interaction class handle and parameter handles
// ---
{
RTI::InteractionClassHandle handle =
p->getInteractionClassHandle(MunitionDetonation::getInteractionFedName());
setInteractionClassHandle(MUNITION_DETONATION_INTERACTION, handle );
setInteractionParameterHandle(
DETONATION_LOCATION_MD_PI,
p->getParameterHandle(
MunitionDetonation::getDetonationLocationParameterFedName(),
handle) );
setInteractionParameterHandle(
DETONATION_RESULT_CODE_MD_PI,
p->getParameterHandle(
MunitionDetonation::getDetonationResultCodeParameterFedName(),
handle) );
setInteractionParameterHandle(
EVENT_IDENTIFIER_MD_PI,
p->getParameterHandle(
MunitionDetonation::getEventIdentifierParameterFedName(),
handle) );
setInteractionParameterHandle(
FIRING_OBJECT_IDENTIFIER_MD_PI,
p->getParameterHandle(
MunitionDetonation::getFiringObjectIdentifierParameterFedName(),
handle) );
setInteractionParameterHandle(
FINAL_VELOCITY_VECTOR_MD_PI,
p->getParameterHandle(
MunitionDetonation::getFinalVelocityVectorParameterFedName(),
handle) );
setInteractionParameterHandle(
FUSE_TYPE_MD_PI,
p->getParameterHandle(
MunitionDetonation::getFuseTypeParameterFedName(),
handle) );
setInteractionParameterHandle(
MUNITION_OBJECT_IDENTIFIER_MD_PI,
p->getParameterHandle(
MunitionDetonation::getMunitionObjectIdentifierParameterFedName(),
handle) );
setInteractionParameterHandle(
MUNITION_TYPE_MD_PI,
p->getParameterHandle(
MunitionDetonation::getMunitionTypeParameterFedName(),
handle) );
setInteractionParameterHandle(
QUANTITY_FIRED_MD_PI,
p->getParameterHandle(
MunitionDetonation::getQuantityFiredParameterFedName(),
handle) );
setInteractionParameterHandle(
RATE_OF_FIRE_MD_PI,
p->getParameterHandle(
MunitionDetonation::getRateOfFireParameterFedName(),
handle) );
setInteractionParameterHandle(
RELATIVE_DETONATION_LOCATION_MD_PI,
p->getParameterHandle(
MunitionDetonation::getRelativeDetonationLocationParameterFedName(),
handle) );
setInteractionParameterHandle(
TARGET_OBJECT_IDENTIFIER_MD_PI,
p->getParameterHandle(
MunitionDetonation::getTargetObjectIdentifierParameterFedName(),
handle) );
setInteractionParameterHandle(
WARHEAD_TYPE_MD_PI,
p->getParameterHandle(
MunitionDetonation::getWarheadTypeParameterFedName(),
handle) );
}
}
catch( RTI::Exception& e) {
std::cerr << &e << std::endl;
ok = false;
}
// ----------
// Publish & Subscribe to class attributes
// ----------
if (ok) {
try {
// ---
// Publish these interactions
// ---
if (isOutputEnabled()) {
p->publishInteractionClass(getInteractionClassHandle(MUNITION_DETONATION_INTERACTION));
setInteractionClassPublished(MUNITION_DETONATION_INTERACTION, true);
}
// ---
// Subscribe to these interactions
// ---
if (isInputEnabled()) {
p->subscribeInteractionClass(getInteractionClassHandle(MUNITION_DETONATION_INTERACTION));
setInteractionClassSubscribed(MUNITION_DETONATION_INTERACTION, true);
}
}
catch (RTI::Exception& e) {
std::cerr << &e << std::endl;
ok = false;
}
}
return ok;
}
