#include <gtkmm/menushell.h>
#include <gtkmm/menu_elems.h>
#include <gtkmm/window.h>
+#include <gtkmm/stock.h>
+#include <gtkmm/messagedialog.h>
#include "ardour/bundle.h"
#include "ardour/types.h"
#include "ardour/session.h"
#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"
}
/* 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 (_session_connections, invalidator (*this), boost::bind (&PortMatrix::routes_changed, this), gui_context());
_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 ());
_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 ();
-
+
setup ();
}
notebook state to decide which ports are being shown */
setup_notebooks ();
-
+
_body->setup ();
setup_scrollbars ();
queue_draw ();
PortMatrix::select_arrangement ()
{
uint32_t const N[2] = {
- count_of_our_type (_ports[0].total_channels()),
- count_of_our_type (_ports[1].total_channels())
+ count_of_our_type_min_1 (_ports[0].total_channels()),
+ count_of_our_type_min_1 (_ports[1].total_channels())
};
/* XXX: shirley there's an easier way than this */
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 {
_row_index = 1;
return visible_ports (_row_index);
}
+/** @param column Column; its bundle may be 0 if we are over a row heading.
+ * @param row Row; its bundle may be 0 if we are over a column heading.
+ */
void
PortMatrix::popup_menu (BundleChannel column, BundleChannel row, uint32_t t)
{
boost::weak_ptr<Bundle> w (bc[dim].bundle);
- bool can_add_or_rename = false;
-
+ /* 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)));
}
}
sigc::bind (sigc::mem_fun (*this, &PortMatrix::rename_channel_proxy), w, bc[dim].channel)
)
);
- can_add_or_rename = true;
}
- if (can_add_or_rename) {
- sub.push_back (SeparatorElem ());
- }
-
- if (can_remove_channels (bc[dim].bundle)) {
+ if (can_remove_channels (bc[dim].bundle) && bc[dim].bundle->nchannels() != ARDOUR::ChanCount::ZERO) {
if (bc[dim].channel != -1) {
add_remove_option (sub, w, bc[dim].channel);
} else {
sub.push_back (
MenuElem (buf, sigc::bind (sigc::mem_fun (*this, &PortMatrix::remove_all_channels), w))
);
-
- 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 (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 || count_of_our_type (bc[dim].bundle->nchannels()) <= 1) {
+ uint32_t c = count_of_our_type (bc[dim].bundle->nchannels ());
+ if ((_show_only_bundles && c > 0) || c == 1) {
+
+ /* we're looking just at bundles, or our bundle has only one channel, so just offer
+ to disassociate all on the bundle.
+ */
+
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_channel), w, bc[dim].channel, dim))
+ MenuElem (buf, sigc::bind (sigc::mem_fun (*this, &PortMatrix::disassociate_all_on_bundle), w, dim))
);
-
- } else {
-
+
+ } else if (c != 0) {
+
if (bc[dim].channel != -1) {
+ /* specific channel under the menu, so just offer to disassociate that */
add_disassociate_option (sub, w, dim, bc[dim].channel);
} else {
+ /* no specific channel; offer to disassociate all, or any one in particular */
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);
for (PortGroup::BundleList::iterator i = a.begin(); i != a.end(); ++i) {
for (uint32_t j = 0; j < (*i)->bundle->nchannels().n_total(); ++j) {
- if (should_show ((*i)->bundle->channel_type(j))) {
+ if (!should_show ((*i)->bundle->channel_type(j))) {
continue;
}
}
_show_only_bundles = !_show_only_bundles;
-
+
setup ();
}
boost::shared_ptr<IO> io = io_from_bundle (b);
if (io) {
- io->add_port ("", this, t);
+ int const r = io->add_port ("", this, t);
+ if (r == -1) {
+ Gtk::MessageDialog msg (_("It is not possible to add a port here, as the first processor in the track or buss cannot "
+ "support the new configuration."
+ ));
+ msg.set_title (_("Cannot add port"));
+ msg.run ();
+ }
}
}
boost::shared_ptr<IO> io = io_from_bundle (b.bundle);
if (io) {
- Port* p = io->nth (b.channel);
+ boost::shared_ptr<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 ();
+ }
}
}
}
return;
}
- for (uint32_t i = 0; i < b->nchannels().n_total(); ++i) {
+ /* Remove channels backwards so that we don't renumber channels
+ that we are about to remove.
+ */
+ for (int i = (b->nchannels().n_total() - 1); i >= 0; --i) {
if (should_show (b->channel_type(i))) {
remove_channel (ARDOUR::BundleChannel (b, i));
}
{
int const h_current_page = _hnotebook.get_current_page ();
int const v_current_page = _vnotebook.get_current_page ();
-
+
/* for some reason best known to GTK, erroneous switch_page signals seem to be generated
when adding or removing pages to or from notebooks, so ignore them */
-
+
_ignore_notebook_page_selected = true;
-
+
remove_notebook_pages (_hnotebook);
remove_notebook_pages (_vnotebook);
Label* label = manage (new Label ((*i)->name));
label->set_angle (_arrangement == LEFT_TO_BOTTOM ? 90 : -90);
label->show ();
- _vnotebook.prepend_page (*dummy, *label);
+ if (_arrangement == LEFT_TO_BOTTOM) {
+ _vnotebook.prepend_page (*dummy, *label);
+ } else {
+ /* Reverse the order of vertical tabs when they are on the right hand side
+ so that from top to bottom it is the same order as that from left to right
+ for the top tabs.
+ */
+ _vnotebook.append_page (*dummy, *label);
+ }
}
for (PortGroupList::List::const_iterator i = _ports[_column_index].begin(); i != _ports[_column_index].end(); ++i) {
PortMatrix::remove_notebook_pages (Notebook& n)
{
int const N = n.get_n_pages ();
-
+
for (int i = 0; i < N; ++i) {
n.remove_page ();
}
/* Don't shrink the window */
m.first = max (int (m.first), curr_width);
m.second = max (int (m.second), curr_height);
-
+
resize_window_to_proportion_of_monitor (_parent, m.first, m.second);
}
-
+/** @return The PortGroup that is currently visible (ie selected by
+ * the notebook) along a given axis.
+ */
boost::shared_ptr<const PortGroup>
PortMatrix::visible_ports (int d) const
{
PortGroupList const & p = _ports[d];
PortGroupList::List::const_iterator j = p.begin ();
+ /* The logic to compute the index here is a bit twisty because for
+ the TOP_TO_RIGHT arrangement we reverse the order of the vertical
+ tabs in setup_notebooks ().
+ */
+
int n = 0;
if (d == _row_index) {
- n = p.size() - _vnotebook.get_current_page () - 1;
+ if (_arrangement == LEFT_TO_BOTTOM) {
+ n = p.size() - _vnotebook.get_current_page () - 1;
+ } else {
+ n = _vnotebook.get_current_page ();
+ }
} else {
n = _hnotebook.get_current_page ();
}
++i;
++j;
}
-
+
if (j == p.end()) {
return boost::shared_ptr<const PortGroup> ();
}
if (!b) {
return;
}
-
+
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 (!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)));
{
return (_type == DataType::NIL || t == _type);
}
-
+
uint32_t
PortMatrix::count_of_our_type (ChanCount c) const
{
return c.get (_type);
}
+
+/** @return The number of ports of our type in the given channel count,
+ * but returning 1 if there are no ports.
+ */
+uint32_t
+PortMatrix::count_of_our_type_min_1 (ChanCount c) const
+{
+ uint32_t n = count_of_our_type (c);
+ if (n == 0) {
+ n = 1;
+ }
+
+ return n;
+}
+
+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 {
+
+ ARDOUR::BundleChannel c[2];
+ c[column_index()] = node.column;
+ c[row_index()] = node.row;
+ return get_state (c);
+
+ }
+
+ /* NOTREACHED */
+ return PortMatrixNode::NOT_ASSOCIATED;
+}
+
+/** @return true if b is a non-zero pointer and the bundle it points to has some channels */
+bool
+PortMatrix::bundle_with_channels (boost::shared_ptr<ARDOUR::Bundle> b)
+{
+ return b && b->nchannels() != ARDOUR::ChanCount::ZERO;
+}
projects / ardour.git / blobdiff