/* Copyright (C) 2002-2003 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include #include #include #include #include #include #include "ardour/session.h" #include "ardour/io.h" #include "ardour/audioengine.h" #include "ardour/track.h" #include "ardour/audio_track.h" #include "ardour/midi_track.h" #include "ardour/data_type.h" #include "io_selector.h" #include "utils.h" #include "gui_thread.h" #include "i18n.h" void PortGroup::add (std::string const & p) { if (prefix.empty() == false && p.substr (0, prefix.length()) == prefix) { ports.push_back (p.substr (prefix.length())); } else { ports.push_back (p); } } RotatedLabelSet::RotatedLabelSet (GroupedPortList& g) : Glib::ObjectBase ("RotatedLabelSet"), Gtk::Widget (), _port_list (g), _base_start (64), _base_width (128) { set_flags (Gtk::NO_WINDOW); set_angle (30); } RotatedLabelSet::~RotatedLabelSet () { } /** Set the angle that the labels are drawn at. * @param degrees New angle in degrees. */ void RotatedLabelSet::set_angle (int degrees) { _angle_degrees = degrees; _angle_radians = M_PI * _angle_degrees / 180; queue_resize (); } void RotatedLabelSet::on_size_request (Gtk::Requisition* requisition) { *requisition = Gtk::Requisition (); if (_pango_layout == 0) { return; } /* Our height is the highest label */ requisition->height = 0; for (GroupedPortList::const_iterator i = _port_list.begin(); i != _port_list.end(); ++i) { for (std::vector::const_iterator j = i->ports.begin(); j != i->ports.end(); ++j) { std::pair const d = setup_layout (*j); if (d.second > requisition->height) { requisition->height = d.second; } } } /* And our width is the base plus the width of the last label */ requisition->width = _base_start + _base_width; int const n = _port_list.n_ports (); if (n > 0) { std::pair const d = setup_layout (_port_list.get_port_by_index (n - 1, false)); requisition->width += d.first; } } void RotatedLabelSet::on_size_allocate (Gtk::Allocation& allocation) { set_allocation (allocation); if (_gdk_window) { _gdk_window->move_resize ( allocation.get_x(), allocation.get_y(), allocation.get_width(), allocation.get_height() ); } } void RotatedLabelSet::on_realize () { Gtk::Widget::on_realize (); Glib::RefPtr style = get_style (); if (!_gdk_window) { GdkWindowAttr attributes; memset (&attributes, 0, sizeof (attributes)); Gtk::Allocation allocation = get_allocation (); attributes.x = allocation.get_x (); attributes.y = allocation.get_y (); attributes.width = allocation.get_width (); attributes.height = allocation.get_height (); attributes.event_mask = get_events () | Gdk::EXPOSURE_MASK; attributes.window_type = GDK_WINDOW_CHILD; attributes.wclass = GDK_INPUT_OUTPUT; _gdk_window = Gdk::Window::create (get_window (), &attributes, GDK_WA_X | GDK_WA_Y); unset_flags (Gtk::NO_WINDOW); set_window (_gdk_window); _bg_colour = style->get_bg (Gtk::STATE_NORMAL ); modify_bg (Gtk::STATE_NORMAL, _bg_colour); _fg_colour = style->get_fg (Gtk::STATE_NORMAL); ; _gdk_window->set_user_data (gobj ()); /* Set up Pango stuff */ _pango_context = create_pango_context (); Pango::Matrix matrix = PANGO_MATRIX_INIT; pango_matrix_rotate (&matrix, _angle_degrees); _pango_context->set_matrix (matrix); _pango_layout = Pango::Layout::create (_pango_context); _gc = Gdk::GC::create (get_window ()); } } void RotatedLabelSet::on_unrealize() { _gdk_window.clear (); Gtk::Widget::on_unrealize (); } /** * Set up our Pango layout to plot a given string, and compute its dimensions once it has been rotated. * @param s String to use. * @return width and height of the rotated string, in pixels. */ std::pair RotatedLabelSet::setup_layout (std::string const & s) { _pango_layout->set_text (s); /* Here's the unrotated size */ int w; int h; _pango_layout->get_pixel_size (w, h); /* Rotate the width and height as appropriate. I thought Pango might be able to do this for us, but I can't find out how... */ std::pair d; d.first = int (w * cos (_angle_radians) - h * sin (_angle_radians)); d.second = int (w * sin (_angle_radians) + h * cos (_angle_radians)); return d; } bool RotatedLabelSet::on_expose_event (GdkEventExpose* event) { if (!_gdk_window) { return true; } int const height = get_allocation().get_height (); double const spacing = double (_base_width) / _port_list.n_ports(); /* Plot all the labels; really we should clip for efficiency */ int n = 0; for (GroupedPortList::const_iterator i = _port_list.begin(); i != _port_list.end(); ++i) { for (uint32_t j = 0; j < i->ports.size(); ++j) { std::pair const d = setup_layout (i->ports[j]); get_window()->draw_layout (_gc, _base_start + int ((n + 0.25) * spacing), height - d.second, _pango_layout, _fg_colour, _bg_colour); ++n; } } return true; } /** * Set the `base dimensions'. These are the dimensions of the area at which the labels start, and * have to be set up to match whatever they are labelling. * * Roughly speaking, we have * * L L L L * E E E E * B B B B * A A A A * L L L L * <--s--><--w---> */ void RotatedLabelSet::set_base_dimensions (int s, int w) { _base_start = s; _base_width = w; queue_resize (); } /** * Construct an IOSelector. * @param session Session to operate on. * @param io IO to operate on. * @param for_input true if the selector is for an input, otherwise false. */ IOSelector::IOSelector (ARDOUR::Session& session, boost::shared_ptr io, bool for_input) : _session (session), _port_list (session, io, for_input), _io (io), _for_input (for_input), _width (0), _height (0), _column_labels (_port_list), _ignore_check_button_toggle (false), _add_remove_box_added (false) { /* Column labels */ pack_start (_column_labels, true, true); /* Buttons for adding and removing ports */ _add_port_button.set_image (*Gtk::manage (new Gtk::Image (Gtk::Stock::ADD, Gtk::ICON_SIZE_MENU))); _add_port_button.set_label (_("Add port")); _add_port_button.signal_clicked().connect (mem_fun (*this, &IOSelector::add_port_button_clicked)); _add_remove_box.pack_start (_add_port_button); _remove_port_button.set_image (*Gtk::manage (new Gtk::Image (Gtk::Stock::REMOVE, Gtk::ICON_SIZE_MENU))); _remove_port_button.set_label (_("Remove port")); _remove_port_button.signal_clicked().connect (mem_fun (*this, &IOSelector::remove_port_button_clicked)); _add_remove_box.pack_start (_remove_port_button); set_button_sensitivity (); /* Table. We need to put in a HBox, with a dummy label to its right, so that the rotated column labels can overhang the right hand side of the table. */ setup_table (); setup_row_labels (); setup_check_button_states (); _table_hbox.pack_start (_table, false, false); _table_hbox.pack_start (_dummy); _table.set_col_spacings (4); pack_start (_table_hbox); show_all (); update_column_label_dimensions (); /* Listen for ports changing on the IO */ if (_for_input) { _io->input_changed.connect (mem_fun(*this, &IOSelector::ports_changed)); } else { _io->output_changed.connect (mem_fun(*this, &IOSelector::ports_changed)); } } IOSelector::~IOSelector () { for (std::vector::iterator i = _row_labels.begin(); i != _row_labels.end(); ++i) { delete *i; } for (uint32_t x = 0; x < _check_buttons.size(); ++x) { for (uint32_t y = 0; y < _check_buttons[x].size(); ++y) { delete _check_buttons[x][y]; } } } /** * Sets up the sizing of the column label widget to match the table that's underneath it. */ void IOSelector::update_column_label_dimensions () { if (_row_labels.empty() || _check_buttons.empty() || _check_buttons[0].empty()) { return; } _column_labels.set_base_dimensions ( /* width of the row label + a column spacing */ _row_labels.front()->get_width() + _table.get_col_spacing (0), /* width of a check button + a column spacing for each column */ _check_buttons.size() * ( _check_buttons[0][0]->get_width() + _table.get_col_spacing(1)) ); } void IOSelector::setup_table () { if (_add_remove_box_added) { _table.remove (_add_remove_box); } for (std::vector::iterator i = _group_labels.begin(); i != _group_labels.end(); ++i) { _table.remove (**i); delete *i; } _group_labels.clear (); /* New width */ int const old_width = _width; _width = _port_list.n_ports (); /* New height */ int const old_height = _height; ARDOUR::DataType const t = _io->default_type(); if (_for_input) { _height = _io->n_inputs().get(t); } else { _height = _io->n_outputs().get(t); } _table.resize (_width + 1, _height + 1); /* Add checkbuttons where required, and remove those that aren't */ for (int x = _width; x < old_width; ++x) { for (int y = 0; y < old_height; ++y) { delete _check_buttons[x][y]; } } _check_buttons.resize (_width); for (int x = 0; x < _width; x++) { for (int y = _height; y < old_height; ++y) { delete _check_buttons[x][y]; } _check_buttons[x].resize (_height); for (int y = 0; y < _height; y++) { if (x >= old_width || y >= old_height) { Gtk::CheckButton* button = new Gtk::CheckButton; button->signal_toggled().connect ( sigc::bind (sigc::mem_fun (*this, &IOSelector::check_button_toggled), x, y) ); _check_buttons[x][y] = button; _table.attach (*button, x + 1, x + 2, y, y + 1); } } } /* Add more row labels where required, and remove those that aren't */ for (int y = _height; y < old_height; ++y) { delete _row_labels[y]; } _row_labels.resize (_height); for (int y = old_height; y < _height; ++y) { Gtk::Label* label = new Gtk::Label; _row_labels[y] = label; _table.attach (*label, 0, 1, y, y + 1); } _table.attach (_add_remove_box, 0, 1, _height, _height + 1); _add_remove_box_added = true; /* Add group labels */ int n = 1; int m = 0; /* XXX: this is a bit of a hack; should probably use a configurable colour here */ Gdk::Color alt_bg = get_style()->get_bg (Gtk::STATE_NORMAL); alt_bg.set_rgb (alt_bg.get_red() + 4096, alt_bg.get_green() + 4096, alt_bg.get_blue () + 4096); for (GroupedPortList::iterator i = _port_list.begin(); i != _port_list.end(); ++i) { if (i->ports.empty() == false) { Gtk::Label* label = new Gtk::Label ("" + i->name + ""); label->set_use_markup (true); Gtk::EventBox* box = new Gtk::EventBox (); box->add (*Gtk::manage (label)); if (m % 2 == 0) { box->modify_bg (Gtk::STATE_NORMAL, alt_bg); } _group_labels.push_back (box); _table.attach (*box, n, n + i->ports.size(), _height, _height + 1); n += i->ports.size(); ++m; } } show_all (); } /** * Write the correct text to the row labels. */ void IOSelector::setup_row_labels () { for (int y = 0; y < _height; y++) { _row_labels[y]->set_text (_for_input ? _io->input(y)->name() : _io->output(y)->name()); } } /** * Set up the state of each check button according to what connections are made. */ void IOSelector::setup_check_button_states () { _ignore_check_button_toggle = true; /* Set the state of the check boxes according to current connections */ for (int i = 0; i < _height; ++i) { const char **connections = _for_input ? _io->input(i)->get_connections() : _io->output(i)->get_connections(); for (int j = 0; j < _width; ++j) { std::string const t = _port_list.get_port_by_index (j); int k = 0; bool required_state = false; while (connections && connections[k]) { if (std::string(connections[k]) == t) { required_state = true; break; } ++k; } _check_buttons[j][i]->set_active (required_state); } } _ignore_check_button_toggle = false; } /** * Handle a toggle of a check button. */ void IOSelector::check_button_toggled (int x, int y) { if (_ignore_check_button_toggle) { return; } bool const new_state = _check_buttons[x][y]->get_active (); std::string const port = _port_list.get_port_by_index (x); if (new_state) { if (_for_input) { _io->connect_input (_io->input(y), port, 0); } else { _io->connect_output (_io->output(y), port, 0); } } else { if (_for_input) { _io->disconnect_input (_io->input(y), port, 0); } else { _io->disconnect_output (_io->output(y), port, 0); } } } void IOSelector::add_port_button_clicked () { /* add a new port, then hide the button if we're up to the maximum allowed */ // The IO selector only works for single typed IOs const ARDOUR::DataType t = _io->default_type(); if (_for_input) { try { _io->add_input_port ("", this); } catch (ARDOUR::AudioEngine::PortRegistrationFailure& err) { Gtk::MessageDialog msg (0, _("There are no more JACK ports available.")); msg.run (); } } else { try { _io->add_output_port ("", this); } catch (ARDOUR::AudioEngine::PortRegistrationFailure& err) { Gtk::MessageDialog msg (0, _("There are no more JACK ports available.")); msg.run (); } } set_button_sensitivity (); } void IOSelector::remove_port_button_clicked () { uint32_t nports; // The IO selector only works for single typed IOs const ARDOUR::DataType t = _io->default_type(); // always remove last port if (_for_input) { if ((nports = _io->n_inputs().get(t)) > 0) { _io->remove_input_port (_io->input(nports - 1), this); } } else { if ((nports = _io->n_outputs().get(t)) > 0) { _io->remove_output_port (_io->output(nports - 1), this); } } set_button_sensitivity (); } void IOSelector::set_button_sensitivity () { ARDOUR::DataType const t = _io->default_type(); if (_for_input) { _add_port_button.set_sensitive ( _io->input_maximum().get(t) > _io->n_inputs().get(t) ); } else { _add_port_button.set_sensitive ( _io->output_maximum().get(t) > _io->n_outputs().get(t) ); } if (_for_input) { _remove_port_button.set_sensitive ( _io->n_inputs().get(t) && _io->input_minimum().get(t) < _io->n_inputs().get(t) ); } else { _remove_port_button.set_sensitive ( _io->n_outputs().get(t) && _io->output_minimum().get(t) < _io->n_outputs().get(t) ); } } void IOSelector::ports_changed (ARDOUR::IOChange change, void *src) { ENSURE_GUI_THREAD (bind (mem_fun (*this, &IOSelector::ports_changed), change, src)); redisplay (); } void IOSelector::redisplay () { _port_list.refresh (); setup_table (); setup_row_labels (); setup_check_button_states (); update_column_label_dimensions (); } GroupedPortList::GroupedPortList (ARDOUR::Session & session, boost::shared_ptr io, bool for_input) : _session (session), _io (io), _for_input (for_input) { refresh (); } void GroupedPortList::refresh () { clear (); /* Find the ports provided by ardour; we can't derive their type just from their names, so we'll have to be more devious. */ boost::shared_ptr routes = _session.get_routes (); PortGroup buss (_("Buss"), "ardour:"); PortGroup track (_("Track"), "ardour:"); for (ARDOUR::Session::RouteList::const_iterator i = routes->begin(); i != routes->end(); ++i) { PortGroup* g = 0; if (_io->default_type() == ARDOUR::DataType::AUDIO && dynamic_cast ((*i).get())) { /* Audio track for an audio IO */ g = &track; } else if (_io->default_type() == ARDOUR::DataType::MIDI && dynamic_cast ((*i).get())) { /* Midi track for a MIDI IO */ g = &track; } else if (_io->default_type() == ARDOUR::DataType::AUDIO && dynamic_cast ((*i).get()) == 0) { /* Non-MIDI track for an Audio IO; must be an audio buss */ g = &buss; } if (g) { ARDOUR::PortSet const & p = _for_input ? ((*i)->outputs()) : ((*i)->inputs()); for (uint32_t j = 0; j < p.num_ports(); ++j) { g->add (p.port(j)->name ()); } std::sort (g->ports.begin(), g->ports.end()); } } /* XXX: inserts, sends, plugin inserts? */ /* Now we need to find the non-ardour ports; we do this by first finding all the ports that we can connect to. */ const char **ports = _session.engine().get_ports ( "", _io->default_type().to_jack_type(), _for_input ? JackPortIsOutput : JackPortIsInput ); PortGroup system (_("System"), "system:"); PortGroup other (_("Other"), ""); if (ports) { int n = 0; while (ports[n]) { std::string const p = ports[n]; if (p.substr(0, strlen ("system:")) == "system:") { /* system: prefix */ system.add (p); } else { if (p.substr(0, strlen("ardour:")) != "ardour:") { /* other (non-ardour) prefix */ other.add (p); } } ++n; } } push_back (buss); push_back (track); push_back (system); push_back (other); } int GroupedPortList::n_ports () const { int n = 0; for (const_iterator i = begin(); i != end(); ++i) { for (std::vector::const_iterator j = i->ports.begin(); j != i->ports.end(); ++j) { ++n; } } return n; } std::string GroupedPortList::get_port_by_index (int n, bool with_prefix) const { /* XXX: slightly inefficient algorithm */ for (const_iterator i = begin(); i != end(); ++i) { for (std::vector::const_iterator j = i->ports.begin(); j != i->ports.end(); ++j) { if (n == 0) { if (with_prefix) { return i->prefix + *j; } else { return *j; } } --n; } } return ""; } IOSelectorWindow::IOSelectorWindow ( ARDOUR::Session& session, boost::shared_ptr io, bool for_input, bool can_cancel ) : ArdourDialog ("I/O selector"), _selector (session, io, for_input), ok_button (can_cancel ? _("OK"): _("Close")), cancel_button (_("Cancel")), rescan_button (_("Rescan")) { add_events (Gdk::KEY_PRESS_MASK | Gdk::KEY_RELEASE_MASK); set_name ("IOSelectorWindow2"); string title; if (for_input) { title = string_compose(_("%1 input"), io->name()); } else { title = string_compose(_("%1 output"), io->name()); } ok_button.set_name ("IOSelectorButton"); if (!can_cancel) { ok_button.set_image (*Gtk::manage (new Gtk::Image (Gtk::Stock::CLOSE, Gtk::ICON_SIZE_BUTTON))); } cancel_button.set_name ("IOSelectorButton"); rescan_button.set_name ("IOSelectorButton"); rescan_button.set_image (*Gtk::manage (new Gtk::Image (Gtk::Stock::REFRESH, Gtk::ICON_SIZE_BUTTON))); get_action_area()->pack_start (rescan_button, false, false); if (can_cancel) { cancel_button.set_image (*Gtk::manage (new Gtk::Image (Gtk::Stock::CANCEL, Gtk::ICON_SIZE_BUTTON))); get_action_area()->pack_start (cancel_button, false, false); } else { cancel_button.hide(); } get_action_area()->pack_start (ok_button, false, false); get_vbox()->set_spacing (8); get_vbox()->pack_start (_selector); ok_button.signal_clicked().connect (mem_fun(*this, &IOSelectorWindow::accept)); cancel_button.signal_clicked().connect (mem_fun(*this, &IOSelectorWindow::cancel)); rescan_button.signal_clicked().connect (mem_fun(*this, &IOSelectorWindow::rescan)); set_title (title); set_position (Gtk::WIN_POS_MOUSE); show_all (); signal_delete_event().connect (bind (sigc::ptr_fun (just_hide_it), reinterpret_cast (this))); } IOSelectorWindow::~IOSelectorWindow() { } void IOSelectorWindow::rescan () { _selector.redisplay (); } void IOSelectorWindow::cancel () { _selector.Finished (IOSelector::Cancelled); hide (); } void IOSelectorWindow::accept () { _selector.Finished (IOSelector::Accepted); hide (); } void IOSelectorWindow::on_map () { _selector.redisplay (); Window::on_map (); } PortInsertUI::PortInsertUI (ARDOUR::Session& sess, boost::shared_ptr pi) : input_selector (sess, pi->io(), true), output_selector (sess, pi->io(), false) { hbox.pack_start (output_selector, true, true); hbox.pack_start (input_selector, true, true); pack_start (hbox); } void PortInsertUI::redisplay () { input_selector.redisplay(); output_selector.redisplay(); } void PortInsertUI::finished (IOSelector::Result r) { input_selector.Finished (r); output_selector.Finished (r); } PortInsertWindow::PortInsertWindow (ARDOUR::Session& sess, boost::shared_ptr pi, bool can_cancel) : ArdourDialog ("port insert dialog"), _portinsertui (sess, pi), ok_button (can_cancel ? _("OK"): _("Close")), cancel_button (_("Cancel")), rescan_button (_("Rescan")) { set_name ("IOSelectorWindow"); string title = _("ardour: "); title += pi->name(); set_title (title); ok_button.set_name ("IOSelectorButton"); if (!can_cancel) { ok_button.set_image (*Gtk::manage (new Gtk::Image (Gtk::Stock::CLOSE, Gtk::ICON_SIZE_BUTTON))); } cancel_button.set_name ("IOSelectorButton"); rescan_button.set_name ("IOSelectorButton"); rescan_button.set_image (*Gtk::manage (new Gtk::Image (Gtk::Stock::REFRESH, Gtk::ICON_SIZE_BUTTON))); get_action_area()->pack_start (rescan_button, false, false); if (can_cancel) { cancel_button.set_image (*Gtk::manage (new Gtk::Image (Gtk::Stock::CANCEL, Gtk::ICON_SIZE_BUTTON))); get_action_area()->pack_start (cancel_button, false, false); } else { cancel_button.hide(); } get_action_area()->pack_start (ok_button, false, false); get_vbox()->pack_start (_portinsertui); ok_button.signal_clicked().connect (mem_fun (*this, &PortInsertWindow::accept)); cancel_button.signal_clicked().connect (mem_fun (*this, &PortInsertWindow::cancel)); rescan_button.signal_clicked().connect (mem_fun (*this, &PortInsertWindow::rescan)); signal_delete_event().connect (bind (sigc::ptr_fun (just_hide_it), reinterpret_cast (this))); going_away_connection = pi->GoingAway.connect (mem_fun (*this, &PortInsertWindow::plugin_going_away)); } void PortInsertWindow::plugin_going_away () { ENSURE_GUI_THREAD (mem_fun (*this, &PortInsertWindow::plugin_going_away)); going_away_connection.disconnect (); delete_when_idle (this); } void PortInsertWindow::on_map () { _portinsertui.redisplay (); Window::on_map (); } void PortInsertWindow::rescan () { _portinsertui.redisplay (); } void PortInsertWindow::cancel () { _portinsertui.finished (IOSelector::Cancelled); hide (); } void PortInsertWindow::accept () { _portinsertui.finished (IOSelector::Accepted); hide (); }