2 Copyright (C) 2002-2009 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include <gtkmm/scrolledwindow.h>
22 #include <gtkmm/adjustment.h>
23 #include <gtkmm/label.h>
24 #include <gtkmm/menu.h>
25 #include <gtkmm/menushell.h>
26 #include <gtkmm/menu_elems.h>
27 #include <gtkmm/window.h>
28 #include <gtkmm/stock.h>
29 #include <gtkmm/messagedialog.h>
30 #include "ardour/bundle.h"
31 #include "ardour/types.h"
32 #include "ardour/session.h"
33 #include "ardour/route.h"
34 #include "ardour/audioengine.h"
35 #include "port_matrix.h"
36 #include "port_matrix_body.h"
37 #include "port_matrix_component.h"
38 #include "ardour_dialog.h"
40 #include "gui_thread.h"
45 using namespace ARDOUR;
47 /** PortMatrix constructor.
48 * @param session Our session.
49 * @param type Port type that we are handling.
51 PortMatrix::PortMatrix (Window* parent, Session* session, DataType type)
56 , _arrangement (TOP_TO_RIGHT)
59 , _min_height_divisor (1)
60 , _show_only_bundles (false)
61 , _inhibit_toggle_show_only_bundles (false)
62 , _ignore_notebook_page_selected (false)
64 set_session (session);
66 _body = new PortMatrixBody (this);
67 _body->DimensionsChanged.connect (sigc::mem_fun (*this, &PortMatrix::body_dimensions_changed));
69 _hbox.pack_end (_hspacer, true, true);
70 _hbox.pack_end (_hnotebook, false, false);
71 _hbox.pack_end (_hlabel, false, false);
73 _vnotebook.signal_switch_page().connect (sigc::mem_fun (*this, &PortMatrix::notebook_page_selected));
74 _vnotebook.property_tab_border() = 4;
75 _vnotebook.set_name (X_("PortMatrixLabel"));
76 _hnotebook.signal_switch_page().connect (sigc::mem_fun (*this, &PortMatrix::notebook_page_selected));
77 _hnotebook.property_tab_border() = 4;
78 _hnotebook.set_name (X_("PortMatrixLabel"));
80 _vlabel.set_use_markup ();
81 _vlabel.set_alignment (1, 1);
82 _vlabel.set_padding (4, 16);
83 _vlabel.set_name (X_("PortMatrixLabel"));
84 _hlabel.set_use_markup ();
85 _hlabel.set_alignment (1, 0.5);
86 _hlabel.set_padding (16, 4);
87 _hlabel.set_name (X_("PortMatrixLabel"));
89 set_row_spacing (0, 8);
90 set_col_spacing (0, 8);
91 set_row_spacing (2, 8);
92 set_col_spacing (2, 8);
107 PortMatrix::~PortMatrix ()
113 /** Perform initial and once-only setup. This must be called by
114 * subclasses after they have set up _ports[] to at least some
115 * reasonable extent. Two-part initialisation is necessary because
116 * setting up _ports is largely done by virtual functions in
123 select_arrangement ();
125 /* Signal handling is kind of split into three parts:
127 * 1. When _ports[] changes, we call setup(). This essentially sorts out our visual
128 * representation of the information in _ports[].
130 * 2. When certain other things change, we need to get our subclass to clear and
131 * re-fill _ports[], which in turn causes appropriate signals to be raised to
132 * hook into part (1).
134 * 3. Assorted other signals.
138 /* Part 1: the basic _ports[] change -> reset visuals */
140 for (int i = 0; i < 2; ++i) {
141 /* watch for the content of _ports[] changing */
142 _ports[i].Changed.connect (_changed_connections, invalidator (*this), boost::bind (&PortMatrix::setup, this), gui_context());
144 /* and for bundles in _ports[] changing */
145 _ports[i].BundleChanged.connect (_bundle_changed_connections, invalidator (*this), boost::bind (&PortMatrix::setup, this), gui_context());
148 /* Part 2: notice when things have changed that require our subclass to clear and refill _ports[] */
150 /* watch for routes being added or removed */
151 _session->RouteAdded.connect (_session_connections, invalidator (*this), boost::bind (&PortMatrix::routes_changed, this), gui_context());
153 /* and also bundles */
154 _session->BundleAdded.connect (_session_connections, invalidator (*this), boost::bind (&PortMatrix::setup_global_ports, this), gui_context());
157 _session->engine().PortRegisteredOrUnregistered.connect (_session_connections, invalidator (*this), boost::bind (&PortMatrix::setup_global_ports, this), gui_context());
159 /* watch for route order keys changing, which changes the order of things in our global ports list(s) */
160 _session->RouteOrderKeyChanged.connect (_session_connections, invalidator (*this), boost::bind (&PortMatrix::setup_global_ports_proxy, this), gui_context());
162 /* Part 3: other stuff */
164 _session->engine().PortConnectedOrDisconnected.connect (_session_connections, invalidator (*this), boost::bind (&PortMatrix::port_connected_or_disconnected, this), gui_context ());
166 _hscroll.signal_value_changed().connect (sigc::mem_fun (*this, &PortMatrix::hscroll_changed));
167 _vscroll.signal_value_changed().connect (sigc::mem_fun (*this, &PortMatrix::vscroll_changed));
169 reconnect_to_routes ();
174 /** Disconnect from and reconnect to routes' signals that we need to watch for things that affect the matrix */
176 PortMatrix::reconnect_to_routes ()
178 _route_connections.drop_connections ();
180 boost::shared_ptr<RouteList> routes = _session->get_routes ();
181 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
182 (*i)->processors_changed.connect (_route_connections, invalidator (*this), boost::bind (&PortMatrix::route_processors_changed, this, _1), gui_context());
187 PortMatrix::route_processors_changed (RouteProcessorChange c)
189 if (c.type == RouteProcessorChange::MeterPointChange) {
190 /* this change has no impact on the port matrix */
194 setup_global_ports ();
197 /** A route has been added to or removed from the session */
199 PortMatrix::routes_changed ()
201 reconnect_to_routes ();
202 setup_global_ports ();
205 /** Set up everything that depends on the content of _ports[] */
209 /* this needs to be done first, as the visible_ports() method uses the
210 notebook state to decide which ports are being shown */
216 update_tab_highlighting ();
221 PortMatrix::set_type (DataType t)
227 PortMatrix::hscroll_changed ()
229 _body->set_xoffset (_hscroll.get_adjustment()->get_value());
233 PortMatrix::vscroll_changed ()
235 _body->set_yoffset (_vscroll.get_adjustment()->get_value());
239 PortMatrix::setup_scrollbars ()
241 Adjustment* a = _hscroll.get_adjustment ();
243 a->set_upper (_body->full_scroll_width());
244 a->set_page_size (_body->alloc_scroll_width());
245 a->set_step_increment (32);
246 a->set_page_increment (128);
248 a = _vscroll.get_adjustment ();
250 a->set_upper (_body->full_scroll_height());
251 a->set_page_size (_body->alloc_scroll_height());
252 a->set_step_increment (32);
253 a->set_page_increment (128);
256 /** Disassociate all of our ports from each other */
258 PortMatrix::disassociate_all ()
260 PortGroup::BundleList a = _ports[0].bundles ();
261 PortGroup::BundleList b = _ports[1].bundles ();
263 for (PortGroup::BundleList::iterator i = a.begin(); i != a.end(); ++i) {
264 for (uint32_t j = 0; j < (*i)->bundle->nchannels().n_total(); ++j) {
265 for (PortGroup::BundleList::iterator k = b.begin(); k != b.end(); ++k) {
266 for (uint32_t l = 0; l < (*k)->bundle->nchannels().n_total(); ++l) {
268 if (!should_show ((*i)->bundle->channel_type(j)) || !should_show ((*k)->bundle->channel_type(l))) {
272 BundleChannel c[2] = {
273 BundleChannel ((*i)->bundle, j),
274 BundleChannel ((*k)->bundle, l)
277 if (get_state (c) == PortMatrixNode::ASSOCIATED) {
278 set_state (c, false);
286 _body->rebuild_and_draw_grid ();
289 /* Decide how to arrange the components of the matrix */
291 PortMatrix::select_arrangement ()
293 uint32_t const N[2] = {
294 count_of_our_type_min_1 (_ports[0].total_channels()),
295 count_of_our_type_min_1 (_ports[1].total_channels())
298 /* XXX: shirley there's an easier way than this */
300 if (_vspacer.get_parent()) {
301 _vbox.remove (_vspacer);
304 if (_vnotebook.get_parent()) {
305 _vbox.remove (_vnotebook);
308 if (_vlabel.get_parent()) {
309 _vbox.remove (_vlabel);
312 /* The list with the most channels goes on left or right, so that the most channel
313 names are printed horizontally and hence more readable. However we also
314 maintain notional `signal flow' vaguely from left to right. Subclasses
315 should choose where to put ports based on signal flowing from _ports[0]
322 _arrangement = LEFT_TO_BOTTOM;
323 _vlabel.set_label (_("<b>Sources</b>"));
324 _hlabel.set_label (_("<b>Destinations</b>"));
325 _vlabel.set_angle (90);
327 _vbox.pack_end (_vlabel, false, false);
328 _vbox.pack_end (_vnotebook, false, false);
329 _vbox.pack_end (_vspacer, true, true);
331 attach (*_body, 2, 3, 1, 2, FILL | EXPAND, FILL | EXPAND);
332 attach (_vscroll, 3, 4, 1, 2, SHRINK);
333 attach (_hscroll, 2, 3, 3, 4, FILL | EXPAND, SHRINK);
334 attach (_vbox, 1, 2, 1, 2, SHRINK);
335 attach (_hbox, 2, 3, 2, 3, FILL | EXPAND, SHRINK);
341 _arrangement = TOP_TO_RIGHT;
342 _hlabel.set_label (_("<b>Sources</b>"));
343 _vlabel.set_label (_("<b>Destinations</b>"));
344 _vlabel.set_angle (-90);
346 _vbox.pack_end (_vspacer, true, true);
347 _vbox.pack_end (_vnotebook, false, false);
348 _vbox.pack_end (_vlabel, false, false);
350 attach (*_body, 1, 2, 2, 3, FILL | EXPAND, FILL | EXPAND);
351 attach (_vscroll, 3, 4, 2, 3, SHRINK);
352 attach (_hscroll, 1, 2, 3, 4, FILL | EXPAND, SHRINK);
353 attach (_vbox, 2, 3, 2, 3, SHRINK);
354 attach (_hbox, 1, 2, 1, 2, FILL | EXPAND, SHRINK);
358 /** @return columns list */
359 PortGroupList const *
360 PortMatrix::columns () const
362 return &_ports[_column_index];
365 boost::shared_ptr<const PortGroup>
366 PortMatrix::visible_columns () const
368 return visible_ports (_column_index);
371 /* @return rows list */
372 PortGroupList const *
373 PortMatrix::rows () const
375 return &_ports[_row_index];
378 boost::shared_ptr<const PortGroup>
379 PortMatrix::visible_rows () const
381 return visible_ports (_row_index);
384 /** @param column Column; its bundle may be 0 if we are over a row heading.
385 * @param row Row; its bundle may be 0 if we are over a column heading.
388 PortMatrix::popup_menu (BundleChannel column, BundleChannel row, uint32_t t)
390 using namespace Menu_Helpers;
395 _menu->set_name ("ArdourContextMenu");
397 MenuList& items = _menu->items ();
400 bc[_column_index] = column;
401 bc[_row_index] = row;
404 bool need_separator = false;
406 for (int dim = 0; dim < 2; ++dim) {
408 if (bc[dim].bundle) {
410 Menu* m = manage (new Menu);
411 MenuList& sub = m->items ();
413 boost::weak_ptr<Bundle> w (bc[dim].bundle);
415 if (can_add_channels (bc[dim].bundle)) {
416 /* Start off with options for the `natural' port type */
417 for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
418 if (should_show (*i)) {
419 snprintf (buf, sizeof (buf), _("Add %s %s"), (*i).to_i18n_string(), channel_noun().c_str());
420 sub.push_back (MenuElem (buf, sigc::bind (sigc::mem_fun (*this, &PortMatrix::add_channel_proxy), w, *i)));
424 /* Now add other ones */
425 for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
426 if (!should_show (*i)) {
427 snprintf (buf, sizeof (buf), _("Add %s %s"), (*i).to_i18n_string(), channel_noun().c_str());
428 sub.push_back (MenuElem (buf, sigc::bind (sigc::mem_fun (*this, &PortMatrix::add_channel_proxy), w, *i)));
433 if (can_rename_channels (bc[dim].bundle) && bc[dim].channel != -1) {
435 buf, sizeof (buf), _("Rename '%s'..."),
436 escape_underscores (bc[dim].bundle->channel_name (bc[dim].channel)).c_str()
441 sigc::bind (sigc::mem_fun (*this, &PortMatrix::rename_channel_proxy), w, bc[dim].channel)
446 if (can_remove_channels (bc[dim].bundle) && bc[dim].bundle->nchannels() != ARDOUR::ChanCount::ZERO) {
447 if (bc[dim].channel != -1) {
448 add_remove_option (sub, w, bc[dim].channel);
451 MenuElem (_("Remove all"), sigc::bind (sigc::mem_fun (*this, &PortMatrix::remove_all_channels), w))
454 if (bc[dim].bundle->nchannels().n_total() > 1) {
455 for (uint32_t i = 0; i < bc[dim].bundle->nchannels().n_total(); ++i) {
456 if (should_show (bc[dim].bundle->channel_type(i))) {
457 add_remove_option (sub, w, i);
464 uint32_t c = count_of_our_type (bc[dim].bundle->nchannels ());
465 if ((_show_only_bundles && c > 0) || c == 1) {
467 /* we're looking just at bundles, or our bundle has only one channel, so just offer
468 to disassociate all on the bundle.
471 snprintf (buf, sizeof (buf), _("%s all"), disassociation_verb().c_str());
473 MenuElem (buf, sigc::bind (sigc::mem_fun (*this, &PortMatrix::disassociate_all_on_bundle), w, dim))
478 if (bc[dim].channel != -1) {
479 /* specific channel under the menu, so just offer to disassociate that */
480 add_disassociate_option (sub, w, dim, bc[dim].channel);
482 /* no specific channel; offer to disassociate all, or any one in particular */
483 snprintf (buf, sizeof (buf), _("%s all"), disassociation_verb().c_str());
485 MenuElem (buf, sigc::bind (sigc::mem_fun (*this, &PortMatrix::disassociate_all_on_bundle), w, dim))
488 for (uint32_t i = 0; i < bc[dim].bundle->nchannels().n_total(); ++i) {
489 if (should_show (bc[dim].bundle->channel_type(i))) {
490 add_disassociate_option (sub, w, dim, i);
496 items.push_back (MenuElem (escape_underscores (bc[dim].bundle->name()).c_str(), *m));
497 need_separator = true;
502 if (need_separator) {
503 items.push_back (SeparatorElem ());
506 items.push_back (MenuElem (_("Rescan"), sigc::mem_fun (*this, &PortMatrix::setup_all_ports)));
507 items.push_back (CheckMenuElem (_("Show individual ports"), sigc::mem_fun (*this, &PortMatrix::toggle_show_only_bundles)));
508 CheckMenuItem* i = dynamic_cast<CheckMenuItem*> (&items.back());
509 _inhibit_toggle_show_only_bundles = true;
510 i->set_active (!_show_only_bundles);
511 _inhibit_toggle_show_only_bundles = false;
517 PortMatrix::remove_channel_proxy (boost::weak_ptr<Bundle> b, uint32_t c)
519 boost::shared_ptr<Bundle> sb = b.lock ();
524 remove_channel (BundleChannel (sb, c));
529 PortMatrix::rename_channel_proxy (boost::weak_ptr<Bundle> b, uint32_t c)
531 boost::shared_ptr<Bundle> sb = b.lock ();
536 rename_channel (BundleChannel (sb, c));
540 PortMatrix::disassociate_all_on_bundle (boost::weak_ptr<Bundle> bundle, int dim)
542 boost::shared_ptr<Bundle> sb = bundle.lock ();
547 for (uint32_t i = 0; i < sb->nchannels().n_total(); ++i) {
548 if (should_show (sb->channel_type(i))) {
549 disassociate_all_on_channel (bundle, i, dim);
555 PortMatrix::disassociate_all_on_channel (boost::weak_ptr<Bundle> bundle, uint32_t channel, int dim)
557 boost::shared_ptr<Bundle> sb = bundle.lock ();
562 PortGroup::BundleList a = _ports[1-dim].bundles ();
564 for (PortGroup::BundleList::iterator i = a.begin(); i != a.end(); ++i) {
565 for (uint32_t j = 0; j < (*i)->bundle->nchannels().n_total(); ++j) {
567 if (!should_show ((*i)->bundle->channel_type(j))) {
572 c[dim] = BundleChannel (sb, channel);
573 c[1-dim] = BundleChannel ((*i)->bundle, j);
575 if (get_state (c) == PortMatrixNode::ASSOCIATED) {
576 set_state (c, false);
581 _body->rebuild_and_draw_grid ();
585 PortMatrix::setup_global_ports ()
587 ENSURE_GUI_THREAD (*this, &PortMatrix::setup_global_ports)
589 for (int i = 0; i < 2; ++i) {
590 if (list_is_global (i)) {
597 PortMatrix::setup_global_ports_proxy ()
599 /* Avoid a deadlock by calling this in an idle handler: see IOSelector::io_changed_proxy
603 Glib::signal_idle().connect_once (sigc::mem_fun (*this, &PortMatrix::setup_global_ports));
607 PortMatrix::setup_all_ports ()
609 if (_session->deletion_in_progress()) {
613 ENSURE_GUI_THREAD (*this, &PortMatrix::setup_all_ports)
620 PortMatrix::toggle_show_only_bundles ()
622 if (_inhibit_toggle_show_only_bundles) {
626 _show_only_bundles = !_show_only_bundles;
630 /* The way in which hardware ports are grouped changes depending on the _show_only_bundles
631 setting, so we need to set things up again now.
636 pair<uint32_t, uint32_t>
637 PortMatrix::max_size () const
639 pair<uint32_t, uint32_t> m = _body->max_size ();
641 m.first += _vscroll.get_width () + _vbox.get_width () + 4;
642 m.second += _hscroll.get_height () + _hbox.get_height () + 4;
648 PortMatrix::on_scroll_event (GdkEventScroll* ev)
650 double const h = _hscroll.get_value ();
651 double const v = _vscroll.get_value ();
653 switch (ev->direction) {
655 _vscroll.set_value (v - PortMatrixComponent::grid_spacing ());
657 case GDK_SCROLL_DOWN:
658 _vscroll.set_value (v + PortMatrixComponent::grid_spacing ());
660 case GDK_SCROLL_LEFT:
661 _hscroll.set_value (h - PortMatrixComponent::grid_spacing ());
663 case GDK_SCROLL_RIGHT:
664 _hscroll.set_value (h + PortMatrixComponent::grid_spacing ());
671 boost::shared_ptr<IO>
672 PortMatrix::io_from_bundle (boost::shared_ptr<Bundle> b) const
674 boost::shared_ptr<IO> io = _ports[0].io_from_bundle (b);
676 io = _ports[1].io_from_bundle (b);
683 PortMatrix::can_add_channels (boost::shared_ptr<Bundle> b) const
685 return io_from_bundle (b);
689 PortMatrix::add_channel (boost::shared_ptr<Bundle> b, DataType t)
691 boost::shared_ptr<IO> io = io_from_bundle (b);
694 int const r = io->add_port ("", this, t);
696 Gtk::MessageDialog msg (_("It is not possible to add a port here, as the first processor in the track or buss cannot "
697 "support the new configuration."
699 msg.set_title (_("Cannot add port"));
706 PortMatrix::can_remove_channels (boost::shared_ptr<Bundle> b) const
708 return io_from_bundle (b);
712 PortMatrix::remove_channel (ARDOUR::BundleChannel b)
714 boost::shared_ptr<IO> io = io_from_bundle (b.bundle);
717 boost::shared_ptr<Port> p = io->nth (b.channel);
719 int const r = io->remove_port (p, this);
721 ArdourDialog d (_("Port removal not allowed"));
722 Label l (_("This port cannot be removed, as the first plugin in the track or buss cannot accept the new number of inputs."));
723 d.get_vbox()->pack_start (l);
724 d.add_button (Stock::OK, RESPONSE_ACCEPT);
734 PortMatrix::remove_all_channels (boost::weak_ptr<Bundle> w)
736 boost::shared_ptr<Bundle> b = w.lock ();
741 /* Remove channels backwards so that we don't renumber channels
742 that we are about to remove.
744 for (int i = (b->nchannels().n_total() - 1); i >= 0; --i) {
745 if (should_show (b->channel_type(i))) {
746 remove_channel (ARDOUR::BundleChannel (b, i));
752 PortMatrix::add_channel_proxy (boost::weak_ptr<Bundle> w, DataType t)
754 boost::shared_ptr<Bundle> b = w.lock ();
763 PortMatrix::setup_notebooks ()
765 int const h_current_page = _hnotebook.get_current_page ();
766 int const v_current_page = _vnotebook.get_current_page ();
768 /* for some reason best known to GTK, erroneous switch_page signals seem to be generated
769 when adding or removing pages to or from notebooks, so ignore them */
771 _ignore_notebook_page_selected = true;
773 remove_notebook_pages (_hnotebook);
774 remove_notebook_pages (_vnotebook);
776 for (PortGroupList::List::const_iterator i = _ports[_row_index].begin(); i != _ports[_row_index].end(); ++i) {
777 HBox* dummy = manage (new HBox);
779 Label* label = manage (new Label ((*i)->name));
780 label->set_angle (_arrangement == LEFT_TO_BOTTOM ? 90 : -90);
781 label->set_use_markup ();
783 if (_arrangement == LEFT_TO_BOTTOM) {
784 _vnotebook.prepend_page (*dummy, *label);
786 /* Reverse the order of vertical tabs when they are on the right hand side
787 so that from top to bottom it is the same order as that from left to right
790 _vnotebook.append_page (*dummy, *label);
794 for (PortGroupList::List::const_iterator i = _ports[_column_index].begin(); i != _ports[_column_index].end(); ++i) {
795 HBox* dummy = manage (new HBox);
797 Label* label = manage (new Label ((*i)->name));
798 label->set_use_markup ();
800 _hnotebook.append_page (*dummy, *label);
803 _ignore_notebook_page_selected = false;
805 if (_arrangement == TOP_TO_RIGHT) {
806 _vnotebook.set_tab_pos (POS_RIGHT);
807 _hnotebook.set_tab_pos (POS_TOP);
809 _vnotebook.set_tab_pos (POS_LEFT);
810 _hnotebook.set_tab_pos (POS_BOTTOM);
813 if (h_current_page != -1 && _hnotebook.get_n_pages() > h_current_page) {
814 _hnotebook.set_current_page (h_current_page);
816 _hnotebook.set_current_page (0);
819 if (v_current_page != -1 && _vnotebook.get_n_pages() > v_current_page) {
820 _vnotebook.set_current_page (v_current_page);
822 _vnotebook.set_current_page (0);
825 if (_hnotebook.get_n_pages() <= 1) {
831 if (_vnotebook.get_n_pages() <= 1) {
839 PortMatrix::remove_notebook_pages (Notebook& n)
841 int const N = n.get_n_pages ();
843 for (int i = 0; i < N; ++i) {
849 PortMatrix::notebook_page_selected (GtkNotebookPage *, guint)
851 if (_ignore_notebook_page_selected) {
861 PortMatrix::session_going_away ()
867 PortMatrix::body_dimensions_changed ()
869 _hspacer.set_size_request (_body->column_labels_border_x (), -1);
870 if (_arrangement == TOP_TO_RIGHT) {
871 _vspacer.set_size_request (-1, _body->column_labels_height ());
879 _parent->get_size (curr_width, curr_height);
881 pair<uint32_t, uint32_t> m = max_size ();
883 /* Don't shrink the window */
884 m.first = max (int (m.first), curr_width);
885 m.second = max (int (m.second), curr_height);
887 resize_window_to_proportion_of_monitor (_parent, m.first, m.second);
890 /** @return The PortGroup that is currently visible (ie selected by
891 * the notebook) along a given axis.
893 boost::shared_ptr<const PortGroup>
894 PortMatrix::visible_ports (int d) const
896 PortGroupList const & p = _ports[d];
897 PortGroupList::List::const_iterator j = p.begin ();
899 /* The logic to compute the index here is a bit twisty because for
900 the TOP_TO_RIGHT arrangement we reverse the order of the vertical
901 tabs in setup_notebooks ().
905 if (d == _row_index) {
906 if (_arrangement == LEFT_TO_BOTTOM) {
907 n = p.size() - _vnotebook.get_current_page () - 1;
909 n = _vnotebook.get_current_page ();
912 n = _hnotebook.get_current_page ();
916 while (i != int (n) && j != p.end ()) {
922 return boost::shared_ptr<const PortGroup> ();
929 PortMatrix::add_remove_option (Menu_Helpers::MenuList& m, boost::weak_ptr<Bundle> w, int c)
931 using namespace Menu_Helpers;
933 boost::shared_ptr<Bundle> b = w.lock ();
939 snprintf (buf, sizeof (buf), _("Remove '%s'"), escape_underscores (b->channel_name (c)).c_str());
940 m.push_back (MenuElem (buf, sigc::bind (sigc::mem_fun (*this, &PortMatrix::remove_channel_proxy), w, c)));
944 PortMatrix::add_disassociate_option (Menu_Helpers::MenuList& m, boost::weak_ptr<Bundle> w, int d, int c)
946 using namespace Menu_Helpers;
948 boost::shared_ptr<Bundle> b = w.lock ();
954 snprintf (buf, sizeof (buf), _("%s all from '%s'"), disassociation_verb().c_str(), escape_underscores (b->channel_name (c)).c_str());
955 m.push_back (MenuElem (buf, sigc::bind (sigc::mem_fun (*this, &PortMatrix::disassociate_all_on_channel), w, c, d)));
959 PortMatrix::port_connected_or_disconnected ()
961 _body->rebuild_and_draw_grid ();
962 update_tab_highlighting ();
965 /** Update the highlighting of tab names to reflect which ones
966 * have connections. This is pretty inefficient, unfortunately,
967 * but maybe that doesn't matter too much.
970 PortMatrix::update_tab_highlighting ()
976 for (int i = 0; i < 2; ++i) {
978 Gtk::Notebook* notebook = row_index() == i ? &_vnotebook : &_hnotebook;
980 PortGroupList const * gl = ports (i);
982 for (PortGroupList::List::const_iterator j = gl->begin(); j != gl->end(); ++j) {
983 bool has_connection = false;
984 PortGroup::BundleList const & bl = (*j)->bundles ();
985 PortGroup::BundleList::const_iterator k = bl.begin ();
986 while (k != bl.end()) {
987 if ((*k)->bundle->connected_to_anything (_session->engine())) {
988 has_connection = true;
994 /* Find the page index that we should update; this is backwards
995 for the vertical tabs in the LEFT_TO_BOTTOM arrangement.
998 if (i == row_index() && _arrangement == LEFT_TO_BOTTOM) {
999 page = notebook->get_n_pages() - p - 1;
1002 Gtk::Label* label = dynamic_cast<Gtk::Label*> (notebook->get_tab_label(*notebook->get_nth_page (page)));
1003 string c = label->get_label ();
1004 if (c.length() && c[0] == '<' && !has_connection) {
1005 /* this label is marked up with <b> but shouldn't be */
1006 label->set_markup ((*j)->name);
1007 } else if (c.length() && c[0] != '<' && has_connection) {
1008 /* this label is not marked up with <b> but should be */
1009 label->set_markup (string_compose ("<b>%1</b>", (*j)->name));
1018 PortMatrix::channel_noun () const
1020 return _("channel");
1023 /** @return true if this matrix should show bundles / ports of type \t */
1025 PortMatrix::should_show (DataType t) const
1027 return (_type == DataType::NIL || t == _type);
1031 PortMatrix::count_of_our_type (ChanCount c) const
1033 if (_type == DataType::NIL) {
1034 return c.n_total ();
1037 return c.get (_type);
1040 /** @return The number of ports of our type in the given channel count,
1041 * but returning 1 if there are no ports.
1044 PortMatrix::count_of_our_type_min_1 (ChanCount c) const
1046 uint32_t n = count_of_our_type (c);
1054 PortMatrixNode::State
1055 PortMatrix::get_association (PortMatrixNode node) const
1057 if (show_only_bundles ()) {
1059 bool have_off_diagonal_association = false;
1060 bool have_diagonal_association = false;
1061 bool have_diagonal_not_association = false;
1063 for (uint32_t i = 0; i < node.row.bundle->nchannels().n_total(); ++i) {
1065 for (uint32_t j = 0; j < node.column.bundle->nchannels().n_total(); ++j) {
1067 if (!should_show (node.row.bundle->channel_type(i)) || !should_show (node.column.bundle->channel_type(j))) {
1071 ARDOUR::BundleChannel c[2];
1072 c[row_index()] = ARDOUR::BundleChannel (node.row.bundle, i);
1073 c[column_index()] = ARDOUR::BundleChannel (node.column.bundle, j);
1075 PortMatrixNode::State const s = get_state (c);
1078 case PortMatrixNode::ASSOCIATED:
1080 have_diagonal_association = true;
1082 have_off_diagonal_association = true;
1086 case PortMatrixNode::NOT_ASSOCIATED:
1088 have_diagonal_not_association = true;
1098 if (have_diagonal_association && !have_off_diagonal_association && !have_diagonal_not_association) {
1099 return PortMatrixNode::ASSOCIATED;
1100 } else if (!have_diagonal_association && !have_off_diagonal_association) {
1101 return PortMatrixNode::NOT_ASSOCIATED;
1104 return PortMatrixNode::PARTIAL;
1108 ARDOUR::BundleChannel c[2];
1109 c[column_index()] = node.column;
1110 c[row_index()] = node.row;
1111 return get_state (c);
1116 return PortMatrixNode::NOT_ASSOCIATED;
1119 /** @return true if b is a non-zero pointer and the bundle it points to has some channels */
1121 PortMatrix::bundle_with_channels (boost::shared_ptr<ARDOUR::Bundle> b)
1123 return b && b->nchannels() != ARDOUR::ChanCount::ZERO;