}
int
-Editor::set_state (const XMLNode& node, int version)
+Editor::set_state (const XMLNode& node, int /*version*/)
{
const XMLProperty* prop;
XMLNode* geometry;
return *node;
}
-int
-Keyboard::set_state (const XMLNode& node, int version)
+int
+Keyboard::set_state (const XMLNode& node, int /*version*/)
{
const XMLProperty* prop;
}
int
-TimeAxisView::set_state (const XMLNode& node, int version)
+TimeAxisView::set_state (const XMLNode& node, int /*version*/)
{
const XMLProperty *prop;
}
int
-UIConfiguration::set_state (const XMLNode& root, int version)
+UIConfiguration::set_state (const XMLNode& root, int /*version*/)
{
if (root.name() != "Ardour") {
return -1;
}
int
-AudioDiskstream::set_state (const XMLNode& node, int version)
+AudioDiskstream::set_state (const XMLNode& node, int /*version*/)
{
const XMLProperty* prop;
XMLNodeList nlist = node.children();
use_new_diskstream ();
}
-AudioTrack::AudioTrack (Session& sess, const XMLNode& node, int version)
+AudioTrack::AudioTrack (Session& sess, const XMLNode& node, int /*version*/)
: Track (sess, node)
{
_set_state (node, Stateful::loading_state_version, false);
}
int
-AudioSource::set_state (const XMLNode& node, int version)
+AudioSource::set_state (const XMLNode& node, int /*version*/)
{
const XMLProperty* prop;
}
int
-ControlProtocolManager::set_state (const XMLNode& node, int version)
+ControlProtocolManager::set_state (const XMLNode& node, int /*version*/)
{
XMLNodeList clist;
XMLNodeConstIterator citer;
}
int
-Crossfade::set_state (const XMLNode& node, int version)
+Crossfade::set_state (const XMLNode& node, int /*version*/)
{
XMLNodeConstIterator i;
XMLNodeList children;
}
int
-FileSource::set_state (const XMLNode& node, int version)
+FileSource::set_state (const XMLNode& node, int /*version*/)
{
const XMLProperty* prop;
}
int
-IO::get_port_counts_2X (XMLNode const & node, int version, ChanCount& n, boost::shared_ptr<Bundle>& c)
+IO::get_port_counts_2X (XMLNode const & node, int /*version*/, ChanCount& n, boost::shared_ptr<Bundle>& /*c*/)
{
XMLProperty const * prop;
XMLNodeList children = node.children ();
int
-IO::make_connections_2X (const XMLNode& node, int version, bool in)
+IO::make_connections_2X (const XMLNode& node, int /*version*/, bool in)
{
const XMLProperty* prop;
}
int
-Location::set_state (const XMLNode& node, int version)
+Location::set_state (const XMLNode& node, int /*version*/)
{
const XMLProperty *prop;
}
int
-Locations::set_state (const XMLNode& node, int version)
+Locations::set_state (const XMLNode& node, int /*version*/)
{
XMLNodeList nlist;
XMLNodeConstIterator niter;
}
int
-LV2Plugin::set_state(const XMLNode& node, int version)
+LV2Plugin::set_state(const XMLNode& node, int /*version*/)
{
XMLNodeList nodes;
XMLProperty *prop;
}
int
-MidiDiskstream::set_state (const XMLNode& node, int version)
+MidiDiskstream::set_state (const XMLNode& node, int /*version*/)
{
const XMLProperty* prop;
XMLNodeList nlist = node.children();
#define DELTA_COMMAND_ELEMENT "DeltaCommand"
int
-MidiModel::DeltaCommand::set_state (const XMLNode& delta_command, int version)
+MidiModel::DeltaCommand::set_state (const XMLNode& delta_command, int /*version*/)
{
if (delta_command.name() != string(DELTA_COMMAND_ELEMENT)) {
return 1;
}
int
-MidiModel::DiffCommand::set_state(const XMLNode& diff_command, int version)
+MidiModel::DiffCommand::set_state(const XMLNode& diff_command, int /*version*/)
{
if (diff_command.name() != string(DIFF_COMMAND_ELEMENT)) {
return 1;
}
int
-MidiSource::set_state (const XMLNode& node, int version)
+MidiSource::set_state (const XMLNode& node, int /*version*/)
{
const XMLProperty* prop;
_mode = mode;
}
-MidiTrack::MidiTrack (Session& sess, const XMLNode& node, int version)
+MidiTrack::MidiTrack (Session& sess, const XMLNode& node, int /*version*/)
: Track (sess, node, DataType::MIDI)
, _immediate_events(1024) // FIXME: size?
, _step_edit_ring_buffer(64) // FIXME: size?
}
int
-MuteMaster::set_state (const XMLNode& node, int version)
+MuteMaster::set_state (const XMLNode& node, int /*version*/)
{
const XMLProperty* prop;
}
int
-StreamPanner::set_state (const XMLNode& node, int version)
+StreamPanner::set_state (const XMLNode& node, int /*version*/)
{
const XMLProperty* prop;
XMLNodeConstIterator iter;
}
int
-Multi2dPanner::set_state (const XMLNode& node, int version)
+Multi2dPanner::set_state (const XMLNode& node, int /*version*/)
{
const XMLProperty* prop;
float newx,newy;
}
int
-Processor::set_state_2X (const XMLNode & node, int version)
+Processor::set_state_2X (const XMLNode & node, int /*version*/)
{
XMLProperty const * prop;
}
int
-RCConfiguration::set_state (const XMLNode& root, int version)
+RCConfiguration::set_state (const XMLNode& root, int /*version*/)
{
if (root.name() != "Ardour") {
return -1;
}
int
-Region::set_live_state (const XMLNode& node, int version, Change& what_changed, bool send)
+Region::set_live_state (const XMLNode& node, int /*version*/, Change& what_changed, bool send)
{
const XMLNodeList& nlist = node.children();
const XMLProperty *prop;
return *node;
}
-int
+int
RouteGroup::set_state (const XMLNode& node, int version)
{
if (version < 3000) {
}
int
-RouteGroup::set_state_2X (const XMLNode& node, int version)
+RouteGroup::set_state_2X (const XMLNode& node, int /*version*/)
{
XMLProperty const * prop;
-
+
if ((prop = node.property ("name")) != 0) {
_name = prop->value();
}
-
+
if ((prop = node.property ("flags")) != 0) {
_flags = Flag (string_2_enum (prop->value(), _flags));
}
}
int
-Session::GlobalRouteStateCommand::set_state (const XMLNode& node, int version)
+Session::GlobalRouteStateCommand::set_state (const XMLNode& node, int /*version*/)
{
GlobalRouteBooleanState states;
XMLNodeList nlist;
}
int
-Session::GlobalMeteringStateCommand::set_state (const XMLNode& node, int version)
+Session::GlobalMeteringStateCommand::set_state (const XMLNode& node, int /*version*/)
{
GlobalRouteBooleanState states;
XMLNodeList nlist;
int
-SessionConfiguration::set_state (XMLNode const& root, int version)
+SessionConfiguration::set_state (XMLNode const& root, int /*version*/)
{
if (root.name() != "Ardour") {
return -1;
}
int
-SessionMetadata::set_state (const XMLNode & state, int version)
+SessionMetadata::set_state (const XMLNode & state, int /*version*/)
{
const XMLNodeList & children = state.children();
ustring name;
}
int
-Source::set_state (const XMLNode& node, int version)
+Source::set_state (const XMLNode& node, int /*version*/)
{
const XMLProperty* prop;
}
int
-TempoMap::set_state (const XMLNode& node, int version)
+TempoMap::set_state (const XMLNode& node, int /*version*/)
{
{
Glib::RWLock::WriterLock lm (lock);
}
int
-ARDOUR::UserBundle::set_state (XMLNode const & node, int version)
+ARDOUR::UserBundle::set_state (XMLNode const & node, int /*version*/)
{
XMLProperty const * name;
/*
- Copyright (C) 2008 Hans Baier
+ Copyright (C) 2008 Hans Baier
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
assert(control != "");
string value = node->property("Value")->value();
assert(value != "");
-
+
if (control == "0") {
id.msb = PBD::atoi(value);
} else if (control == "32") {
int
-Patch::set_state (const XMLNode& node, int version)
+Patch::set_state (const XMLNode& node, int /*version*/)
{
assert(node.name() == "Patch");
_number = node.property("Number")->value();
_name = node.property("Name")->value();
XMLNode* commands = node.child("PatchMIDICommands");
-
+
if (commands) {
initialize_primary_key_from_commands(_id, commands);
} else {
cerr << "deserialized Patch: name: " << _name << " msb: " << _id.msb << " lsb: " << _id.lsb << " program " << _id.program_number << endl;
// TODO: handle that more gracefully
assert(_id.is_sane());
-
+
return 0;
}
}
int
-Note::set_state (const XMLNode& node, int version)
+Note::set_state (const XMLNode& node, int /*version*/)
{
assert(node.name() == "Note");
_number = node.property("Number")->value();
note->set_state(*(*i), version);
_notes.push_back(note);
}
-
+
return 0;
}
_id = new PatchPrimaryKey();
initialize_primary_key_from_commands(*_id, commands);
}
-
+
XMLNode* patch_name_list = node.child("PatchNameList");
assert(patch_name_list);
const XMLNodeList patches = patch_name_list->children();
patch->set_state(*(*i), version);
_patch_name_list.push_back(patch);
}
-
+
return 0;
}
// cerr << "AvailableForChannels after insert" << endl;
}
}
-
+
// cerr << "before PatchBank" << endl;
if (node->name() == "PatchBank") {
// cerr << "after PatchBank pushback" << endl;
}
}
-
+
// cerr << "ChannelnameSet done" << endl;
return 0;
}
int
-CustomDeviceMode::set_state(const XMLNode& a_node, int version)
+CustomDeviceMode::set_state(const XMLNode& a_node, int /*version*/)
{
assert(a_node.name() == "CustomDeviceMode");
-
+
_name = a_node.property("Name")->value();
-
+
boost::shared_ptr<XMLSharedNodeList> channel_name_set_assignments =
a_node.find("//ChannelNameSetAssign");
for(XMLSharedNodeList::const_iterator i = channel_name_set_assignments->begin();
{
XMLNode* custom_device_mode = new XMLNode("CustomDeviceMode");
custom_device_mode->add_property("Name", _name);
- XMLNode* channel_name_set_assignments =
+ XMLNode* channel_name_set_assignments =
custom_device_mode->add_child("ChannelNameSetAssignments");
for (int i = 0; i < 15 && !_channel_name_set_assignments[i].empty(); i++) {
- XMLNode* channel_name_set_assign =
+ XMLNode* channel_name_set_assign =
channel_name_set_assignments->add_child("ChannelNameSetAssign");
channel_name_set_assign->add_property("Channel", i + 1);
channel_name_set_assign->add_property("NameSet", _channel_name_set_assignments[i]);
}
-
+
return *custom_device_mode;
}
++i) {
boost::shared_ptr<CustomDeviceMode> custom_device_mode(new CustomDeviceMode());
custom_device_mode->set_state(*(*i), version);
-
+
_custom_device_modes[custom_device_mode->name()] = custom_device_mode;
_custom_device_mode_names.push_back(custom_device_mode->name());
}
}
MIDINameDocument::MIDINameDocument (const string& filename)
- : _document(XMLTree(filename))
-{
- set_state(*_document.root(), 0);
+ : _document(XMLTree(filename))
+{
+ set_state(*_document.root(), 0);
}
int
boost::shared_ptr<XMLSharedNodeList> author = a_node.find("//Author");
assert(author->size() == 1);
_author = author->front()->content();
-
+
// cerr << "MIDINameDocument::set_state befor masterdevicenames" << endl;
// MasterDeviceNames
boost::shared_ptr<XMLSharedNodeList> master_device_names_list = a_node.find("//MasterDeviceNames");
// cerr << "MIDINameDocument::set_state before masterdevicenames->set_state" << endl;
master_device_names->set_state(*(*i), version);
// cerr << "MIDINameDocument::set_state after masterdevicenames->set_state" << endl;
-
+
for (MasterDeviceNames::Models::const_iterator model = master_device_names->models().begin();
model != master_device_names->models().end();
++model) {
_master_device_names_list.insert(
std::pair<std::string, boost::shared_ptr<MasterDeviceNames> >
(*model, master_device_names));
-
+
_all_models.push_back(*model);
}
}
-
+
return 0;
}
}
int
-Controllable::set_state (const XMLNode& node, int version)
+Controllable::set_state (const XMLNode& node, int /*version*/)
{
const XMLProperty* prop = node.property (X_("id"));
/*
Copyright (C) 1998-2006 Paul Davis
-
+
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
control_additional = (byte) -1;
connections = 0;
feedback = true; // for now
-
+
/* use channel 0 ("1") as the initial channel */
midi_rebind (0);
/* stop listening for incoming messages, but retain
our existing event + type information.
*/
-
+
if (connections > 0) {
midi_sense_connection[0].disconnect ();
- }
-
+ }
+
if (connections > 1) {
midi_sense_connection[1].disconnect ();
}
-
+
connections = 0;
midi_learn_connection.disconnect ();
-
+
}
void
{
if (connections > 0) {
midi_sense_connection[0].disconnect ();
- }
+ }
if (connections > 1) {
midi_sense_connection[1].disconnect ();
}
return val / midi_range * control_range + control_min;
}
-void
-MIDIControllable::midi_sense_note_on (Parser &p, EventTwoBytes *tb)
+void
+MIDIControllable::midi_sense_note_on (Parser &p, EventTwoBytes *tb)
{
midi_sense_note (p, tb, true);
}
-void
-MIDIControllable::midi_sense_note_off (Parser &p, EventTwoBytes *tb)
+void
+MIDIControllable::midi_sense_note_off (Parser &p, EventTwoBytes *tb)
{
midi_sense_note (p, tb, false);
}
/* Note: parser handles the use of zero velocity to
mean note off. if we get called with is_on=true, then we
- got a *real* note on.
+ got a *real* note on.
*/
if (msg->note_number == control_additional) {
if (!bistate) {
controllable.set_value (msg/127.0);
last_value = (MIDI::byte) (controllable.get_value() * 127.0); // to prevent feedback fights
- }
+ }
}
void
controllable.set_value ((pb/(float) SHRT_MAX));
last_value = (MIDI::byte) (controllable.get_value() * 127.0); // to prevent feedback fights
-}
+}
void
MIDIControllable::midi_receiver (Parser &, byte *msg, size_t /*len*/)
if (_port.input() == 0) {
return;
}
-
+
Parser& p = *_port.input();
int chn_i = chn;
midi_sense_connection[0] = p.channel_note_on[chn_i].connect
(mem_fun (*this, &MIDIControllable::midi_sense_note_on));
if (bistate) {
- midi_sense_connection[1] = p.channel_note_off[chn_i].connect
+ midi_sense_connection[1] = p.channel_note_off[chn_i].connect
(mem_fun (*this, &MIDIControllable::midi_sense_note_off));
connections = 2;
} else {
break;
case MIDI::controller:
- midi_sense_connection[0] = p.channel_controller[chn_i].connect
+ midi_sense_connection[0] = p.channel_controller[chn_i].connect
(mem_fun (*this, &MIDIControllable::midi_sense_controller));
connections = 1;
snprintf (buf, sizeof (buf), "MIDI control: Controller %d", control_additional);
case MIDI::program:
if (!bistate) {
midi_sense_connection[0] = p.channel_program_change[chn_i].connect
- (mem_fun (*this,
+ (mem_fun (*this,
&MIDIControllable::midi_sense_program_change));
connections = 1;
_control_description = "MIDI control: ProgramChange";
return;
}
- msg[0] = (control_type & 0xF0) | (control_channel & 0xF);
+ msg[0] = (control_type & 0xF0) | (control_channel & 0xF);
msg[1] = control_additional;
msg[2] = (byte) (control_to_midi(controllable.get_value()));
MIDIControllable::write_feedback (MIDI::byte* buf, int32_t& bufsize, bool /*force*/)
{
if (control_type != none && feedback && bufsize > 2) {
-
+
MIDI::byte gm = (MIDI::byte) (control_to_midi(controllable.get_value()));
-
+
if (gm != last_value) {
*buf++ = (0xF0 & control_type) | (0xF & control_channel);
*buf++ = control_additional; /* controller number */
bufsize -= 3;
}
}
-
+
return buf;
}
-int
-MIDIControllable::set_state (const XMLNode& node, int version)
+int
+MIDIControllable::set_state (const XMLNode& node, int /*version*/)
{
const XMLProperty* prop;
int xx;
}
bind_midi (control_channel, control_type, control_additional);
-
+
return 0;
}
current_max += (*it)->strips();
if ( index < current_max ) return **it;
}
-
+
// oops - no matching port
ostringstream os;
os << "No port for index " << index;
MackieControlProtocol::Sorted MackieControlProtocol::get_sorted_routes()
{
Sorted sorted;
-
+
// fetch all routes
boost::shared_ptr<RouteList> routes = session->get_routes();
set<uint32_t> remote_ids;
-
+
// routes with remote_id 0 should never be added
// TODO verify this with ardour devs
// remote_ids.insert( 0 );
-
+
// sort in remote_id order, and exclude master, control and hidden routes
// and any routes that are already set.
for (RouteList::iterator it = routes->begin(); it != routes->end(); ++it )
{
// DON'T prevent bank switch if initial == _current_initial_bank
// because then this method can't be used as a refresh
-
+
// sanity checking
Sorted sorted = get_sorted_routes();
int delta = sorted.size() - route_table.size();
return;
}
_current_initial_bank = initial;
-
+
// first clear the signals from old routes
// taken care of by the RouteSignal destructors
clear_route_signals();
-
+
// now set the signals for new routes
if ( _current_initial_bank <= sorted.size() )
{
#ifdef DEBUG
cout << "switch to " << _current_initial_bank << ", " << end_pos << endl;
#endif
-
+
// link routes to strips
uint32_t i = 0;
for ( ; it != end && it != sorted.end(); ++it, ++i )
// update strip from route
rs->notify_all();
}
-
+
// create dead strips if there aren't enough routes to
// fill a bank
for ( ; i < route_table.size(); ++i )
port.write( builder.zero_strip( port, strip ) );
}
}
-
+
// display the current start bank.
surface().display_bank_start( mcu_port(), builder, _current_initial_bank );
}
void MackieControlProtocol::zero_all()
{
// TODO turn off SMPTE displays
-
+
// zero all strips
for ( Surface::Strips::iterator it = surface().strips.begin(); it != surface().strips.end(); ++it )
{
MackiePort & port = port_for_id( (*it)->index() );
port.write( builder.zero_strip( port, **it ) );
}
-
+
// and the master strip
mcu_port().write( builder.zero_strip( dynamic_cast<MackiePort&>( mcu_port() ), master_strip() ) );
-
+
// turn off global buttons and leds
// global buttons are only ever on mcu_port, so we don't have
// to figure out which port.
if ( yn )
{
// TODO what happens if this fails half way?
-
+
// create MackiePorts
{
Glib::Mutex::Lock lock( update_mutex );
create_ports();
}
-
+
// make sure the ports are being listened to
update_ports();
-
+
// wait until poll thread is running, with ports to poll
// the mutex is only there because conditions require a mutex
{
Glib::Mutex::Lock lock( update_mutex );
while ( nfds == 0 ) update_cond.wait( update_mutex );
}
-
+
// now initialise MackiePorts - ie exchange sysex messages
for( MackiePorts::iterator it = _ports.begin(); it != _ports.end(); ++it )
{
(*it)->open();
}
-
+
// wait until all ports are active
// TODO a more sophisticated approach would
// allow things to start up with only an MCU, even if
{
(*it)->wait_for_init();
}
-
+
// create surface object. This depends on the ports being
// correctly initialised
initialize_surface();
connect_session_signals();
-
+
// yeehah!
_active = true;
-
+
// send current control positions to surface
// must come after _active = true otherwise it won't run
update_surface();
//state = default_button_press( dynamic_cast<Button&>( control ) );
}
}
-
+
if ( control.name() == "fader_touch" )
{
state = bs == press;
control.strip().gain().in_use( state );
}
-
+
return state;
}
// do the initial bank switch to connect signals
// _current_initial_bank is initialised by set_state
switch_banks( _current_initial_bank );
-
+
// create a RouteSignal for the master route
boost::shared_ptr<Route> mr = master_route ();
// update strip from route
master_route_signal->notify_all();
}
-
+
// sometimes the jog wheel is a pot
surface().blank_jog_ring( mcu_port(), builder );
-
+
// update global buttons and displays
notify_record_state_changed();
notify_transport_state_changed();
session->config.ParameterChanged.connect ( ( mem_fun (*this, &MackieControlProtocol::notify_parameter_changed) ) );
// receive rude solo changed
connections_back = session->SoloActive.connect( ( mem_fun (*this, &MackieControlProtocol::notify_solo_active_changed) ) );
-
+
// make sure remote id changed signals reach here
// see also notify_route_added
Sorted sorted = get_sorted_routes();
{
MackiePort * sport = new MackiePort( *this, midi_port, number );
_ports.push_back( sport );
-
+
connections_back = sport->init_event.connect(
sigc::bind (
mem_fun (*this, &MackieControlProtocol::handle_port_init)
, sport
)
);
-
+
_ports_changed = true;
}
}
}
add_port( *midi_port, 0 );
}
-
+
// open extender ports. Up to 9. Should be enough.
// could also use mm->get_midi_ports()
string ext_port_base = "mcu_xt_";
{
strips += (*it)->strips();
}
-
+
set_route_table_size( strips );
-
+
// TODO same as code in mackie_port.cc
string emulation = ARDOUR::Config->get_mackie_emulation();
if ( emulation == "bcf" )
}
_surface->init();
-
+
// Connect events. Must be after route table otherwise there will be trouble
for( MackiePorts::iterator it = _ports.begin(); it != _ports.end(); ++it )
{
// calls methods on objects that are deleted
_polling = false;
pthread_join( thread, 0 );
-
+
// TODO disconnect port active/inactive signals
// Or at least put a lock here
-
+
// disconnect global signals from Session
// TODO Since *this is a sigc::trackable, this shouldn't be necessary
// but it is for some reason
it->disconnect();
}
#endif
-
+
if ( _surface != 0 )
{
// These will fail if the port has gone away.
cout << "MackieControlProtocol::close caught exception: " << e.what() << endl;
#endif
}
-
+
for( MackiePorts::iterator it = _ports.begin(); it != _ports.end(); ++it )
{
try
#endif
}
}
-
+
// disconnect routes from strips
clear_route_signals();
-
+
delete _surface;
_surface = 0;
}
-
+
// shut down MackiePorts
for( MackiePorts::iterator it = _ports.begin(); it != _ports.end(); ++it )
{
delete *it;
}
_ports.clear();
-
+
// this is done already in monitor_work. But it's here so we know.
delete[] pfd;
pfd = 0;
#ifdef DEBUG
cout << "MackieControlProtocol::get_state" << endl;
#endif
-
+
// add name of protocol
XMLNode* node = new XMLNode( X_("Protocol") );
node->add_property( X_("name"), _name );
-
+
// add current bank
ostringstream os;
os << _current_initial_bank;
node->add_property( X_("bank"), os.str() );
-
+
return *node;
}
-int MackieControlProtocol::set_state (const XMLNode & node, int version)
+int MackieControlProtocol::set_state (const XMLNode & node, int /*version*/)
{
#ifdef DEBUG
cout << "MackieControlProtocol::set_state: active " << _active << endl;
#endif
int retval = 0;
-
+
// fetch current bank
if ( node.property( X_("bank") ) != 0 )
{
return -1;
}
}
-
+
return retval;
}
cerr << "Warning: index is " << index << " which is not in the route table, size: " << route_table.size() << endl;
}
}
-
+
// This handles control element events from the surface
// the state of the controls on the surface is usually updated
// from UI events.
if ( route != 0 )
{
route->gain_control()->set_value( state.pos );
-
+
// must echo bytes back to slider now, because
// the notifier only works if the fader is not being
// touched. Which it is if we're getting input.
port.write( builder.build_fader( (Fader&)control, state.pos ) );
}
break;
-
+
case Control::type_button:
if ( control.group().is_strip() )
{
surface().handle_button( *this, state.button_state, dynamic_cast<Button&>( control ) );
}
break;
-
+
// pot (jog wheel, external control)
case Control::type_pot:
if ( control.group().is_strip() )
// assume pan for now
float xpos;
route->panner()->streampanner (0).get_effective_position (xpos);
-
+
// calculate new value, and trim
xpos += state.delta * state.sign;
if ( xpos > 1.0 )
xpos = 1.0;
else if ( xpos < 0.0 )
xpos = 0.0;
-
+
route->panner()->streampanner (0).set_position( xpos );
}
}
}
}
break;
-
+
default:
cout << "Control::type not handled: " << control.type() << endl;
}
cout << e.what() << endl;
}
}
-
+
void MackieControlProtocol::notify_gain_changed( RouteSignal * route_signal, bool force_update )
{
try
{
string line1;
string fullname = route_signal->route()->name();
-
+
if ( fullname.length() <= 6 )
{
line1 = fullname;
{
line1 = PBD::short_version( fullname, 6 );
}
-
+
SurfacePort & port = route_signal->port();
port.write( builder.strip_display( port, strip, 0, line1 ) );
port.write( builder.strip_display_blank( port, strip, 1 ) );
{
float pos;
route_signal->route()->panner()->streampanner(0).get_effective_position( pos );
-
+
// cache the MidiByteArray here, because the mackie led control is much lower
// resolution than the panner control. So we save lots of byte
// sends in spite of more work on the comparison
{
notify_gain_changed( &rs, false );
}
-
+
if ( rs.route()->panner() ) {
ARDOUR::AutoState panner_state = rs.route()->panner()->automation_state();
if ( panner_state == Touch || panner_state == Play )
{
BBT_Time bbt_time;
session->bbt_time( now_frame, bbt_time );
-
+
// According to the Logic docs
// digits: 888/88/88/888
// BBT mode: Bars/Beats/Subdivisions/Ticks
ostringstream os;
os << setw(3) << setfill('0') << bbt_time.bars;
os << setw(2) << setfill('0') << bbt_time.beats;
-
+
// figure out subdivisions per beat
const Meter & meter = session->tempo_map().meter_at( now_frame );
int subdiv = 2;
{
subdiv = 3;
}
-
+
uint32_t subdivisions = bbt_time.ticks / uint32_t( Meter::ticks_per_beat / subdiv );
uint32_t ticks = bbt_time.ticks % uint32_t( Meter::ticks_per_beat / subdiv );
-
+
os << setw(2) << setfill('0') << subdivisions + 1;
os << setw(3) << setfill('0') << ticks;
-
+
return os.str();
}
os << setw(2) << setfill('0') << smpte.minutes;
os << setw(2) << setfill('0') << smpte.seconds;
os << setw(3) << setfill('0') << smpte.frames;
-
+
return os.str();
}
// do assignment here so current_frame is fixed
nframes_t current_frame = session->transport_frame();
string timecode;
-
+
switch ( _timecode_type )
{
case ARDOUR::AnyTime::BBT:
ostringstream os;
os << "Unknown timecode: " << _timecode_type;
throw runtime_error( os.str() );
- }
-
+ }
+
// only write the timecode string to the MCU if it's changed
// since last time. This is to reduce midi bandwidth used.
if ( timecode != _timecode_last )
{
update_automation( **it );
}
-
+
// and the master strip
if ( master_route_signal != 0 )
{
update_automation( *master_route_signal );
}
-
+
update_timecode_display();
-
+
_automation_last.start();
}
}
{
// can use first_mark_before/after as well
unsigned long elapsed = _frm_left_last.restart();
-
+
Location * loc = session->locations()->first_location_before (
session->transport_frame()
);
-
- // allow a quick double to go past a previous mark
+
+ // allow a quick double to go past a previous mark
if ( session->transport_rolling() && elapsed < 500 && loc != 0 )
{
Location * loc_two_back = session->locations()->first_location_before ( loc->start() );
loc = loc_two_back;
}
}
-
+
// move to the location, if it's valid
if ( loc != 0 )
{
session->request_locate( loc->start(), session->transport_rolling() );
}
-
+
return on;
}
refresh_current_bank();
}
// otherwise route added, but current bank needs no updating
-
+
// make sure remote id changes in the new route are handled
typedef ARDOUR::RouteList ARS;
for ( ARS::iterator it = rl.begin(); it != rl.end(); ++it )
void MackieControlProtocol::notify_remote_id_changed()
{
Sorted sorted = get_sorted_routes();
-
+
// if a remote id has been moved off the end, we need to shift
// the current bank backwards.
if ( sorted.size() - _current_initial_bank < route_signals.size() )
update_global_button( "play", session->transport_rolling() );
update_global_button( "stop", !session->transport_rolling() );
update_global_button( "loop", session->get_play_loop() );
-
+
_transport_previously_rolling = session->transport_rolling();
-
+
// rec is special because it's tristate
Button * rec = reinterpret_cast<Button*>( surface().controls_by_name["record"] );
mcu_port().write( builder.build_led( *rec, record_release( *rec ) ) );
session->set_dirty();
switch_banks( new_initial );
}
-
+
return on;
}
else
session->set_dirty();
switch_banks( _current_initial_bank + delta );
}
-
+
return on;
}
else
projects / ardour.git / commitdiff