diff --git a/libs/surfaces/osc/osc.cc b/libs/surfaces/osc/osc.cc index 54bc051781..39e61bece5 100644 --- a/libs/surfaces/osc/osc.cc +++ b/libs/surfaces/osc/osc.cc @@ -57,6 +57,7 @@ #include "osc_controllable.h" #include "osc_route_observer.h" #include "osc_global_observer.h" +#include "osc_cue_observer.h" #include "pbd/i18n.h" using namespace ARDOUR; @@ -328,6 +329,7 @@ OSC::stop () periodic_connection.disconnect (); session_connections.drop_connections (); + cueobserver_connections.drop_connections (); // Delete any active route observers for (RouteObservers::iterator x = route_observers.begin(); x != route_observers.end();) { @@ -352,6 +354,7 @@ OSC::stop () ++x; } } + // delete select observers for (uint32_t it = 0; it < _surface.size(); ++it) { OSCSurface* sur = &_surface[it]; @@ -361,6 +364,19 @@ OSC::stop () } } +// delete cue observers + for (CueObservers::iterator x = cue_observers.begin(); x != cue_observers.end();) { + + OSCCueObserver* co; + + if ((co = dynamic_cast(*x)) != 0) { + delete *x; + x = cue_observers.erase (x); + } else { + ++x; + } + } + return 0; } @@ -847,7 +863,7 @@ OSC::catchall (const char *path, const char* types, lo_arg **argv, int argc, lo_ } else if (!strncmp (path, "/cue/", 5)) { - //cue_parse (path, types, argv, argc, msg) + cue_parse (path, types, argv, argc, msg); ret = 0; } else @@ -1442,7 +1458,11 @@ OSC::_recalcbanks () OSCSurface* sur = &_surface[it]; // find lo_address lo_address addr = lo_address_new_from_url (sur->remote_url.c_str()); - _set_bank (sur->bank, addr); + if (sur->cue) { + _cue_set (sur->aux, addr); + } else { + _set_bank (sur->bank, addr); + } } } @@ -3472,6 +3492,14 @@ OSC::periodic (void) so->tick(); } } + for (CueObservers::iterator x = cue_observers.begin(); x != cue_observers.end(); x++) { + + OSCCueObserver* co; + + if ((co = dynamic_cast(*x)) != 0) { + co->tick(); + } + } return true; } @@ -3734,3 +3762,297 @@ OSC::get_sorted_stripables(std::bitset<32> types) return sorted; } +int +OSC::cue_parse (const char *path, const char* types, lo_arg **argv, int argc, lo_message msg) +{ + int ret = 1; /* unhandled */ + + if (!strncmp (path, "/cue/aux", 8)) { + // set our Aux bus + cue_set (argv[0]->i, msg); + ret = 0; + } + else if (!strncmp (path, "/cue/connect", 12)) { + // switch to next Aux bus + cue_set (0, msg); + ret = 0; + } + else if (!strncmp (path, "/cue/next_aux", 13)) { + // switch to next Aux bus + cue_next (msg); + ret = 0; + } + else if (!strncmp (path, "/cue/previous_aux", 17)) { + // switch to previous Aux bus + cue_previous (msg); + ret = 0; + } + else if (!strncmp (path, "/cue/send/fader/", 16) && strlen (path) > 16) { + int id = atoi (&path[16]); + cue_send_fader (id, argv[0]->f, msg); + ret = 0; + } + else if (!strncmp (path, "/cue/send/enable/", 17) && strlen (path) > 17) { + int id = atoi (&path[17]); + cue_send_enable (id, argv[0]->f, msg); + ret = 0; + } + else if (!strncmp (path, "/cue/fader", 10)) { + cue_aux_fader (argv[0]->f, msg); + ret = 0; + } + else if (!strncmp (path, "/cue/mute", 9)) { + cue_aux_mute (argv[0]->f, msg); + ret = 0; + } + + if ((ret && _debugmode == Unhandled)) { + debugmsg (_("Unhandled OSC cue message"), path, types, argv, argc); + } else if ((!ret && _debugmode == All)) { + debugmsg (_("OSC cue"), path, types, argv, argc); + } + + return ret; +} + +int +OSC::cue_set (uint32_t aux, lo_message msg) +{ + return _cue_set (aux, get_address (msg)); +} + +int +OSC::_cue_set (uint32_t aux, lo_address addr) +{ + OSCSurface *s = get_surface(addr); + s->bank_size = 0; + s->strip_types = 128; + s->feedback = 0; + s->gainmode = 1; + s->cue = true; + s->aux = aux; + s->strips = get_sorted_stripables(s->strip_types); + + s->nstrips = s->strips.size(); + // get rid of any old CueObsevers for this address + cueobserver_connections.drop_connections (); + CueObservers::iterator x; + for (x = cue_observers.begin(); x != cue_observers.end();) { + + OSCCueObserver* co; + + if ((co = dynamic_cast(*x)) != 0) { + + int res = strcmp(lo_address_get_url(co->address()), lo_address_get_url(addr)); + + if (res == 0) { + delete *x; + x = cue_observers.erase (x); + } else { + ++x; + } + } else { + ++x; + } + } + + // get a list of Auxes + for (uint32_t n = 0; n < s->nstrips; ++n) { + boost::shared_ptr stp = s->strips[n]; + if (stp) { + text_message (string_compose ("/cue/name/%1", n+1), stp->name(), addr); + if (aux == n+1) { + // aux must be at least one + // need a signal if aux vanishes + stp->DropReferences.connect (*this, MISSING_INVALIDATOR, boost::bind (&OSC::_cue_set, this, aux, addr), this); + + // make a list of stripables with sends that go to this bus + s->sends = cue_get_sorted_stripables(stp, aux, addr); + // start cue observer + OSCCueObserver* co = new OSCCueObserver (stp, s->sends, addr); + cue_observers.push_back (co); + } + + } + } + + return 0; +} + +int +OSC::cue_next (lo_message msg) +{ + OSCSurface *s = get_surface(get_address (msg)); + if (s->aux < s->nstrips) { + cue_set (s->aux + 1, msg); + } else { + cue_set (s->nstrips, msg); + } + return 0; +} + +int +OSC::cue_previous (lo_message msg) +{ + OSCSurface *s = get_surface(get_address (msg)); + if (s->aux > 1) { + cue_set (s->aux - 1, msg); + } + return 0; +} + +boost::shared_ptr +OSC::cue_get_send (uint32_t id, lo_address addr) +{ + OSCSurface *s = get_surface(addr); + if (id && s->aux > 0 && id <= s->sends.size()) { + boost::shared_ptr r = boost::dynamic_pointer_cast (s->sends[id - 1]); + boost::shared_ptr aux = get_strip (s->aux, addr); + if (r && aux) { + return r->internal_send_for (boost::dynamic_pointer_cast (aux)); + } + } + return boost::shared_ptr(); + +} + +int +OSC::cue_aux_fader (float position, lo_message msg) +{ + if (!session) return -1; + + OSCSurface *sur = get_surface(get_address (msg)); + if (sur->cue) { + if (sur->aux) { + boost::shared_ptr s = get_strip (sur->aux, get_address (msg)); + + if (s) { + float abs; + abs = slider_position_to_gain_with_max (position, 2.0); + if (s->gain_control()) { + s->gain_control()->set_value (abs, PBD::Controllable::NoGroup); + return 0; + } + } + } + } + return cue_float_message ("/cue/fader", 0, get_address (msg)); +} + +int +OSC::cue_aux_mute (float state, lo_message msg) +{ + if (!session) return -1; + + OSCSurface *sur = get_surface(get_address (msg)); + if (sur->cue) { + if (sur->aux) { + boost::shared_ptr s = get_strip (sur->aux, get_address (msg)); + + if (s->mute_control()) { + s->mute_control()->set_value (state ? 1.0 : 0.0, PBD::Controllable::NoGroup); + return 0; + } + } + } + return cue_float_message ("/cue/mute", 0, get_address (msg)); +} + +int +OSC::cue_send_fader (uint32_t id, float val, lo_message msg) +{ + if (!session) { + return -1; + } + boost::shared_ptr s = cue_get_send (id, get_address (msg)); + float abs; + if (s) { + if (s->gain_control()) { + abs = slider_position_to_gain_with_max (val, 2.0); + s->gain_control()->set_value (abs, PBD::Controllable::NoGroup); + return 0; + } + } + return cue_float_message (string_compose ("/cue/send/fader/%1", id), 0, get_address (msg)); +} + +int +OSC::cue_send_enable (uint32_t id, float state, lo_message msg) +{ + if (!session) + return -1; + boost::shared_ptr s = cue_get_send (id, get_address (msg)); + if (s) { + if (state) { + s->activate (); + } else { + s->deactivate (); + } + return 0; + } + return cue_float_message (string_compose ("/cue/send/enable/%1", id), 0, get_address (msg)); +} + +int +OSC::cue_float_message (string path, float val, lo_address addr) +{ + + lo_message reply; + reply = lo_message_new (); + lo_message_add_float (reply, (float) val); + + lo_send_message (addr, path.c_str(), reply); + lo_message_free (reply); + + return 0; +} + +int +OSC::text_message (string path, string val, lo_address addr) +{ + + lo_message reply; + reply = lo_message_new (); + lo_message_add_string (reply, val.c_str()); + + lo_send_message (addr, path.c_str(), reply); + lo_message_free (reply); + + return 0; +} + + +// we have to have a sorted list of stripables that have sends pointed at our aux +// we can use the one in osc.cc to get an aux list +OSC::Sorted +OSC::cue_get_sorted_stripables(boost::shared_ptr aux, uint32_t id, lo_message msg) +{ + Sorted sorted; + cueobserver_connections.drop_connections (); + // fetch all stripables + StripableList stripables; + + session->get_stripables (stripables); + + // Look for stripables that have a send to aux + for (StripableList::iterator it = stripables.begin(); it != stripables.end(); ++it) { + + boost::shared_ptr s = *it; + // we only want routes + boost::shared_ptr r = boost::dynamic_pointer_cast (s); + if (r) { + r->processors_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&OSC::recalcbanks, this), this); + boost::shared_ptr snd = r->internal_send_for (boost::dynamic_pointer_cast (aux)); + if (snd) { // test for send to aux + sorted.push_back (s); + s->DropReferences.connect (*this, MISSING_INVALIDATOR, boost::bind (&OSC::cue_set, this, id, msg), this); + } + } + + + } + sort (sorted.begin(), sorted.end(), StripableByPresentationOrder()); + + return sorted; +} + diff --git a/libs/surfaces/osc/osc.h b/libs/surfaces/osc/osc.h index 444e3536a4..dbd603d247 100644 --- a/libs/surfaces/osc/osc.h +++ b/libs/surfaces/osc/osc.h @@ -37,6 +37,7 @@ #include "pbd/abstract_ui.h" #include "ardour/types.h" +#include "ardour/send.h" #include "control_protocol/control_protocol.h" #include "pbd/i18n.h" @@ -45,6 +46,7 @@ class OSCControllable; class OSCRouteObserver; class OSCGlobalObserver; class OSCSelectObserver; +class OSCCueObserver; namespace ARDOUR { class Session; @@ -95,8 +97,6 @@ class OSC : public ARDOUR::ControlProtocol, public AbstractUI typedef std::vector > Sorted; Sorted get_sorted_stripables(std::bitset<32> types); - // cue - //Sorted cue_get_sorted_stripables(boost::shared_ptr aux); // keep a surface's global setup by remote server url struct OSCSurface { @@ -112,6 +112,9 @@ class OSC : public ARDOUR::ControlProtocol, public AbstractUI bool expand_enable; // use expand instead of select OSCSelectObserver* sel_obs; // So we can sync select feedback with selected channel Sorted strips; // list of stripables for this surface + bool cue; // is this a cue surface + uint32_t aux; // aux index for this cue surface + Sorted sends; // list of sends for cue aux }; /* * feedback bits: @@ -215,6 +218,23 @@ class OSC : public ARDOUR::ControlProtocol, public AbstractUI void transport_speed (lo_message msg); void record_enabled (lo_message msg); + // cue + Sorted cue_get_sorted_stripables(boost::shared_ptr aux, uint32_t id, lo_message msg); + int cue_parse (const char *path, const char* types, lo_arg **argv, int argc, lo_message msg); + int cue_set (uint32_t aux, lo_message msg); + int _cue_set (uint32_t aux, lo_address addr); + int cue_next (lo_message msg); + int cue_previous (lo_message msg); + int cue_send_fader (uint32_t id, float position, lo_message msg); + int cue_send_enable (uint32_t id, float state, lo_message msg); + int cue_aux_fader (float position, lo_message msg); + int cue_aux_mute (float state, lo_message msg); + void cue_set_aux (uint32_t aux, lo_message msg); + int cue_float_message (std::string, float value, lo_address addr); + int text_message (std::string path, std::string val, lo_address addr); + boost::shared_ptr cue_get_send (uint32_t id, lo_address addr); + // end cue + #define OSC_DEBUG \ if (_debugmode == All) { \ debugmsg (dgettext(PACKAGE, "OSC"), path, types, argv, argc); \ @@ -575,6 +595,7 @@ class OSC : public ARDOUR::ControlProtocol, public AbstractUI bool periodic (void); sigc::connection periodic_connection; PBD::ScopedConnectionList session_connections; + PBD::ScopedConnectionList cueobserver_connections; int route_send_fail (std::string path, uint32_t ssid, float val, lo_address addr); int sel_send_fail (std::string path, uint32_t id, float val, lo_address addr); @@ -587,6 +608,9 @@ class OSC : public ARDOUR::ControlProtocol, public AbstractUI typedef std::list GlobalObservers; GlobalObservers global_observers; + typedef std::list CueObservers; + CueObservers cue_observers; + void debugmsg (const char *prefix, const char *path, const char* types, lo_arg **argv, int argc); static OSC* _instance; diff --git a/libs/surfaces/osc/osc_cue_observer.cc b/libs/surfaces/osc/osc_cue_observer.cc new file mode 100644 index 0000000000..d6c6e38bfb --- /dev/null +++ b/libs/surfaces/osc/osc_cue_observer.cc @@ -0,0 +1,259 @@ +/* + Copyright (C) 2009 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 + (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, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +*/ + +#include "boost/lambda/lambda.hpp" + +#include "ardour/track.h" +#include "ardour/dB.h" +#include "ardour/meter.h" + +#include "osc.h" +#include "osc_cue_observer.h" + +#include "pbd/i18n.h" + +using namespace std; +using namespace PBD; +using namespace ARDOUR; +using namespace ArdourSurface; + +OSCCueObserver::OSCCueObserver (boost::shared_ptr s, std::vector>& snds, lo_address a) + : sends (snds) + , _strip (s) + , tick_enable (false) +{ + std::cout << "entered observer\n"; + addr = lo_address_new (lo_address_get_hostname(a) , lo_address_get_port(a)); + + _strip->PropertyChanged.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCCueObserver::name_changed, this, boost::lambda::_1, 0), OSC::instance()); + name_changed (ARDOUR::Properties::name, 0); + + _strip->mute_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCCueObserver::send_change_message, this, X_("/cue/mute"), 0, _strip->mute_control()), OSC::instance()); + send_change_message ("/cue/mute", 0, _strip->mute_control()); + + gain_timeout.push_back (0); + std::cout << "observer past gain timeout for aux\n"; + _strip->gain_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCCueObserver::send_gain_message, this, 0, _strip->gain_control()), OSC::instance()); + send_gain_message (0, _strip->gain_control()); + + send_init (); + std::cout << "observer past send init\n"; + + tick_enable = true; + tick (); +} + +OSCCueObserver::~OSCCueObserver () +{ + + strip_connections.drop_connections (); + send_end (); + // all strip buttons should be off and faders 0 and etc. + text_with_id ("/cue/name", 0, " "); + clear_strip ("/cue/mute", 0); + clear_strip ("/cue/fader", 0); + clear_strip ("/cue/signal", 0); + + lo_address_free (addr); +} + +void +OSCCueObserver::tick () +{ + if (!tick_enable) { + return; + } + float now_meter; + if (_strip->peak_meter()) { + now_meter = _strip->peak_meter()->meter_level(0, MeterMCP); + } else { + now_meter = -193; + } + if (now_meter < -120) now_meter = -193; + if (_last_meter != now_meter) { + string path = "/cue/signal"; + lo_message msg = lo_message_new (); + float signal; + if (now_meter < -40) { + signal = 0; + } else { + signal = 1; + } + lo_message_add_float (msg, signal); + lo_send_message (addr, path.c_str(), msg); + lo_message_free (msg); + } + _last_meter = now_meter; + + for (uint32_t i = 0; i < gain_timeout.size(); i++) { + if (gain_timeout[i]) { + if (gain_timeout[i] == 1) { + name_changed (ARDOUR::Properties::name, i); + } + gain_timeout[i]--; + } + } + +} + +void +OSCCueObserver::send_init() +{ + for (uint32_t i = 0; i < sends.size(); i++) { + boost::shared_ptr r = boost::dynamic_pointer_cast (sends[i]); + boost::shared_ptr send = r->internal_send_for (boost::dynamic_pointer_cast (_strip)); + if (r) { + r->processors_changed.connect (send_connections, MISSING_INVALIDATOR, boost::bind (&OSCCueObserver::send_restart, this), OSC::instance()); + } + + if (send) { + // send name + if (r) { + sends[i]->PropertyChanged.connect (send_connections, MISSING_INVALIDATOR, boost::bind (&OSCCueObserver::name_changed, this, boost::lambda::_1, i + 1), OSC::instance()); + name_changed (ARDOUR::Properties::name, i + 1); + } + + + if (send->gain_control()) { + gain_timeout.push_back (0); + send->gain_control()->Changed.connect (send_connections, MISSING_INVALIDATOR, boost::bind (&OSCCueObserver::send_gain_message, this, i + 1, send->gain_control()), OSC::instance()); + send_gain_message (i + 1, send->gain_control()); + } + + boost::shared_ptr proc = boost::dynamic_pointer_cast (send); + proc->ActiveChanged.connect (send_connections, MISSING_INVALIDATOR, boost::bind (&OSCCueObserver::send_enabled_message, this, X_("/cue/send_enable"), i + 1, proc->enabled()), OSC::instance()); + send_enabled_message (X_("/cue/send/enable"), i + 1, proc->enabled()); + } + } + +} + +void +OSCCueObserver::send_end () +{ + send_connections.drop_connections (); + for (uint32_t i = 1; i <= sends.size(); i++) { + clear_strip (string_compose ("/select/send/fader/%1", i), 0); + clear_strip (string_compose ("/select/send/enable/%1", i), 0); + text_with_id (string_compose("/cue/send/name/%1", i), i, " "); + } +} + +void +OSCCueObserver::send_restart () +{ + tick_enable = false; + send_end(); + send_init(); + tick_enable = true; +} + +void +OSCCueObserver::name_changed (const PBD::PropertyChange& what_changed, uint32_t id) +{ + if (!what_changed.contains (ARDOUR::Properties::name)) { + return; + } + + if (!_strip) { + return; + } + if (id) { + text_with_id ("/cue/send/name", id, sends[id - 1]->name()); + } else { + text_with_id ("/cue/name", 0, _strip->name()); + } +} + +void +OSCCueObserver::send_change_message (string path, uint32_t id, boost::shared_ptr controllable) +{ + lo_message msg = lo_message_new (); + + if (id) { + path = string_compose("%1/%2", path, id); + } + float val = controllable->get_value(); + lo_message_add_float (msg, (float) controllable->internal_to_interface (val)); + + lo_send_message (addr, path.c_str(), msg); + lo_message_free (msg); +} + +void +OSCCueObserver::text_with_id (string path, uint32_t id, string val) +{ + lo_message msg = lo_message_new (); + if (id) { + path = string_compose("%1/%2", path, id); + } + + lo_message_add_string (msg, val.c_str()); + + lo_send_message (addr, path.c_str(), msg); + lo_message_free (msg); +} + +void +OSCCueObserver::send_gain_message (uint32_t id, boost::shared_ptr controllable) +{ + string path = "/cue"; + if (id) { + path = "/cue/send"; + } + + text_with_id (string_compose ("%1/name", path), id, string_compose ("%1%2%3", std::fixed, std::setprecision(2), accurate_coefficient_to_dB (controllable->get_value()))); + path = string_compose ("%1/fader", path); + if (id) { + path = string_compose ("%1/%2", path, id); + } + lo_message msg = lo_message_new (); + lo_message_add_float (msg, gain_to_slider_position (controllable->get_value())); + gain_timeout[id] = 8; + + lo_send_message (addr, path.c_str(), msg); + lo_message_free (msg); +} + +void +OSCCueObserver::send_enabled_message (std::string path, uint32_t id, bool enabled) +{ + lo_message msg = lo_message_new (); + + if (id) { + path = string_compose("%1/%2", path, id); + } + lo_message_add_float (msg, (float) enabled); + + lo_send_message (addr, path.c_str(), msg); + lo_message_free (msg); + +} + +void +OSCCueObserver::clear_strip (string path, float val) +{ + lo_message msg = lo_message_new (); + lo_message_add_float (msg, val); + + lo_send_message (addr, path.c_str(), msg); + lo_message_free (msg); + +} + diff --git a/libs/surfaces/osc/osc_cue_observer.h b/libs/surfaces/osc/osc_cue_observer.h new file mode 100644 index 0000000000..4ade6c0e91 --- /dev/null +++ b/libs/surfaces/osc/osc_cue_observer.h @@ -0,0 +1,69 @@ +/* + Copyright (C) 2009 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 + (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, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +*/ + +#ifndef __osc_osccueobserver_h__ +#define __osc_osccueobserver_h__ + +#include +#include +#include +#include + +#include "pbd/controllable.h" +#include "pbd/stateful.h" +#include "ardour/types.h" + +class OSCCueObserver +{ + + public: + OSCCueObserver (boost::shared_ptr, std::vector>& sends, lo_address addr); + ~OSCCueObserver (); + + boost::shared_ptr strip () const { return _strip; } + lo_address address() const { return addr; }; + void tick (void); + typedef std::vector > Sorted; + Sorted sends; + + private: + + boost::shared_ptr _strip; + + PBD::ScopedConnectionList strip_connections; + PBD::ScopedConnectionList send_connections; + + lo_address addr; + std::string path; + float _last_meter; + std::vector gain_timeout; + bool tick_enable; + + void name_changed (const PBD::PropertyChange& what_changed, uint32_t id); + void send_change_message (std::string path, uint32_t id, boost::shared_ptr controllable); + void text_with_id (std::string path, uint32_t id, std::string val); + void send_gain_message (uint32_t id, boost::shared_ptr controllable); + void send_enabled_message (std::string path, uint32_t id, bool enabled); + void clear_strip (std::string path, float val); + void send_init (void); + void send_end (void); + void send_restart (void); +}; + +#endif /* __osc_osccueobserver_h__ */ diff --git a/libs/surfaces/osc/osc_select_observer.cc b/libs/surfaces/osc/osc_select_observer.cc index ab768bc814..b11d277947 100644 --- a/libs/surfaces/osc/osc_select_observer.cc +++ b/libs/surfaces/osc/osc_select_observer.cc @@ -243,14 +243,14 @@ OSCSelectObserver::send_init() do { sends = false; if (_strip->send_level_controllable (nsends)) { - _strip->send_level_controllable(nsends)->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::send_gain, this, nsends, _strip->send_level_controllable(nsends)), OSC::instance()); + _strip->send_level_controllable(nsends)->Changed.connect (send_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::send_gain, this, nsends, _strip->send_level_controllable(nsends)), OSC::instance()); send_timeout.push_back (0); send_gain (nsends, _strip->send_level_controllable(nsends)); sends = true; } if (_strip->send_enable_controllable (nsends)) { - _strip->send_enable_controllable(nsends)->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::enable_message_with_id, this, X_("/select/send_enable"), nsends + 1, _strip->send_enable_controllable(nsends)), OSC::instance()); + _strip->send_enable_controllable(nsends)->Changed.connect (send_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::enable_message_with_id, this, X_("/select/send_enable"), nsends + 1, _strip->send_enable_controllable(nsends)), OSC::instance()); enable_message_with_id ("/select/send_enable", nsends + 1, _strip->send_enable_controllable(nsends)); sends = true; } else if (sends) { @@ -262,7 +262,7 @@ OSCSelectObserver::send_init() boost::shared_ptr snd = boost::dynamic_pointer_cast (r->nth_send(nsends)); if (snd) { boost::shared_ptr proc = boost::dynamic_pointer_cast (snd); - proc->ActiveChanged.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::send_enable, this, X_("/select/send_enable"), nsends + 1, proc), OSC::instance()); + proc->ActiveChanged.connect (send_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::send_enable, this, X_("/select/send_enable"), nsends + 1, proc), OSC::instance()); clear_strip_with_id ("/select/send_enable", nsends + 1, proc->enabled()); } } diff --git a/libs/surfaces/osc/wscript b/libs/surfaces/osc/wscript index 6f2bbfa0a5..4d0dba6750 100644 --- a/libs/surfaces/osc/wscript +++ b/libs/surfaces/osc/wscript @@ -20,6 +20,7 @@ def build(bld): osc_route_observer.cc osc_select_observer.cc osc_global_observer.cc + osc_cue_observer.cc interface.cc osc_gui.cc '''