#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;
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();) {
++x;
}
}
+
// delete select observers
for (uint32_t it = 0; it < _surface.size(); ++it) {
OSCSurface* sur = &_surface[it];
}
}
+// delete cue observers
+ for (CueObservers::iterator x = cue_observers.begin(); x != cue_observers.end();) {
+
+ OSCCueObserver* co;
+
+ if ((co = dynamic_cast<OSCCueObserver*>(*x)) != 0) {
+ delete *x;
+ x = cue_observers.erase (x);
+ } else {
+ ++x;
+ }
+ }
+
return 0;
}
} else
if (!strncmp (path, "/cue/", 5)) {
- //cue_parse (path, types, argv, argc, msg)
+ cue_parse (path, types, argv, argc, msg);
ret = 0;
} else
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);
+ }
}
}
so->tick();
}
}
+ for (CueObservers::iterator x = cue_observers.begin(); x != cue_observers.end(); x++) {
+
+ OSCCueObserver* co;
+
+ if ((co = dynamic_cast<OSCCueObserver*>(*x)) != 0) {
+ co->tick();
+ }
+ }
return true;
}
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<OSCCueObserver*>(*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<Stripable> 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<Send>
+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<Route> r = boost::dynamic_pointer_cast<Route> (s->sends[id - 1]);
+ boost::shared_ptr<Stripable> aux = get_strip (s->aux, addr);
+ if (r && aux) {
+ return r->internal_send_for (boost::dynamic_pointer_cast<Route> (aux));
+ }
+ }
+ return boost::shared_ptr<Send>();
+
+}
+
+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<Stripable> 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<Stripable> 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<Send> 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<Send> 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<Stripable> 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<Stripable> s = *it;
+ // we only want routes
+ boost::shared_ptr<Route> r = boost::dynamic_pointer_cast<Route> (s);
+ if (r) {
+ r->processors_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&OSC::recalcbanks, this), this);
+ boost::shared_ptr<Send> snd = r->internal_send_for (boost::dynamic_pointer_cast<Route> (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;
+}
+
#include "pbd/abstract_ui.h"
#include "ardour/types.h"
+#include "ardour/send.h"
#include "control_protocol/control_protocol.h"
#include "pbd/i18n.h"
class OSCRouteObserver;
class OSCGlobalObserver;
class OSCSelectObserver;
+class OSCCueObserver;
namespace ARDOUR {
class Session;
typedef std::vector<boost::shared_ptr<ARDOUR::Stripable> > Sorted;
Sorted get_sorted_stripables(std::bitset<32> types);
- // cue
- //Sorted cue_get_sorted_stripables(boost::shared_ptr<Route> aux);
// keep a surface's global setup by remote server url
struct OSCSurface {
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:
void transport_speed (lo_message msg);
void record_enabled (lo_message msg);
+ // cue
+ Sorted cue_get_sorted_stripables(boost::shared_ptr<ARDOUR::Stripable> 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<ARDOUR::Send> 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); \
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);
typedef std::list<OSCGlobalObserver*> GlobalObservers;
GlobalObservers global_observers;
+ typedef std::list<OSCCueObserver*> CueObservers;
+ CueObservers cue_observers;
+
void debugmsg (const char *prefix, const char *path, const char* types, lo_arg **argv, int argc);
static OSC* _instance;
--- /dev/null
+/*
+ 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<Stripable> s, std::vector<boost::shared_ptr<ARDOUR::Stripable>>& 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<Route> r = boost::dynamic_pointer_cast<Route> (sends[i]);
+ boost::shared_ptr<Send> send = r->internal_send_for (boost::dynamic_pointer_cast<Route> (_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<Processor> proc = boost::dynamic_pointer_cast<Processor> (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> 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> 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);
+
+}
+
--- /dev/null
+/*
+ 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 <string>
+#include <boost/shared_ptr.hpp>
+#include <sigc++/sigc++.h>
+#include <lo/lo.h>
+
+#include "pbd/controllable.h"
+#include "pbd/stateful.h"
+#include "ardour/types.h"
+
+class OSCCueObserver
+{
+
+ public:
+ OSCCueObserver (boost::shared_ptr<ARDOUR::Stripable>, std::vector<boost::shared_ptr<ARDOUR::Stripable>>& sends, lo_address addr);
+ ~OSCCueObserver ();
+
+ boost::shared_ptr<ARDOUR::Stripable> strip () const { return _strip; }
+ lo_address address() const { return addr; };
+ void tick (void);
+ typedef std::vector<boost::shared_ptr<ARDOUR::Stripable> > Sorted;
+ Sorted sends;
+
+ private:
+
+ boost::shared_ptr<ARDOUR::Stripable> _strip;
+
+ PBD::ScopedConnectionList strip_connections;
+ PBD::ScopedConnectionList send_connections;
+
+ lo_address addr;
+ std::string path;
+ float _last_meter;
+ std::vector<uint32_t> 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<PBD::Controllable> controllable);
+ void text_with_id (std::string path, uint32_t id, std::string val);
+ void send_gain_message (uint32_t id, boost::shared_ptr<PBD::Controllable> 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__ */
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) {
boost::shared_ptr<Send> snd = boost::dynamic_pointer_cast<Send> (r->nth_send(nsends));
if (snd) {
boost::shared_ptr<Processor> proc = boost::dynamic_pointer_cast<Processor> (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());
}
}
osc_route_observer.cc
osc_select_observer.cc
osc_global_observer.cc
+ osc_cue_observer.cc
interface.cc
osc_gui.cc
'''
projects / ardour.git / commitdiff