#include <sigc++/bind.h>
#include "pbd/convert.h"
+#include "canvas/utils.h"
#include <glibmm/miscutils.h>
+#include <glibmm/fileutils.h>
#include <gtkmm/messagedialog.h>
#include "ardour/audioengine.h"
#include "ardour/internal_return.h"
#include "ardour/internal_send.h"
+#include "ardour/luaproc.h"
+#include "ardour/luascripting.h"
#include "ardour/meter.h"
#include "ardour/panner_shell.h"
#include "ardour/plugin_insert.h"
#include "ardour/session.h"
#include "ardour/types.h"
+#include "LuaBridge/LuaBridge.h"
+
#include "actions.h"
#include "ardour_dialog.h"
#include "ardour_ui.h"
#include "gui_thread.h"
#include "io_selector.h"
#include "keyboard.h"
+#include "luainstance.h"
#include "mixer_ui.h"
#include "mixer_strip.h"
+#include "plugin_pin_dialog.h"
#include "plugin_selector.h"
#include "plugin_ui.h"
#include "port_insert_ui.h"
#include "public_editor.h"
#include "return_ui.h"
#include "route_processor_selection.h"
+#include "script_selector.h"
#include "send_ui.h"
#include "timers.h"
#include "tooltips.h"
+#include "new_plugin_preset_dialog.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
#ifdef AUDIOUNIT_SUPPORT
class AUPluginUI;
using namespace Glib;
using namespace Gtkmm2ext;
-ProcessorBox* ProcessorBox::_current_processor_box = 0;
+ProcessorBox* ProcessorBox::_current_processor_box = 0;
RefPtr<Action> ProcessorBox::paste_action;
RefPtr<Action> ProcessorBox::cut_action;
RefPtr<Action> ProcessorBox::copy_action;
RefPtr<Action> ProcessorBox::rename_action;
RefPtr<Action> ProcessorBox::delete_action;
+RefPtr<Action> ProcessorBox::backspace_action;
+RefPtr<Action> ProcessorBox::manage_pins_action;
RefPtr<Action> ProcessorBox::edit_action;
RefPtr<Action> ProcessorBox::edit_generic_action;
+RefPtr<ActionGroup> ProcessorBox::processor_box_actions;
+Gtkmm2ext::ActionMap ProcessorBox::myactions (X_("processor box"));
+Gtkmm2ext::Bindings* ProcessorBox::bindings = 0;
+
-static const uint32_t audio_port_color = 0x4A8A0EFF; // Green
-static const uint32_t midi_port_color = 0x960909FF; //Red
+// TODO consolidate with PluginPinDialog::set_color
+static void set_routing_color (cairo_t* cr, bool midi)
+{
+ static const uint32_t audio_port_color = 0x4A8A0EFF; // Green
+ static const uint32_t midi_port_color = 0x960909FF; //Red
+
+ if (midi) {
+ cairo_set_source_rgb (cr,
+ UINT_RGBA_R_FLT(midi_port_color),
+ UINT_RGBA_G_FLT(midi_port_color),
+ UINT_RGBA_B_FLT(midi_port_color));
+ } else {
+ cairo_set_source_rgb (cr,
+ UINT_RGBA_R_FLT(audio_port_color),
+ UINT_RGBA_G_FLT(audio_port_color),
+ UINT_RGBA_B_FLT(audio_port_color));
+ }
+}
ProcessorEntry::ProcessorEntry (ProcessorBox* parent, boost::shared_ptr<Processor> p, Width w)
: _button (ArdourButton::led_default_elements)
, _position (PreFader)
, _position_num(0)
+ , _parent (parent)
, _selectable(true)
, _unknown_processor(false)
- , _parent (parent)
, _processor (p)
, _width (w)
- , _input_icon(true)
- , _output_icon(false)
+ , input_icon(true)
+ , output_icon(false)
+ , routing_icon(true)
+ , output_routing_icon(false)
+ , _plugin_display(0)
{
_vbox.show ();
_button.set_elements(ArdourButton::Element(_button.elements() & ~ArdourButton::Indicator));
_unknown_processor = true;
}
+ {
+ boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (_processor);
+ if (pi && pi->plugin()) {
+ _plugin_preset_pointer = PluginPresetPtr (new PluginPreset (pi->plugin()->get_info()));
+ }
+ }
if (_processor) {
- _vbox.pack_start (_routing_icon);
- _vbox.pack_start (_input_icon);
+ _vbox.pack_start (routing_icon);
+ _vbox.pack_start (input_icon);
_vbox.pack_start (_button, true, true);
- _vbox.pack_end (_output_icon);
- _button.set_active (_processor->active());
+ boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (_processor);
+ if (pi && pi->plugin() && pi->plugin()->has_inline_display()) {
+ if (pi->plugin()->get_info()->type != ARDOUR::Lua) {
+ _plugin_display = new PluginDisplay (*this, pi->plugin(),
+ std::max (60.f, rintf(112.f * UIConfiguration::instance().get_ui_scale())));
+ } else {
+ assert (boost::dynamic_pointer_cast<LuaProc>(pi->plugin()));
+ _plugin_display = new LuaPluginDisplay (*this, boost::dynamic_pointer_cast<LuaProc>(pi->plugin()),
+ std::max (60.f, rintf(112.f * UIConfiguration::instance().get_ui_scale())));
+ }
+ _vbox.pack_start (*_plugin_display);
+ _plugin_display->set_no_show_all (true);
+ if (UIConfiguration::instance().get_show_inline_display_by_default ()) {
+ _plugin_display->show ();
+ }
+ }
+ _vbox.pack_end (output_routing_icon);
+ _vbox.pack_end (output_icon);
+
+ _button.set_active (_processor->enabled ());
- _routing_icon.set_no_show_all(true);
- _input_icon.set_no_show_all(true);
+ input_icon.set_no_show_all(true);
+ routing_icon.set_no_show_all(true);
+ output_icon.set_no_show_all(true);
+ output_routing_icon.set_no_show_all(true);
_button.show ();
- _routing_icon.set_visible(false);
- _input_icon.hide();
- _output_icon.show();
+ input_icon.hide();
+ output_icon.show();
+ routing_icon.hide();
+ output_routing_icon.hide();
_processor->ActiveChanged.connect (active_connection, invalidator (*this), boost::bind (&ProcessorEntry::processor_active_changed, this), gui_context());
_processor->PropertyChanged.connect (name_connection, invalidator (*this), boost::bind (&ProcessorEntry::processor_property_changed, this, _1), gui_context());
}
}
- _input_icon.set_ports(_processor->input_streams());
- _output_icon.set_ports(_processor->output_streams());
-
- _routing_icon.set_sources(_processor->input_streams());
- _routing_icon.set_sinks(_processor->output_streams());
-
setup_tooltip ();
setup_visuals ();
} else {
for (list<Control*>::iterator i = _controls.begin(); i != _controls.end(); ++i) {
delete *i;
}
+ delete _plugin_display;
}
EventBox&
return name (Wide);
}
+bool
+ProcessorEntry::can_copy_state (Gtkmm2ext::DnDVBoxChild* o) const
+{
+ ProcessorEntry *other = dynamic_cast<ProcessorEntry*> (o);
+ if (!other) {
+ return false;
+ }
+ boost::shared_ptr<ARDOUR::Processor> otherproc = other->processor();
+ boost::shared_ptr<PluginInsert> my_pi = boost::dynamic_pointer_cast<PluginInsert> (_processor);
+ boost::shared_ptr<PluginInsert> ot_pi = boost::dynamic_pointer_cast<PluginInsert> (otherproc);
+ if (boost::dynamic_pointer_cast<UnknownProcessor> (_processor)) {
+ return false;
+ }
+ if (boost::dynamic_pointer_cast<UnknownProcessor> (otherproc)) {
+ return false;
+ }
+ if (!my_pi || !ot_pi) {
+ return false;
+ }
+ if (my_pi->type() != ot_pi->type()) {
+ return false;
+ }
+ boost::shared_ptr<Plugin> my_p = my_pi->plugin();
+ boost::shared_ptr<Plugin> ot_p = ot_pi->plugin();
+ if (!my_p || !ot_p) {
+ return false;
+ }
+ if (my_p->unique_id() != ot_p->unique_id()) {
+ return false;
+ }
+ return true;
+}
+
+bool
+ProcessorEntry::drag_data_get (Glib::RefPtr<Gdk::DragContext> const, Gtk::SelectionData &data)
+{
+ if (data.get_target() == "PluginPresetPtr") {
+ boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (_processor);
+
+ if (!_plugin_preset_pointer || !pi) {
+ data.set (data.get_target(), 8, NULL, 0);
+ return true;
+ }
+
+ boost::shared_ptr<ARDOUR::Plugin> plugin = pi->plugin();
+ assert (plugin);
+
+ PluginManager& manager (PluginManager::instance());
+ bool fav = manager.get_status (_plugin_preset_pointer->_pip) == PluginManager::Favorite;
+
+ NewPluginPresetDialog d (plugin,
+ string_compose(_("New Favorite Preset for \"%1\""),_plugin_preset_pointer->_pip->name), !fav);
+
+ _plugin_preset_pointer->_preset.valid = false;
+
+ switch (d.run ()) {
+ case Gtk::RESPONSE_CANCEL:
+ data.set (data.get_target(), 8, NULL, 0);
+ return true;
+ break;
+
+ case Gtk::RESPONSE_NO:
+ break;
+
+ case Gtk::RESPONSE_ACCEPT:
+ if (d.name().empty()) {
+ break;
+ }
+
+ if (d.replace ()) {
+ plugin->remove_preset (d.name ());
+ }
+
+ Plugin::PresetRecord const r = plugin->save_preset (d.name());
+
+ if (!r.uri.empty ()) {
+ _plugin_preset_pointer->_preset.uri = r.uri;
+ _plugin_preset_pointer->_preset.label = r.label;
+ _plugin_preset_pointer->_preset.user = r.user;
+ _plugin_preset_pointer->_preset.valid = r.valid;
+ }
+ }
+ data.set (data.get_target(), 8, (const guchar *) &_plugin_preset_pointer, sizeof (PluginPresetPtr));
+ return true;
+ }
+ return false;
+}
+
void
ProcessorEntry::set_position (Position p, uint32_t num)
{
_position = p;
_position_num = num;
-
- if (_position_num == 0 || _routing_icon.get_visible()) {
- _input_icon.show();
- } else {
- _input_icon.hide();
- }
-
setup_visuals ();
}
_button.set_name ("processor stub");
return;
}
+ boost::shared_ptr<Send> send;
+ if ((send = boost::dynamic_pointer_cast<Send> (_processor))) {
+ if (send->remove_on_disconnect ()) {
+ _button.set_name ("processor sidechain");
+ return;
+ }
+ }
switch (_position) {
case PreFader:
+ if (_plugin_display) { _plugin_display->set_name ("processor prefader"); }
_button.set_name ("processor prefader");
break;
break;
case PostFader:
+ if (_plugin_display) { _plugin_display->set_name ("processor postfader"); }
_button.set_name ("processor postfader");
break;
}
boost::shared_ptr<Processor>
ProcessorEntry::processor () const
{
+ if (!_processor) {
+ return boost::shared_ptr<Processor>();
+ }
return _processor;
}
_parent->all_visible_processors_active(false);
if (_position == Fader) {
- _processor->deactivate ();
+ _processor->enable (false);
}
}
else {
- _processor->deactivate ();
+ _processor->enable (false);
}
} else {
_parent->all_visible_processors_active(true);
if (_position == Fader) {
- _processor->activate ();
+ _processor->enable (true);
}
}
else {
- _processor->activate ();
+ _processor->enable (true);
}
}
}
ProcessorEntry::processor_active_changed ()
{
if (_processor) {
- _button.set_active (_processor->active());
+ _button.set_active (_processor->enabled ());
}
}
void
ProcessorEntry::processor_configuration_changed (const ChanCount in, const ChanCount out)
{
- _input_icon.set_ports(in);
- _output_icon.set_ports(out);
- _routing_icon.set_sources(in);
- _routing_icon.set_sinks(out);
- _input_icon.queue_draw();
- _output_icon.queue_draw();
- _routing_icon.queue_draw();
+ _parent->setup_routing_feeds ();
+ input_icon.queue_draw();
+ output_icon.queue_draw();
+ routing_icon.queue_draw();
+ output_routing_icon.queue_draw();
}
void
string_compose (_("<b>%1</b>\nThe Plugin is not available on this system\nand has been replaced by a stub."), name (Wide)));
return;
}
+ boost::shared_ptr<Send> send;
+ if ((send = boost::dynamic_pointer_cast<Send> (_processor)) != 0 &&
+ !boost::dynamic_pointer_cast<InternalSend>(_processor)) {
+ if (send->remove_on_disconnect ()) {
+ ARDOUR_UI_UTILS::set_tooltip (_button, string_compose ("<b>> %1</b>\nThis (sidechain) send will be removed when disconnected.", _processor->name()));
+ } else {
+ ARDOUR_UI_UTILS::set_tooltip (_button, string_compose ("<b>> %1</b>", _processor->name()));
+ }
+ return;
+ }
}
ARDOUR_UI_UTILS::set_tooltip (_button, string_compose ("<b>%1</b>", name (Wide)));
}
!boost::dynamic_pointer_cast<InternalSend>(_processor)) {
name_display += '>';
+ std::string send_name;
+ bool pretty_ok = true;
+
+ if (send->remove_on_disconnect ()) {
+ // assume it's a sidechain, find pretty name of connected port(s)
+ PortSet& ps (send->output ()->ports ());
+ for (PortSet::iterator i = ps.begin (); i != ps.end () && pretty_ok; ++i) {
+ vector<string> connections;
+ if (i->get_connections (connections)) {
+ vector<string>::const_iterator ci;
+ for (ci = connections.begin(); ci != connections.end(); ++ci) {
+ std::string pn = AudioEngine::instance()->get_pretty_name_by_name (*ci);
+ if (pn.empty ()) {
+ continue;
+ }
+ if (send_name.empty ()) {
+ send_name = pn;
+ } else if (send_name != pn) {
+ // pretty names don't match
+ pretty_ok = false;
+ break;
+ }
+ }
+ }
+ }
+ }
- /* grab the send name out of its overall name */
+ if (!pretty_ok) {
+ send_name = "";
+ }
- string::size_type lbracket, rbracket;
- lbracket = send->name().find ('[');
- rbracket = send->name().find (']');
+ /* grab the send name out of its overall name */
+ if (send_name.empty()) {
+ send_name = send->name();
+ string::size_type lbracket, rbracket;
+ lbracket = send_name.find ('[');
+ rbracket = send_name.find (']');
+ send_name = send_name.substr (lbracket+1, lbracket-rbracket-1);
+ }
switch (w) {
case Wide:
- name_display += send->name().substr (lbracket+1, lbracket-rbracket-1);
+ name_display += send_name;
break;
case Narrow:
- name_display += PBD::short_version (send->name().substr (lbracket+1, lbracket-rbracket-1), 4);
+ name_display += PBD::short_version (send_name, 5);
break;
}
for (list<Control*>::const_iterator i = _controls.begin(); i != _controls.end(); ++i) {
(*i)->add_state (node);
}
+
+ if (_plugin_display) {
+ XMLNode* c = new XMLNode (X_("Object"));
+ c->add_property (X_("id"), X_("InlineDisplay"));
+ c->add_property (X_("visible"), _plugin_display->is_visible ());
+ node->add_child_nocopy (*c);
+ }
}
void
for (list<Control*>::const_iterator i = _controls.begin(); i != _controls.end(); ++i) {
(*i)->set_state (node);
}
+
+ if (_plugin_display) {
+ XMLNode* n = GUIObjectState::get_node (node, X_("InlineDisplay"));
+ XMLProperty const * p = n ? n->property (X_("visible")) : NULL;
+ if (p) {
+ if (string_is_affirmative (p->value ())) {
+ _plugin_display->show();
+ } else {
+ _plugin_display->hide();
+ }
+ }
+ }
}
string
Menu* menu = manage (new Menu);
MenuList& items = menu->items ();
+ if (_plugin_display) {
+ items.push_back (CheckMenuElem (_("Inline Display")));
+ Gtk::CheckMenuItem* c = dynamic_cast<Gtk::CheckMenuItem*> (&items.back ());
+ c->set_active (_plugin_display->is_visible ());
+ c->signal_toggled().connect (sigc::mem_fun (*this, &ProcessorEntry::toggle_inline_display_visibility));
+ items.push_back (SeparatorElem ());
+ }
+
items.push_back (
MenuElem (_("Show All Controls"), sigc::mem_fun (*this, &ProcessorEntry::show_all_controls))
);
return menu;
}
+void
+ProcessorEntry::toggle_inline_display_visibility ()
+{
+ if (_plugin_display->is_visible ()) {
+ _plugin_display->hide();
+ } else {
+ _plugin_display->show();
+ }
+ _parent->update_gui_object_state (this);
+}
+
void
ProcessorEntry::toggle_control_visibility (Control* c)
{
return;
}
- c->set_value ( c->interface_to_internal(_adjustment.get_value ()) );
+ c->set_value ( c->interface_to_internal(_adjustment.get_value ()) , Controllable::NoGroup);
set_tooltip ();
}
bool const n = _button.get_active ();
- c->set_value (n ? 0 : 1);
+ c->set_value (n ? 0 : 1, Controllable::NoGroup);
_button.set_active (!n);
set_tooltip ();
}
{
XMLNode* n = GUIObjectState::get_node (node, state_id ());
if (n) {
- XMLProperty* p = n->property (X_("visible"));
+ XMLProperty const * p = n->property (X_("visible"));
set_visible (p && string_is_affirmative (p->value ()));
} else {
set_visible (false);
, _plugin_insert (p)
{
p->PluginIoReConfigure.connect (
- _splitting_connection, invalidator (*this), boost::bind (&PluginInsertProcessorEntry::plugin_insert_splitting_changed, this), gui_context()
+ _iomap_connection, invalidator (*this), boost::bind (&PluginInsertProcessorEntry::iomap_changed, this), gui_context()
+ );
+ p->PluginMapChanged.connect (
+ _iomap_connection, invalidator (*this), boost::bind (&PluginInsertProcessorEntry::iomap_changed, this), gui_context()
);
+ p->PluginConfigChanged.connect (
+ _iomap_connection, invalidator (*this), boost::bind (&PluginInsertProcessorEntry::iomap_changed, this), gui_context()
+ );
+}
+
+void
+PluginInsertProcessorEntry::iomap_changed ()
+{
+ _parent->setup_routing_feeds ();
+ routing_icon.queue_draw();
+ output_routing_icon.queue_draw();
+}
+
+void
+PluginInsertProcessorEntry::hide_things ()
+{
+ ProcessorEntry::hide_things ();
+}
+
+ProcessorEntry::PortIcon::PortIcon(bool input) {
+ _input = input;
+ _ports = ARDOUR::ChanCount(ARDOUR::DataType::AUDIO, 1);
+ set_size_request (-1, std::max (2.f, rintf(2.f * UIConfiguration::instance().get_ui_scale())));
+}
+
+bool
+ProcessorEntry::PortIcon::on_expose_event (GdkEventExpose* ev)
+{
+ cairo_t* cr = gdk_cairo_create (get_window()->gobj());
+
+ cairo_rectangle (cr, ev->area.x, ev->area.y, ev->area.width, ev->area.height);
+ cairo_clip (cr);
+
+ Gtk::Allocation a = get_allocation();
+ double const width = a.get_width();
+ double const height = a.get_height();
+
+ Gdk::Color const bg = get_style()->get_bg (STATE_NORMAL);
+ cairo_set_source_rgb (cr, bg.get_red_p (), bg.get_green_p (), bg.get_blue_p ());
+
+ cairo_rectangle (cr, 0, 0, width, height);
+ cairo_fill (cr);
+
+ const double dx = rint(max(2., 2. * UIConfiguration::instance().get_ui_scale()));
+ for (uint32_t i = 0; i < _ports.n_total(); ++i) {
+ set_routing_color (cr, i < _ports.n_midi());
+ const double x = ProcessorEntry::RoutingIcon::pin_x_pos (i, width, _ports.n_total(), 0 , false);
+ cairo_rectangle (cr, x - .5 - dx * .5, 0, 1 + dx, height);
+ cairo_fill(cr);
+ }
+
+ cairo_destroy(cr);
+ return true;
+}
+
+ProcessorEntry::RoutingIcon::RoutingIcon (bool input)
+ : _fed_by (false)
+ , _input (input)
+{
+ set_terminal (false);
+}
+
+void
+ProcessorEntry::RoutingIcon::set_terminal (bool b) {
+ _terminal = b;
+ int h = std::max (8.f, rintf(8.f * sqrt (UIConfiguration::instance().get_ui_scale())));
+ if (_terminal) {
+ h += std::max (4.f, rintf(4.f * sqrt (UIConfiguration::instance().get_ui_scale())));
+ }
+ set_size_request (-1, h);
+}
+
+void
+ProcessorEntry::RoutingIcon::set (
+ const ARDOUR::ChanCount& in,
+ const ARDOUR::ChanCount& out,
+ const ARDOUR::ChanCount& sinks,
+ const ARDOUR::ChanCount& sources,
+ const ARDOUR::ChanMapping& in_map,
+ const ARDOUR::ChanMapping& out_map,
+ const ARDOUR::ChanMapping& thru_map)
+{
+ _in = in;
+ _out = out;
+ _sources = sources;
+ _sinks = sinks;
+ _in_map = in_map;
+ _out_map = out_map;
+ _thru_map = thru_map;
+}
+
+bool
+ProcessorEntry::RoutingIcon::in_identity () const {
+ if (_thru_map.n_total () > 0) {
+ return false;
+ }
+ if (!_in_map.is_monotonic () || !_in_map.is_identity ()) {
+ return false;
+ }
+ if (_in_map.n_total () != _sinks.n_total () || _in.n_total () != _sinks.n_total ()) {
+ return false;
+ }
+ return true;
+}
+
+bool
+ProcessorEntry::RoutingIcon::out_identity () const {
+ if (_thru_map.n_total () > 0) {
+ // TODO skip if trhu is not connected to any of next's inputs
+ return false;
+ }
+ if (!_out_map.is_monotonic () || !_out_map.is_identity ()) {
+ return false;
+ }
+ if (_out_map.n_total () != _sources.n_total () || _out.n_total () != _sources.n_total ()) {
+ return false;
+ }
+ return true;
+}
- plugin_insert_splitting_changed ();
+bool
+ProcessorEntry::RoutingIcon::can_coalesce () const {
+ if (_thru_map.n_total () > 0) {
+ return false;
+ }
+ if (_fed_by && _f_out != _f_sources) {
+ return false;
+ }
+ if (_fed_by && !_f_out_map.is_identity () && !_in_map.is_identity ()) {
+ return false;
+ }
+ if (_input && _sinks == _in && (!_fed_by || _f_out == _in)) {
+ return true;
+ }
+ return false;
}
void
-PluginInsertProcessorEntry::plugin_insert_splitting_changed ()
+ProcessorEntry::RoutingIcon::set_fed_by (
+ const ARDOUR::ChanCount& out,
+ const ARDOUR::ChanCount& sources,
+ const ARDOUR::ChanMapping& out_map,
+ const ARDOUR::ChanMapping& thru_map)
{
- ChanCount in, out; // actual configured i/o
- _plugin_insert->configured_io (in, out);
+ _f_out = out;
+ _f_sources = sources;
+ _f_out_map = out_map;
+ _f_thru_map = thru_map;
+ _fed_by = true;
+}
+
+void
+ProcessorEntry::RoutingIcon::set_feeding (
+ const ARDOUR::ChanCount& in,
+ const ARDOUR::ChanCount& sinks,
+ const ARDOUR::ChanMapping& in_map,
+ const ARDOUR::ChanMapping& thru_map)
+{
+ _i_in = in;
+ _i_sinks = sinks;
+ _i_in_map = in_map;
+ _i_thru_map = thru_map;
+ _feeding = true;
+}
+
+double
+ProcessorEntry::RoutingIcon::pin_x_pos (uint32_t i, double width, uint32_t n_total, uint32_t n_midi, bool midi)
+{
+ if (!midi) { i += n_midi; }
+ if (n_total == 1) {
+ assert (i == 0);
+ return rint (width * .5) +.5;
+ }
+ return rint (width * (.15 + .7 * i / (n_total - 1))) + .5;
+}
+
+void
+ProcessorEntry::RoutingIcon::draw_gnd (cairo_t* cr, double x0, double y0, double height, bool midi)
+{
+ const double dx = 1 + rint (max(2., 2. * UIConfiguration::instance().get_ui_scale()));
+ const double y1 = rint (height * .66) + .5;
+
+ cairo_save (cr);
+ cairo_translate (cr, x0, y0);
+ cairo_move_to (cr, 0, height);
+ cairo_line_to (cr, 0, y1);
+ cairo_move_to (cr, 0 - dx, y1);
+ cairo_line_to (cr, 0 + dx, y1);
+
+ set_routing_color (cr, midi);
+ cairo_set_line_width (cr, 1.0);
+ cairo_stroke (cr);
+ cairo_restore (cr);
+}
+
+void
+ProcessorEntry::RoutingIcon::draw_sidechain (cairo_t* cr, double x0, double y0, double height, bool midi)
+{
+ const double dx = 1 + rint (max(2., 2. * UIConfiguration::instance().get_ui_scale()));
+ const double y1 = rint (height * .5) - .5;
+
+ cairo_save (cr);
+ cairo_translate (cr, x0, y0);
+ cairo_move_to (cr, 0 - dx, height);
+ cairo_line_to (cr, 0, y1);
+ cairo_line_to (cr, 0 + dx, height);
+ cairo_close_path (cr);
+
+ set_routing_color (cr, midi);
+ cairo_fill (cr);
+ cairo_restore (cr);
+}
+
+void
+ProcessorEntry::RoutingIcon::draw_thru_src (cairo_t* cr, double x0, double y0, double height, bool midi)
+{
+ const double rad = 1;
+ const double y1 = height - rad - 1.5;
+
+ cairo_arc (cr, x0, y0 + y1, rad, 0, 2. * M_PI);
+ cairo_move_to (cr, x0, y0 + height - 1.5);
+ cairo_line_to (cr, x0, y0 + height);
+ set_routing_color (cr, midi);
+ cairo_set_line_width (cr, 1.0);
+ cairo_stroke (cr);
+}
+
+void
+ProcessorEntry::RoutingIcon::draw_thru_sink (cairo_t* cr, double x0, double y0, double height, bool midi)
+{
+ const double rad = 1;
+ const double y1 = rad + 1;
+
+ cairo_arc (cr, x0, y0 + y1, rad, 0, 2. * M_PI);
+ cairo_move_to (cr, x0, y0);
+ cairo_line_to (cr, x0, y0 + 1);
+ set_routing_color (cr, midi);
+ cairo_set_line_width (cr, 1.0);
+ cairo_stroke (cr);
+}
+
+void
+ProcessorEntry::RoutingIcon::draw_connection (cairo_t* cr, double x0, double x1, double y0, double y1, bool midi, bool dashed)
+{
+ double bz = abs (y1 - y0);
+
+ cairo_move_to (cr, x0, y0);
+ cairo_curve_to (cr, x0, y0 + bz, x1, y1 - bz, x1, y1);
+ cairo_set_line_width (cr, 1.0);
+ cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
+ cairo_set_source_rgb (cr, 1, 0, 0);
+ if (dashed) {
+ const double dashes[] = { 2, 3 };
+ cairo_set_dash (cr, dashes, 2, 0);
+ }
+ set_routing_color (cr, midi);
+ cairo_stroke (cr);
+ if (dashed) {
+ cairo_set_dash (cr, 0, 0, 0);
+ }
+}
+
+bool
+ProcessorEntry::RoutingIcon::on_expose_event (GdkEventExpose* ev)
+{
+ cairo_t* cr = gdk_cairo_create (get_window()->gobj());
+
+ cairo_rectangle (cr, ev->area.x, ev->area.y, ev->area.width, ev->area.height);
+ cairo_clip (cr);
+
+ cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
+
+ Gtk::Allocation a = get_allocation();
+ double const width = a.get_width();
+ double const height = a.get_height();
+
+ Gdk::Color const bg = get_style()->get_bg (STATE_NORMAL);
+ cairo_set_source_rgb (cr, bg.get_red_p (), bg.get_green_p (), bg.get_blue_p ());
+
+ cairo_rectangle (cr, 0, 0, width, height);
+ cairo_fill (cr);
+
+ if (_input) {
+ if (can_coalesce ()) {
+ expose_coalesced_input_map (cr, width, height);
+ } else {
+ expose_input_map (cr, width, height);
+ }
+ } else {
+ expose_output_map (cr, width, height);
+ }
- /* get number of input ports */
- ChanCount sinks = _plugin_insert->natural_input_streams();
- if (!_plugin_insert->splitting () && _plugin_insert->get_count() > 1) {
- /* replicated instances */
- for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
- sinks.set(*t, sinks.get(*t) * _plugin_insert->get_count());
+ cairo_destroy(cr);
+ return true;
+}
+
+void
+ProcessorEntry::RoutingIcon::expose_coalesced_input_map (cairo_t* cr, const double width, const double height)
+{
+ const uint32_t pc_in = _sinks.n_total();
+ const uint32_t pc_in_midi = _sinks.n_midi();
+
+ for (uint32_t i = 0; i < pc_in; ++i) {
+ const bool is_midi = i < pc_in_midi;
+ bool valid_in;
+ uint32_t pn = is_midi ? i : i - pc_in_midi;
+ DataType dt = is_midi ? DataType::MIDI : DataType::AUDIO;
+ uint32_t idx = _in_map.get (dt, pn, &valid_in);
+ if (!valid_in) {
+ double x = pin_x_pos (i, width, pc_in, 0, is_midi);
+ draw_gnd (cr, x, 0, height, is_midi);
+ continue;
+ }
+ if (idx >= _in.get (dt)) {
+ // side-chain, probably
+ double x = pin_x_pos (i, width, pc_in, 0, is_midi);
+ draw_sidechain (cr, x, 0, height, is_midi);
+ continue;
+ }
+ double c_x0;
+ double c_x1 = pin_x_pos (i, width, pc_in, 0, false);
+
+ if (_fed_by) {
+ bool valid_src;
+ uint32_t src = _f_out_map.get_src (dt, idx, &valid_src);
+ if (!valid_src) {
+ double x = pin_x_pos (i, width, pc_in, 0, false);
+ bool valid_thru;
+ _f_thru_map.get (dt, idx, &valid_thru);
+ if (valid_thru) {
+ draw_thru_src (cr, x, 0, height, is_midi);
+ } else {
+ draw_gnd (cr, x, 0, height, is_midi);
+ }
+ continue;
+ }
+ c_x0 = pin_x_pos (src, width, _f_sources.n_total(), _f_sources.n_midi(), is_midi);
+ } else {
+ c_x0 = pin_x_pos (idx, width, _in.n_total(), _in.n_midi(), is_midi);
}
+ draw_connection (cr, c_x0, c_x1, 0, height, is_midi);
}
- /* MIDI bypass */
- if (_plugin_insert->natural_output_streams().n_midi() == 0 &&
- _plugin_insert->output_streams().n_midi() == 1) {
- in.set(DataType::MIDI, 1);
- out.set(DataType::MIDI, 1);
- sinks.set(DataType::MIDI, 1);
+}
+
+void
+ProcessorEntry::RoutingIcon::expose_input_map (cairo_t* cr, const double width, const double height)
+{
+ const uint32_t n_in = _in.n_total();
+ const uint32_t n_in_midi = _in.n_midi();
+ const uint32_t pc_in = _sinks.n_total();
+ const uint32_t pc_in_midi = _sinks.n_midi();
+
+ // draw inputs to this
+ for (uint32_t i = 0; i < pc_in; ++i) {
+ const bool is_midi = i < pc_in_midi;
+ bool valid_in;
+ uint32_t pn = is_midi ? i : i - pc_in_midi;
+ DataType dt = is_midi ? DataType::MIDI : DataType::AUDIO;
+ uint32_t idx = _in_map.get (dt, pn, &valid_in);
+ // check if it's fed
+ bool valid_src = true;
+ if (valid_in && idx < _in.get (dt) && _fed_by) {
+ bool valid_out;
+ bool valid_thru;
+ _f_out_map.get_src (dt, idx, &valid_out);
+ _f_thru_map.get (dt, idx, &valid_thru);
+ if (!valid_out && !valid_thru) {
+ valid_src = false;
+ }
+ }
+ if (!valid_in || !valid_src) {
+ double x = pin_x_pos (i, width, pc_in, 0, is_midi);
+ draw_gnd (cr, x, 0, height, is_midi);
+ continue;
+ }
+ if (idx >= _in.get (dt)) {
+ // side-chain, probably
+ double x = pin_x_pos (i, width, pc_in, 0, is_midi);
+ draw_sidechain (cr, x, 0, height, is_midi);
+ continue;
+ }
+ double c_x1 = pin_x_pos (i, width, pc_in, 0, false);
+ double c_x0 = pin_x_pos (idx, width, n_in, n_in_midi, is_midi);
+ draw_connection (cr, c_x0, c_x1, 0, height, is_midi);
+ }
+
+ // draw reverse thru
+ for (uint32_t i = 0; i < n_in; ++i) {
+ const bool is_midi = i < n_in_midi;
+ bool valid_thru;
+ uint32_t pn = is_midi ? i : i - n_in_midi;
+ DataType dt = is_midi ? DataType::MIDI : DataType::AUDIO;
+ _thru_map.get_src (dt, pn, &valid_thru);
+ if (!valid_thru) {
+ continue;
+ }
+ double x = pin_x_pos (i, width, n_in, 0, is_midi);
+ draw_thru_sink (cr, x, 0, height, is_midi);
}
+}
+
+void
+ProcessorEntry::RoutingIcon::expose_output_map (cairo_t* cr, const double width, const double height)
+{
+ int dh = std::max (4.f, rintf(4.f * UIConfiguration::instance().get_ui_scale()));
+ double ht = _terminal ? height - dh : height;
+
+ // draw outputs of this
+ const uint32_t pc_out = _sources.n_total();
+ const uint32_t pc_out_midi = _sources.n_midi();
+ const uint32_t n_out = _out.n_total();
+ const uint32_t n_out_midi = _out.n_midi();
+
+ for (uint32_t i = 0; i < pc_out; ++i) {
+ const bool is_midi = i < pc_out_midi;
+ bool valid_out;
+ uint32_t pn = is_midi ? i : i - pc_out_midi;
+ DataType dt = is_midi ? DataType::MIDI : DataType::AUDIO;
+ uint32_t idx = _out_map.get (dt, pn, &valid_out);
+ if (!valid_out) {
+ continue;
+ }
+ // skip connections that are not used in the next's input
+ if (_feeding) {
+ bool valid_thru, valid_sink;
+ _i_in_map.get_src (dt, idx, &valid_sink);
+ _i_thru_map.get_src (dt, idx, &valid_thru);
+ if (!valid_thru && !valid_sink) {
+ if (!is_midi || i != 0) { // special case midi-bypass
+ continue;
+ }
+ }
+ }
+ double c_x0 = pin_x_pos (i, width, pc_out, 0, false);
+ double c_x1 = pin_x_pos (idx, width, n_out, n_out_midi, is_midi);
+ draw_connection (cr, c_x0, c_x1, 0, ht, is_midi);
+ }
+
+ for (uint32_t i = 0; i < n_out; ++i) {
+ const bool is_midi = i < n_out_midi;
+ uint32_t pn = is_midi ? i : i - n_out_midi;
+ DataType dt = is_midi ? DataType::MIDI : DataType::AUDIO;
+ double x = pin_x_pos (i, width, n_out, 0, is_midi);
+
+ if (!_terminal) {
+ bool valid_thru_f = false;
+ // skip connections that are not used in the next's input
+ if (_feeding) {
+ bool valid_sink;
+ _i_in_map.get_src (dt, pn, &valid_sink);
+ _i_thru_map.get_src (dt, pn, &valid_thru_f);
+ if (!valid_thru_f && !valid_sink) {
+ if (!is_midi || i != 0) { // special case midi-bypass
+ continue;
+ }
+ }
+ }
+
+ bool valid_src;
+ _out_map.get_src (dt, pn, &valid_src);
+ if (!valid_src) {
+ bool valid_thru;
+ uint32_t idx = _thru_map.get (dt, pn, &valid_thru);
+ if (valid_thru) {
+ if (idx >= _in.get (dt)) {
+ draw_sidechain (cr, x, 0, height, is_midi);
+ } else {
+ draw_thru_src (cr, x, 0, height, is_midi);
+ }
+ } else if (valid_thru_f){
+ // gnd is part of input, unless it's a thru input
+ // (also only true if !coalesced into one small display)
+ draw_gnd (cr, x, 0, height, is_midi);
+ }
+ }
+ } else {
+ // terminal node, add arrows
+ bool valid_src;
+ _out_map.get_src (dt, pn, &valid_src);
+ if (!valid_src) {
+ bool valid_thru;
+ uint32_t idx = _thru_map.get (dt, pn, &valid_thru);
+ if (valid_thru) {
+ if (idx >= _in.get (dt)) {
+ draw_sidechain (cr, x, 0, height - dh, is_midi);
+ } else {
+ draw_thru_src (cr, x, 0, height - dh, is_midi);
+ }
+ } else {
+ draw_gnd (cr, x, 0, height - dh, is_midi);
+ }
+ }
- /* the Input streams available (*valid* outputs from prev. plugin)
- * this will be <= sinks. Some input-ports of this processor
- * may be unconnected.
+ set_routing_color (cr, is_midi);
+ cairo_set_line_width (cr, 1.0);
+ cairo_move_to (cr, x, height - dh);
+ cairo_line_to (cr, x, height - 2);
+ cairo_stroke (cr);
+
+ const double ar = dh - 1;
+ cairo_move_to (cr, x - ar, height - ar);
+ cairo_line_to (cr, x , height - .5);
+ cairo_line_to (cr, x + ar, height - ar);
+ cairo_line_to (cr, x , height - ar * .5);
+ cairo_close_path (cr);
+ cairo_fill_preserve (cr);
+ cairo_stroke (cr);
+ }
+ }
+}
+
+ProcessorEntry::PluginDisplay::PluginDisplay (ProcessorEntry& e, boost::shared_ptr<ARDOUR::Plugin> p, uint32_t max_height)
+ : _entry (e)
+ , _plug (p)
+ , _surf (0)
+ , _max_height (max_height)
+ , _cur_height (1)
+ , _scroll (false)
+{
+ set_name ("processor prefader");
+ add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
+ _plug->QueueDraw.connect (_qdraw_connection, invalidator (*this),
+ boost::bind (&Gtk::Widget::queue_draw, this), gui_context ());
+
+ std::string postfix = "";
+ if (_plug->has_editor()) {
+ ARDOUR_UI_UTILS::set_tooltip (*this,
+ string_compose (_("<b>%1</b>\nDouble-click to show GUI.\n%2+double-click to show generic GUI.%3"), e.name (Wide), Keyboard::primary_modifier_name (), postfix));
+ } else {
+ ARDOUR_UI_UTILS::set_tooltip (*this,
+ string_compose (_("<b>%1</b>\nDouble-click to show generic GUI.%2"), e.name (Wide), postfix));
+ }
+}
+
+ProcessorEntry::PluginDisplay::~PluginDisplay ()
+{
+ if (_surf) {
+ cairo_surface_destroy (_surf);
+ }
+}
+
+bool
+ProcessorEntry::PluginDisplay::on_button_press_event (GdkEventButton *ev)
+{
+ assert (_entry.processor ());
+
+ // consider some tweaks to pass this up to the DnDVBox somehow:
+ // select processor, then call (private)
+ //_entry._parent->processor_button_press_event (ev, &_entry);
+ if (Keyboard::is_edit_event (ev) || (ev->button == 1 && ev->type == GDK_2BUTTON_PRESS)) {
+ if (Keyboard::modifier_state_equals (ev->state, Keyboard::SecondaryModifier)) {
+ _entry._parent->generic_edit_processor (_entry.processor ());
+ } else {
+ _entry._parent->edit_processor (_entry.processor ());
+ }
+ return true;
+ }
+ return false;
+}
+
+bool
+ProcessorEntry::PluginDisplay::on_button_release_event (GdkEventButton *ev)
+{
+ return false;
+}
+
+void
+ProcessorEntry::PluginDisplay::on_size_request (Requisition* req)
+{
+ req->width = 56;
+ req->height = _cur_height;
+}
+
+
+void
+ProcessorEntry::PluginDisplay::update_height_alloc (uint32_t inline_height)
+{
+ /* work-around scroll-bar + aspect ratio
+ * show inline-view -> height changes -> scrollbar gets added
+ * -> width changes -> inline-view, fixed aspect ratio -> height changes
+ * -> scroll bar is removed [-> width changes ; repeat ]
*/
- _routing_icon.set_sources(in);
+ uint32_t shm = std::min (_max_height, inline_height);
+ bool sc = false;
+ Gtk::Container* pr = get_parent();
+ for (uint32_t i = 0; i < 4 && pr; ++i) {
+ // VBox, EventBox, ViewPort, ScrolledWindow
+ pr = pr->get_parent();
+ }
+ Gtk::ScrolledWindow* sw = dynamic_cast<Gtk::ScrolledWindow*> (pr);
+ if (sw) {
+ const Gtk::VScrollbar* vsb = sw->get_vscrollbar();
+ sc = vsb && vsb->is_visible();
+ }
+
+ if (shm != _cur_height) {
+ if (_scroll == sc || _cur_height < shm) {
+ queue_resize ();
+ }
+ _cur_height = shm;
+ }
+ _scroll = sc;
+}
- /* the actual input ports of this processor */
- _input_icon.set_ports(sinks);
- _routing_icon.set_sinks(sinks);
+uint32_t
+ProcessorEntry::PluginDisplay::render_inline (cairo_t* cr, uint32_t width)
+{
+ Plugin::Display_Image_Surface* dis = _plug->render_inline_display (width, _max_height);
+ if (!dis) {
+ return 0;
+ }
- /* set/override plugin-output ports to actual outputs-streams.
- *
- * This plugin may have unconnected output-ports (currently only in Mixbus,
- * e.g channelstrip-EQ at the top of a MIDI-channel before the synth).
- *
- * The *next* processor below this one will only see the
- * actual available streams (it cannot know the real outputs
- * of this plugin).
- *
- * There is currently no API to query the ports of the previous (or next)
- * processor.
- *
- * (normally - iff configuration succeeds - this is set during
- * ProcessorEntry::processor_configuration_changed() and should
- * equal _plugin_insert->output_streams())
+ /* allocate a local image-surface,
+ * We cannot re-use the data via cairo_image_surface_create_for_data(),
+ * since pixman keeps a reference to it.
+ * we'd need to hand over the data and ha cairo_surface_destroy to free it.
+ * it might be possible to work around via cairo_surface_set_user_data().
*/
- _output_icon.set_ports(out);
-#ifndef NDEBUG
- if (out != _plugin_insert->output_streams()) {
- std::cerr << "Processor Wiring: " << processor()->name()
- << " out-ports: " << _plugin_insert->output_streams() // NB. does not include midi-bypass
- << " out-connections: " << out
- << endmsg;
+ if (!_surf
+ || dis->width != cairo_image_surface_get_width (_surf)
+ || dis->height != cairo_image_surface_get_height (_surf)
+ ) {
+ if (_surf) {
+ cairo_surface_destroy (_surf);
+ }
+ _surf = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, dis->width, dis->height);
}
-#endif
- _routing_icon.set_splitting(_plugin_insert->splitting ());
-
- if (_plugin_insert->splitting () || in != sinks)
- {
- _routing_icon.set_size_request (-1, std::max (7.f, rintf(7.f * UIConfiguration::instance().get_ui_scale())));
- _routing_icon.set_visible(true);
- _input_icon.show();
+ if (cairo_image_surface_get_stride (_surf) == dis->stride) {
+ memcpy (cairo_image_surface_get_data (_surf), dis->data, dis->stride * dis->height);
} else {
- _routing_icon.set_visible(false);
- if (_position_num != 0) {
- _input_icon.hide();
+ unsigned char *src = dis->data;
+ unsigned char *dst = cairo_image_surface_get_data (_surf);
+ const int dst_stride = cairo_image_surface_get_stride (_surf);
+ for (int y = 0; y < dis->height; ++y) {
+ memcpy (dst, src, dis->width * 4 /*ARGB32*/);
+ src += dis->stride;
+ dst += dst_stride;
}
}
- _input_icon.queue_draw();
- _output_icon.queue_draw();
- _routing_icon.queue_draw();
-}
-
-void
-PluginInsertProcessorEntry::hide_things ()
-{
- ProcessorEntry::hide_things ();
- plugin_insert_splitting_changed ();
-}
+ cairo_surface_flush(_surf);
+ cairo_surface_mark_dirty(_surf);
+ const double xc = floor ((width - dis->width) * .5);
+ cairo_set_source_surface(cr, _surf, xc, 0);
+ cairo_paint (cr);
-ProcessorEntry::PortIcon::PortIcon(bool input) {
- _input = input;
- _ports = ARDOUR::ChanCount(ARDOUR::DataType::AUDIO, 1);
- set_size_request (-1, std::max (2.f, rintf(2.f * UIConfiguration::instance().get_ui_scale())));
+ return dis->height;
}
bool
-ProcessorEntry::PortIcon::on_expose_event (GdkEventExpose* ev)
+ProcessorEntry::PluginDisplay::on_expose_event (GdkEventExpose* ev)
{
- cairo_t* cr = gdk_cairo_create (get_window()->gobj());
-
- cairo_rectangle (cr, ev->area.x, ev->area.y, ev->area.width, ev->area.height);
- cairo_clip (cr);
-
Gtk::Allocation a = get_allocation();
double const width = a.get_width();
double const height = a.get_height();
+ cairo_t* cr = gdk_cairo_create (get_window()->gobj());
+ cairo_rectangle (cr, ev->area.x, ev->area.y, ev->area.width, ev->area.height);
+ cairo_clip (cr);
+
Gdk::Color const bg = get_style()->get_bg (STATE_NORMAL);
cairo_set_source_rgb (cr, bg.get_red_p (), bg.get_green_p (), bg.get_blue_p ());
-
cairo_rectangle (cr, 0, 0, width, height);
cairo_fill (cr);
- const double dx = rint(max(2., 2. * UIConfiguration::instance().get_ui_scale()));
- if (_ports.n_total() > 1) {
- for (uint32_t i = 0; i < _ports.n_total(); ++i) {
- if (i < _ports.n_midi()) {
- cairo_set_source_rgb (cr,
- UINT_RGBA_R_FLT(midi_port_color),
- UINT_RGBA_G_FLT(midi_port_color),
- UINT_RGBA_B_FLT(midi_port_color));
- } else {
- cairo_set_source_rgb (cr,
- UINT_RGBA_R_FLT(audio_port_color),
- UINT_RGBA_G_FLT(audio_port_color),
- UINT_RGBA_B_FLT(audio_port_color));
- }
- const float x = rintf(width * (.2f + .6f * i / (_ports.n_total() - 1.f)));
- cairo_rectangle (cr, x-dx * .5, 0, 1+dx, height);
- cairo_fill(cr);
- }
- } else if (_ports.n_total() == 1) {
- if (_ports.n_midi() == 1) {
- cairo_set_source_rgb (cr,
- UINT_RGBA_R_FLT(midi_port_color),
- UINT_RGBA_G_FLT(midi_port_color),
- UINT_RGBA_B_FLT(midi_port_color));
- } else {
- cairo_set_source_rgb (cr,
- UINT_RGBA_R_FLT(audio_port_color),
- UINT_RGBA_G_FLT(audio_port_color),
- UINT_RGBA_B_FLT(audio_port_color));
+ cairo_save (cr);
+ cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+ Gtkmm2ext::rounded_rectangle (cr, .5, -1.5, width - 1, height + 1, 7);
+ cairo_clip (cr);
+ cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
+
+ uint32_t ht = render_inline (cr, width);
+ cairo_restore (cr);
+
+ if (ht == 0) {
+ hide ();
+ if (_cur_height != 1) {
+ _cur_height = 1;
+ queue_resize ();
}
- const float x = rintf(width * .5);
- cairo_rectangle (cr, x-dx * .5, 0, 1+dx, height);
- cairo_fill(cr);
- cairo_stroke(cr);
+ cairo_destroy (cr);
+ return true;
+ } else {
+ update_height_alloc (ht);
}
+ bool failed = false;
+ std::string name = get_name();
+ ArdourCanvas::Color fill_color = UIConfiguration::instance().color (string_compose ("%1: fill active", name), &failed);
+
+ Gtkmm2ext::rounded_rectangle (cr, .5, -1.5, width - 1, height + 1, 7);
+ cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
+ cairo_set_line_width(cr, 1.0);
+ ArdourCanvas::set_source_rgb_a (cr, fill_color, 1.0);
+ cairo_stroke (cr);
+
cairo_destroy(cr);
return true;
}
-bool
-ProcessorEntry::RoutingIcon::on_expose_event (GdkEventExpose* ev)
+ProcessorEntry::LuaPluginDisplay::LuaPluginDisplay (ProcessorEntry& e, boost::shared_ptr<ARDOUR::LuaProc> p, uint32_t max_height)
+ : PluginDisplay (e, p, max_height)
+ , _luaproc (p)
+ , _lua_render_inline (0)
{
- cairo_t* cr = gdk_cairo_create (get_window()->gobj());
-
- cairo_rectangle (cr, ev->area.x, ev->area.y, ev->area.width, ev->area.height);
- cairo_clip (cr);
-
- cairo_set_line_width (cr, max (1.f, UIConfiguration::instance().get_ui_scale()));
- cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
-
- Gtk::Allocation a = get_allocation();
- double const width = a.get_width();
- double const height = a.get_height();
-
- Gdk::Color const bg = get_style()->get_bg (STATE_NORMAL);
- cairo_set_source_rgb (cr, bg.get_red_p (), bg.get_green_p (), bg.get_blue_p ());
+ p->setup_lua_inline_gui (&lua_gui);
- cairo_rectangle (cr, 0, 0, width, height);
- cairo_fill (cr);
+ lua_State* LG = lua_gui.getState ();
+ LuaInstance::bind_cairo (LG);
+ luabridge::LuaRef lua_render = luabridge::getGlobal (LG, "render_inline");
+ assert (lua_render.isFunction ());
+ _lua_render_inline = new luabridge::LuaRef (lua_render);
+}
- Gdk::Color const fg = get_style()->get_fg (STATE_NORMAL);
- cairo_set_source_rgb (cr, fg.get_red_p (), fg.get_green_p (), fg.get_blue_p ());
-
- const uint32_t sources = _sources.n_total();
- const uint32_t sinks = _sinks.n_total();
-
- const uint32_t midi_sources = _sources.n_midi();
- const uint32_t midi_sinks = _sinks.n_midi();
- const uint32_t audio_sources = _sources.n_audio();
- const uint32_t audio_sinks = _sinks.n_audio();
-
- /* MIDI */
- cairo_set_source_rgb (cr,
- UINT_RGBA_R_FLT(midi_port_color),
- UINT_RGBA_G_FLT(midi_port_color),
- UINT_RGBA_B_FLT(midi_port_color));
- if (midi_sources > 0 && midi_sinks > 0 && sinks > 1 && sources > 1) {
- for (uint32_t i = 0 ; i < midi_sources; ++i) {
- const float si_x = rintf(width * (.2f + .6f * i / (sinks - 1.f))) + .5f;
- const float si_x0 = rintf(width * (.2f + .6f * i / (sources - 1.f))) + .5f;
- cairo_move_to (cr, si_x, height);
- cairo_curve_to (cr, si_x, 0, si_x0, height, si_x0, 0);
- cairo_stroke (cr);
- }
- } else if (midi_sources == 1 && midi_sinks == 1 && sinks == 1 && sources == 1) {
- const float si_x = rintf(width * .5f) + .5f;
- cairo_move_to (cr, si_x, height);
- cairo_line_to (cr, si_x, 0);
- cairo_stroke (cr);
- } else if (midi_sources == 1 && midi_sinks == 1) {
- /* unusual cases -- removed synth, midi-track w/audio plugins */
- const float si_x = rintf(width * (sinks > 1 ? .2f : .5f)) + .5f;
- const float si_x0 = rintf(width * (sources > 1 ? .2f : .5f)) + .5f;
- cairo_move_to (cr, si_x, height);
- cairo_curve_to (cr, si_x, 0, si_x0, height, si_x0, 0);
- cairo_stroke (cr);
- } else if (midi_sources == 0 && midi_sinks == 1) {
- const double dx = 1 + rint(max(2., 2. * UIConfiguration::instance().get_ui_scale()));
- // draw "T"
- // TODO connect back to track-input of last midi-out if any, otherwise draw "X"
- const float si_x = rintf(width * .2f) + .5f;
- cairo_move_to (cr, si_x, height);
- cairo_line_to (cr, si_x, height * .66);
- cairo_move_to (cr, si_x - dx, height * .66);
- cairo_line_to (cr, si_x + dx, height * .66);
- cairo_stroke (cr);
-#ifndef NDEBUG
- } else if (midi_sources != 0 && midi_sinks != 0) {
- PBD::warning << string_compose("Programming error: midi routing display: A %1 -> %2 | M %3 -> %4 | T %5 -> %6",
- audio_sources, audio_sinks, midi_sources, midi_sinks, sources, sinks) << endmsg;
-#endif
- }
+ProcessorEntry::LuaPluginDisplay::~LuaPluginDisplay ()
+{
+ delete (_lua_render_inline);
+}
- /* AUDIO */
- cairo_set_source_rgb (cr,
- UINT_RGBA_R_FLT(audio_port_color),
- UINT_RGBA_G_FLT(audio_port_color),
- UINT_RGBA_B_FLT(audio_port_color));
-
- if (_splitting) {
- assert(audio_sources < 2);
- assert(audio_sinks > 1);
- /* assume there is only ever one MIDI port */
- const float si_x0 = rintf(width * (midi_sources > 0 ? .8f : .5f)) + .5f;
- for (uint32_t i = midi_sinks; i < sinks; ++i) {
- const float si_x = rintf(width * (.2f + .6f * i / (sinks - 1.f))) + .5f;
- cairo_move_to (cr, si_x, height);
- cairo_curve_to (cr, si_x, 0, si_x0, height, si_x0, 0);
- cairo_stroke (cr);
- }
- } else if (audio_sources > 1 && sinks > 1) {
- for (uint32_t i = 0 ; i < audio_sources; ++i) {
- const float si_x = rintf(width * (.2f + .6f * (i + midi_sinks) / (sinks - 1.f))) + .5f;
- const float si_x0 = rintf(width * (.2f + .6f * (i + midi_sources) / (sources - 1.f))) + .5f;
- cairo_move_to (cr, si_x, height);
- cairo_curve_to (cr, si_x, 0, si_x0, height, si_x0, 0);
- cairo_stroke (cr);
- }
- } else if (audio_sources == 1 && audio_sinks > 0) {
- float si_x, si_x0;
- if (sinks == 1) {
- si_x = rintf(width * .5f) + .5f;
- } else {
- si_x = rintf(width * (.2f + .6f * midi_sinks / (sinks - 1.f))) + .5f;
- }
- if (sources == 1) {
- si_x0 = rintf(width * .5f) + .5f;
- } else {
- si_x0 = rintf(width * (.2f + .6f * midi_sources / (sources - 1.f))) + .5f;
+uint32_t
+ProcessorEntry::LuaPluginDisplay::render_inline (cairo_t *cr, uint32_t width)
+{
+ Cairo::Context ctx (cr);
+ try {
+ luabridge::LuaRef rv = (*_lua_render_inline)((Cairo::Context *)&ctx, width, _max_height);
+ if (rv.isTable ()) {
+ uint32_t h = rv[2];
+ return h;
}
- cairo_move_to (cr, si_x, height);
- cairo_curve_to (cr, si_x, 0, si_x0, height, si_x0, 0);
- cairo_stroke (cr);
+ } catch (luabridge::LuaException const& e) {
#ifndef NDEBUG
- } else if (audio_sources != 0 && audio_sinks != 0) {
- PBD::warning << string_compose("Programming error: audio routing display: A %1 -> %2 | M %3 -> %4 | T %5 -> %6",
- audio_sources, audio_sinks, midi_sources, midi_sinks, sources, sinks) << endmsg;
+ cerr << "LuaException:" << e.what () << endl;
#endif
}
- cairo_destroy(cr);
- return true;
+ return 0;
}
+
static std::list<Gtk::TargetEntry> drop_targets()
{
std::list<Gtk::TargetEntry> tmp;
- tmp.push_back (Gtk::TargetEntry ("processor"));
- tmp.push_back (Gtk::TargetEntry ("PluginInfoPtr"));
- tmp.push_back (Gtk::TargetEntry ("PluginPresetPtr"));
+ tmp.push_back (Gtk::TargetEntry ("processor")); // from processor-box to processor-box
+ tmp.push_back (Gtk::TargetEntry ("PluginInfoPtr")); // from plugin-manager
+ tmp.push_back (Gtk::TargetEntry ("PluginFavoritePtr")); // from sidebar
+ return tmp;
+}
+
+static std::list<Gtk::TargetEntry> drag_targets()
+{
+ std::list<Gtk::TargetEntry> tmp;
+ tmp.push_back (Gtk::TargetEntry ("PluginPresetPtr")); // to sidebar (optional preset)
+ tmp.push_back (Gtk::TargetEntry ("processor")); // to processor-box (copy)
+ return tmp;
+}
+
+static std::list<Gtk::TargetEntry> drag_targets_noplugin()
+{
+ std::list<Gtk::TargetEntry> tmp;
+ tmp.push_back (Gtk::TargetEntry ("processor")); // to processor box (sends, faders re-order)
return tmp;
}
, _rr_selection(rsel)
, processor_display (drop_targets())
, _redisplay_pending (false)
-
{
set_session (sess);
+ /* ProcessorBox actions and bindings created statically by call to
+ * ProcessorBox::register_actions(), made by ARDOUR_UI so that actions
+ * are available for context menus.
+ */
+
+ processor_display.set_data ("ardour-bindings", bindings);
+
_width = Wide;
processor_menu = 0;
no_processor_redisplay = false;
boost::shared_ptr<Processor> processor (new PluginInsert (*_session, p));
if (Config->get_new_plugins_active ()) {
- processor->activate ();
+ processor->enable (true);
}
pl.push_back (processor);
}
}
boost::shared_ptr<Processor> processor (new PluginInsert (*_session, p));
if (Config->get_new_plugins_active ()) {
- processor->activate ();
+ processor->enable (true);
}
pl.push_back (processor);
}
if (data.get_target() == "PluginInfoPtr") {
_drop_plugin (data, pl);
}
- else if (data.get_target() == "PluginPresetPtr") {
+ else if (data.get_target() == "PluginFavoritePtr") {
_drop_plugin_preset (data, pl);
}
else {
void
ProcessorBox::object_drop (DnDVBox<ProcessorEntry>* source, ProcessorEntry* position, Glib::RefPtr<Gdk::DragContext> const & context)
{
+ if (Gdk::ACTION_LINK == context->get_selected_action()) {
+ list<ProcessorEntry*> children = source->selection ();
+ assert (children.size() == 1);
+ ProcessorEntry* other = *children.begin();
+ assert (other->can_copy_state (position));
+ boost::shared_ptr<ARDOUR::Processor> otherproc = other->processor();
+ boost::shared_ptr<ARDOUR::Processor> proc = position->processor();
+ boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (proc);
+ assert (otherproc && proc && pi);
+
+ PBD::ID id = pi->id();
+ XMLNode& state = otherproc->get_state ();
+ /* strip side-chain state (processor inside processor must be a side-chain)
+ * otherwise we'll end up with duplicate ports-names.
+ * (this needs a better solution which retains connections)
+ */
+ state.remove_nodes ("Processor");
+ proc->set_state (state, Stateful::loading_state_version);
+ boost::dynamic_pointer_cast<PluginInsert>(proc)->update_id (id);
+ return;
+ }
+
boost::shared_ptr<Processor> p = find_drop_position (position);
list<ProcessorEntry*> children = source->selection ();
}
}
- Gtk::MenuItem* send_menu_item = dynamic_cast<Gtk::MenuItem*>(ActionManager::get_widget("/ProcessorMenu/send_options"));
- if (send_menu_item) {
- if (single_selection && !_route->is_monitor()) {
- Menu* m = single_selection->build_send_options_menu ();
- if (m && !m->items().empty()) {
- send_menu_item->set_submenu (*m);
- send_menu_item->set_sensitive (true);
+
+ if (!ARDOUR::Profile->get_mixbus()) {
+ Gtk::MenuItem* send_menu_item = dynamic_cast<Gtk::MenuItem*>(ActionManager::get_widget("/ProcessorMenu/send_options"));
+ if (send_menu_item) {
+ if (single_selection && !_route->is_monitor()) {
+ Menu* m = single_selection->build_send_options_menu ();
+ if (m && !m->items().empty()) {
+ send_menu_item->set_submenu (*m);
+ send_menu_item->set_sensitive (true);
+ } else {
+ gtk_menu_item_set_submenu (send_menu_item->gobj(), 0);
+ send_menu_item->set_sensitive (false);
+ }
} else {
- gtk_menu_item_set_submenu (send_menu_item->gobj(), 0);
send_menu_item->set_sensitive (false);
}
- } else {
- send_menu_item->set_sensitive (false);
}
}
cut_action->set_sensitive (sensitive && can_cut ());
copy_action->set_sensitive (sensitive);
delete_action->set_sensitive (sensitive || stub_processor_selected ());
+ backspace_action->set_sensitive (sensitive || stub_processor_selected ());
edit_action->set_sensitive (one_processor_can_be_edited ());
edit_generic_action->set_sensitive (one_processor_can_be_edited ());
pi = boost::dynamic_pointer_cast<PluginInsert> (single_selection->processor ());
}
+ manage_pins_action->set_sensitive (pi != 0);
+
/* allow editing with an Ardour-generated UI for plugin inserts with editors */
edit_action->set_sensitive (pi && pi->plugin()->has_editor ());
bool
ProcessorBox::enter_notify (GdkEventCrossing*)
{
+ processor_display.grab_focus ();
_current_processor_box = this;
return false;
}
bool
-ProcessorBox::leave_notify (GdkEventCrossing*)
+ProcessorBox::leave_notify (GdkEventCrossing* ev)
{
+ if (ev->detail == GDK_NOTIFY_INFERIOR) {
+ return false;
+ }
+
+ Widget* top = get_toplevel();
+
+ if (top->is_toplevel()) {
+ Window* win = dynamic_cast<Window*> (top);
+ gtk_window_set_focus (win->gobj(), 0);
+ }
+
return false;
}
}
*/
- if ( (op == ProcessorsDelete) && targets.empty() )
+ if ((op == ProcessorsDelete) && targets.empty()) {
return false; //nothing to delete. return false so the editor-mixer, because the user was probably intending to delete something in the editor
+ }
switch (op) {
case ProcessorsSelectAll:
case ProcessorsToggleActive:
for (ProcSelection::iterator i = targets.begin(); i != targets.end(); ++i) {
- if ((*i)->active()) {
- (*i)->deactivate ();
- } else {
- (*i)->activate ();
- }
+ (*i)->enable (!(*i)->enabled ());
}
break;
boost::weak_ptr<Processor>(processor)));
} else if (processor && Keyboard::is_button2_event (ev)
-#ifndef GTKOSX
+#ifndef __APPLE__
&& (Keyboard::no_modifier_keys_pressed (ev) && ((ev->state & Gdk::BUTTON2_MASK) == Gdk::BUTTON2_MASK))
#endif
) {
/* button2-click with no/appropriate modifiers */
-
- if (processor->active()) {
- processor->deactivate ();
- } else {
- processor->activate ();
- }
+ processor->enable (!processor->enabled ());
}
return false;
weird_plugin_dialog (**p, err_streams);
return true;
// XXX SHAREDPTR delete plugin here .. do we even need to care?
- } else if (plugins.size() == 1 && Config->get_open_gui_after_adding_plugin()) {
- if (_session->engine().connected () && processor_can_be_edited (processor)) {
+ } else if (plugins.size() == 1 && UIConfiguration::instance().get_open_gui_after_adding_plugin()) {
+ if (boost::dynamic_pointer_cast<PluginInsert>(processor)->plugin()->has_inline_display() && UIConfiguration::instance().get_prefer_inline_over_gui()) {
+ ;
+ } else if (_session->engine().connected () && processor_can_be_edited (processor)) {
if ((*p)->has_editor ()) {
edit_processor (processor);
} else {
void
ProcessorBox::choose_send ()
{
- boost::shared_ptr<Pannable> sendpan(new Pannable (*_session));
- boost::shared_ptr<Send> send (new Send (*_session, sendpan, _route->mute_master()));
+ boost::shared_ptr<Send> send (new Send (*_session, _route->pannable (), _route->mute_master()));
/* make an educated guess at the initial number of outputs for the send */
ChanCount outs = (_session->master_out())
case IOSelector::Accepted:
_route->add_processor_by_index (processor, _placement);
- if (Profile->get_sae()) {
- processor->activate ();
- }
break;
}
case IOSelector::Accepted:
_route->add_processor_by_index (processor, _placement);
- if (Profile->get_sae()) {
- processor->activate ();
- }
break;
}
_route->foreach_processor (sigc::mem_fun (*this, &ProcessorBox::add_processor_to_display));
_route->foreach_processor (sigc::mem_fun (*this, &ProcessorBox::maybe_add_processor_to_ui_list));
+ _route->foreach_processor (sigc::mem_fun (*this, &ProcessorBox::maybe_add_processor_pin_mgr));
+
setup_entry_positions ();
}
const XMLNode* ui_xml = _session->extra_xml (X_("UI"));
if (ui_xml) {
- wp->set_state (*ui_xml);
+ wp->set_state (*ui_xml, 0);
}
void* existing_ui = p->get_ui ();
WM::Manager::instance().register_window (wp);
}
+void
+ProcessorBox::maybe_add_processor_pin_mgr (boost::weak_ptr<Processor> w)
+{
+ boost::shared_ptr<Processor> p = w.lock ();
+ if (!p || p->pinmgr_proxy ()) {
+ return;
+ }
+
+ PluginPinWindowProxy* wp = new PluginPinWindowProxy (
+ string_compose ("PM-%2-%3", _route->id(), p->id()), w);
+ wp->set_session (_session);
+
+ const XMLNode* ui_xml = _session->extra_xml (X_("UI"));
+ if (ui_xml) {
+ wp->set_state (*ui_xml, 0);
+ }
+
+ p->set_pingmgr_proxy (wp);
+ WM::Manager::instance().register_window (wp);
+}
void
ProcessorBox::help_count_visible_prefader_processors (boost::weak_ptr<Processor> p, uint32_t* cnt, bool* amp_seen)
{
)
) {
- if (boost::dynamic_pointer_cast<Amp>(processor) && boost::dynamic_pointer_cast<Amp>(processor)->type() == X_("amp")) {
+ if (boost::dynamic_pointer_cast<Amp>(processor) &&
+ boost::dynamic_pointer_cast<Amp>(processor)->gain_control()->parameter().type() == GainAutomation) {
*amp_seen = true;
} else {
if (!*amp_seen) {
e->show_all_controls ();
}
- processor_display.add_child (e);
+ if (plugin_insert
+#ifdef MIXBUS
+ && !plugin_insert->plugin(0)->is_channelstrip()
+#endif
+ )
+ {
+ processor_display.add_child (e, drag_targets());
+ } else {
+ processor_display.add_child (e, drag_targets_noplugin());
+ }
}
void
setup_entry_positions ();
}
+void
+ProcessorBox::setup_routing_feeds ()
+{
+ list<ProcessorEntry*> children = processor_display.children ();
+ /* first set the i/o maps for every processor */
+ list<ProcessorEntry*>::iterator prev = children.begin();
+
+ for (list<ProcessorEntry*>::iterator i = children.begin(); i != children.end(); ++i) {
+ boost::shared_ptr<ARDOUR::Processor> p = (*i)->processor();
+ boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (p);
+
+ list<ProcessorEntry*>::iterator next = i;
+ next++;
+
+ if (pi) {
+ ChanCount sinks = pi->natural_input_streams ();
+ ChanCount sources = pi->natural_output_streams ();
+ uint32_t count = pi->get_count ();
+ ChanCount in, out;
+ pi->configured_io (in, out);
+
+ ChanCount midi_thru;
+ ChanCount midi_bypass;
+ ChanMapping input_map (pi->input_map ());
+ if (pi->has_midi_thru ()) {
+ midi_thru.set(DataType::MIDI, 1);
+ input_map.set (DataType::MIDI, 0, 0);
+ }
+ if (pi->has_midi_bypass ()) {
+ midi_bypass.set(DataType::MIDI, 1);
+ }
+
+ (*i)->input_icon.set_ports (sinks * count + midi_thru);
+ (*i)->output_icon.set_ports (sources * count + midi_bypass);
+
+ (*i)->routing_icon.set (
+ in, out,
+ sinks * count + midi_thru,
+ sources * count + midi_bypass,
+ input_map,
+ pi->output_map (),
+ pi->thru_map ());
+
+ if (next != children.end()) {
+ (*next)->routing_icon.set_fed_by (out, sources * count + midi_bypass,
+ pi->output_map (), pi->thru_map ());
+ }
+
+ if (prev != i) {
+ (*prev)->routing_icon.set_feeding (in, sinks * count + midi_thru,
+ pi->input_map (), pi->thru_map ());
+ }
+
+ } else {
+ (*i)->input_icon.set_ports (p->input_streams());
+ (*i)->output_icon.set_ports (p->output_streams());
+ ChanMapping inmap (p->input_streams ());
+ ChanMapping outmap (p->input_streams ());
+ ChanMapping thrumap;
+ (*i)->routing_icon.set (
+ p->input_streams(),
+ p->output_streams(),
+ p->input_streams(),
+ p->output_streams(),
+ inmap, outmap, thrumap);
+
+ if (next != children.end()) {
+ (*next)->routing_icon.set_fed_by (
+ p->output_streams(),
+ p->output_streams(),
+ outmap, thrumap);
+ }
+ if (prev != i) {
+ (*prev)->routing_icon.set_feeding (
+ p->input_streams(),
+ p->output_streams(),
+ inmap, thrumap);
+ }
+ }
+
+ if (i == children.begin()) {
+ (*i)->routing_icon.unset_fed_by ();
+ }
+ prev = i;
+ (*i)->input_icon.hide();
+ }
+
+ /* now set which icons need to be displayed */
+ for (list<ProcessorEntry*>::iterator i = children.begin(); i != children.end(); ++i) {
+ (*i)->output_routing_icon.copy_state ((*i)->routing_icon);
+
+ if ((*i)->routing_icon.in_identity ()) {
+ (*i)->routing_icon.hide();
+ if (i == children.begin()) {
+ (*i)->input_icon.show();
+ }
+ } else {
+ (*i)->routing_icon.show();
+ (*i)->routing_icon.queue_draw();
+ (*i)->input_icon.show();
+ }
+
+ list<ProcessorEntry*>::iterator next = i;
+ if (++next == children.end()) {
+ // last processor in the chain
+ (*i)->output_routing_icon.set_terminal(true);
+ (*i)->output_routing_icon.unset_feeding ();
+ if ((*i)->routing_icon.out_identity ()) {
+ (*i)->output_routing_icon.hide();
+ } else {
+ (*i)->output_routing_icon.show();
+ (*i)->output_routing_icon.queue_draw();
+ }
+ } else {
+ (*i)->output_routing_icon.set_terminal(false);
+ if ( !(*i)->routing_icon.out_identity ()
+ && !(*next)->routing_icon.in_identity ()
+ && (*next)->routing_icon.can_coalesce ()) {
+ (*i)->output_routing_icon.hide();
+ } else if (!(*i)->routing_icon.out_identity ()) {
+ (*i)->output_routing_icon.show();
+ (*i)->output_routing_icon.queue_draw();
+ (*next)->input_icon.show();
+ } else {
+ (*i)->output_routing_icon.hide();
+ }
+ }
+ }
+}
+
void
ProcessorBox::setup_entry_positions ()
{
uint32_t num = 0;
for (list<ProcessorEntry*>::iterator i = children.begin(); i != children.end(); ++i) {
- if (boost::dynamic_pointer_cast<Amp>((*i)->processor()) && boost::dynamic_pointer_cast<Amp>((*i)->processor())->type() == X_("amp")) {
+ if (boost::dynamic_pointer_cast<Amp>((*i)->processor()) &&
+ boost::dynamic_pointer_cast<Amp>((*i)->processor())->gain_control()->parameter().type() == GainAutomation) {
pre_fader = false;
(*i)->set_position (ProcessorEntry::Fader, num++);
} else {
}
}
}
+ setup_routing_feeds ();
}
void
(boost::dynamic_pointer_cast<Return>((*i)) != 0)) {
node->add_child_nocopy ((*i)->get_state());
}
- }
+ }
_rr_selection.set (node);
}
}
p.reset (pi);
-
} else {
/* XXX its a bit limiting to assume that everything else
is a plugin.
*/
p.reset (new PluginInsert (*_session));
+ /* we can't use RAII Stateful::ForceIDRegeneration
+ * because that'd void copying the state and wrongly bump
+ * the state-version counter.
+ * we need to load the state (incl external files) first and
+ * only then update the ID)
+ */
PBD::ID id = p->id();
- p->set_state (**niter, Stateful::current_state_version);
+ /* strip side-chain state (processor inside processor must be a side-chain)
+ * otherwise we'll end up with duplicate ports-names.
+ * (this needs a better solution which retains connections)
+ * We really would want Stateful::ForceIDRegeneration here :(
+ */
+ XMLNode state (**niter);
+ state.remove_nodes ("Processor");
+
+ p->set_state (state, Stateful::current_state_version);
boost::dynamic_pointer_cast<PluginInsert>(p)->update_id (id);
}
}
}
- if (boost::dynamic_pointer_cast<Amp> (processor) && boost::dynamic_pointer_cast<Amp> (processor)->type() == X_("amp")) {
+ if (boost::dynamic_pointer_cast<Amp> (processor) && boost::dynamic_pointer_cast<Amp> (processor)->gain_control()->parameter().type() == GainAutomation) {
if (_parent_strip) {
_parent_strip->revert_to_default_display ();
void
ProcessorBox::register_actions ()
{
- Glib::RefPtr<Gtk::ActionGroup> popup_act_grp = Gtk::ActionGroup::create(X_("ProcessorMenu"));
+ processor_box_actions = myactions.create_action_group (X_("ProcessorMenu"));
+
Glib::RefPtr<Action> act;
/* new stuff */
- ActionManager::register_action (popup_act_grp, X_("newplugin"), _("New Plugin"),
+ myactions.register_action (processor_box_actions, X_("newplugin"), _("New Plugin"),
sigc::ptr_fun (ProcessorBox::rb_choose_plugin));
- act = ActionManager::register_action (popup_act_grp, X_("newinsert"), _("New Insert"),
+ act = myactions.register_action (processor_box_actions, X_("newinsert"), _("New Insert"),
sigc::ptr_fun (ProcessorBox::rb_choose_insert));
ActionManager::engine_sensitive_actions.push_back (act);
- act = ActionManager::register_action (popup_act_grp, X_("newsend"), _("New External Send ..."),
+ act = myactions.register_action (processor_box_actions, X_("newsend"), _("New External Send ..."),
sigc::ptr_fun (ProcessorBox::rb_choose_send));
ActionManager::engine_sensitive_actions.push_back (act);
- ActionManager::register_action (popup_act_grp, X_("newaux"), _("New Aux Send ..."));
+ myactions.register_action (processor_box_actions, X_("newaux"), _("New Aux Send ..."));
- ActionManager::register_action (popup_act_grp, X_("controls"), _("Controls"));
- ActionManager::register_action (popup_act_grp, X_("send_options"), _("Send Options"));
+ myactions.register_action (processor_box_actions, X_("controls"), _("Controls"));
+ myactions.register_action (processor_box_actions, X_("send_options"), _("Send Options"));
- ActionManager::register_action (popup_act_grp, X_("clear"), _("Clear (all)"),
+ myactions.register_action (processor_box_actions, X_("clear"), _("Clear (all)"),
sigc::ptr_fun (ProcessorBox::rb_clear));
- ActionManager::register_action (popup_act_grp, X_("clear_pre"), _("Clear (pre-fader)"),
+ myactions.register_action (processor_box_actions, X_("clear_pre"), _("Clear (pre-fader)"),
sigc::ptr_fun (ProcessorBox::rb_clear_pre));
- ActionManager::register_action (popup_act_grp, X_("clear_post"), _("Clear (post-fader)"),
+ myactions.register_action (processor_box_actions, X_("clear_post"), _("Clear (post-fader)"),
sigc::ptr_fun (ProcessorBox::rb_clear_post));
/* standard editing stuff */
- cut_action = ActionManager::register_action (popup_act_grp, X_("cut"), _("Cut"),
- sigc::ptr_fun (ProcessorBox::rb_cut));
- copy_action = ActionManager::register_action (popup_act_grp, X_("copy"), _("Copy"),
- sigc::ptr_fun (ProcessorBox::rb_copy));
- delete_action = ActionManager::register_action (popup_act_grp, X_("delete"), _("Delete"),
- sigc::ptr_fun (ProcessorBox::rb_delete));
-
- paste_action = ActionManager::register_action (popup_act_grp, X_("paste"), _("Paste"),
+
+ cut_action = myactions.register_action (processor_box_actions, X_("cut"), _("Cut"),
+ sigc::ptr_fun (ProcessorBox::rb_cut));
+ copy_action = myactions.register_action (processor_box_actions, X_("copy"), _("Copy"),
+ sigc::ptr_fun (ProcessorBox::rb_copy));
+ delete_action = myactions.register_action (processor_box_actions, X_("delete"), _("Delete"),
+ sigc::ptr_fun (ProcessorBox::rb_delete));
+ backspace_action = myactions.register_action (processor_box_actions, X_("backspace"), _("Delete"),
+ sigc::ptr_fun (ProcessorBox::rb_delete));
+
+ ActionManager::plugin_selection_sensitive_actions.push_back (cut_action);
+ ActionManager::plugin_selection_sensitive_actions.push_back (copy_action);
+ ActionManager::plugin_selection_sensitive_actions.push_back (delete_action);
+ ActionManager::plugin_selection_sensitive_actions.push_back (backspace_action);
+
+ paste_action = myactions.register_action (processor_box_actions, X_("paste"), _("Paste"),
sigc::ptr_fun (ProcessorBox::rb_paste));
- rename_action = ActionManager::register_action (popup_act_grp, X_("rename"), _("Rename"),
+ rename_action = myactions.register_action (processor_box_actions, X_("rename"), _("Rename"),
sigc::ptr_fun (ProcessorBox::rb_rename));
- ActionManager::register_action (popup_act_grp, X_("selectall"), _("Select All"),
+ myactions.register_action (processor_box_actions, X_("selectall"), _("Select All"),
sigc::ptr_fun (ProcessorBox::rb_select_all));
- ActionManager::register_action (popup_act_grp, X_("deselectall"), _("Deselect All"),
+ myactions.register_action (processor_box_actions, X_("deselectall"), _("Deselect All"),
sigc::ptr_fun (ProcessorBox::rb_deselect_all));
/* activation etc. */
- ActionManager::register_action (popup_act_grp, X_("activate_all"), _("Activate All"),
+ myactions.register_action (processor_box_actions, X_("activate_all"), _("Activate All"),
sigc::ptr_fun (ProcessorBox::rb_activate_all));
- ActionManager::register_action (popup_act_grp, X_("deactivate_all"), _("Deactivate All"),
+ myactions.register_action (processor_box_actions, X_("deactivate_all"), _("Deactivate All"),
sigc::ptr_fun (ProcessorBox::rb_deactivate_all));
- ActionManager::register_action (popup_act_grp, X_("ab_plugins"), _("A/B Plugins"),
+ myactions.register_action (processor_box_actions, X_("ab_plugins"), _("A/B Plugins"),
sigc::ptr_fun (ProcessorBox::rb_ab_plugins));
+ manage_pins_action = myactions.register_action (
+ processor_box_actions, X_("manage-pins"), _("Pin Connections..."),
+ sigc::ptr_fun (ProcessorBox::rb_manage_pins));
+
/* show editors */
- edit_action = ActionManager::register_action (
- popup_act_grp, X_("edit"), _("Edit..."),
+ edit_action = myactions.register_action (
+ processor_box_actions, X_("edit"), _("Edit..."),
sigc::ptr_fun (ProcessorBox::rb_edit));
- edit_generic_action = ActionManager::register_action (
- popup_act_grp, X_("edit-generic"), _("Edit with generic controls..."),
+ edit_generic_action = myactions.register_action (
+ processor_box_actions, X_("edit-generic"), _("Edit with generic controls..."),
sigc::ptr_fun (ProcessorBox::rb_edit_generic));
- ActionManager::add_action_group (popup_act_grp);
+ load_bindings ();
}
void
_current_processor_box->ab_plugins ();
}
+void
+ProcessorBox::rb_manage_pins ()
+{
+ if (_current_processor_box == 0) {
+ return;
+ }
+
+ _current_processor_box->for_selected_processors (&ProcessorBox::manage_pins);
+}
void
ProcessorBox::rb_choose_plugin ()
{
if (edit_aux_send (processor)) {
return;
}
+ if (!_session->engine().connected()) {
+ return;
+ }
ProcessorWindowProxy* proxy = find_window_proxy (processor);
if (proxy) {
proxy->set_custom_ui_mode (true);
- proxy->toggle ();
+ proxy->show_the_right_window ();
}
}
if (edit_aux_send (processor)) {
return;
}
+ if (!_session->engine().connected()) {
+ return;
+ }
ProcessorWindowProxy* proxy = find_window_proxy (processor);
if (proxy) {
proxy->set_custom_ui_mode (false);
- proxy->toggle ();
+ proxy->show_the_right_window ();
+ }
+}
+
+void
+ProcessorBox::manage_pins (boost::shared_ptr<Processor> processor)
+{
+ if (!processor) {
+ return;
+ }
+ PluginPinWindowProxy* proxy = processor->pinmgr_proxy ();
+ if (proxy) {
+ proxy->get (true);
+ proxy->present();
}
}
+
void
ProcessorBox::route_property_changed (const PropertyChange& what_changed)
{
for (list<ProcessorEntry*>::iterator iter = children.begin(); iter != children.end(); ++iter) {
- processor = (*iter)->processor ();
+ processor = (*iter)->processor ();
if (!processor) {
continue;
ProcessorBox::processor_menu_unmapped ()
{
processor_display.remove_placeholder ();
+ /* make all possibly-desensitized actions sensitive again so that
+ they be activated by other means (e.g. bindings)
+ */
+ ActionManager::set_sensitive (ActionManager::plugin_selection_sensitive_actions, true);
}
XMLNode *
}
XMLNode&
-ProcessorWindowProxy::get_state () const
+ProcessorWindowProxy::get_state ()
{
XMLNode *node;
node = &ProxyBase::get_state();
return *node;
}
-void
-ProcessorWindowProxy::set_state (const XMLNode& node)
+int
+ProcessorWindowProxy::set_state (const XMLNode& node, int /*version*/)
{
XMLNodeList children = node.children ();
XMLNodeList::const_iterator i = children.begin ();
while (i != children.end()) {
- XMLProperty* prop = (*i)->property (X_("name"));
+ XMLProperty const * prop = (*i)->property (X_("name"));
if ((*i)->name() == X_("Window") && prop && prop->value() == _name) {
break;
}
}
if (i != children.end()) {
- XMLProperty* prop;
+ XMLProperty const * prop;
if ((prop = (*i)->property (X_("custom-ui"))) != 0) {
want_custom = PBD::string_is_affirmative (prop->value ());
}
}
- ProxyBase::set_state(node);
+ return ProxyBase::set_state (node, 0);
}
Gtk::Window*
if (_window) {
setup ();
}
+ _window->show_all ();
}
-
return _window;
}
void
-ProcessorWindowProxy::toggle ()
+ProcessorWindowProxy::show_the_right_window ()
{
if (_window && (is_custom != want_custom)) {
/* drop existing window - wrong type */
drop_window ();
}
- is_custom = want_custom;
+ toggle ();
+}
+
+
+PluginPinWindowProxy::PluginPinWindowProxy(std::string const &name, boost::weak_ptr<ARDOUR::Processor> processor)
+ : WM::ProxyBase (name, string())
+ , _processor (processor)
+{
+ boost::shared_ptr<Processor> p = _processor.lock ();
+ if (!p) {
+ return;
+ }
+ p->DropReferences.connect (going_away_connection, MISSING_INVALIDATOR, boost::bind (&PluginPinWindowProxy::processor_going_away, this), gui_context());
+}
+
+PluginPinWindowProxy::~PluginPinWindowProxy()
+{
+ _window = 0;
+}
+
+ARDOUR::SessionHandlePtr*
+PluginPinWindowProxy::session_handle ()
+{
+ ArdourWindow* aw = dynamic_cast<ArdourWindow*> (_window);
+ if (aw) { return aw; }
+ return 0;
+}
+
+Gtk::Window*
+PluginPinWindowProxy::get (bool create)
+{
+ boost::shared_ptr<Processor> p = _processor.lock ();
+ boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (p);
+ if (!p || !pi) {
+ return 0;
+ }
+
+ if (!_window) {
+ if (!create) {
+ return 0;
+ }
+ _window = new PluginPinDialog (pi);
+ ArdourWindow* aw = dynamic_cast<ArdourWindow*> (_window);
+ if (aw) {
+ aw->set_session (_session);
+ }
+ _window->show_all ();
+ }
+ return _window;
+}
+
+void
+PluginPinWindowProxy::processor_going_away ()
+{
+ delete _window;
+ _window = 0;
+ WM::Manager::instance().remove (this);
+ going_away_connection.disconnect();
+}
- WM::ProxyBase::toggle ();
+void
+ProcessorBox::load_bindings ()
+{
+ bindings = Bindings::get_bindings (X_("Processor Box"), myactions);
}