sigc::signal<void,Controllable*,int,int> Controllable::CreateBinding;
sigc::signal<void,Controllable*> Controllable::DeleteBinding;
-Glib::Mutex* Controllable::registry_lock = 0;
+Glib::StaticRWLock Controllable::registry_lock = GLIBMM_STATIC_RW_LOCK_INIT;
Controllable::Controllables Controllable::registry;
+Controllable::ControllablesByURI Controllable::registry_by_uri;
-Controllable::Controllable (std::string name)
+Controllable::Controllable (const std::string& name, const std::string& uri)
: _name (name)
+ , _uri (uri)
, _touching (false)
{
- if (registry_lock == 0) {
- registry_lock = new Glib::Mutex;
- }
-
add ();
}
void
Controllable::add ()
{
- Glib::Mutex::Lock lm (*registry_lock);
+ Glib::RWLock::WriterLock lm (*registry_lock);
registry.insert (this);
+
+ if (!_uri.empty()) {
+ pair<string,Controllable*> newpair;
+ newpair.first = _uri;
+ newpair.second = this;
+ registry_by_uri.insert (newpair);
+ }
+
this->GoingAway.connect (mem_fun (this, &Controllable::remove));
}
void
Controllable::remove ()
{
- Glib::Mutex::Lock lm (*registry_lock);
+ Glib::RWLock::WriterLock lm (*registry_lock);
+
for (Controllables::iterator i = registry.begin(); i != registry.end(); ++i) {
if ((*i) == this) {
registry.erase (i);
break;
}
}
+
+ if (_uri) {
+ ControllablesByURI::iterator i = registry_by_uri.find (_uri);
+ if (i != registry_by_uri.end()) {
+ registry_by_uri.erase (i);
+ }
+ }
+
+
+}
+
+void
+Controllable::set_uri (const std::string& new_uri)
+{
+ Glib::RWLock::WriterLock lm (*registry_lock);
+
+ if (_uri) {
+ ControllablesByURI::iterator i = registry_by_uri.find (_uri);
+ if (i != registry_by_uri.end()) {
+ registry_by_uri.erase (i);
+ }
+ }
+
+ _uri = new_uri;
+
+ if (!_uri.empty()) {
+ pair<string,Controllable*> newpair;
+ newpair.first = _uri;
+ newpair.second = this;
+ registry_by_uri.insert (newpair);
+ }
}
Controllable*
Controllable::by_id (const ID& id)
{
- Glib::Mutex::Lock lm (*registry_lock);
+ Glib::RWLock::ReaderLock lm (*registry_lock);
for (Controllables::iterator i = registry.begin(); i != registry.end(); ++i) {
if ((*i)->id() == id) {
return 0;
}
+Controllable*
+Controllable::by_uri (const string& uri)
+{
+ Glib::RWLock::ReaderLock lm (*registry_lock);
+ ControllablesByURI::iterator i;
+
+ if ((i = registry_by_ui.find (uri)) != registry_by_uri.end()) {
+ return i->second;
+ }
+ return 0;
+}
Controllable*
Controllable::by_name (const std::string& str)
{
- Glib::Mutex::Lock lm (*registry_lock);
+ Glib::RWLock::ReaderLock lm (*registry_lock);
for (Controllables::iterator i = registry.begin(); i != registry.end(); ++i) {
if ((*i)->_name == str) {
node->add_property (X_("name"), _name); // not reloaded from XML state, just there to look at
_id.print (buf, sizeof (buf));
node->add_property (X_("id"), buf);
+
+ if (!_uri.empty()) {
+ node->add_property (X_("uri"), _uri);
+ }
+
return *node;
}
int
Controllable::set_state (const XMLNode& node, int /*version*/)
{
- const XMLProperty* prop = node.property (X_("id"));
+ const XMLProperty* prop;
- if (prop) {
+ if ((prop = node.property (X_("id"))) != 0) {
_id = prop->value();
return 0;
} else {
error << _("Controllable state node has no ID property") << endmsg;
return -1;
}
+
+ if ((prop = node.property (X_("uri"))) != 0) {
+ set_uri (prop->value());
+ }
}
Copyright (C) 2000-2007 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
+v it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
class Controllable : public PBD::StatefulDestructible {
public:
- Controllable (std::string name);
+ Controllable (std::string name, const std::string& uri);
virtual ~Controllable() { Destroyed (this); }
+ void set_uri (const std::string&);
+ const std::string& uri() const { return _uri; }
+
virtual void set_value (float) = 0;
virtual float get_value (void) const = 0;
static Controllable* by_id (const PBD::ID&);
static Controllable* by_name (const std::string&);
+ static Controllable* by_uri (const std::string&);
private:
std::string _name;
+ std::string _uri;
bool _touching;
void add ();
void remove ();
typedef std::set<PBD::Controllable*> Controllables;
- static Glib::Mutex* registry_lock;
+ typedef std::map<std::string,PBD::Controllable*> ControllablesByURI;
+ static Glib::StaticRWLock registry_lock;
static Controllables registry;
+ static ControllablesByURI registry_by_uri;
};
/* a utility class for the occasions when you need but do not have
using namespace PBD;
using namespace ARDOUR;
+MIDIControllable::MIDIControllable (Port& p, const string& c, bool is_bistate)
+ : controllable (0), _port (p), bistate (is_bistate)
+{
+ init ();
+}
+
MIDIControllable::MIDIControllable (Port& p, Controllable& c, bool is_bistate)
- : controllable (c), _port (p), bistate (is_bistate)
+ : controllable (&c), _current_uri (c.uri()), _port (p), bistate (is_bistate)
+{
+ init ();
+}
+
+MIDIControllable::~MIDIControllable ()
+{
+ drop_external_control ();
+}
+
+void
+MIDIControllable::init ()
{
setting = false;
last_value = 0; // got a better idea ?
midi_rebind (0);
}
-MIDIControllable::~MIDIControllable ()
-{
- drop_external_control ();
-}
-
void
MIDIControllable::midi_forget ()
{
}
+void
+MIDIControllable::reacquire_controllable ()
+{
+ _controllable = Controllable::controllable_by_uri (current_uri);
+}
+
void
MIDIControllable::midi_rebind (channel_t c)
{
void
MIDIControllable::midi_sense_note (Parser &, EventTwoBytes *msg, bool is_on)
{
+ if (!controllable) {
+ return;
+ }
+
if (!bistate) {
- controllable.set_value (msg->note_number/127.0);
+ controllable->set_value (msg->note_number/127.0);
} else {
/* Note: parser handles the use of zero velocity to
}
}
- last_value = (MIDI::byte) (controllable.get_value() * 127.0); // to prevent feedback fights
+ last_value = (MIDI::byte) (controllable->get_value() * 127.0); // to prevent feedback fights
}
void
MIDIControllable::midi_sense_controller (Parser &, EventTwoBytes *msg)
{
- if (controllable.touching()) {
+ if (!controllable) {
+ return;
+ }
+
+ if (controllable->touching()) {
return; // to prevent feedback fights when e.g. dragging a UI slider
}
if (control_additional == msg->controller_number) {
if (!bistate) {
- controllable.set_value (midi_to_control(msg->value));
+ controllable->set_value (midi_to_control(msg->value));
} else {
if (msg->value > 64.0) {
- controllable.set_value (1);
+ controllable->set_value (1);
} else {
- controllable.set_value (0);
+ controllable->set_value (0);
}
}
- last_value = (MIDI::byte) (control_to_midi(controllable.get_value())); // to prevent feedback fights
+ last_value = (MIDI::byte) (control_to_midi(controllable->get_value())); // to prevent feedback fights
}
}
void
MIDIControllable::midi_sense_program_change (Parser &, byte msg)
{
+ if (!controllable) {
+ return;
+ }
/* XXX program change messages make no sense for bistates */
if (!bistate) {
- controllable.set_value (msg/127.0);
- last_value = (MIDI::byte) (controllable.get_value() * 127.0); // to prevent feedback fights
+ controllable->set_value (msg/127.0);
+ last_value = (MIDI::byte) (controllable->get_value() * 127.0); // to prevent feedback fights
}
}
void
MIDIControllable::midi_sense_pitchbend (Parser &, pitchbend_t pb)
{
+ if (!controllable) {
+ return;
+ }
+
/* pitchbend messages make no sense for bistates */
/* XXX gack - get rid of assumption about typeof pitchbend_t */
- controllable.set_value ((pb/(float) SHRT_MAX));
- last_value = (MIDI::byte) (controllable.get_value() * 127.0); // to prevent feedback fights
+ controllable->set_value ((pb/(float) SHRT_MAX));
+ last_value = (MIDI::byte) (controllable->get_value() * 127.0); // to prevent feedback fights
}
void
bind_midi ((channel_t) (msg[0] & 0xf), eventType (msg[0] & 0xF0), msg[1]);
- controllable.LearningFinished ();
+ controllable->LearningFinished ();
}
void
msg[0] = (control_type & 0xF0) | (control_channel & 0xF);
msg[1] = control_additional;
- msg[2] = (byte) (control_to_midi(controllable.get_value()));
+ msg[2] = (byte) (control_to_midi(controllable->get_value()));
_port.write (msg, 3, 0);
}
{
if (control_type != none && feedback && bufsize > 2) {
- MIDI::byte gm = (MIDI::byte) (control_to_midi(controllable.get_value()));
+ MIDI::byte gm = (MIDI::byte) (control_to_midi(controllable->get_value()));
if (gm != last_value) {
*buf++ = (0xF0 & control_type) | (0xF & control_channel);
XMLNode&
MIDIControllable::get_state ()
{
+ if (!controllable) {
+ return XXX !what!;
+ }
+
char buf[32];
- XMLNode& node (controllable.get_state ());
+ XMLNode& node (controllable->get_state ());
snprintf (buf, sizeof(buf), "0x%x", (int) control_type);
node.add_property ("event", buf);
{
public:
MIDIControllable (MIDI::Port&, PBD::Controllable&, bool bistate = false);
+ MIDIControllable (MIDI::Port&, const std::string& uri, bool bistate = false);
virtual ~MIDIControllable ();
+ bool ok() const { return !_current_uri.empty(); }
+
void send_feedback ();
MIDI::byte* write_feedback (MIDI::byte* buf, int32_t& bufsize, bool force = false);
float midi_to_control(float val);
MIDI::Port& get_port() const { return _port; }
- PBD::Controllable& get_controllable() const { return controllable; }
+ PBD::Controllable* get_controllable() const { return controllable; }
std::string control_description() const { return _control_description; }
MIDI::channel_t get_control_channel () { return control_channel; }
MIDI::eventType get_control_type () { return control_type; }
MIDI::byte get_control_additional () { return control_additional; }
+
private:
- PBD::Controllable& controllable;
+ PBD::Controllable* controllable;
+ std::string _current_uri;
MIDI::Port& _port;
bool setting;
MIDI::byte last_value;
MIDI::channel_t control_channel;
std::string _control_description;
bool feedback;
+
+ void reacquire_controllable ();
void midi_receiver (MIDI::Parser &p, MIDI::byte *, size_t);
void midi_sense_note (MIDI::Parser &, MIDI::EventTwoBytes *, bool is_on);
projects / ardour.git / commitdiff