X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fport_matrix.cc;h=696c625da0eeb352224bc024a99435a59ec27be7;hb=786028a20a2a83bbcc2eebe457353b221d57d10a;hp=58c8a099bdc738b99545db8e73f58d80c42be637;hpb=1a447016437727452fdf00e7c762f339c796f736;p=ardour.git

diff --git a/gtk2_ardour/port_matrix.cc b/gtk2_ardour/port_matrix.cc
index 58c8a099bd..696c625da0 100644
--- a/gtk2_ardour/port_matrix.cc
+++ b/gtk2_ardour/port_matrix.cc
@@ -25,6 +25,7 @@
 #include <gtkmm/menushell.h>
 #include <gtkmm/menu_elems.h>
 #include <gtkmm/window.h>
+#include <gtkmm/stock.h>
 #include "ardour/bundle.h"
 #include "ardour/types.h"
 #include "ardour/session.h"
@@ -33,11 +34,12 @@
 #include "port_matrix.h"
 #include "port_matrix_body.h"
 #include "port_matrix_component.h"
+#include "ardour_dialog.h"
 #include "i18n.h"
 #include "gui_thread.h"
+#include "utils.h"
 
 using namespace std;
-using namespace sigc;
 using namespace Gtk;
 using namespace ARDOUR;
 
@@ -46,40 +48,34 @@ using namespace ARDOUR;
  *  @param type Port type that we are handling.
  */
 PortMatrix::PortMatrix (Window* parent, Session* session, DataType type)
-	: Table (3, 3),
-	  _session (session),
-	  _parent (parent),
-	  _type (type),
-	  _menu (0),
-	  _arrangement (TOP_TO_RIGHT),
-	  _row_index (0),
-	  _column_index (1),
-	  _min_height_divisor (1),
-	  _show_only_bundles (false),
-	  _inhibit_toggle_show_only_bundles (false),
-	  _ignore_notebook_page_selected (false)
-{
+	: Table (4, 4)
+	, _parent (parent)
+	, _type (type)
+	, _menu (0)
+	, _arrangement (TOP_TO_RIGHT)
+	, _row_index (0)
+	, _column_index (1)
+	, _min_height_divisor (1)
+	, _show_only_bundles (false)
+	, _inhibit_toggle_show_only_bundles (false)
+	, _ignore_notebook_page_selected (false)
+{
+	set_session (session);
+
 	_body = new PortMatrixBody (this);
-	_body->DimensionsChanged.connect (mem_fun (*this, &PortMatrix::body_dimensions_changed));
+	_body->DimensionsChanged.connect (sigc::mem_fun (*this, &PortMatrix::body_dimensions_changed));
 
-	_vbox.pack_start (_vspacer, false, false);
-	_vbox.pack_start (_vnotebook, false, false);
-	_vbox.pack_start (_vlabel, true, true);
-	_hbox.pack_start (_hspacer, false, false);
-	_hbox.pack_start (_hnotebook, false, false);
-	_hbox.pack_start (_hlabel, true, true);
+	_hbox.pack_end (_hspacer, true, true);
+	_hbox.pack_end (_hnotebook, false, false);
+	_hbox.pack_end (_hlabel, false, false);
 
-	_vnotebook.signal_switch_page().connect (mem_fun (*this, &PortMatrix::v_page_selected));
+	_vnotebook.signal_switch_page().connect (sigc::mem_fun (*this, &PortMatrix::notebook_page_selected));
 	_vnotebook.property_tab_border() = 4;
 	_vnotebook.set_name (X_("PortMatrixLabel"));
-	_hnotebook.signal_switch_page().connect (mem_fun (*this, &PortMatrix::h_page_selected));
+	_hnotebook.signal_switch_page().connect (sigc::mem_fun (*this, &PortMatrix::notebook_page_selected));
 	_hnotebook.property_tab_border() = 4;
 	_hnotebook.set_name (X_("PortMatrixLabel"));
 
-	for (int i = 0; i < 2; ++i) {
-		_ports[i].set_type (type);
-	}
-
 	_vlabel.set_use_markup ();
 	_vlabel.set_alignment (1, 1);
 	_vlabel.set_padding (4, 16);
@@ -89,12 +85,22 @@ PortMatrix::PortMatrix (Window* parent, Session* session, DataType type)
 	_hlabel.set_padding (16, 4);
 	_hlabel.set_name (X_("PortMatrixLabel"));
 
+	set_row_spacing (0, 8);
+	set_col_spacing (0, 8);
+	set_row_spacing (2, 8);
+	set_col_spacing (2, 8);
+
 	_body->show ();
 	_vbox.show ();
 	_hbox.show ();
+	_vscroll.show ();
+	_hscroll.show ();
 	_vlabel.show ();
 	_hlabel.show ();
 	_hspacer.show ();
+	_vspacer.show ();
+	_vnotebook.show ();
+	_hnotebook.show ();
 }
 
 PortMatrix::~PortMatrix ()
@@ -115,15 +121,7 @@ PortMatrix::init ()
 {
 	select_arrangement ();
 
-	if (!_ports[0].empty()) {
-		_visible_ports[0] = *_ports[0].begin();
-	}
-	
-	if (!_ports[1].empty()) {
-		_visible_ports[1] = *_ports[1].begin();
-	}
-
-	/* Signal handling is kind of split into two parts:
+	/* Signal handling is kind of split into three parts:
 	 *
 	 * 1.  When _ports[] changes, we call setup().  This essentially sorts out our visual
 	 *     representation of the information in _ports[].
@@ -131,6 +129,8 @@ PortMatrix::init ()
 	 * 2.  When certain other things change, we need to get our subclass to clear and
 	 *     re-fill _ports[], which in turn causes appropriate signals to be raised to
 	 *     hook into part (1).
+	 *
+	 * 3.  Assorted other signals.
 	 */
 
 
@@ -138,29 +138,32 @@ PortMatrix::init ()
 
 	for (int i = 0; i < 2; ++i) {
 		/* watch for the content of _ports[] changing */
-		_ports[i].Changed.connect (mem_fun (*this, &PortMatrix::setup));
+		_ports[i].Changed.connect (_changed_connections, invalidator (*this), boost::bind (&PortMatrix::setup, this), gui_context());
 
 		/* and for bundles in _ports[] changing */
-		_ports[i].BundleChanged.connect (sigc::hide (mem_fun (*this, &PortMatrix::setup)));
+		_ports[i].BundleChanged.connect (_bundle_changed_connections, invalidator (*this), boost::bind (&PortMatrix::setup, this), gui_context());
 	}
 
-	/* scrolling stuff */
-	_hscroll.signal_value_changed().connect (mem_fun (*this, &PortMatrix::hscroll_changed));
-	_vscroll.signal_value_changed().connect (mem_fun (*this, &PortMatrix::vscroll_changed));
-
-
 	/* Part 2: notice when things have changed that require our subclass to clear and refill _ports[] */
 	
 	/* watch for routes being added or removed */
-	_session->RouteAdded.connect (sigc::hide (mem_fun (*this, &PortMatrix::routes_changed)));
+	_session->RouteAdded.connect (_session_connections, invalidator (*this), boost::bind (&PortMatrix::routes_changed, this), gui_context());
 
 	/* and also bundles */
-	_session->BundleAdded.connect (sigc::hide (mem_fun (*this, &PortMatrix::setup_global_ports)));
+	_session->BundleAdded.connect (_session_connections, invalidator (*this), boost::bind (&PortMatrix::setup_global_ports, this), gui_context());
 
 	/* and also ports */
-	_session->engine().PortRegisteredOrUnregistered.connect (mem_fun (*this, &PortMatrix::setup_global_ports));
+	_session->engine().PortRegisteredOrUnregistered.connect (_session_connections, invalidator (*this), boost::bind (&PortMatrix::setup_global_ports, this), gui_context());
+
+	/* watch for route order keys changing, which changes the order of things in our global ports list(s) */
+	_session->RouteOrderKeyChanged.connect (_session_connections, invalidator (*this), boost::bind (&PortMatrix::setup_global_ports_proxy, this), gui_context());
+
+	/* Part 3: other stuff */
+	
+	_session->engine().PortConnectedOrDisconnected.connect (_session_connections, invalidator (*this), boost::bind (&PortMatrix::port_connected_or_disconnected, this), gui_context ());
 
-	_session->GoingAway.connect (mem_fun (*this, &PortMatrix::session_going_away));
+	_hscroll.signal_value_changed().connect (sigc::mem_fun (*this, &PortMatrix::hscroll_changed));
+	_vscroll.signal_value_changed().connect (sigc::mem_fun (*this, &PortMatrix::vscroll_changed));
 
 	reconnect_to_routes ();
 	
@@ -171,16 +174,11 @@ PortMatrix::init ()
 void
 PortMatrix::reconnect_to_routes ()
 {
-	for (vector<connection>::iterator i = _route_connections.begin(); i != _route_connections.end(); ++i) {
-		i->disconnect ();
-	}
-	_route_connections.clear ();
+	_route_connections.drop_connections ();
 
 	boost::shared_ptr<RouteList> routes = _session->get_routes ();
 	for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
-		_route_connections.push_back (
-			(*i)->processors_changed.connect (mem_fun (*this, &PortMatrix::route_processors_changed))
-			);
+		(*i)->processors_changed.connect (_route_connections, invalidator (*this), ui_bind (&PortMatrix::route_processors_changed, this, _1), gui_context());
 	}
 }
 
@@ -207,9 +205,13 @@ PortMatrix::routes_changed ()
 void
 PortMatrix::setup ()
 {
+	/* this needs to be done first, as the visible_ports() method uses the
+	   notebook state to decide which ports are being shown */
+
+	setup_notebooks ();
+	
 	_body->setup ();
 	setup_scrollbars ();
-	setup_notebooks ();
 	queue_draw ();
 }
 
@@ -217,10 +219,6 @@ void
 PortMatrix::set_type (DataType t)
 {
 	_type = t;
-	_ports[0].set_type (_type);
-	_ports[1].set_type (_type);
-
-	setup_all_ports ();
 }
 
 void
@@ -261,13 +259,17 @@ PortMatrix::disassociate_all ()
 	PortGroup::BundleList b = _ports[1].bundles ();
 
 	for (PortGroup::BundleList::iterator i = a.begin(); i != a.end(); ++i) {
-		for (uint32_t j = 0; j < i->bundle->nchannels(); ++j) {
+		for (uint32_t j = 0; j < (*i)->bundle->nchannels().n_total(); ++j) {
 			for (PortGroup::BundleList::iterator k = b.begin(); k != b.end(); ++k) {
-				for (uint32_t l = 0; l < k->bundle->nchannels(); ++l) {
+				for (uint32_t l = 0; l < (*k)->bundle->nchannels().n_total(); ++l) {
+
+					if (!should_show ((*i)->bundle->channel_type(j)) || !should_show ((*k)->bundle->channel_type(l))) {
+						continue;
+					}
 
 					BundleChannel c[2] = {
-						BundleChannel (i->bundle, j),
-						BundleChannel (k->bundle, l)
+						BundleChannel ((*i)->bundle, j),
+						BundleChannel ((*k)->bundle, l)
 							};
 
 					if (get_state (c) == PortMatrixNode::ASSOCIATED) {
@@ -287,10 +289,24 @@ void
 PortMatrix::select_arrangement ()
 {
 	uint32_t const N[2] = {
-		_ports[0].total_channels (),
-		_ports[1].total_channels ()
+		count_of_our_type (_ports[0].total_channels()),
+		count_of_our_type (_ports[1].total_channels())
 	};
 
+	/* XXX: shirley there's an easier way than this */
+
+	if (_vspacer.get_parent()) {
+		_vbox.remove (_vspacer);
+	}
+
+	if (_vnotebook.get_parent()) {
+		_vbox.remove (_vnotebook);
+	}
+
+	if (_vlabel.get_parent()) {
+		_vbox.remove (_vlabel);
+	}
+
 	/* The list with the most channels goes on left or right, so that the most channel
 	   names are printed horizontally and hence more readable.  However we also
 	   maintain notional `signal flow' vaguely from left to right.  Subclasses
@@ -306,14 +322,15 @@ PortMatrix::select_arrangement ()
 		_hlabel.set_label (_("<b>Destinations</b>"));
 		_vlabel.set_angle (90);
 
-		attach (*_body, 1, 2, 0, 1);
-		attach (_vscroll, 2, 3, 0, 1, SHRINK);
-		attach (_hscroll, 1, 2, 2, 3, FILL | EXPAND, SHRINK);
-		attach (_vbox, 0, 1, 0, 1, SHRINK);
-		attach (_hbox, 1, 2, 1, 2, FILL | EXPAND, SHRINK);
+		_vbox.pack_end (_vlabel, false, false);
+		_vbox.pack_end (_vnotebook, false, false);
+		_vbox.pack_end (_vspacer, true, true);
 
-		set_col_spacing (0, 4);
-		set_row_spacing (0, 4);
+		attach (*_body, 2, 3, 1, 2, FILL | EXPAND, FILL | EXPAND);
+		attach (_vscroll, 3, 4, 1, 2, SHRINK);
+		attach (_hscroll, 2, 3, 3, 4, FILL | EXPAND, SHRINK);
+		attach (_vbox, 1, 2, 1, 2, SHRINK);
+		attach (_hbox, 2, 3, 2, 3, FILL | EXPAND, SHRINK);
 		
 	} else {
 
@@ -324,14 +341,15 @@ PortMatrix::select_arrangement ()
 		_vlabel.set_label (_("<b>Destinations</b>"));
 		_vlabel.set_angle (-90);
 
-		attach (*_body, 0, 1, 1, 2);
-		attach (_vscroll, 2, 3, 1, 2, SHRINK);
-		attach (_hscroll, 0, 1, 2, 3, FILL | EXPAND, SHRINK);
-		attach (_vbox, 1, 2, 1, 2, SHRINK);
-		attach (_hbox, 0, 1, 0, 1, FILL | EXPAND, SHRINK);
+		_vbox.pack_end (_vspacer, true, true);
+		_vbox.pack_end (_vnotebook, false, false);
+		_vbox.pack_end (_vlabel, false, false);
 
-		set_col_spacing (1, 4);
-		set_row_spacing (1, 4);
+		attach (*_body, 1, 2, 2, 3, FILL | EXPAND, FILL | EXPAND);
+		attach (_vscroll, 3, 4, 2, 3, SHRINK);
+		attach (_hscroll, 1, 2, 3, 4, FILL | EXPAND, SHRINK);
+		attach (_vbox, 2, 3, 2, 3, SHRINK);
+		attach (_hbox, 1, 2, 1, 2, FILL | EXPAND, SHRINK);
 	}
 }
 
@@ -342,10 +360,10 @@ PortMatrix::columns () const
 	return &_ports[_column_index];
 }
 
-boost::shared_ptr<PortGroup>
+boost::shared_ptr<const PortGroup>
 PortMatrix::visible_columns () const
 {
-	return _visible_ports[_column_index];
+	return visible_ports (_column_index);
 }
 
 /* @return rows list */
@@ -355,10 +373,10 @@ PortMatrix::rows () const
 	return &_ports[_row_index];
 }
 
-boost::shared_ptr<PortGroup>
+boost::shared_ptr<const PortGroup>
 PortMatrix::visible_rows () const
 {
-	return _visible_ports[_row_index];
+	return visible_ports (_row_index);
 }
 
 void
@@ -391,19 +409,33 @@ PortMatrix::popup_menu (BundleChannel column, BundleChannel row, uint32_t t)
 
 			bool can_add_or_rename = false;
 
-			if (can_add_channel (bc[dim].bundle)) {
-				snprintf (buf, sizeof (buf), _("Add %s"), channel_noun().c_str());
-				sub.push_back (MenuElem (buf, bind (mem_fun (*this, &PortMatrix::add_channel_proxy), w)));
-				can_add_or_rename = true;
+			/* Start off with options for the `natural' port type */
+			for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
+				if (should_show (*i)) {
+					snprintf (buf, sizeof (buf), _("Add %s %s"), (*i).to_i18n_string(), channel_noun().c_str());
+					sub.push_back (MenuElem (buf, sigc::bind (sigc::mem_fun (*this, &PortMatrix::add_channel_proxy), w, *i)));
+					can_add_or_rename = true;
+				}
 			}
 
-
+			/* Now add other ones */
+			for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
+				if (!should_show (*i)) {
+					snprintf (buf, sizeof (buf), _("Add %s %s"), (*i).to_i18n_string(), channel_noun().c_str());
+					sub.push_back (MenuElem (buf, sigc::bind (sigc::mem_fun (*this, &PortMatrix::add_channel_proxy), w, *i)));
+					can_add_or_rename = true;
+				}
+			}
+			
 			if (can_rename_channels (bc[dim].bundle)) {
-				snprintf (buf, sizeof (buf), _("Rename '%s'..."), bc[dim].bundle->channel_name (bc[dim].channel).c_str());
+				snprintf (
+					buf, sizeof (buf), _("Rename '%s'..."),
+					escape_underscores (bc[dim].bundle->channel_name (bc[dim].channel)).c_str()
+					);
 				sub.push_back (
 					MenuElem (
 						buf,
-						bind (mem_fun (*this, &PortMatrix::rename_channel_proxy), w, bc[dim].channel)
+						sigc::bind (sigc::mem_fun (*this, &PortMatrix::rename_channel_proxy), w, bc[dim].channel)
 						)
 					);
 				can_add_or_rename = true;
@@ -414,30 +446,50 @@ PortMatrix::popup_menu (BundleChannel column, BundleChannel row, uint32_t t)
 			}
 
 			if (can_remove_channels (bc[dim].bundle)) {
-				snprintf (buf, sizeof (buf), _("Remove '%s'"), bc[dim].bundle->channel_name (bc[dim].channel).c_str());
-				sub.push_back (
-					MenuElem (
-						buf,
-						bind (mem_fun (*this, &PortMatrix::remove_channel_proxy), w, bc[dim].channel)
-						)
-					);
+				if (bc[dim].channel != -1) {
+					add_remove_option (sub, w, bc[dim].channel);
+				} else {
+
+					snprintf (buf, sizeof (buf), _("Remove all"));
+					sub.push_back (
+						MenuElem (buf, sigc::bind (sigc::mem_fun (*this, &PortMatrix::remove_all_channels), w))
+						);
+					
+					if (bc[dim].bundle->nchannels().n_total() > 1) {
+                                                for (uint32_t i = 0; i < bc[dim].bundle->nchannels().n_total(); ++i) {
+                                                        if (should_show (bc[dim].bundle->channel_type(i))) {
+                                                                add_remove_option (sub, w, i);
+                                                        }
+                                                }
+                                        }
+				}
 			}
 
-			if (_show_only_bundles || bc[dim].bundle->nchannels() <= 1) {
+			if (_show_only_bundles || count_of_our_type (bc[dim].bundle->nchannels()) <= 1) {
 				snprintf (buf, sizeof (buf), _("%s all"), disassociation_verb().c_str());
-			} else {
-				snprintf (
-					buf, sizeof (buf), _("%s all from '%s'"),
-					disassociation_verb().c_str(),
-					bc[dim].bundle->channel_name (bc[dim].channel).c_str()
+				sub.push_back (
+					MenuElem (buf, sigc::bind (sigc::mem_fun (*this, &PortMatrix::disassociate_all_on_channel), w, bc[dim].channel, dim))
 					);
+				
+			} else {
+				
+				if (bc[dim].channel != -1) {
+					add_disassociate_option (sub, w, dim, bc[dim].channel);
+				} else {
+					snprintf (buf, sizeof (buf), _("%s all"), disassociation_verb().c_str());
+					sub.push_back (
+						MenuElem (buf, sigc::bind (sigc::mem_fun (*this, &PortMatrix::disassociate_all_on_bundle), w, dim))
+						);
+							
+					for (uint32_t i = 0; i < bc[dim].bundle->nchannels().n_total(); ++i) {
+						if (should_show (bc[dim].bundle->channel_type(i))) {
+							add_disassociate_option (sub, w, dim, i);
+						}
+					}
+				}
 			}
 
-			sub.push_back (
-				MenuElem (buf, bind (mem_fun (*this, &PortMatrix::disassociate_all_on_channel), w, bc[dim].channel, dim))
-				);
-
-			items.push_back (MenuElem (bc[dim].bundle->name().c_str(), *m));
+			items.push_back (MenuElem (escape_underscores (bc[dim].bundle->name()).c_str(), *m));
 			need_separator = true;
 		}
 
@@ -447,8 +499,8 @@ PortMatrix::popup_menu (BundleChannel column, BundleChannel row, uint32_t t)
 		items.push_back (SeparatorElem ());
 	}
 
-	items.push_back (MenuElem (_("Rescan"), mem_fun (*this, &PortMatrix::setup_all_ports)));
-	items.push_back (CheckMenuElem (_("Show individual ports"), mem_fun (*this, &PortMatrix::toggle_show_only_bundles)));
+	items.push_back (MenuElem (_("Rescan"), sigc::mem_fun (*this, &PortMatrix::setup_all_ports)));
+	items.push_back (CheckMenuElem (_("Show individual ports"), sigc::mem_fun (*this, &PortMatrix::toggle_show_only_bundles)));
 	CheckMenuItem* i = dynamic_cast<CheckMenuItem*> (&items.back());
 	_inhibit_toggle_show_only_bundles = true;
 	i->set_active (!_show_only_bundles);
@@ -480,6 +532,21 @@ PortMatrix::rename_channel_proxy (boost::weak_ptr<Bundle> b, uint32_t c)
 	rename_channel (BundleChannel (sb, c));
 }
 
+void
+PortMatrix::disassociate_all_on_bundle (boost::weak_ptr<Bundle> bundle, int dim)
+{
+	boost::shared_ptr<Bundle> sb = bundle.lock ();
+	if (!sb) {
+		return;
+	}
+
+	for (uint32_t i = 0; i < sb->nchannels().n_total(); ++i) {
+		if (should_show (sb->channel_type(i))) {
+			disassociate_all_on_channel (bundle, i, dim);
+		}
+	}
+}
+
 void
 PortMatrix::disassociate_all_on_channel (boost::weak_ptr<Bundle> bundle, uint32_t channel, int dim)
 {
@@ -491,11 +558,15 @@ PortMatrix::disassociate_all_on_channel (boost::weak_ptr<Bundle> bundle, uint32_
 	PortGroup::BundleList a = _ports[1-dim].bundles ();
 
 	for (PortGroup::BundleList::iterator i = a.begin(); i != a.end(); ++i) {
-		for (uint32_t j = 0; j < i->bundle->nchannels(); ++j) {
+		for (uint32_t j = 0; j < (*i)->bundle->nchannels().n_total(); ++j) {
+
+			if (should_show ((*i)->bundle->channel_type(j))) {
+				continue;
+			}
 
 			BundleChannel c[2];
 			c[dim] = BundleChannel (sb, channel);
-			c[1-dim] = BundleChannel (i->bundle, j);
+			c[1-dim] = BundleChannel ((*i)->bundle, j);
 
 			if (get_state (c) == PortMatrixNode::ASSOCIATED) {
 				set_state (c, false);
@@ -509,8 +580,8 @@ PortMatrix::disassociate_all_on_channel (boost::weak_ptr<Bundle> bundle, uint32_
 void
 PortMatrix::setup_global_ports ()
 {
-	ENSURE_GUI_THREAD (mem_fun (*this, &PortMatrix::setup_global_ports));
-	
+	ENSURE_GUI_THREAD (*this, &PortMatrix::setup_global_ports)
+
 	for (int i = 0; i < 2; ++i) {
 		if (list_is_global (i)) {
 			setup_ports (i);
@@ -518,6 +589,16 @@ PortMatrix::setup_global_ports ()
 	}
 }
 
+void
+PortMatrix::setup_global_ports_proxy ()
+{
+	/* Avoid a deadlock by calling this in an idle handler: see IOSelector::io_changed_proxy
+	   for a discussion.
+	*/
+
+	Glib::signal_idle().connect_once (sigc::mem_fun (*this, &PortMatrix::setup_global_ports));
+}
+
 void
 PortMatrix::setup_all_ports ()
 {
@@ -525,7 +606,7 @@ PortMatrix::setup_all_ports ()
 		return;
 	}
 
-	ENSURE_GUI_THREAD (mem_fun (*this, &PortMatrix::setup_all_ports));
+	ENSURE_GUI_THREAD (*this, &PortMatrix::setup_all_ports)
 
 	setup_ports (0);
 	setup_ports (1);
@@ -548,8 +629,8 @@ PortMatrix::max_size () const
 {
 	pair<uint32_t, uint32_t> m = _body->max_size ();
 
-	m.first += _vscroll.get_width ();
-	m.second += _hscroll.get_height ();
+	m.first += _vscroll.get_width () + _vbox.get_width () + 4;
+	m.second += _hscroll.get_height () + _hbox.get_height () + 4;
 
 	return m;
 }
@@ -596,12 +677,12 @@ PortMatrix::can_add_channel (boost::shared_ptr<Bundle> b) const
 }
 
 void
-PortMatrix::add_channel (boost::shared_ptr<Bundle> b)
+PortMatrix::add_channel (boost::shared_ptr<Bundle> b, DataType t)
 {
 	boost::shared_ptr<IO> io = io_from_bundle (b);
 
 	if (io) {
-		io->add_port ("", this, _type);
+		io->add_port ("", this, t);
 	}
 }
 
@@ -619,20 +700,44 @@ PortMatrix::remove_channel (ARDOUR::BundleChannel b)
 	if (io) {
 		Port* p = io->nth (b.channel);
 		if (p) {
-			io->remove_port (p, this);
+			int const r = io->remove_port (p, this);
+			if (r == -1) {
+				ArdourDialog d (_("Port removal not allowed"));
+				Label l (_("This port cannot be removed, as the first plugin in the track or buss cannot accept the new number of inputs."));
+				d.get_vbox()->pack_start (l);
+				d.add_button (Stock::OK, RESPONSE_ACCEPT);
+				d.set_modal (true);
+				d.show_all ();
+				d.run ();
+			}
 		}
 	}
 }
 
 void
-PortMatrix::add_channel_proxy (boost::weak_ptr<Bundle> w)
+PortMatrix::remove_all_channels (boost::weak_ptr<Bundle> w)
 {
 	boost::shared_ptr<Bundle> b = w.lock ();
 	if (!b) {
 		return;
 	}
 
-	add_channel (b);
+	for (uint32_t i = 0; i < b->nchannels().n_total(); ++i) {
+		if (should_show (b->channel_type(i))) {
+			remove_channel (ARDOUR::BundleChannel (b, i));
+		}
+	}
+}
+
+void
+PortMatrix::add_channel_proxy (boost::weak_ptr<Bundle> w, DataType t)
+{
+	boost::shared_ptr<Bundle> b = w.lock ();
+	if (!b) {
+		return;
+	}
+
+	add_channel (b, t);
 }
 
 void
@@ -654,6 +759,7 @@ PortMatrix::setup_notebooks ()
 		dummy->show ();
 		Label* label = manage (new Label ((*i)->name));
 		label->set_angle (_arrangement == LEFT_TO_BOTTOM ? 90 : -90);
+		label->show ();
 		_vnotebook.prepend_page (*dummy, *label);
 	}
 
@@ -665,8 +771,13 @@ PortMatrix::setup_notebooks ()
 
 	_ignore_notebook_page_selected = false;
 
-	_vnotebook.set_tab_pos (POS_LEFT);
-	_hnotebook.set_tab_pos (POS_TOP);
+	if (_arrangement == TOP_TO_RIGHT) {
+		_vnotebook.set_tab_pos (POS_RIGHT);
+		_hnotebook.set_tab_pos (POS_TOP);
+	} else {
+		_vnotebook.set_tab_pos (POS_LEFT);
+		_hnotebook.set_tab_pos (POS_BOTTOM);
+	}
 
 	if (h_current_page != -1 && _hnotebook.get_n_pages() > h_current_page) {
 		_hnotebook.set_current_page (h_current_page);
@@ -683,7 +794,7 @@ PortMatrix::setup_notebooks ()
 	if (_hnotebook.get_n_pages() <= 1) {
 		_hbox.hide ();
 	} else {
-		_vbox.show ();
+		_hbox.show ();
 	}
 
 	if (_vnotebook.get_n_pages() <= 1) {
@@ -704,70 +815,195 @@ PortMatrix::remove_notebook_pages (Notebook& n)
 }
 
 void
-PortMatrix::v_page_selected (GtkNotebookPage *, guint n)
+PortMatrix::notebook_page_selected (GtkNotebookPage *, guint)
 {
 	if (_ignore_notebook_page_selected) {
 		return;
 	}
+
+	_body->setup ();
+	setup_scrollbars ();
+	queue_draw ();
+}
+
+void
+PortMatrix::session_going_away ()
+{
+	_session = 0;
+}
+
+void
+PortMatrix::body_dimensions_changed ()
+{
+	_hspacer.set_size_request (_body->column_labels_border_x (), -1);
+	if (_arrangement == TOP_TO_RIGHT) {
+		_vspacer.set_size_request (-1, _body->column_labels_height ());
+		_vspacer.show ();
+	} else {
+		_vspacer.hide ();
+	}
+
+	int curr_width;
+	int curr_height;
+	_parent->get_size (curr_width, curr_height);
+
+	pair<uint32_t, uint32_t> m = max_size ();
+
+	/* Don't shrink the window */
+	m.first = max (int (m.first), curr_width);
+	m.second = max (int (m.second), curr_height);
 	
-	PortGroupList& p = _ports[_row_index];
+	resize_window_to_proportion_of_monitor (_parent, m.first, m.second);
+}
+
+
+boost::shared_ptr<const PortGroup>
+PortMatrix::visible_ports (int d) const
+{
+	PortGroupList const & p = _ports[d];
+	PortGroupList::List::const_iterator j = p.begin ();
 
-	n = p.size() - n - 1;
+	int n = 0;
+	if (d == _row_index) {
+		n = p.size() - _vnotebook.get_current_page () - 1;
+	} else {
+		n = _hnotebook.get_current_page ();
+	}
 
 	int i = 0;
-	PortGroupList::List::const_iterator j = p.begin();
-	while (i != int (n) && j != p.end()) {
+	while (i != int (n) && j != p.end ()) {
 		++i;
 		++j;
 	}
-
-	if (j != p.end()) {
-		_visible_ports[_row_index] = *j;
-		_body->setup ();
-		setup_scrollbars ();
-		queue_draw ();
+		
+	if (j == p.end()) {
+		return boost::shared_ptr<const PortGroup> ();
 	}
+
+	return *j;
 }
 
 void
-PortMatrix::h_page_selected (GtkNotebookPage *, guint n)
+PortMatrix::add_remove_option (Menu_Helpers::MenuList& m, boost::weak_ptr<Bundle> w, int c)
 {
-	if (_ignore_notebook_page_selected) {
+	using namespace Menu_Helpers;
+
+	boost::shared_ptr<Bundle> b = w.lock ();
+	if (!b) {
 		return;
 	}
-
-	PortGroupList& p = _ports[_column_index];
 	
-	int i = 0;
-	PortGroupList::List::const_iterator j = p.begin();
-	while (i != int (n) && j != p.end()) {
-		++i;
-		++j;
-	}
+	char buf [64];
+	snprintf (buf, sizeof (buf), _("Remove '%s'"), escape_underscores (b->channel_name (c)).c_str());
+	m.push_back (MenuElem (buf, sigc::bind (sigc::mem_fun (*this, &PortMatrix::remove_channel_proxy), w, c)));
+}
 
-	if (j != p.end()) {
-		_visible_ports[_column_index] = *j;
-		_body->setup ();
-		setup_scrollbars ();
-		queue_draw ();
+void
+PortMatrix::add_disassociate_option (Menu_Helpers::MenuList& m, boost::weak_ptr<Bundle> w, int d, int c)
+{
+	using namespace Menu_Helpers;
+
+	boost::shared_ptr<Bundle> b = w.lock ();
+	if (!b) {
+		return;
 	}
+	
+	char buf [64];
+	snprintf (buf, sizeof (buf), _("%s all from '%s'"), disassociation_verb().c_str(), escape_underscores (b->channel_name (c)).c_str());
+	m.push_back (MenuElem (buf, sigc::bind (sigc::mem_fun (*this, &PortMatrix::disassociate_all_on_channel), w, c, d)));
 }
 
 void
-PortMatrix::session_going_away ()
+PortMatrix::port_connected_or_disconnected ()
 {
-	_session = 0;
+	_body->rebuild_and_draw_grid ();
 }
 
-void
-PortMatrix::body_dimensions_changed ()
+string
+PortMatrix::channel_noun () const
 {
-	_hspacer.set_size_request (_body->column_labels_border_x (), -1);
-	if (_arrangement == TOP_TO_RIGHT) {
-		_vspacer.set_size_request (-1, _body->column_labels_height ());
-		_vspacer.show ();
+	return _("channel");
+}
+
+/** @return true if this matrix should show bundles / ports of type \t */
+bool
+PortMatrix::should_show (DataType t) const
+{
+	return (_type == DataType::NIL || t == _type);
+}
+	
+uint32_t
+PortMatrix::count_of_our_type (ChanCount c) const
+{
+	if (_type == DataType::NIL) {
+		return c.n_total ();
+	}
+
+	return c.get (_type);
+}
+
+PortMatrixNode::State
+PortMatrix::get_association (PortMatrixNode node) const
+{
+	if (show_only_bundles ()) {
+
+		bool have_off_diagonal_association = false;
+		bool have_diagonal_association = false;
+		bool have_diagonal_not_association = false;
+
+		for (uint32_t i = 0; i < node.row.bundle->nchannels().n_total(); ++i) {
+
+			for (uint32_t j = 0; j < node.column.bundle->nchannels().n_total(); ++j) {
+
+				if (!should_show (node.row.bundle->channel_type(i)) || !should_show (node.column.bundle->channel_type(j))) {
+					continue;
+				}
+
+				ARDOUR::BundleChannel c[2];
+				c[row_index()] = ARDOUR::BundleChannel (node.row.bundle, i);
+				c[column_index()] = ARDOUR::BundleChannel (node.column.bundle, j);
+
+				PortMatrixNode::State const s = get_state (c);
+
+				switch (s) {
+				case PortMatrixNode::ASSOCIATED:
+					if (i == j) {
+						have_diagonal_association = true;
+					} else {
+						have_off_diagonal_association = true;
+					}
+					break;
+
+				case PortMatrixNode::NOT_ASSOCIATED:
+					if (i == j) {
+						have_diagonal_not_association = true;
+					}
+					break;
+
+				default:
+					break;
+				}
+			}
+		}
+
+		if (have_diagonal_association && !have_off_diagonal_association && !have_diagonal_not_association) {
+			return PortMatrixNode::ASSOCIATED;
+		} else if (!have_diagonal_association && !have_off_diagonal_association) {
+			return PortMatrixNode::NOT_ASSOCIATED;
+		}
+
+		return PortMatrixNode::PARTIAL;
+
 	} else {
-		_vspacer.hide ();
+
+		ARDOUR::BundleChannel c[2];
+		c[column_index()] = node.column;
+		c[row_index()] = node.row;
+		return get_state (c);
+
 	}
 
+	/* NOTREACHED */
+	return PortMatrixNode::NOT_ASSOCIATED;
 }
+