merge 3.0-panexp (pan experiments) branch, revisions 8534-8585 into 3.0, thus ending 3.0-panexp. THIS COMMIT WILL BREAK ALL EXISTING 3.0 SESSIONS IN SOME WAY (possibly not fatally).

git-svn-id: svn://localhost/ardour2/branches/3.0@8586 d708f5d6-7413-0410-9779-e7cbd77b26cf

19 files changed, 159 insertions, 349 deletions

diff --git a/gtk2_ardour/about.cc b/gtk2_ardour/about.cc
index 7eb33f02df..8f4d6e0526 100644
--- a/gtk2_ardour/about.cc
+++ b/gtk2_ardour/about.cc
@@ -165,6 +165,7 @@ static const char* authors[] = {
 	N_("Petter Sundlöf"),
 	N_("Mike Täht"),
 	N_("Thorsten Wilms"),
+        N_("Robin Gareus"),
 	0
 };
 
diff --git a/gtk2_ardour/ardev_common.sh.in b/gtk2_ardour/ardev_common.sh.in
index 44dc3445c7..116a6d88fc 100644
--- a/gtk2_ardour/ardev_common.sh.in
+++ b/gtk2_ardour/ardev_common.sh.in
@@ -6,6 +6,7 @@ libs=$TOP/@LIBS@
 
 export ARDOUR_PATH=$TOP/gtk2_ardour/icons:$TOP/gtk2_ardour/pixmaps:$TOP/build/default/gtk2_ardour:$TOP/gtk2_ardour:.
 export ARDOUR_SURFACES_PATH=$libs/surfaces/osc:$libs/surfaces/generic_midi:$libs/surfaces/tranzport:$libs/surfaces/powermate:$libs/surfaces/mackie
+export ARDOUR_PANNER_PATH=$libs/panners/2in2out:$libs/panners/1in2out:$libs/panners/vbap
 export ARDOUR_DATA_PATH=$TOP/gtk2_ardour:build/default/gtk2_ardour:.
 
 if test -d $HOME/gtk/inst ; then
diff --git a/gtk2_ardour/audio_time_axis.cc b/gtk2_ardour/audio_time_axis.cc
index d791290562..fcdc4bbdfa 100644
--- a/gtk2_ardour/audio_time_axis.cc
+++ b/gtk2_ardour/audio_time_axis.cc
@@ -40,6 +40,7 @@
 #include "ardour/audioplaylist.h"
 #include "ardour/event_type_map.h"
 #include "ardour/location.h"
+#include "ardour/pannable.h"
 #include "ardour/panner.h"
 #include "ardour/playlist.h"
 #include "ardour/processor.h"
@@ -191,7 +192,9 @@ AudioTimeAxisView::create_automation_child (const Evoral::Parameter& param, bool
 
 		create_gain_automation_child (param, show);
 
-	} else if (param.type() == PanAutomation) {
+	} else if (param.type() == PanWidthAutomation ||
+                   param.type() == PanElevationAutomation ||
+                   param.type() == PanAzimuthAutomation) {
 
 		ensure_xml_node ();
 		ensure_pan_views (show);
@@ -217,13 +220,11 @@ AudioTimeAxisView::ensure_pan_views (bool show)
 		return;
 	}
 
-	const set<Evoral::Parameter>& params = _route->panner()->what_can_be_automated();
+	set<Evoral::Parameter> params = _route->panner()->what_can_be_automated();
 	set<Evoral::Parameter>::iterator p;
 
 	for (p = params.begin(); p != params.end(); ++p) {
-		boost::shared_ptr<ARDOUR::AutomationControl> pan_control
-			= boost::dynamic_pointer_cast<ARDOUR::AutomationControl>(
-				_route->panner()->control(*p));
+		boost::shared_ptr<ARDOUR::AutomationControl> pan_control = _route->pannable()->automation_control(*p);
 
 		if (pan_control->parameter().type() == NullAutomation) {
 			error << "Pan control has NULL automation type!" << endmsg;
@@ -238,7 +239,9 @@ AudioTimeAxisView::ensure_pan_views (bool show)
 
 			boost::shared_ptr<AutomationTimeAxisView> t (
 				new AutomationTimeAxisView (_session,
-							    _route, _route->panner(), pan_control,
+							    _route, 
+                                                            _route->pannable(), 
+                                                            pan_control,
 							    _editor,
 							    *this,
 							    false,
@@ -442,7 +445,7 @@ AudioTimeAxisView::build_automation_action_menu ()
 	pan_automation_item = dynamic_cast<CheckMenuItem*> (&automation_items.back ());
 	pan_automation_item->set_active (pan_tracks.front()->marked_for_display ());
 
-	set<Evoral::Parameter> const & params = _route->panner()->what_can_be_automated ();
+	set<Evoral::Parameter> const & params = _route->pannable()->what_can_be_automated ();
 	for (set<Evoral::Parameter>::iterator p = params.begin(); p != params.end(); ++p) {
 		_main_automation_menu_map[*p] = pan_automation_item;
 	}
diff --git a/gtk2_ardour/automation_controller.cc b/gtk2_ardour/automation_controller.cc
index 3af5f34445..f09fae905b 100644
--- a/gtk2_ardour/automation_controller.cc
+++ b/gtk2_ardour/automation_controller.cc
@@ -27,6 +27,7 @@
 #include "ardour/event_type_map.h"
 #include "ardour/automatable.h"
 #include "ardour/panner.h"
+#include "ardour/pan_controllable.h"
 #include "ardour/session.h"
 
 #include "ardour_ui.h"
@@ -90,8 +91,6 @@ AutomationController::get_label (int&)
 	// Hack to display CC rounded to int
 	if (_controllable->parameter().type() == MidiCCAutomation) {
 		s << (int)_controllable->get_value();
-	} else if (_controllable->parameter().type() == PanAutomation) {
-		s << Panner::value_as_string (_controllable->get_value ());
 	} else {
 		s << std::fixed << std::setprecision(3) << _controllable->get_value();
 	}
diff --git a/gtk2_ardour/automation_line.cc b/gtk2_ardour/automation_line.cc
index a8125c0818..45b9573f71 100644
--- a/gtk2_ardour/automation_line.cc
+++ b/gtk2_ardour/automation_line.cc
@@ -1204,8 +1204,9 @@ AutomationLine::view_to_model_coord_y (double& y) const
 		y = slider_position_to_gain (y);
 		y = max (0.0, y);
 		y = min (2.0, y);
-	} else if (alist->parameter().type() == PanAutomation) {
-		// vertical coordinate axis reversal
+	} else if (alist->parameter().type() == PanAzimuthAutomation ||
+                   alist->parameter().type() == PanElevationAutomation ||
+                   alist->parameter().type() == PanWidthAutomation) {
 		y = 1.0 - y;
 	} else if (alist->parameter().type() == PluginAutomation) {
 		y = y * (double)(alist->get_max_y()- alist->get_min_y()) + alist->get_min_y();
@@ -1221,7 +1222,9 @@ AutomationLine::model_to_view_coord (double& x, double& y) const
 	if (alist->parameter().type() == GainAutomation ||
 	    alist->parameter().type() == EnvelopeAutomation) {
 		y = gain_to_slider_position (y);
-	} else if (alist->parameter().type() == PanAutomation) {
+	} else if (alist->parameter().type() == PanAzimuthAutomation ||
+                   alist->parameter().type() == PanElevationAutomation ||
+                   alist->parameter().type() == PanWidthAutomation) {
 		// vertical coordinate axis reversal
 		y = 1.0 - y;
 	} else if (alist->parameter().type() == PluginAutomation) {
diff --git a/gtk2_ardour/editor.h b/gtk2_ardour/editor.h
index b14c5f20e7..aca4015083 100644
--- a/gtk2_ardour/editor.h
+++ b/gtk2_ardour/editor.h
@@ -639,6 +639,7 @@ class Editor : public PublicEditor, public PBD::ScopedConnectionList, public ARD
 
 	void set_selected_track (TimeAxisView&, Selection::Operation op = Selection::Set, bool no_remove=false);
 	void select_all_tracks ();
+        void select_all_internal_edit (Selection::Operation);
 
 	bool set_selected_control_point_from_click (Selection::Operation op = Selection::Set, bool no_remove=false);
 	void set_selected_track_from_click (bool press, Selection::Operation op = Selection::Set, bool no_remove=false);
diff --git a/gtk2_ardour/editor_mouse.cc b/gtk2_ardour/editor_mouse.cc
index 0c8da2bf1b..d1d9afc985 100644
--- a/gtk2_ardour/editor_mouse.cc
+++ b/gtk2_ardour/editor_mouse.cc
@@ -2628,11 +2628,6 @@ Editor::set_internal_edit (bool yn)
 		ARDOUR_UI::instance()->set_tip (mouse_select_button, _("Draw/Edit MIDI Notes"));
 		mouse_mode_toggled (mouse_mode);
 
-		/* deselect everything to avoid confusion when e.g. we can't now cut a previously selected
-		   region because cut means "cut note" rather than "cut region".
-		*/
-		selection->clear ();
-
 	} else {
 
 		mouse_select_button.set_image (*(manage (new Image (::get_icon("tool_range")))));
diff --git a/gtk2_ardour/editor_selection.cc b/gtk2_ardour/editor_selection.cc
index 482a778ae7..3212c93bb7 100644
--- a/gtk2_ardour/editor_selection.cc
+++ b/gtk2_ardour/editor_selection.cc
@@ -37,6 +37,7 @@
 #include "control_point.h"
 #include "editor_regions.h"
 #include "editor_cursors.h"
+#include "midi_region_view.h"
 
 #include "i18n.h"
 
@@ -1213,10 +1214,26 @@ Editor::select_all_in_track (Selection::Operation op)
 }
 
 void
+Editor::select_all_internal_edit (Selection::Operation op)
+{
+        /* currently limited to MIDI only */
+
+	for (MidiRegionSelection::iterator i = selection->midi_regions.begin(); i != selection->midi_regions.end(); ++i) {
+		MidiRegionView* mrv = *i;
+		mrv->select_all_notes ();
+	}
+}
+
+void
 Editor::select_all (Selection::Operation op)
 {
 	list<Selectable *> touched;
 
+        if (_internal_editing) {
+                select_all_internal_edit (op);
+                return;
+        }
+
 	for (TrackViewList::iterator iter = track_views.begin(); iter != track_views.end(); ++iter) {
 		if ((*iter)->hidden()) {
 			continue;
diff --git a/gtk2_ardour/midi_region_view.cc b/gtk2_ardour/midi_region_view.cc
index fd2d629a09..60e07c17e0 100644
--- a/gtk2_ardour/midi_region_view.cc
+++ b/gtk2_ardour/midi_region_view.cc
@@ -1874,6 +1874,16 @@ MidiRegionView::unique_select(ArdourCanvas::CanvasNoteEvent* ev)
 }
 
 void
+MidiRegionView::select_all_notes ()
+{
+        clear_selection ();
+
+	for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
+                add_to_selection (*i);
+        }
+}
+
+void
 MidiRegionView::select_matching_notes (uint8_t notenum, uint16_t channel_mask, bool add, bool extend)
 {
 	uint8_t low_note = 127;
diff --git a/gtk2_ardour/midi_region_view.h b/gtk2_ardour/midi_region_view.h
index 846b1651a1..edf418afb4 100644
--- a/gtk2_ardour/midi_region_view.h
+++ b/gtk2_ardour/midi_region_view.h
@@ -191,6 +191,7 @@ class MidiRegionView : public RegionView
 	void   delete_selection();
 	void   delete_note (boost::shared_ptr<NoteType>);
 	size_t selection_size() { return _selection.size(); }
+        void   select_all_notes ();
 
 	void move_selection(double dx, double dy, double cumulative_dy);
 	void note_dropped (ArdourCanvas::CanvasNoteEvent* ev, ARDOUR::frameoffset_t, int8_t d_note);
diff --git a/gtk2_ardour/mixer_strip.cc b/gtk2_ardour/mixer_strip.cc
index 8c6d612012..245b5c0072 100644
--- a/gtk2_ardour/mixer_strip.cc
+++ b/gtk2_ardour/mixer_strip.cc
@@ -40,6 +40,7 @@
 #include "ardour/route.h"
 #include "ardour/route_group.h"
 #include "ardour/audio_track.h"
+#include "ardour/pannable.h"
 #include "ardour/panner.h"
 #include "ardour/send.h"
 #include "ardour/processor.h"
@@ -967,14 +968,10 @@ MixerStrip::connect_to_pan ()
 		return;
 	}
 
-	boost::shared_ptr<ARDOUR::AutomationControl> pan_control
-		= boost::dynamic_pointer_cast<ARDOUR::AutomationControl>(
-				_route->panner()->control(Evoral::Parameter(PanAutomation)));
+        boost::shared_ptr<Pannable> p = _route->pannable ();
 
-	if (pan_control) {
-		pan_control->alist()->automation_state_changed.connect (panstate_connection, invalidator (*this), boost::bind (&PannerUI::pan_automation_state_changed, &panners), gui_context());
-		pan_control->alist()->automation_style_changed.connect (panstyle_connection, invalidator (*this), boost::bind (&PannerUI::pan_automation_style_changed, &panners), gui_context());
-	}
+        p->automation_state_changed.connect (panstate_connection, invalidator (*this), boost::bind (&PannerUI::pan_automation_state_changed, &panners), gui_context());
+        p->automation_style_changed.connect (panstyle_connection, invalidator (*this), boost::bind (&PannerUI::pan_automation_style_changed, &panners), gui_context());
 
 	panners.panner_changed (this);
 }
@@ -1598,10 +1595,10 @@ MixerStrip::reset_strip_style ()
 		if (is_midi_track()) {
 			if (_route->active()) {
 				set_name ("MidiTrackStripBase");
-				gpm.set_meter_strip_name ("MidiTrackStripBase");
+				gpm.set_meter_strip_name ("MidiTrackMetrics");
 			} else {
 				set_name ("MidiTrackStripBaseInactive");
-				gpm.set_meter_strip_name ("MidiTrackStripBaseInactive");
+				gpm.set_meter_strip_name ("MidiTrackMetricsInactive");
 			}
 			gpm.set_fader_name ("MidiTrackFader");
 		} else if (is_audio_track()) {
diff --git a/gtk2_ardour/mono_panner.cc b/gtk2_ardour/mono_panner.cc
index 93f635d970..52c417a9fd 100644
--- a/gtk2_ardour/mono_panner.cc
+++ b/gtk2_ardour/mono_panner.cc
@@ -32,6 +32,7 @@
 #include "gtkmm2ext/keyboard.h"
 
 #include "ardour/panner.h"
+#include "ardour/panner.h"
 
 #include "ardour_ui.h"
 #include "global_signals.h"
diff --git a/gtk2_ardour/panner2d.cc b/gtk2_ardour/panner2d.cc
index 0700685056..1d98ca0093 100644
--- a/gtk2_ardour/panner2d.cc
+++ b/gtk2_ardour/panner2d.cc
@@ -78,7 +78,7 @@ Panner2d::~Panner2d()
 void
 Panner2d::reset (uint32_t n_inputs)
 {
-	Targets::size_type existing_pucks = pucks.size();
+        uint32_t nouts = panner->out().n_audio();
 
 	/* pucks */
 
@@ -120,36 +120,40 @@ Panner2d::reset (uint32_t n_inputs)
 		break;
 	}
 
+#ifdef PANNER_HACKS
 	for (uint32_t i = existing_pucks; i < n_inputs; ++i) {
 		pucks[i]->position = panner->streampanner (i).get_position ();
 		pucks[i]->visible = true;
 	}
+#endif
 
 	/* add all outputs */
 
-	while (targets.size() < panner->nouts()) {
+	while (targets.size() < nouts) {
 		add_target (AngularVector());
 	}
 
-	if (targets.size() > panner->nouts()) {
-		for (uint32_t i = panner->nouts(); i < targets.size(); ++i) {
+	if (targets.size() > nouts) {
+		for (uint32_t i = nouts; i < targets.size(); ++i) {
 			delete targets[i];
 		}
 
-		targets.resize (panner->nouts ());
+		targets.resize (nouts);
 	}
 
 	for (Targets::iterator x = targets.begin(); x != targets.end(); ++x) {
 		(*x)->visible = false;
 	}
 
-	for (uint32_t n = 0; n < panner->nouts(); ++n) {
+	for (uint32_t n = 0; n < nouts; ++n) {
 		char buf[16];
 
 		snprintf (buf, sizeof (buf), "%d", n+1);
 		targets[n]->set_text (buf);
+#ifdef PANNER_HACKS
 		targets[n]->position = panner->output(n).position;
 		targets[n]->visible = true;
+#endif
 	}
 
 	queue_draw ();
@@ -201,6 +205,7 @@ Panner2d::handle_state_change ()
 void
 Panner2d::handle_position_change ()
 {
+#ifdef PANNER_HACKS 
 	uint32_t n;
 	ENSURE_GUI_THREAD (*this, &Panner2d::handle_position_change)
 
@@ -213,6 +218,7 @@ Panner2d::handle_position_change ()
 	}
 
 	queue_draw ();
+#endif
 }
 
 void
@@ -528,7 +534,9 @@ Panner2d::handle_motion (gint evx, gint evy, GdkModifierType state)
 
 			cp.angular (drag_target->position); /* sets drag target position */
 
+#ifdef PANNER_HACKS
 			panner->streampanner (drag_index).set_position (drag_target->position);
+#endif 
                         
 			queue_draw ();
 		}
diff --git a/gtk2_ardour/panner_ui.cc b/gtk2_ardour/panner_ui.cc
index 52ae16a648..79a7259b32 100644
--- a/gtk2_ardour/panner_ui.cc
+++ b/gtk2_ardour/panner_ui.cc
@@ -36,6 +36,7 @@
 #include "ardour/delivery.h"
 #include "ardour/session.h"
 #include "ardour/panner.h"
+#include "ardour/pannable.h"
 #include "ardour/route.h"
 
 #include "i18n.h"
@@ -50,13 +51,7 @@ const int PannerUI::pan_bar_height = 40;
 
 PannerUI::PannerUI (Session* s)
 	: _current_nouts (-1)
-	, _current_npans (-1)
-	, hAdjustment(0.0, 0.0, 0.0)
-	, vAdjustment(0.0, 0.0, 0.0)
-	, panning_viewport(hAdjustment, vAdjustment)
-	, panning_up_arrow (Gtk::ARROW_UP, Gtk::SHADOW_OUT)
-	, panning_down_arrow (Gtk::ARROW_DOWN, Gtk::SHADOW_OUT)
-	, panning_link_button (_("link"))
+	, _current_nins (-1)
 	, pan_automation_style_button ("")
 	, pan_automation_state_button ("")
 {
@@ -80,52 +75,13 @@ PannerUI::PannerUI (Session* s)
 	//set_size_request_to_display_given_text (pan_automation_state_button, X_("O"), 2, 2);
 	//set_size_request_to_display_given_text (pan_automation_style_button, X_("0"), 2, 2);
 
-	panning_viewport.set_name (X_("BaseFrame"));
-
-	ARDOUR_UI::instance()->set_tip (panning_link_button,
-						   _("panning link control"));
-	ARDOUR_UI::instance()->set_tip (panning_link_direction_button,
-						   _("panning link direction"));
-
 	pan_automation_style_button.unset_flags (Gtk::CAN_FOCUS);
 	pan_automation_state_button.unset_flags (Gtk::CAN_FOCUS);
 
 	pan_automation_style_button.signal_button_press_event().connect (sigc::mem_fun(*this, &PannerUI::pan_automation_style_button_event), false);
 	pan_automation_state_button.signal_button_press_event().connect (sigc::mem_fun(*this, &PannerUI::pan_automation_state_button_event), false);
 
-	panning_link_button.set_name (X_("PanningLinkButton"));
-	panning_link_direction_button.set_name (X_("PanningLinkDirectionButton"));
-
-	panning_link_box.pack_start (panning_link_button, true, true);
-	panning_link_box.pack_start (panning_link_direction_button, true, true);
-	panning_link_box.pack_start (pan_automation_state_button, true, true);
-
-	/* the pixmap will be reset at some point, but the key thing is that
-	   we need a pixmap in the button just to get started.
-	*/
-	panning_link_direction_button.add (*(manage (new Image (get_xpm("forwardblarrow.xpm")))));
-
-	panning_link_direction_button.signal_clicked().connect
-		(sigc::mem_fun(*this, &PannerUI::panning_link_direction_clicked));
-
-	panning_link_button.signal_button_press_event().connect
-		(sigc::mem_fun(*this, &PannerUI::panning_link_button_press), false);
-	panning_link_button.signal_button_release_event().connect
-		(sigc::mem_fun(*this, &PannerUI::panning_link_button_release), false);
-
-	panning_up.set_border_width (3);
-	panning_down.set_border_width (3);
-	panning_up.add (panning_up_arrow);
-	panning_down.add (panning_down_arrow);
-	panning_up.set_name (X_("PanScrollerBase"));
-	panning_down.set_name (X_("PanScrollerBase"));
-	panning_up_arrow.set_name (X_("PanScrollerArrow"));
-	panning_down_arrow.set_name (X_("PanScrollerArrow"));
-
 	pan_vbox.set_spacing (2);
-	pan_vbox.pack_start (panning_viewport, Gtk::PACK_SHRINK);
-	pan_vbox.pack_start (panning_link_box, Gtk::PACK_SHRINK);
-        
 	pack_start (pan_vbox, true, true);
 
 	twod_panner = 0;
@@ -158,18 +114,16 @@ PannerUI::set_panner (boost::shared_ptr<Panner> p)
 	}
 
 	_panner->Changed.connect (connections, invalidator (*this), boost::bind (&PannerUI::panner_changed, this, this), gui_context());
-	_panner->LinkStateChanged.connect (connections, invalidator (*this), boost::bind (&PannerUI::update_pan_linkage, this), gui_context());
 	_panner->StateChanged.connect (connections, invalidator (*this), boost::bind (&PannerUI::update_pan_state, this), gui_context());
 
         /* new panner object, force complete reset of panner GUI
          */
 
         _current_nouts = 0;
-        _current_npans = 0;
+        _current_nins = 0;
 
 	panner_changed (0);
 	update_pan_sensitive ();
-	update_pan_linkage ();
 	pan_automation_state_changed ();
 
 }
@@ -224,61 +178,6 @@ PannerUI::get_controllable()
 	return pan_bars[0]->get_controllable();
 }
 
-bool
-PannerUI::panning_link_button_press (GdkEventButton*)
-{
-	return true;
-}
-
-bool
-PannerUI::panning_link_button_release (GdkEventButton*)
-{
-	if (!ignore_toggle) {
-		_panner->set_linked (!_panner->linked());
-	}
-	return true;
-}
-
-void
-PannerUI::panning_link_direction_clicked()
-{
-	switch (_panner->link_direction()) {
-	case Panner::SameDirection:
-		_panner->set_link_direction (Panner::OppositeDirection);
-		break;
-	default:
-		_panner->set_link_direction (Panner::SameDirection);
-		break;
-	}
-}
-
-void
-PannerUI::update_pan_linkage ()
-{
-	ENSURE_GUI_THREAD (*this, &PannerUI::update_pan_linkage)
-
-	bool const x = _panner->linked();
-	bool const bx = panning_link_button.get_active();
-
-	if (x != bx) {
-
-		ignore_toggle = true;
-		panning_link_button.set_active (x);
-		ignore_toggle = false;
-	}
-
-	panning_link_direction_button.set_sensitive (x);
-
-	switch (_panner->link_direction()) {
-	case Panner::SameDirection:
-	        panning_link_direction_button.set_image (*(manage (new Image (get_xpm ("forwardblarrow.xpm")))));
-		break;
-	default:
-	        panning_link_direction_button.set_image (*(manage (new Image (get_xpm("revdblarrow.xpm")))));
-		break;
-	}
-}
-
 void
 PannerUI::on_size_allocate (Allocation& a)
 {
@@ -288,19 +187,9 @@ PannerUI::on_size_allocate (Allocation& a)
 void
 PannerUI::set_width (Width w)
 {
-	switch (w) {
-	case Wide:
-		panning_link_button.set_label (_("link"));
-		break;
-	case Narrow:
-		panning_link_button.set_label (_("L"));
-		break;
-	}
-
 	_width = w;
 }
 
-
 PannerUI::~PannerUI ()
 {
 	for (vector<MonoPanner*>::iterator i = pan_bars.begin(); i != pan_bars.end(); ++i) {
@@ -319,50 +208,13 @@ PannerUI::~PannerUI ()
 void
 PannerUI::panner_changed (void* src)
 {
-	ENSURE_GUI_THREAD (*this, &PannerUI::panner_changed)
-
 	setup_pan ();
-
-	if (src == this) {
-		return;
-	}
-
-	switch (_panner->npanners()) {
-	case 0:
-		panning_link_direction_button.set_sensitive (false);
-		panning_link_button.set_sensitive (false);
-		return;
-	case 1:
-		panning_link_direction_button.set_sensitive (false);
-		panning_link_button.set_sensitive (false);
-		break;
-	default:
-		panning_link_direction_button.set_sensitive (_panner->linked ());
-		panning_link_button.set_sensitive (true);
-	}
-
-	uint32_t const nouts = _panner->nouts();
-
-	switch (nouts) {
-	case 0:
-	case 1:
-		/* relax */
-		break;
-
-	case 2:
-		break;
-
-	default:
-		// panner->move_puck (pan_value (pans[0], pans[1]), 0.5);
-		break;
-	}
 }
 
 void
 PannerUI::update_pan_state ()
 {
 	/* currently nothing to do */
-	// ENSURE_GUI_THREAD (*this, &PannerUI::update_panner_state)
 }
 
 void
@@ -370,101 +222,81 @@ PannerUI::setup_pan ()
 {
 	if (!_panner) {
 		return;
-	}
-
-	uint32_t const nouts = _panner->nouts();
-	uint32_t const npans = _panner->npanners();
+	} 
+	uint32_t const nouts = _panner->out().n_audio();
+	uint32_t const nins = _panner->in().n_audio();
 
-	if (int32_t (nouts) == _current_nouts && int32_t (npans) == _current_npans) {
+	if (int32_t (nouts) == _current_nouts && int32_t (nins) == _current_nins) {
 		return;
 	}
 
-	_current_nouts = nouts;
-	_current_npans = npans;
-
-        panning_viewport.remove ();
+        container_clear (pan_vbox);
 
         delete twod_panner;
         twod_panner = 0;
         delete _stereo_panner;
         _stereo_panner = 0;
-
+        
 	if (nouts == 0 || nouts == 1) {
 
-		while (!pan_bars.empty()) {
-			delete pan_bars.back();
-			pan_bars.pop_back ();
-		}
+                delete _stereo_panner;
+                delete twod_panner;
 
 		/* stick something into the panning viewport so that it redraws */
 
 		EventBox* eb = manage (new EventBox());
-		panning_viewport.add (*eb);
+		pan_vbox.pack_start (*eb, false, false);
 
 	} else if (nouts == 2) {
 
-		vector<Adjustment*>::size_type p;
-
-		while (!pan_bars.empty()) {
-			delete pan_bars.back();
-			pan_bars.pop_back ();
-		}
-
-                if (npans == 2) {
+                if (nins == 2) {
 
                         /* add integrated 2in/2out panner GUI */
 
-                        _stereo_panner = new StereoPanner (_panner->direction_control(), 
-                                                           _panner->width_control());
+                        boost::shared_ptr<Pannable> pannable = _panner->pannable();
+
+                        _stereo_panner = new StereoPanner (_panner);
                         _stereo_panner->set_size_request (-1, pan_bar_height);
-                        panning_viewport.add (*_stereo_panner);
+                        pan_vbox.pack_start (*_stereo_panner, false, false);
 
                         boost::shared_ptr<AutomationControl> ac;
 
-                        ac = _panner->direction_control();
+                        ac = pannable->pan_azimuth_control;
                         _stereo_panner->StartPositionGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::start_touch), 
                                                               boost::weak_ptr<AutomationControl> (ac)));
                         _stereo_panner->StopPositionGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::stop_touch), 
                                                              boost::weak_ptr<AutomationControl>(ac)));
 
-                        ac = _panner->width_control();
+                        ac = pannable->pan_width_control;
                         _stereo_panner->StartWidthGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::start_touch), 
                                                               boost::weak_ptr<AutomationControl> (ac)));
                         _stereo_panner->StopWidthGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::stop_touch), 
                                                              boost::weak_ptr<AutomationControl>(ac)));
 
-                } else {
+                } else if (nins == 1) {
+                        /* 1-in/2out */
                         
-                        /* N-in/2out - just use a set of single-channel panners */
-
-                        while ((p = pan_bars.size()) < npans) {
-                                
-                                MonoPanner* mp;
-                                boost::shared_ptr<AutomationControl> ac = _panner->pan_control (p);
-
-                                mp = new MonoPanner (_panner->pan_control (p));
-                                
-                                mp->StartGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::start_touch), 
+                        MonoPanner* mp;
+                        boost::shared_ptr<Pannable> pannable = _panner->pannable();
+                        boost::shared_ptr<AutomationControl> ac = pannable->pan_azimuth_control;
+                        
+                        mp = new MonoPanner (ac);
+                        
+                        mp->StartGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::start_touch), 
                                                                       boost::weak_ptr<AutomationControl> (ac)));
-                                mp->StopGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::stop_touch), 
-                                                                     boost::weak_ptr<AutomationControl>(ac)));
-
-                                mp->signal_button_release_event().connect
-                                        (sigc::bind (sigc::mem_fun(*this, &PannerUI::pan_button_event), (uint32_t) p));
-                                
-                                mp->set_size_request (-1, pan_bar_height);
-                                
-                                pan_bars.push_back (mp);
-                                pan_bar_packer.pack_start (*mp, false, false);
-                        }
+                        mp->StopGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::stop_touch), 
+                                                             boost::weak_ptr<AutomationControl>(ac)));
                         
-                        /* now that we actually have the pan bars,
-                           set their sensitivity based on current
-                           automation state.
-                        */
+                        mp->signal_button_release_event().connect (sigc::mem_fun(*this, &PannerUI::pan_button_event));
+                        
+                        mp->set_size_request (-1, pan_bar_height);
                         
                         update_pan_sensitive ();
-                        panning_viewport.add (pan_bar_packer);
+                        pan_vbox.pack_start (*mp, false, false);
+
+                } else {
+                        warning << string_compose (_("No panner user interface is currently available for %1-in/2out tracks/busses"),
+                                                   nins) << endmsg;
                 }
 
 
@@ -474,24 +306,22 @@ PannerUI::setup_pan ()
 			twod_panner = new Panner2d (_panner, 61);
 			twod_panner->set_name ("MixerPanZone");
 			twod_panner->show ();
-
-			twod_panner->signal_button_press_event().connect
-				(sigc::bind (sigc::mem_fun(*this, &PannerUI::pan_button_event), (uint32_t) 0), false);
+			twod_panner->signal_button_press_event().connect (sigc::mem_fun(*this, &PannerUI::pan_button_event), false);
 		}
 
 		update_pan_sensitive ();
-		twod_panner->reset (npans);
+		twod_panner->reset (nins);
  		if (big_window) {
- 			big_window->reset (npans);
+ 			big_window->reset (nins);
  		}
 		twod_panner->set_size_request (-1, 61);
 
 		/* and finally, add it to the panner frame */
 
-		panning_viewport.add (*twod_panner);
+                pan_vbox.pack_start (*twod_panner, false, false);
 	}
 
-        panning_viewport.show_all ();
+        pan_vbox.show_all ();
 }
 
 void
@@ -515,13 +345,13 @@ PannerUI::stop_touch (boost::weak_ptr<AutomationControl> wac)
 }
 
 bool
-PannerUI::pan_button_event (GdkEventButton* ev, uint32_t which)
+PannerUI::pan_button_event (GdkEventButton* ev)
 {
 	switch (ev->button) {
 	case 1:
 		if (twod_panner && ev->type == GDK_2BUTTON_PRESS) {
 			if (!big_window) {
-				big_window = new Panner2dWindow (_panner, 400, _panner->npanners());
+				big_window = new Panner2dWindow (_panner, 400, _panner->in().n_audio());
 			}
 			big_window->show ();
 			return true;
@@ -533,7 +363,7 @@ PannerUI::pan_button_event (GdkEventButton* ev, uint32_t which)
 			pan_menu = manage (new Menu);
 			pan_menu->set_name ("ArdourContextMenu");
 		}
-		build_pan_menu (which);
+		build_pan_menu ();
 		pan_menu->popup (1, ev->time);
 		return true;
 		break;
@@ -545,21 +375,13 @@ PannerUI::pan_button_event (GdkEventButton* ev, uint32_t which)
 }
 
 void
-PannerUI::build_pan_menu (uint32_t which)
+PannerUI::build_pan_menu ()
 {
 	using namespace Menu_Helpers;
 	MenuList& items (pan_menu->items());
 
 	items.clear ();
 
-	items.push_back (CheckMenuElem (_("Mute")));
-
-	/* set state first, connect second */
-
-	(dynamic_cast<CheckMenuItem*> (&items.back()))->set_active (_panner->streampanner(which).muted());
-	(dynamic_cast<CheckMenuItem*> (&items.back()))->signal_toggled().connect
-		(sigc::bind (sigc::mem_fun(*this, &PannerUI::pan_mute), which));
-
 	items.push_back (CheckMenuElem (_("Bypass"), sigc::mem_fun(*this, &PannerUI::pan_bypass_toggle)));
 	bypass_menu_item = static_cast<CheckMenuItem*> (&items.back());
 
@@ -568,16 +390,7 @@ PannerUI::build_pan_menu (uint32_t which)
 	bypass_menu_item->set_active (_panner->bypassed());
 	bypass_menu_item->signal_toggled().connect (sigc::mem_fun(*this, &PannerUI::pan_bypass_toggle));
 
-	items.push_back (MenuElem (_("Reset"), sigc::bind (sigc::mem_fun (*this, &PannerUI::pan_reset), which)));
-	items.push_back (SeparatorElem());
-	items.push_back (MenuElem (_("Reset all"), sigc::mem_fun (*this, &PannerUI::pan_reset_all)));
-}
-
-void
-PannerUI::pan_mute (uint32_t which)
-{
-	StreamPanner& sp = _panner->streampanner(which);
-	sp.set_muted (!sp.muted());
+	items.push_back (MenuElem (_("Reset"), sigc::mem_fun (*this, &PannerUI::pan_reset)));
 }
 
 void
@@ -589,15 +402,9 @@ PannerUI::pan_bypass_toggle ()
 }
 
 void
-PannerUI::pan_reset (uint32_t which)
-{
-	_panner->reset_streampanner (which);
-}
-
-void
-PannerUI::pan_reset_all ()
+PannerUI::pan_reset ()
 {
-	_panner->reset_to_default ();
+	_panner->reset ();
 }
 
 void
@@ -617,26 +424,14 @@ PannerUI::effective_pan_display ()
 void
 PannerUI::update_pan_sensitive ()
 {
-	bool const sensitive = !(_panner->mono()) && !(_panner->automation_state() & Play);
+	bool const sensitive = !(_panner->is_mono()) && !(_panner->pannable()->automation_state() & Play);
 
-	switch (_panner->nouts()) {
-	case 0:
-	case 1:
-		break;
-	case 2:
-		for (vector<MonoPanner*>::iterator i = pan_bars.begin(); i != pan_bars.end(); ++i) {
-			(*i)->set_sensitive (sensitive);
-		}
-		break;
-	default:
-		if (twod_panner) {
-			twod_panner->set_sensitive (sensitive);
-		}
-		if (big_window) {
-			big_window->set_sensitive (sensitive);
-		}
-		break;
-	}
+#ifdef PANNER_HACKS
+        pan_vbox.set_sensitive (sensitive);
+#endif
+        if (big_window) {
+                big_window->set_sensitive (sensitive);
+        }
 }
 
 gint
@@ -700,42 +495,31 @@ PannerUI::pan_automation_style_changed ()
 void
 PannerUI::pan_automation_state_changed ()
 {
-	ENSURE_GUI_THREAD (*this, &PannerUI::pan_automation_state_changed)
-
-	bool x;
+        boost::shared_ptr<Pannable> pannable (_panner->pannable());
 
 	switch (_width) {
 	case Wide:
-	  pan_automation_state_button.set_label (astate_string(_panner->automation_state()));
+                pan_automation_state_button.set_label (astate_string(pannable->automation_state()));
 		break;
 	case Narrow:
-	  pan_automation_state_button.set_label (short_astate_string(_panner->automation_state()));
+                pan_automation_state_button.set_label (short_astate_string(pannable->automation_state()));
 		break;
 	}
 
-	/* when creating a new session, we get to create busses (and
-	   sometimes tracks) with no outputs by the time they get
-	   here.
-	*/
-
-	if (_panner->empty()) {
-		return;
-	}
-
-	x = (_panner->streampanner(0).pan_control()->alist()->automation_state() != Off);
-
+	bool x = (pannable->automation_state() != Off);
+        
 	if (pan_automation_state_button.get_active() != x) {
-	ignore_toggle = true;
+                ignore_toggle = true;
 		pan_automation_state_button.set_active (x);
 		ignore_toggle = false;
 	}
 
 	update_pan_sensitive ();
-
+        
 	/* start watching automation so that things move */
-
+        
 	pan_watching.disconnect();
-
+        
 	if (x) {
 		pan_watching = ARDOUR_UI::RapidScreenUpdate.connect (sigc::mem_fun (*this, &PannerUI::effective_pan_display));
 	}
diff --git a/gtk2_ardour/panner_ui.h b/gtk2_ardour/panner_ui.h
index 50fc6b228d..e64419b457 100644
--- a/gtk2_ardour/panner_ui.h
+++ b/gtk2_ardour/panner_ui.h
@@ -24,7 +24,6 @@
 
 #include <gtkmm/box.h>
 #include <gtkmm/adjustment.h>
-#include <gtkmm/viewport.h>
 #include <gtkmm/eventbox.h>
 #include <gtkmm/arrow.h>
 #include <gtkmm/togglebutton.h>
@@ -95,7 +94,7 @@ class PannerUI : public Gtk::HBox, public ARDOUR::SessionHandlePtr
 	bool ignore_toggle;
 	bool in_pan_update;
 	int _current_nouts;
-	int _current_npans;
+	int _current_nins;
 
 	static const int pan_bar_height;
 
@@ -103,13 +102,6 @@ class PannerUI : public Gtk::HBox, public ARDOUR::SessionHandlePtr
 	Panner2dWindow* big_window;
 
 	Gtk::VBox           pan_bar_packer;
-	Gtk::Adjustment	    hAdjustment;
-	Gtk::Adjustment     vAdjustment;
-	Gtk::Viewport       panning_viewport;
-	Gtk::EventBox       panning_up;
-	Gtk::Arrow          panning_up_arrow;
-	Gtk::EventBox       panning_down;
-	Gtk::Arrow          panning_down_arrow;
 	Gtk::VBox           pan_vbox;
         Gtk::VBox           poswidth_box;
 	Width              _width;
@@ -122,25 +114,15 @@ class PannerUI : public Gtk::HBox, public ARDOUR::SessionHandlePtr
         void position_adjusted ();
         void show_position ();
 
-	Gtk::ToggleButton   panning_link_button;
-	Gtk::Button         panning_link_direction_button;
-	Gtk::HBox           panning_link_box;
-
-	bool panning_link_button_press (GdkEventButton*);
-	bool panning_link_button_release (GdkEventButton*);
-
 	Gtk::Menu* pan_astate_menu;
 	Gtk::Menu* pan_astyle_menu;
 
 	Gtk::Button pan_automation_style_button;
 	Gtk::ToggleButton pan_automation_state_button;
 
-	void panning_link_direction_clicked ();
-
 	std::vector<MonoPanner*> pan_bars;
 
 	void pan_value_changed (uint32_t which);
-	void update_pan_linkage ();
 	void update_pan_state ();
 	void build_astate_menu ();
 	void build_astyle_menu ();
@@ -153,14 +135,12 @@ class PannerUI : public Gtk::HBox, public ARDOUR::SessionHandlePtr
 	gint start_pan_touch (GdkEventButton*);
 	gint end_pan_touch (GdkEventButton*);
 
-	bool pan_button_event (GdkEventButton*, uint32_t which);
+	bool pan_button_event (GdkEventButton*);
 
 	Gtk::Menu* pan_menu;
 	Gtk::CheckMenuItem* bypass_menu_item;
-	void build_pan_menu (uint32_t which);
-	void pan_mute (uint32_t which);
-	void pan_reset (uint32_t);
-	void pan_reset_all ();
+	void build_pan_menu ();
+	void pan_reset ();
 	void pan_bypass_toggle ();
 
 	void pan_automation_state_changed();
diff --git a/gtk2_ardour/processor_box.cc b/gtk2_ardour/processor_box.cc
index 05f49a4e4e..2eaeeb83f7 100644
--- a/gtk2_ardour/processor_box.cc
+++ b/gtk2_ardour/processor_box.cc
@@ -898,7 +898,7 @@ ProcessorBox::weird_plugin_dialog (Plugin& p, Route::ProcessorStreams streams)
 void
 ProcessorBox::choose_insert ()
 {
-	boost::shared_ptr<Processor> processor (new PortInsert (*_session, _route->mute_master()));
+	boost::shared_ptr<Processor> processor (new PortInsert (*_session, _route->pannable(), _route->mute_master()));
 	_route->add_processor (processor, _placement);
 }
 
@@ -906,7 +906,7 @@ ProcessorBox::choose_insert ()
 void
 ProcessorBox::choose_send ()
 {
-	boost::shared_ptr<Send> send (new Send (*_session, _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())
@@ -1510,7 +1510,7 @@ ProcessorBox::paste_processor_state (const XMLNodeList& nlist, boost::shared_ptr
 
 				XMLNode n (**niter);
 				Send::make_unique (n, *_session);
-                                Send* s = new Send (*_session, _route->mute_master());
+                                Send* s = new Send (*_session, _route->pannable(), _route->mute_master());
                                 if (s->set_state (n, Stateful::loading_state_version)) {
                                         delete s;
                                         return;
diff --git a/gtk2_ardour/stereo_panner.cc b/gtk2_ardour/stereo_panner.cc
index 4e715c49ee..8442b45e67 100644
--- a/gtk2_ardour/stereo_panner.cc
+++ b/gtk2_ardour/stereo_panner.cc
@@ -31,6 +31,7 @@
 #include "gtkmm2ext/gtk_ui.h"
 #include "gtkmm2ext/keyboard.h"
 
+#include "ardour/pannable.h"
 #include "ardour/panner.h"
 
 #include "ardour_ui.h"
@@ -53,9 +54,12 @@ static const int top_step = 2;
 StereoPanner::ColorScheme StereoPanner::colors[3];
 bool StereoPanner::have_colors = false;
 
-StereoPanner::StereoPanner (boost::shared_ptr<PBD::Controllable> position, boost::shared_ptr<PBD::Controllable> width)
-        : position_control (position)
-        , width_control (width)
+using namespace ARDOUR;
+
+StereoPanner::StereoPanner (boost::shared_ptr<Panner> panner)
+        : _panner (panner)
+        , position_control (_panner->pannable()->pan_azimuth_control)
+        , width_control (_panner->pannable()->pan_width_control)
         , dragging (false)
         , dragging_position (false)
         , dragging_left (false)
@@ -66,8 +70,8 @@ StereoPanner::StereoPanner (boost::shared_ptr<PBD::Controllable> position, boost
         , detented (false)
         , drag_data_window (0)
         , drag_data_label (0)
-        , position_binder (position)
-        , width_binder (width)
+        , position_binder (position_control)
+        , width_binder (width_control)
 {
         if (!have_colors) {
                 set_colors ();
@@ -326,8 +330,9 @@ StereoPanner::on_button_press_event (GdkEventButton* ev)
                                         /* 2ndary-double click on right, collapse to hard right */
                                         width_control->set_value (0);
                                         position_control->set_value (1.0);
+                                } else {
+                                        position_control->set_value (max_pos);
                                 }
-                                position_control->set_value (max_pos);
                         } else {
                                 position_control->set_value (0.5);
                         }
diff --git a/gtk2_ardour/stereo_panner.h b/gtk2_ardour/stereo_panner.h
index 86a53eccf7..294f86babb 100644
--- a/gtk2_ardour/stereo_panner.h
+++ b/gtk2_ardour/stereo_panner.h
@@ -31,10 +31,14 @@ namespace PBD {
         class Controllable;
 }
 
+namespace ARDOUR { 
+        class Panner;
+}
+
 class StereoPanner : public Gtk::DrawingArea
 {
   public:
-	StereoPanner (boost::shared_ptr<PBD::Controllable> pos, boost::shared_ptr<PBD::Controllable> width);
+	StereoPanner (boost::shared_ptr<ARDOUR::Panner>);
 	~StereoPanner ();
 
 	sigc::signal<void> StartPositionGesture;
@@ -54,6 +58,7 @@ class StereoPanner : public Gtk::DrawingArea
         bool on_leave_notify_event (GdkEventCrossing* ev);
 
   private:
+        boost::shared_ptr<ARDOUR::Panner> _panner;
         boost::shared_ptr<PBD::Controllable> position_control;
         boost::shared_ptr<PBD::Controllable> width_control;
         PBD::ScopedConnectionList connections;
diff --git a/gtk2_ardour/wscript b/gtk2_ardour/wscript
index 43b45e1039..38700fcbc3 100644
--- a/gtk2_ardour/wscript
+++ b/gtk2_ardour/wscript
@@ -156,7 +156,6 @@ gtk2_ardour_sources = [
         'note_player.cc',
 	'option_editor.cc',
 	'opts.cc',
-	'panner.cc',
 	'panner2d.cc',
 	'panner_ui.cc',
 	'piano_roll_header.cc',