X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fprocessor_box.cc;h=c01d9e497cc976551a2ae5652f86d7e9e4b29224;hb=a450024c56a6a023a985adea4c542f9cc02dd6f3;hp=4271f313fd127bc948a3bd5cd7e3a1869679cc42;hpb=9010262bed21611f2db652d16f63e4af4380259d;p=ardour.git

diff --git a/gtk2_ardour/processor_box.cc b/gtk2_ardour/processor_box.cc
index 4271f313fd..c01d9e497c 100644
--- a/gtk2_ardour/processor_box.cc
+++ b/gtk2_ardour/processor_box.cc
@@ -28,8 +28,10 @@
 #include <sigc++/bind.h>
 
 #include "pbd/convert.h"
+#include "canvas/utils.h"
 
 #include <glibmm/miscutils.h>
+#include <glibmm/fileutils.h>
 
 #include <gtkmm/messagedialog.h>
 
@@ -45,6 +47,8 @@
 #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"
@@ -57,14 +61,18 @@
 #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"
@@ -72,12 +80,13 @@
 #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;
@@ -94,29 +103,54 @@ using namespace Gtk;
 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;
+
+
+// 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
 
-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 ();
 
@@ -141,20 +175,41 @@ ProcessorEntry::ProcessorEntry (ProcessorBox* parent, boost::shared_ptr<Processo
 	}
 	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());
@@ -181,12 +236,6 @@ ProcessorEntry::ProcessorEntry (ProcessorBox* parent, boost::shared_ptr<Processo
 			}
 		}
 
-		_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 {
@@ -199,6 +248,7 @@ ProcessorEntry::~ProcessorEntry ()
 	for (list<Control*>::iterator i = _controls.begin(); i != _controls.end(); ++i) {
 		delete *i;
 	}
+	delete _plugin_display;
 }
 
 EventBox&
@@ -218,6 +268,40 @@ ProcessorEntry::drag_text () const
 {
 	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)
 {
@@ -278,13 +362,6 @@ 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 ();
 }
 
@@ -305,9 +382,17 @@ ProcessorEntry::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;
 
@@ -316,6 +401,7 @@ ProcessorEntry::setup_visuals ()
 		break;
 
 	case PostFader:
+		if (_plugin_display) { _plugin_display->set_name ("processor postfader"); }
 		_button.set_name ("processor postfader");
 		break;
 	}
@@ -325,6 +411,9 @@ ProcessorEntry::setup_visuals ()
 boost::shared_ptr<Processor>
 ProcessorEntry::processor () const
 {
+	if (!_processor) {
+		return boost::shared_ptr<Processor>();
+	}
 	return _processor;
 }
 
@@ -351,11 +440,11 @@ ProcessorEntry::led_clicked(GdkEventButton *ev)
 				_parent->all_visible_processors_active(false);
 
 				if (_position == Fader) {
-					_processor->deactivate ();
+					_processor->enable (false);
 				}
 			}
 			else {
-				_processor->deactivate ();
+				_processor->enable (false);
 			}
 
 		} else {
@@ -363,11 +452,11 @@ ProcessorEntry::led_clicked(GdkEventButton *ev)
 				_parent->all_visible_processors_active(true);
 
 				if (_position == Fader) {
-					_processor->activate ();
+					_processor->enable (true);
 				}
 			}
 			else {
-				_processor->activate ();
+				_processor->enable (true);
 			}
 		}
 	}
@@ -377,7 +466,7 @@ void
 ProcessorEntry::processor_active_changed ()
 {
 	if (_processor) {
-		_button.set_active (_processor->active());
+		_button.set_active (_processor->enabled ());
 	}
 }
 
@@ -393,13 +482,11 @@ ProcessorEntry::processor_property_changed (const PropertyChange& what_changed)
 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
@@ -427,6 +514,16 @@ ProcessorEntry::setup_tooltip ()
 					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>&gt; %1</b>\nThis (sidechain) send will be removed when disconnected.", _processor->name()));
+			} else {
+				ARDOUR_UI_UTILS::set_tooltip (_button, string_compose ("<b>&gt; %1</b>", _processor->name()));
+			}
+			return;
+		}
 	}
 	ARDOUR_UI_UTILS::set_tooltip (_button, string_compose ("<b>%1</b>", name (Wide)));
 }
@@ -445,19 +542,52 @@ ProcessorEntry::name (Width w) const
 	    !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;
 		}
 
@@ -510,6 +640,13 @@ ProcessorEntry::add_control_state (XMLNode* node) const
 	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
@@ -518,6 +655,18 @@ ProcessorEntry::set_control_state (XMLNode const * node)
 	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
@@ -542,6 +691,14 @@ ProcessorEntry::build_controls_menu ()
 	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))
 		);
@@ -564,6 +721,17 @@ ProcessorEntry::build_controls_menu ()
 	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)
 {
@@ -780,7 +948,7 @@ ProcessorEntry::Control::set_state (XMLNode const * node)
 {
 	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);
@@ -824,94 +992,28 @@ PluginInsertProcessorEntry::PluginInsertProcessorEntry (ProcessorBox* b, boost::
 	, _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()
 		);
-
-	plugin_insert_splitting_changed ();
 }
 
 void
-PluginInsertProcessorEntry::plugin_insert_splitting_changed ()
+PluginInsertProcessorEntry::iomap_changed ()
 {
-	ChanCount in, out; // actual configured i/o
-	_plugin_insert->configured_io (in, out);
-
-	/* 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());
-		}
-	}
-	/* 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);
-	}
-
-	/* the Input streams available (*valid* outputs from prev. plugin)
-	 * this will be <= sinks. Some input-ports of this processor
-	 * may be unconnected.
-	 */
-	_routing_icon.set_sources(in);
-
-	/* the actual input ports of this processor */
-	_input_icon.set_ports(sinks);
-	_routing_icon.set_sinks(sinks);
-
-	/* 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())
-	 */
-	_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;
-	}
-#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();
-	} else {
-		_routing_icon.set_visible(false);
-		if (_position_num != 0) {
-			_input_icon.hide();
-		}
-	}
-
-	_input_icon.queue_draw();
-	_output_icon.queue_draw();
-	_routing_icon.queue_draw();
+	_parent->setup_routing_feeds ();
+	routing_icon.queue_draw();
+	output_routing_icon.queue_draw();
 }
 
 void
 PluginInsertProcessorEntry::hide_things ()
 {
 	ProcessorEntry::hide_things ();
-	plugin_insert_splitting_changed ();
 }
 
 ProcessorEntry::PortIcon::PortIcon(bool input) {
@@ -939,45 +1041,224 @@ ProcessorEntry::PortIcon::on_expose_event (GdkEventExpose* ev)
 	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));
-		}
-		const float x = rintf(width * .5);
-		cairo_rectangle (cr, x-dx * .5, 0, 1+dx, height);
+	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_stroke(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;
+}
+
+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
+ProcessorEntry::RoutingIcon::set_fed_by (
+				const ARDOUR::ChanCount& out,
+				const ARDOUR::ChanCount& sources,
+				const ARDOUR::ChanMapping& out_map,
+				const ARDOUR::ChanMapping& thru_map)
+{
+	_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)
 {
@@ -986,7 +1267,6 @@ ProcessorEntry::RoutingIcon::on_expose_event (GdkEventExpose* ev)
 	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();
@@ -999,115 +1279,470 @@ ProcessorEntry::RoutingIcon::on_expose_event (GdkEventExpose* ev)
 	cairo_rectangle (cr, 0, 0, width, height);
 	cairo_fill (cr);
 
-	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);
+	if (_input) {
+		if (can_coalesce ()) {
+			expose_coalesced_input_map (cr, width, height);
+		} else {
+			expose_input_map (cr, width, height);
 		}
-	} 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
+	} else {
+		expose_output_map (cr, width, height);
 	}
 
-	/* 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);
+	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;
 		}
-	} 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);
+		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;
 		}
-	} else if (audio_sources == 1 && audio_sinks > 0) {
-		float si_x, si_x0;
-		if (sinks == 1) {
-			si_x = rintf(width * .5f) + .5f;
+		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 {
-			si_x = rintf(width * (.2f + .6f * midi_sinks / (sinks - 1.f))) + .5f;
+			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);
+	}
+}
+
+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;
 		}
-		if (sources == 1) {
-			si_x0 = rintf(width * .5f) + .5f;
+		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 {
-			si_x0 = rintf(width * (.2f + .6f * midi_sources / (sources - 1.f))) + .5f;
+			// 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);
+				}
+			}
+
+			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);
 		}
-		cairo_move_to (cr, si_x, height);
-		cairo_curve_to (cr, si_x, 0, si_x0, height, si_x0, 0);
-		cairo_stroke (cr);
-#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;
-#endif
 	}
+}
+
+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 ]
+	 */
+	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;
+}
+
+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;
+	}
+
+	/* 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().
+	 */
+	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);
+	}
+
+	if (cairo_image_surface_get_stride (_surf) == dis->stride) {
+		memcpy (cairo_image_surface_get_data (_surf), dis->data, dis->stride * dis->height);
+	} else {
+		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;
+		}
+	}
+
+	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);
+
+	return dis->height;
+}
+
+bool
+ProcessorEntry::PluginDisplay::on_expose_event (GdkEventExpose* ev)
+{
+	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);
+
+	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 ();
+		}
+		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;
 }
 
+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)
+{
+	p->setup_lua_inline_gui (&lua_gui);
+
+	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);
+}
+
+ProcessorEntry::LuaPluginDisplay::~LuaPluginDisplay ()
+{
+	delete (_lua_render_inline);
+}
+
+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);
+		lua_gui.collect_garbage_step ();
+		if (rv.isTable ()) {
+			uint32_t h = rv[2];
+			return h;
+		}
+	} catch (luabridge::LuaException const& e) {
+#ifndef NDEBUG
+		cerr << "LuaException:" << e.what () << endl;
+#endif
+	}
+	return 0;
+}
+
+
 static std::list<Gtk::TargetEntry> drop_targets()
 {
 	std::list<Gtk::TargetEntry> tmp;
 	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 ("PluginPresetPtr")); // from sidebar
+	tmp.push_back (Gtk::TargetEntry ("PluginFavoritePtr")); // from sidebar
 	return tmp;
 }
 
@@ -1137,10 +1772,16 @@ ProcessorBox::ProcessorBox (ARDOUR::Session* sess, boost::function<PluginSelecto
 	, _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;
@@ -1271,7 +1912,7 @@ ProcessorBox::_drop_plugin_preset (Gtk::SelectionData const &data, Route::Proces
 
 			boost::shared_ptr<Processor> processor (new PluginInsert (*_session, p));
 			if (Config->get_new_plugins_active ()) {
-				processor->activate ();
+				processor->enable (true);
 			}
 			pl.push_back (processor);
 		}
@@ -1294,7 +1935,7 @@ ProcessorBox::_drop_plugin (Gtk::SelectionData const &data, Route::ProcessorList
 			}
 			boost::shared_ptr<Processor> processor (new PluginInsert (*_session, p));
 			if (Config->get_new_plugins_active ()) {
-				processor->activate ();
+				processor->enable (true);
 			}
 			pl.push_back (processor);
 		}
@@ -1313,7 +1954,7 @@ ProcessorBox::plugin_drop (Gtk::SelectionData const &data, ProcessorEntry* posit
 	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 {
@@ -1334,6 +1975,28 @@ not match the configuration of this track.");
 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 ();
@@ -1470,19 +2133,22 @@ ProcessorBox::show_processor_menu (int arg)
 		}
 	}
 
-	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);
 		}
 	}
 
@@ -1495,6 +2161,7 @@ ProcessorBox::show_processor_menu (int arg)
 	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 ());
@@ -1504,6 +2171,8 @@ ProcessorBox::show_processor_menu (int arg)
 		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 ());
 
@@ -1530,13 +2199,25 @@ ProcessorBox::show_processor_menu (int arg)
 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;
 }
 
@@ -1560,8 +2241,9 @@ ProcessorBox::processor_operation (ProcessorOperation op)
 	}
 */
 
-	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:
@@ -1602,11 +2284,7 @@ ProcessorBox::processor_operation (ProcessorOperation op)
 
 	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;
 
@@ -1692,18 +2370,13 @@ ProcessorBox::processor_button_release_event (GdkEventButton *ev, ProcessorEntry
 				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;
@@ -1749,8 +2422,10 @@ ProcessorBox::use_plugins (const SelectedPlugins& plugins)
 			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 {
@@ -1819,11 +2494,10 @@ ProcessorBox::choose_insert ()
 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())
+	ChanCount outs = (_route->n_outputs().n_audio() && _session->master_out())
 			? _session->master_out()->n_outputs()
 			: _route->n_outputs();
 
@@ -1876,9 +2550,6 @@ ProcessorBox::send_io_finished (IOSelector::Result r, boost::weak_ptr<Processor>
 
 	case IOSelector::Accepted:
 		_route->add_processor_by_index (processor, _placement);
-		if (Profile->get_sae()) {
-			processor->activate ();
-		}
 		break;
 	}
 
@@ -1904,9 +2575,6 @@ ProcessorBox::return_io_finished (IOSelector::Result r, boost::weak_ptr<Processo
 
 	case IOSelector::Accepted:
 		_route->add_processor_by_index (processor, _placement);
-		if (Profile->get_sae()) {
-			processor->activate ();
-		}
 		break;
 	}
 
@@ -1960,6 +2628,8 @@ ProcessorBox::redisplay_processors ()
 
 	_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 ();
 }
 
@@ -2015,6 +2685,26 @@ ProcessorBox::maybe_add_processor_to_ui_list (boost::weak_ptr<Processor> w)
 	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)
 {
@@ -2027,7 +2717,7 @@ ProcessorBox::help_count_visible_prefader_processors (boost::weak_ptr<Processor>
 	                 )
 	   ) {
 
-		if (boost::dynamic_pointer_cast<Amp>(processor) && 
+		if (boost::dynamic_pointer_cast<Amp>(processor) &&
 		    boost::dynamic_pointer_cast<Amp>(processor)->gain_control()->parameter().type() == GainAutomation) {
 			*amp_seen = true;
 		} else {
@@ -2110,6 +2800,136 @@ ProcessorBox::reordered ()
 	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 ()
 {
@@ -2118,7 +2938,7 @@ 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()) && 
+		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++);
@@ -2130,6 +2950,7 @@ ProcessorBox::setup_entry_positions ()
 			}
 		}
 	}
+	setup_routing_feeds ();
 }
 
 void
@@ -2292,7 +3113,7 @@ ProcessorBox::copy_processors (const ProcSelection& to_be_copied)
 		    (boost::dynamic_pointer_cast<Return>((*i)) != 0)) {
 			node->add_child_nocopy ((*i)->get_state());
 		}
-  	}
+	}
 
 	_rr_selection.set (node);
 }
@@ -2520,14 +3341,27 @@ ProcessorBox::paste_processor_state (const XMLNodeList& nlist, boost::shared_ptr
 				}
 
 				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);
 			}
 
@@ -2800,68 +3634,81 @@ ProcessorBox::get_generic_editor_window (boost::shared_ptr<Processor> processor)
 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
@@ -2884,6 +3731,15 @@ ProcessorBox::rb_ab_plugins ()
 	_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 ()
 {
@@ -3077,12 +3933,15 @@ ProcessorBox::edit_processor (boost::shared_ptr<Processor> processor)
 	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 ();
 	}
 }
 
@@ -3095,15 +3954,32 @@ ProcessorBox::generic_edit_processor (boost::shared_ptr<Processor> processor)
 	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)
 {
@@ -3121,7 +3997,7 @@ 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;
@@ -3227,6 +4103,10 @@ void
 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 *
@@ -3319,7 +4199,7 @@ 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;
 		}
@@ -3327,7 +4207,7 @@ ProcessorWindowProxy::set_state (const XMLNode& node, int /*version*/)
 	}
 
 	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 ());
 		}
@@ -3360,19 +4240,80 @@ ProcessorWindowProxy::get (bool create)
 		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;
+	}
 
-	WM::ProxyBase::toggle ();
+	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();
+}
+
+void
+ProcessorBox::load_bindings ()
+{
+	bindings = Bindings::get_bindings (X_("Processor Box"), myactions);
 }