return TRUE;
}
-void
-ARDOUR_UI::control_methods_adjusted ()
-
-{
- int which_method;
-
- which_method = (int) online_control_button->adjustment.get_value();
- switch (which_method) {
- case 0:
- allow_mmc_and_local ();
- break;
- case 1:
- allow_mmc_only ();
- break;
- case 2:
- allow_local_only ();
- break;
- default:
- fatal << _("programming error: impossible control method") << endmsg;
- }
-}
-
-
-void
-ARDOUR_UI::mmc_device_id_adjusted ()
-
-{
-#if 0
- if (mmc) {
- int dev_id = (int) mmc_id_button->adjustment.get_value();
- mmc->set_device_id (dev_id);
- }
-#endif
-}
gint
ARDOUR_UI::session_menu (GdkEventButton *ev)
}
}
-void
-ARDOUR_UI::allow_local_only ()
-{
-
-}
-
-void
-ARDOUR_UI::allow_mmc_only ()
-{
-
-}
-
-void
-ARDOUR_UI::allow_mmc_and_local ()
-{
-
-}
-
void
ARDOUR_UI::GlobalClickBox::printer (char buf[32], Adjustment &adj, void *arg)
{
GlobalClickBox *crossfade_time_button;
vector<string> crossfade_time_strings;
- GlobalClickBox *mmc_id_button;
- vector<string> mmc_id_strings;
-
Gtk::ToggleButton preroll_button;
Gtk::ToggleButton postroll_button;
int setup_windows ();
void setup_transport ();
void setup_clock ();
- void setup_adjustables ();
static ARDOUR_UI *theArdourUI;
void start_blinking ();
void stop_blinking ();
- void control_methods_adjusted ();
- void mmc_device_id_adjusted ();
-
void about_signal_response(int response);
private:
void transport_rec_enable_blink (bool onoff);
- /* These change where we accept control from:
- MMC, X (local) or both.
- */
-
- void allow_mmc_only ();
- void allow_mmc_and_local ();
- void allow_local_only ();
-
Gtk::Menu* session_popup_menu;
struct RecentSessionModelColumns : public Gtk::TreeModel::ColumnRecord {
setup_clock ();
setup_transport();
- setup_adjustables ();
build_menu_bar ();
top_packer.pack_start (menu_bar_base, false, false);
return 0;
}
-void
-ARDOUR_UI::setup_adjustables ()
-{
- adjuster_table.set_homogeneous (true);
-
- online_control_strings.push_back (_("MMC + Local"));
- online_control_strings.push_back (_("MMC"));
- online_control_strings.push_back (_("Local"));
-
- online_control_button = new GlobalClickBox ("CONTROL",
- online_control_strings);
-
- online_control_button->adjustment.signal_value_changed().connect(mem_fun(*this,&ARDOUR_UI::control_methods_adjusted));
-
- mmc_id_strings.push_back ("1");
- mmc_id_strings.push_back ("2");
- mmc_id_strings.push_back ("3");
- mmc_id_strings.push_back ("4");
- mmc_id_strings.push_back ("5");
- mmc_id_strings.push_back ("6");
- mmc_id_strings.push_back ("7");
- mmc_id_strings.push_back ("8");
- mmc_id_strings.push_back ("9");
-
- mmc_id_button = new GlobalClickBox (_("MMC ID"), mmc_id_strings);
-
- mmc_id_button->adjustment.signal_value_changed().connect (mem_fun(*this,&ARDOUR_UI::mmc_device_id_adjusted));
-
- adjuster_table.attach (*online_control_button, 0, 2, 1, 2, FILL|EXPAND, FILL, 5, 5);
- adjuster_table.attach (*mmc_id_button, 2, 3, 1, 2, FILL, FILL, 5, 5);
-}
-
void
ARDOUR_UI::transport_stopped ()
{
}
Meta = possible_meta[i];
- if (Meta) {
- cerr << "Using " << possible_meta[i] << " for Meta\n";
- } else {
- cerr << "NO Meta\n";
- }
-
snooper_id = gtk_key_snooper_install (_snooper, (gpointer) this);
XMLNode* node = ARDOUR_UI::instance()->keyboard_settings();
/* MIDI */
+ mmc_device_id_adjustment (0.0, 0.0, (double) 0x7f, 1.0, 16.0),
+ mmc_device_id_spinner (mmc_device_id_adjustment),
+
/* Click */
click_table (2, 3),
ToggleButton* tb;
RadioButton* rb;
- Gtk::Table* table = manage (new Table (ports.size() + 4, 9));
+ Gtk::Table* table = manage (new Table (ports.size() + 4, 10));
table->set_row_spacings (6);
table->set_col_spacings (10);
- table->attach (*(manage (new Label (X_("Port")))), 0, 1, 0, 1);
- table->attach (*(manage (new Label (X_("Offline")))), 1, 2, 0, 1);
- table->attach (*(manage (new Label (X_("Trace\nInput")))), 2, 3, 0, 1);
- table->attach (*(manage (new Label (X_("Trace\nOutput")))), 3, 4, 0, 1);
- table->attach (*(manage (new Label (X_("MTC")))), 4, 5, 0, 1);
- table->attach (*(manage (new Label (X_("MMC")))), 6, 7, 0, 1);
- table->attach (*(manage (new Label (X_("MIDI Parameter\nControl")))), 8, 9, 0, 1);
+ table->attach (*(manage (new Label (_("Port")))), 0, 1, 0, 1);
+ table->attach (*(manage (new Label (_("Offline")))), 1, 2, 0, 1);
+ table->attach (*(manage (new Label (_("Trace\nInput")))), 2, 3, 0, 1);
+ table->attach (*(manage (new Label (_("Trace\nOutput")))), 3, 4, 0, 1);
+ table->attach (*(manage (new Label (_("MTC")))), 4, 5, 0, 1);
+ table->attach (*(manage (new Label (_("MMC")))), 6, 7, 0, 1);
+ table->attach (*(manage (new Label (_("MIDI Parameter\nControl")))), 8, 9, 0, 1);
table->attach (*(manage (new HSeparator())), 0, 9, 1, 2);
table->attach (*(manage (new VSeparator())), 5, 6, 0, 8);
table->attach (*(manage (new VSeparator())), 7, 8, 0, 8);
+ table->attach (*(manage (new Label (_("MMC Device ID")))), 9, 10, 0, 1);
+ table->attach (mmc_device_id_spinner, 9, 10, 1, 2);
+
+ mmc_device_id_adjustment.signal_value_changed().connect (mem_fun (*this, &OptionEditor::mmc_device_id_adjusted));
+
for (n = 0, i = ports.begin(); i != ports.end(); ++n, ++i) {
pair<MIDI::Port*,vector<RadioButton*> > newpair;
}
}
+void
+OptionEditor::mmc_device_id_adjusted ()
+{
+ uint8_t id = (uint8_t) mmc_device_id_spinner.get_value();
+
+ if (id != Config->get_mmc_device_id()) {
+ Config->set_mmc_device_id (id);
+ }
+}
+
void
OptionEditor::port_trace_in_toggled (MIDI::Port* port, ToggleButton* tb)
{
bool trace = tb->get_active();
if (port->input()->tracing() != trace) {
- port->output()->trace (trace, &cerr, string (port->name()) + string (" input: "));
+ port->input()->trace (trace, &cerr, string (port->name()) + string (" input: "));
}
}
Gtk::RadioButton::Group mmc_button_group;
Gtk::RadioButton::Group midi_button_group;
+ Gtk::Adjustment mmc_device_id_adjustment;
+ Gtk::SpinButton mmc_device_id_spinner;
+
void port_online_toggled (MIDI::Port*,Gtk::ToggleButton*);
void port_trace_in_toggled (MIDI::Port*,Gtk::ToggleButton*);
void port_trace_out_toggled (MIDI::Port*,Gtk::ToggleButton*);
void mtc_port_chosen (MIDI::Port*,Gtk::RadioButton*);
void midi_port_chosen (MIDI::Port*,Gtk::RadioButton*);
+ void mmc_device_id_adjusted ();
+
void map_port_online (MIDI::Port*, Gtk::ToggleButton*);
void setup_midi_options();
CONFIG_VARIABLE (bool, mmc_control, "mmc-control", false)
CONFIG_VARIABLE (bool, midi_feedback, "midi-feedback", false)
CONFIG_VARIABLE (bool, midi_control, "midi-control", false)
+CONFIG_VARIABLE (uint8_t, mmc_device_id, "mmc-device-id", 0)
/* control surfaces */
void deliver_midi (MIDI::Port*, MIDI::byte*, int32_t size);
+ void set_mmc_device_id (uint32_t id);
+
/* Scrubbing */
void start_scrub (nframes_t where);
void mmc_record_pause (MIDI::MachineControl &);
void mmc_record_strobe (MIDI::MachineControl &);
void mmc_record_exit (MIDI::MachineControl &);
- void mmc_track_record_status (MIDI::MachineControl &,
- uint32_t track, bool enabled);
+ void mmc_track_record_status (MIDI::MachineControl &, uint32_t track, bool enabled);
void mmc_fast_forward (MIDI::MachineControl &);
void mmc_rewind (MIDI::MachineControl &);
void mmc_locate (MIDI::MachineControl &, const MIDI::byte *);
return 0;
}
+void
+Session::set_mmc_device_id (uint32_t device_id)
+{
+ if (mmc) {
+ mmc->set_device_id (device_id);
+ }
+}
+
int
Session::set_mmc_port (string port_tag)
{
+ MIDI::byte old_device_id;
+ bool reset_id = false;
+
if (port_tag.length() == 0) {
if (_mmc_port == 0) {
return 0;
_mmc_port = port;
if (mmc) {
+ old_device_id = mmc->device_id();
+ reset_id = true;
delete mmc;
}
MMC_CommandSignature,
MMC_ResponseSignature);
+ if (reset_id) {
+ mmc->set_device_id (old_device_id);
+ }
mmc->Play.connect
(mem_fun (*this, &Session::mmc_deferred_play));
mmc->TrackRecordStatusChange.connect
(mem_fun (*this, &Session::mmc_record_enable));
+
/* also handle MIDI SPP because its so common */
_mmc_port->input()->start.connect (mem_fun (*this, &Session::spp_start));
static bool step_queued = false;
void
-
Session::mmc_step (MIDI::MachineControl &mmc, int steps)
{
if (!Config->get_mmc_control()) {
void
Session::add_controllable (Controllable* c)
{
+ /* this adds a controllable to the list managed by the Session.
+ this is a subset of those managed by the Controllable class
+ itself, and represents the only ones whose state will be saved
+ as part of the session.
+ */
+
Glib::Mutex::Lock lm (controllables_lock);
controllables.insert (c);
}
poke_midi_thread ();
+ } else if (PARAM_IS ("mmc-device-id")) {
+
+ if (mmc) {
+ mmc->set_device_id (Config->get_mmc_device_id());
+ }
+
} else if (PARAM_IS ("midi-control")) {
poke_midi_thread ();
Port &port() { return _port; }
void set_device_id (byte id);
+ byte device_id () const { return _device_id; }
+
static bool is_mmc (byte *sysex_buf, size_t len);
/* Signals to connect to if you want to run "callbacks"
#include <unistd.h>
#include <string>
#include <iostream>
+#include <iterator>
#include <midi++/types.h>
#include <midi++/parser.h>
void
Parser::trace_event (Parser &p, byte *msg, size_t len)
-
{
eventType type;
ostream *o;
void
Parser::trace (bool onoff, ostream *o, const string &prefix)
-
{
trace_connection.disconnect ();
if (onoff) {
trace_stream = o;
trace_prefix = prefix;
- trace_connection = any.connect
- (mem_fun (*this, &Parser::trace_event));
+ trace_connection = any.connect (mem_fun (*this, &Parser::trace_event));
} else {
trace_prefix = "";
trace_stream = 0;
build_mmc_cmd_map ();
- _device_id = 1;
+ _device_id = 0;
if ((parser = _port.input()) != 0) {
parser->mmc.connect
*/
#if 0
- cerr << "*** MMC message: len = " << len << "\n\t";
+ cerr << "*** me = " << (int) _device_id << " MMC message: len = " << len << "\n\t";
for (size_t i = 0; i < len; i++) {
cerr << hex << (int) msg[i] << dec << ' ';
}
sigc::signal<bool,Controllable*> Controllable::StartLearning;
sigc::signal<void,Controllable*> Controllable::StopLearning;
+Glib::Mutex* Controllable::registry_lock = 0;
+Controllable::Controllables Controllable::registry;
+
Controllable::Controllable (std::string name)
: _name (name)
{
+ if (registry_lock == 0) {
+ registry_lock = new Glib::Mutex;
+ }
+
+ add ();
+}
+
+void
+Controllable::add ()
+{
+ Glib::Mutex::Lock lm (*registry_lock);
+ registry.insert (this);
+ this->GoingAway.connect (mem_fun (this, &Controllable::remove));
+}
+
+void
+Controllable::remove ()
+{
+ Glib::Mutex::Lock lm (*registry_lock);
+ for (Controllables::iterator i = registry.begin(); i != registry.end(); ++i) {
+ if ((*i) == this) {
+ registry.erase (i);
+ break;
+ }
+ }
+}
+
+Controllable*
+Controllable::by_id (const ID& id)
+{
+ Glib::Mutex::Lock lm (*registry_lock);
+
+ for (Controllables::iterator i = registry.begin(); i != registry.end(); ++i) {
+ if ((*i)->id() == id) {
+ return (*i);
+ }
+ }
+ return 0;
+}
+
+
+Controllable*
+Controllable::by_name (const std::string& str)
+{
+ Glib::Mutex::Lock lm (*registry_lock);
+
+ for (Controllables::iterator i = registry.begin(); i != registry.end(); ++i) {
+ if ((*i)->_name == str) {
+ return (*i);
+ }
+ }
+ return 0;
}
XMLNode&
#define __pbd_controllable_h__
#include <string>
+#include <set>
#include <sigc++/trackable.h>
#include <sigc++/signal.h>
std::string name() const { return _name; }
+ static Controllable* by_id (const PBD::ID&);
+ static Controllable* by_name (const std::string&);
+
private:
std::string _name;
+
+ void add ();
+ void remove ();
+
+ typedef std::set<PBD::Controllable*> Controllables;
+ static Glib::Mutex* registry_lock;
+ static Controllables registry;
};
}
GenericMidiControlProtocol::stop_learning (Controllable* c)
{
Glib::Mutex::Lock lm (pending_lock);
+ Glib::Mutex::Lock lm2 (controllables_lock);
+ MIDIControllable* dptr = 0;
/* learning timed out, and we've been told to consider this attempt to learn to be cancelled. find the
relevant MIDIControllable and remove it from the pending list.
for (MIDIControllables::iterator i = pending_controllables.begin(); i != pending_controllables.end(); ++i) {
if (&(*i)->get_controllable() == c) {
(*i)->stop_learning ();
- delete (*i);
+ dptr = *i;
pending_controllables.erase (i);
break;
}
}
+
+ for (MIDIControllables::iterator i = controllables.begin(); i != controllables.end(); ++i) {
+ if (&(*i)->get_controllable() == c) {
+ controllables.erase (i);
+ break;
+ }
+ }
+
+ if (dptr) {
+ delete dptr;
+ }
}
XMLNode&
ID id = prop->value ();
- c = session->controllable_by_id (id);
+ c = Controllable::by_id (id);
if (c) {
MIDIControllable* mc = new MIDIControllable (*_port, *c);
}
} else {
- warning << string_compose (_("Generic MIDI control: controllable %1 not found in session (ignored)"),
- id)
+ warning << string_compose (_("Generic MIDI control: controllable %1 not found (ignored)"), id)
<< endmsg;
}
}
if ( sorted.size() - _current_initial_bank < route_signals.size() )
{
// but don't shift backwards past the zeroth channel
- switch_banks( max( (unsigned int)0, sorted.size() - route_signals.size() ) );
+ switch_banks( max(0UL, sorted.size() - route_signals.size() ) );
}
// Otherwise just refresh the current bank
else
projects / ardour.git / commitdiff