X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fport_group.cc;h=5db8585a83bc76ba34dd71b66b7d33935b9d9a8a;hb=dc0139d4af4d246f6dcafb04425e3f1198c347c3;hp=cafcaad51fc44bf9da6b4023953f233dc33d886d;hpb=a1a3f6c8265264227ce19f731bf1863aff229a94;p=ardour.git

diff --git a/gtk2_ardour/port_group.cc b/gtk2_ardour/port_group.cc
index cafcaad51f..5db8585a83 100644
--- a/gtk2_ardour/port_group.cc
+++ b/gtk2_ardour/port_group.cc
@@ -30,9 +30,10 @@
 #include "ardour/io_processor.h"
 #include "ardour/midi_port.h"
 #include "ardour/midiport_manager.h"
+#include "ardour/port.h"
+#include "ardour/profile.h"
 #include "ardour/session.h"
 #include "ardour/user_bundle.h"
-#include "ardour/port.h"
 
 #include "control_protocol/control_protocol.h"
 
@@ -42,7 +43,7 @@
 #include "time_axis_view.h"
 #include "public_editor.h"
 
-#include "i18n.h"
+#include "pbd/i18n.h"
 
 using namespace std;
 using namespace Gtk;
@@ -315,7 +316,7 @@ struct RouteIOs {
 class RouteIOsComparator {
 public:
 	bool operator() (RouteIOs const & a, RouteIOs const & b) {
-		return a.route->order_key () < b.route->order_key ();
+		return a.route->presentation_info ().order() < b.route->presentation_info().order();
 	}
 };
 
@@ -337,7 +338,7 @@ PortGroupList::gather (ARDOUR::Session* session, ARDOUR::DataType type, bool inp
 	boost::shared_ptr<PortGroup> bus (new PortGroup (string_compose (_("%1 Busses"), PROGRAM_NAME)));
 	boost::shared_ptr<PortGroup> track (new PortGroup (string_compose (_("%1 Tracks"), PROGRAM_NAME)));
 	boost::shared_ptr<PortGroup> system (new PortGroup (_("Hardware")));
-	boost::shared_ptr<PortGroup> ardour (new PortGroup (string_compose (_("%1 Misc"), PROGRAM_NAME)));
+	boost::shared_ptr<PortGroup> program (new PortGroup (string_compose (_("%1 Misc"), PROGRAM_NAME)));
 	boost::shared_ptr<PortGroup> other (new PortGroup (_("Other")));
 
 	/* Find the IOs which have bundles for routes and their processors.  We store
@@ -374,13 +375,10 @@ PortGroupList::gather (ARDOUR::Session* session, ARDOUR::DataType type, bool inp
 	/* Sort RouteIOs by the routes' editor order keys */
 	route_ios.sort (RouteIOsComparator ());
 
-	/* Now put the bundles that belong to these sorted RouteIOs into the PortGroup.
-	   Note that if the RouteIO's bundles are multi-type, we may make new Bundles
-	   with only the ports of one type.
-	*/
+	/* Now put the bundles that belong to these sorted RouteIOs into the PortGroup. */
 
 	for (list<RouteIOs>::iterator i = route_ios.begin(); i != route_ios.end(); ++i) {
-		TimeAxisView* tv = PublicEditor::instance().axis_view_from_route (i->route);
+		TimeAxisView* tv = PublicEditor::instance().time_axis_view_from_stripable (i->route);
 
 		/* Work out which group to put these IOs' bundles in */
 		boost::shared_ptr<PortGroup> g;
@@ -391,10 +389,14 @@ PortGroupList::gather (ARDOUR::Session* session, ARDOUR::DataType type, bool inp
 		}
 
 		for (list<boost::shared_ptr<IO> >::iterator j = i->ios.begin(); j != i->ios.end(); ++j) {
-			if (tv) {
-				g->add_bundle ((*j)->bundle(), *j, tv->color ());
-			} else {
-				g->add_bundle ((*j)->bundle(), *j);
+			/* Only add the bundle if there is at least one port
+			 * with a type that's been asked for */
+			if (type == DataType::NIL || (*j)->bundle()->nchannels().n(type) > 0) {
+				if (tv) {
+					g->add_bundle ((*j)->bundle(), *j, tv->color ());
+				} else {
+					g->add_bundle ((*j)->bundle(), *j);
+				}
 			}
 		}
 	}
@@ -420,39 +422,48 @@ PortGroupList::gather (ARDOUR::Session* session, ARDOUR::DataType type, bool inp
 		}
 	}
 
-	/* Ardour stuff */
+	/* miscellany */
 
-	if (!inputs) {
-		ardour->add_bundle (session->the_auditioner()->output()->bundle());
-		ardour->add_bundle (session->click_io()->bundle());
-		/* Note: the LTC ports do not have the usual ":audio_out 1" postfix, so
-		 *  ardour->add_bundle (session->ltc_output_io()->bundle());
-		 *  won't work
-		 */
-		boost::shared_ptr<Bundle> ltc (new Bundle (_("LTC Out"), inputs));
-		ltc->add_channel (_("LTC Out"), DataType::AUDIO, session->engine().make_port_name_non_relative (session->ltc_output_port()->name()));
-		ardour->add_bundle (ltc);
-	} else {
-		boost::shared_ptr<Bundle> ltc (new Bundle (_("LTC In"), inputs));
-		ltc->add_channel (_("LTC In"), DataType::AUDIO, session->engine().make_port_name_non_relative (session->ltc_input_port()->name()));
-		ardour->add_bundle (ltc);
+	if (type == DataType::AUDIO || type == DataType::NIL) {
+		if (!inputs) {
+			program->add_bundle (session->the_auditioner()->output()->bundle());
+			program->add_bundle (session->click_io()->bundle());
+			/* Note: the LTC ports do not have the usual ":audio_out 1" postfix, so
+			 *  program->add_bundle (session->ltc_output_io()->bundle());
+			 *  won't work
+			 */
+			boost::shared_ptr<Bundle> ltc (new Bundle (_("LTC Out"), inputs));
+			ltc->add_channel (_("LTC Out"), DataType::AUDIO, session->engine().make_port_name_non_relative (session->ltc_output_port()->name()));
+			program->add_bundle (ltc);
+		} else {
+			boost::shared_ptr<Bundle> ltc (new Bundle (_("LTC In"), inputs));
+			ltc->add_channel (_("LTC In"), DataType::AUDIO, session->engine().make_port_name_non_relative (session->ltc_input_port()->name()));
+			program->add_bundle (ltc);
+		}
 	}
 
-	/* Ardour's control surfaces */
+	/* our control surfaces */
+
+	/* XXX assume for now that all control protocols with ports use
+	 * MIDI. If anyone created a control protocol that used audio ports,
+	 * this will break.
+	 */
 
-	ControlProtocolManager& m = ControlProtocolManager::instance ();
-	for (list<ControlProtocolInfo*>::iterator i = m.control_protocol_info.begin(); i != m.control_protocol_info.end(); ++i) {
-		if ((*i)->protocol) {
-			list<boost::shared_ptr<Bundle> > b = (*i)->protocol->bundles ();
-			for (list<boost::shared_ptr<Bundle> >::iterator j = b.begin(); j != b.end(); ++j) {
-				if ((*j)->ports_are_inputs() == inputs) {
-					ardour->add_bundle (*j);
+	if ((type == DataType::MIDI || type == DataType::NIL)) {
+		ControlProtocolManager& m = ControlProtocolManager::instance ();
+		for (list<ControlProtocolInfo*>::iterator i = m.control_protocol_info.begin(); i != m.control_protocol_info.end(); ++i) {
+			if ((*i)->protocol) {
+				list<boost::shared_ptr<Bundle> > b = (*i)->protocol->bundles ();
+				for (list<boost::shared_ptr<Bundle> >::iterator j = b.begin(); j != b.end(); ++j) {
+					if ((*j)->ports_are_inputs() == inputs) {
+						program->add_bundle (*j);
+					}
 				}
 			}
 		}
 	}
 
-	/* Ardour's sync ports */
+	/* our sync ports */
 
 	if ((type == DataType::MIDI || type == DataType::NIL)) {
 		boost::shared_ptr<Bundle> sync (new Bundle (_("Sync"), inputs));
@@ -462,9 +473,6 @@ PortGroupList::gather (ARDOUR::Session* session, ARDOUR::DataType type, bool inp
 			sync->add_channel (
 				_("MTC in"), DataType::MIDI, ae->make_port_name_non_relative (session->mtc_input_port()->name())
 				);
-			sync->add_channel (
-				_("MIDI control in"), DataType::MIDI, ae->make_port_name_non_relative (session->midi_input_port()->name())
-				);
 			sync->add_channel (
 				_("MIDI clock in"), DataType::MIDI, ae->make_port_name_non_relative (session->midi_clock_input_port()->name())
 				);
@@ -475,9 +483,6 @@ PortGroupList::gather (ARDOUR::Session* session, ARDOUR::DataType type, bool inp
 			sync->add_channel (
 				_("MTC out"), DataType::MIDI, ae->make_port_name_non_relative (session->mtc_output_port()->name())
 				);
-			sync->add_channel (
-				_("MIDI control out"), DataType::MIDI, ae->make_port_name_non_relative (session->midi_output_port()->name())
-				);
 			sync->add_channel (
 				_("MIDI clock out"), DataType::MIDI, ae->make_port_name_non_relative (session->midi_clock_output_port()->name())
 				);
@@ -486,12 +491,13 @@ PortGroupList::gather (ARDOUR::Session* session, ARDOUR::DataType type, bool inp
 				);
 		}
 
-		ardour->add_bundle (sync);
+		program->add_bundle (sync);
 	}
 
 	/* Now find all other ports that we haven't thought of yet */
 
 	std::vector<std::string> extra_system[DataType::num_types];
+	std::vector<std::string> extra_program[DataType::num_types];
 	std::vector<std::string> extra_other[DataType::num_types];
 
         string lpn (PROGRAM_NAME);
@@ -500,7 +506,18 @@ PortGroupList::gather (ARDOUR::Session* session, ARDOUR::DataType type, bool inp
         lpnc += ':';
 
 	vector<string> ports;
-	if (AudioEngine::instance()->get_ports ("", type, inputs ? IsInput : IsOutput, ports) > 0) {
+	if (type == DataType::NIL) {
+		vector<string> p1;
+		AudioEngine::instance()->get_ports ("", DataType::AUDIO, inputs ? IsInput : IsOutput, ports);
+		AudioEngine::instance()->get_ports ("", DataType::MIDI, inputs ? IsInput : IsOutput, p1);
+		for (vector<string>::const_iterator s = p1.begin(); s != p1.end(); ++s) {
+			ports.push_back (*s);
+		}
+	} else {
+		AudioEngine::instance()->get_ports ("", type, inputs ? IsInput : IsOutput, ports);
+	}
+
+	if (ports.size () > 0) {
 
 		for (vector<string>::const_iterator s = ports.begin(); s != ports.end(); ) {
 
@@ -509,7 +526,7 @@ PortGroupList::gather (ARDOUR::Session* session, ARDOUR::DataType type, bool inp
 			if (!system->has_port(p) &&
 			    !bus->has_port(p) &&
 			    !track->has_port(p) &&
-			    !ardour->has_port(p) &&
+			    !program->has_port(p) &&
 			    !other->has_port(p)) {
 
                                 /* special hack: ignore MIDI ports labelled Midi-Through. these
@@ -517,7 +534,7 @@ PortGroupList::gather (ARDOUR::Session* session, ARDOUR::DataType type, bool inp
                                    connections.
                                 */
 
-                                if (p.find ("Midi-Through") != string::npos) {
+				if (p.find ("Midi-Through") != string::npos || p.find ("Midi Through") != string::npos) {
                                         ++s;
                                         continue;
                                 }
@@ -526,28 +543,54 @@ PortGroupList::gather (ARDOUR::Session* session, ARDOUR::DataType type, bool inp
                                    we excluded them earlier.
                                 */
 
-                                string lp = p;
-                                boost::to_lower (lp);
+				string lp = p;
+				string monitor = _("Monitor");
 
-                                if ((lp.find (N_(":monitor")) != string::npos) &&
+				boost::to_lower (lp);
+                                boost::to_lower (monitor);
+
+                                if ((lp.find (monitor) != string::npos) &&
                                     (lp.find (lpn) != string::npos)) {
                                         ++s;
                                         continue;
                                 }
 
-				/* can't use the audio engine for this as we are looking at non-Ardour ports */
+				/* can't use the audio engine for this as we
+				 * are looking at ports not owned by the
+				 * application, and the audio engine/port
+				 * manager doesn't seem them.
+				 */
 
 				PortEngine::PortHandle ph = AudioEngine::instance()->port_engine().get_port_by_name (p);
-				if (ph) {
-					DataType t (AudioEngine::instance()->port_engine().port_data_type (ph));
-					if (t != DataType::NIL) {
-						if (port_has_prefix (p, N_("system:")) ||
-                                                    port_has_prefix (p, N_("alsa_pcm")) ||
-                                                    port_has_prefix (p, lpnc)) {
-							extra_system[t].push_back (p);
-						} else {
-							extra_other[t].push_back (p);
+
+				if (!ph) {
+					continue;
+				}
+
+				DataType t (AudioEngine::instance()->port_engine().port_data_type (ph));
+
+				if (t != DataType::NIL) {
+
+					if (port_has_prefix (p, X_("system:")) ||
+					    port_has_prefix (p, X_("alsa_pcm:")) ||
+					    port_has_prefix (p, X_("alsa_midi:"))) {
+						extra_system[t].push_back (p);
+
+					} else if (port_has_prefix (p, lpnc)) {
+
+						/* we own this port (named after the program) */
+
+						/* Hide scene ports from non-Tracks Live builds */
+						if (!ARDOUR::Profile->get_trx()) {
+							if (p.find (_("Scene ")) != string::npos) {
+								++s;
+								continue;
+							}
 						}
+
+						extra_program[t].push_back (p);
+					} else {
+						extra_other[t].push_back (p);
 					}
 				}
 			}
@@ -563,6 +606,14 @@ PortGroupList::gather (ARDOUR::Session* session, ARDOUR::DataType type, bool inp
 		}
 	}
 
+	for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
+		if (!extra_program[*i].empty()) {
+			/* used program name as bundle name */
+			boost::shared_ptr<Bundle> b = make_bundle_from_ports (extra_program[*i], *i, inputs, lpn);
+			program->add_bundle (b);
+		}
+	}
+
 	for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
 		if (extra_other[*i].empty()) continue;
 		std::string cp;
@@ -589,28 +640,35 @@ PortGroupList::gather (ARDOUR::Session* session, ARDOUR::DataType type, bool inp
 	}
 
 	add_group_if_not_empty (other);
-	if (type != DataType::MIDI) {
-		add_group_if_not_empty (bus);
-	}
+	add_group_if_not_empty (bus);
 	add_group_if_not_empty (track);
-	add_group_if_not_empty (ardour);
+	add_group_if_not_empty (program);
 	add_group_if_not_empty (system);
 
 	emit_changed ();
 }
 
 boost::shared_ptr<Bundle>
-PortGroupList::make_bundle_from_ports (std::vector<std::string> const & p, ARDOUR::DataType type, bool inputs) const
+PortGroupList::make_bundle_from_ports (std::vector<std::string> const & p, ARDOUR::DataType type, bool inputs, std::string const& bundle_name) const
 {
 	boost::shared_ptr<Bundle> b (new Bundle ("", inputs));
-
 	std::string const pre = common_prefix (p);
-	if (!pre.empty()) {
-		b->set_name (pre.substr (0, pre.length() - 1));
+
+	if (!bundle_name.empty()) {
+		b->set_name (bundle_name);
+	} else {
+		if (!pre.empty()) {
+			b->set_name (pre.substr (0, pre.length() - 1));
+		}
 	}
 
 	for (uint32_t j = 0; j < p.size(); ++j) {
-		b->add_channel (p[j].substr (pre.length()), type);
+		std::string n = p[j].substr (pre.length());
+		std::string pn = AudioEngine::instance()->get_pretty_name_by_name (p[j]);
+		if (!pn.empty()) {
+			n = pn;
+		}
+		b->add_channel (n, type);
 		b->set_port (j, p[j]);
 	}
 
@@ -791,4 +849,3 @@ PortGroupList::empty () const
 {
 	return _groups.empty ();
 }
-