X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fprocessor_box.cc;h=852acf230f1de0323bf61909ccf2c3005aeb7041;hb=786cb746d0ce387a6194555e6757ec64c937690b;hp=3b49b61aaed83794a3ed3627f8cd7243d58abde9;hpb=62d2d22b4425dabe22dc2a97f2b375907dc0f65e;p=ardour.git diff --git a/gtk2_ardour/processor_box.cc b/gtk2_ardour/processor_box.cc index 3b49b61aae..852acf230f 100644 --- a/gtk2_ardour/processor_box.cc +++ b/gtk2_ardour/processor_box.cc @@ -61,6 +61,8 @@ #include "ardour/session.h" #include "ardour/types.h" +#include "LuaBridge/LuaBridge.h" + #include "actions.h" #include "ardour_dialog.h" #include "ardour_ui.h" @@ -84,7 +86,7 @@ #include "tooltips.h" #include "new_plugin_preset_dialog.h" -#include "i18n.h" +#include "pbd/i18n.h" #ifdef AUDIOUNIT_SUPPORT class AUPluginUI; @@ -107,6 +109,7 @@ RefPtr ProcessorBox::cut_action; RefPtr ProcessorBox::copy_action; RefPtr ProcessorBox::rename_action; RefPtr ProcessorBox::delete_action; +RefPtr ProcessorBox::backspace_action; RefPtr ProcessorBox::manage_pins_action; RefPtr ProcessorBox::edit_action; RefPtr ProcessorBox::edit_generic_action; @@ -114,20 +117,39 @@ RefPtr ProcessorBox::processor_box_actions; Gtkmm2ext::ActionMap ProcessorBox::myactions (X_("processor box")); Gtkmm2ext::Bindings* ProcessorBox::bindings = 0; -static const uint32_t audio_port_color = 0x4A8A0EFF; // Green -static const uint32_t midi_port_color = 0x960909FF; //Red + +// TODO consolidate with PluginPinDialog::set_color +static void set_routing_color (cairo_t* cr, bool midi) +{ + static const uint32_t audio_port_color = 0x4A8A0EFF; // Green + static const uint32_t midi_port_color = 0x960909FF; //Red + + if (midi) { + cairo_set_source_rgb (cr, + UINT_RGBA_R_FLT(midi_port_color), + UINT_RGBA_G_FLT(midi_port_color), + UINT_RGBA_B_FLT(midi_port_color)); + } else { + cairo_set_source_rgb (cr, + UINT_RGBA_R_FLT(audio_port_color), + UINT_RGBA_G_FLT(audio_port_color), + UINT_RGBA_B_FLT(audio_port_color)); + } +} ProcessorEntry::ProcessorEntry (ProcessorBox* parent, boost::shared_ptr p, Width w) : _button (ArdourButton::led_default_elements) , _position (PreFader) , _position_num(0) + , _parent (parent) , _selectable(true) , _unknown_processor(false) - , _parent (parent) , _processor (p) , _width (w) - , _input_icon(true) - , _output_icon(false) + , input_icon(true) + , output_icon(false) + , routing_icon(true) + , output_routing_icon(false) , _plugin_display(0) { _vbox.show (); @@ -147,24 +169,24 @@ ProcessorEntry::ProcessorEntry (ProcessorBox* parent, boost::shared_ptr pi = boost::dynamic_pointer_cast (_processor); - if (pi && pi->plugin() && pi->plugin()->get_info()->type != ARDOUR::Lua) { + if (pi && pi->plugin()) { _plugin_preset_pointer = PluginPresetPtr (new PluginPreset (pi->plugin()->get_info())); } } if (_processor) { - _vbox.pack_start (_routing_icon); - _vbox.pack_start (_input_icon); + _vbox.pack_start (routing_icon); + _vbox.pack_start (input_icon); _vbox.pack_start (_button, true, true); boost::shared_ptr pi = boost::dynamic_pointer_cast (_processor); if (pi && pi->plugin() && pi->plugin()->has_inline_display()) { if (pi->plugin()->get_info()->type != ARDOUR::Lua) { - _plugin_display = new PluginDisplay (pi->plugin(), + _plugin_display = new PluginDisplay (*this, pi->plugin(), std::max (60.f, rintf(112.f * UIConfiguration::instance().get_ui_scale()))); } else { assert (boost::dynamic_pointer_cast(pi->plugin())); - _plugin_display = new LuaPluginDisplay (boost::dynamic_pointer_cast(pi->plugin()), + _plugin_display = new LuaPluginDisplay (*this, boost::dynamic_pointer_cast(pi->plugin()), std::max (60.f, rintf(112.f * UIConfiguration::instance().get_ui_scale()))); } _vbox.pack_start (*_plugin_display); @@ -173,17 +195,21 @@ ProcessorEntry::ProcessorEntry (ProcessorBox* parent, boost::shared_ptrshow (); } } - _vbox.pack_end (_output_icon); + _vbox.pack_end (output_routing_icon); + _vbox.pack_end (output_icon); - _button.set_active (_processor->active()); + _button.set_active (_processor->enabled ()); - _routing_icon.set_no_show_all(true); - _input_icon.set_no_show_all(true); + input_icon.set_no_show_all(true); + routing_icon.set_no_show_all(true); + output_icon.set_no_show_all(true); + output_routing_icon.set_no_show_all(true); _button.show (); - _routing_icon.set_visible(false); - _input_icon.hide(); - _output_icon.show(); + input_icon.hide(); + output_icon.show(); + routing_icon.hide(); + output_routing_icon.hide(); _processor->ActiveChanged.connect (active_connection, invalidator (*this), boost::bind (&ProcessorEntry::processor_active_changed, this), gui_context()); _processor->PropertyChanged.connect (name_connection, invalidator (*this), boost::bind (&ProcessorEntry::processor_property_changed, this, _1), gui_context()); @@ -210,12 +236,6 @@ ProcessorEntry::ProcessorEntry (ProcessorBox* parent, boost::shared_ptrinput_streams()); - _output_icon.set_ports(_processor->output_streams()); - - _routing_icon.set_sources(_processor->input_streams()); - _routing_icon.set_sinks(_processor->output_streams()); - setup_tooltip (); setup_visuals (); } else { @@ -342,13 +362,6 @@ ProcessorEntry::set_position (Position p, uint32_t num) { _position = p; _position_num = num; - - if (_position_num == 0 || _routing_icon.get_visible()) { - _input_icon.show(); - } else { - _input_icon.hide(); - } - setup_visuals (); } @@ -369,6 +382,13 @@ ProcessorEntry::setup_visuals () _button.set_name ("processor stub"); return; } + boost::shared_ptr send; + if ((send = boost::dynamic_pointer_cast (_processor))) { + if (send->remove_on_disconnect ()) { + _button.set_name ("processor sidechain"); + return; + } + } switch (_position) { case PreFader: @@ -420,11 +440,11 @@ ProcessorEntry::led_clicked(GdkEventButton *ev) _parent->all_visible_processors_active(false); if (_position == Fader) { - _processor->deactivate (); + _processor->enable (false); } } else { - _processor->deactivate (); + _processor->enable (false); } } else { @@ -432,11 +452,11 @@ ProcessorEntry::led_clicked(GdkEventButton *ev) _parent->all_visible_processors_active(true); if (_position == Fader) { - _processor->activate (); + _processor->enable (true); } } else { - _processor->activate (); + _processor->enable (true); } } } @@ -446,7 +466,7 @@ void ProcessorEntry::processor_active_changed () { if (_processor) { - _button.set_active (_processor->active()); + _button.set_active (_processor->enabled ()); } } @@ -462,13 +482,11 @@ ProcessorEntry::processor_property_changed (const PropertyChange& what_changed) void ProcessorEntry::processor_configuration_changed (const ChanCount in, const ChanCount out) { - _input_icon.set_ports(in); - _output_icon.set_ports(out); - _routing_icon.set_sources(in); - _routing_icon.set_sinks(out); - _input_icon.queue_draw(); - _output_icon.queue_draw(); - _routing_icon.queue_draw(); + _parent->setup_routing_feeds (); + input_icon.queue_draw(); + output_icon.queue_draw(); + routing_icon.queue_draw(); + output_routing_icon.queue_draw(); } void @@ -496,6 +514,16 @@ ProcessorEntry::setup_tooltip () string_compose (_("%1\nThe Plugin is not available on this system\nand has been replaced by a stub."), name (Wide))); return; } + boost::shared_ptr send; + if ((send = boost::dynamic_pointer_cast (_processor)) != 0 && + !boost::dynamic_pointer_cast(_processor)) { + if (send->remove_on_disconnect ()) { + ARDOUR_UI_UTILS::set_tooltip (_button, string_compose ("> %1\nThis (sidechain) send will be removed when disconnected.", _processor->name())); + } else { + ARDOUR_UI_UTILS::set_tooltip (_button, string_compose ("> %1", _processor->name())); + } + return; + } } ARDOUR_UI_UTILS::set_tooltip (_button, string_compose ("%1", name (Wide))); } @@ -514,19 +542,52 @@ ProcessorEntry::name (Width w) const !boost::dynamic_pointer_cast(_processor)) { name_display += '>'; + std::string send_name; + bool pretty_ok = true; + + if (send->remove_on_disconnect ()) { + // assume it's a sidechain, find pretty name of connected port(s) + PortSet& ps (send->output ()->ports ()); + for (PortSet::iterator i = ps.begin (); i != ps.end () && pretty_ok; ++i) { + vector connections; + if (i->get_connections (connections)) { + vector::const_iterator ci; + for (ci = connections.begin(); ci != connections.end(); ++ci) { + std::string pn = AudioEngine::instance()->get_pretty_name_by_name (*ci); + if (pn.empty ()) { + continue; + } + if (send_name.empty ()) { + send_name = pn; + } else if (send_name != pn) { + // pretty names don't match + pretty_ok = false; + break; + } + } + } + } + } - /* grab the send name out of its overall name */ + if (!pretty_ok) { + send_name = ""; + } - string::size_type lbracket, rbracket; - lbracket = send->name().find ('['); - rbracket = send->name().find (']'); + /* grab the send name out of its overall name */ + if (send_name.empty()) { + send_name = send->name(); + string::size_type lbracket, rbracket; + lbracket = send_name.find ('['); + rbracket = send_name.find (']'); + send_name = send_name.substr (lbracket+1, lbracket-rbracket-1); + } switch (w) { case Wide: - name_display += send->name().substr (lbracket+1, lbracket-rbracket-1); + name_display += send_name; break; case Narrow: - name_display += PBD::short_version (send->name().substr (lbracket+1, lbracket-rbracket-1), 4); + name_display += PBD::short_version (send_name, 5); break; } @@ -597,7 +658,7 @@ ProcessorEntry::set_control_state (XMLNode const * node) if (_plugin_display) { XMLNode* n = GUIObjectState::get_node (node, X_("InlineDisplay")); - XMLProperty* p = n ? n->property (X_("visible")) : NULL; + XMLProperty const * p = n ? n->property (X_("visible")) : NULL; if (p) { if (string_is_affirmative (p->value ())) { _plugin_display->show(); @@ -887,7 +948,7 @@ ProcessorEntry::Control::set_state (XMLNode const * node) { XMLNode* n = GUIObjectState::get_node (node, state_id ()); if (n) { - XMLProperty* p = n->property (X_("visible")); + XMLProperty const * p = n->property (X_("visible")); set_visible (p && string_is_affirmative (p->value ())); } else { set_visible (false); @@ -931,94 +992,28 @@ PluginInsertProcessorEntry::PluginInsertProcessorEntry (ProcessorBox* b, boost:: , _plugin_insert (p) { p->PluginIoReConfigure.connect ( - _splitting_connection, invalidator (*this), boost::bind (&PluginInsertProcessorEntry::plugin_insert_splitting_changed, this), gui_context() + _iomap_connection, invalidator (*this), boost::bind (&PluginInsertProcessorEntry::iomap_changed, this), gui_context() + ); + p->PluginMapChanged.connect ( + _iomap_connection, invalidator (*this), boost::bind (&PluginInsertProcessorEntry::iomap_changed, this), gui_context() + ); + p->PluginConfigChanged.connect ( + _iomap_connection, invalidator (*this), boost::bind (&PluginInsertProcessorEntry::iomap_changed, this), gui_context() ); - - plugin_insert_splitting_changed (); } void -PluginInsertProcessorEntry::plugin_insert_splitting_changed () +PluginInsertProcessorEntry::iomap_changed () { - ChanCount in, out; // actual configured i/o - _plugin_insert->configured_io (in, out); - - /* get number of input ports */ - ChanCount sinks = _plugin_insert->natural_input_streams(); - if (!_plugin_insert->splitting () && _plugin_insert->get_count() > 1) { - /* replicated instances */ - for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) { - sinks.set(*t, sinks.get(*t) * _plugin_insert->get_count()); - } - } - /* MIDI bypass */ - if (_plugin_insert->natural_output_streams().n_midi() == 0 && - _plugin_insert->output_streams().n_midi() == 1) { - in.set(DataType::MIDI, 1); - out.set(DataType::MIDI, 1); - sinks.set(DataType::MIDI, 1); - } - - /* the Input streams available (*valid* outputs from prev. plugin) - * this will be <= sinks. Some input-ports of this processor - * may be unconnected. - */ - _routing_icon.set_sources(in); - - /* the actual input ports of this processor */ - _input_icon.set_ports(sinks); - _routing_icon.set_sinks(sinks); - - /* set/override plugin-output ports to actual outputs-streams. - * - * This plugin may have unconnected output-ports (currently only in Mixbus, - * e.g channelstrip-EQ at the top of a MIDI-channel before the synth). - * - * The *next* processor below this one will only see the - * actual available streams (it cannot know the real outputs - * of this plugin). - * - * There is currently no API to query the ports of the previous (or next) - * processor. - * - * (normally - iff configuration succeeds - this is set during - * ProcessorEntry::processor_configuration_changed() and should - * equal _plugin_insert->output_streams()) - */ - _output_icon.set_ports(out); -#ifndef NDEBUG - if (out != _plugin_insert->output_streams()) { - std::cerr << "Processor Wiring: " << processor()->name() - << " out-ports: " << _plugin_insert->output_streams() // NB. does not include midi-bypass - << " out-connections: " << out - << endmsg; - } -#endif - - _routing_icon.set_splitting(_plugin_insert->splitting ()); - - if (_plugin_insert->splitting () || in != sinks) - { - _routing_icon.set_size_request (-1, std::max (7.f, rintf(7.f * UIConfiguration::instance().get_ui_scale()))); - _routing_icon.set_visible(true); - _input_icon.show(); - } else { - _routing_icon.set_visible(false); - if (_position_num != 0) { - _input_icon.hide(); - } - } - - _input_icon.queue_draw(); - _output_icon.queue_draw(); - _routing_icon.queue_draw(); + _parent->setup_routing_feeds (); + routing_icon.queue_draw(); + output_routing_icon.queue_draw(); } void PluginInsertProcessorEntry::hide_things () { ProcessorEntry::hide_things (); - plugin_insert_splitting_changed (); } ProcessorEntry::PortIcon::PortIcon(bool input) { @@ -1046,45 +1041,224 @@ ProcessorEntry::PortIcon::on_expose_event (GdkEventExpose* ev) cairo_fill (cr); const double dx = rint(max(2., 2. * UIConfiguration::instance().get_ui_scale())); - if (_ports.n_total() > 1) { - for (uint32_t i = 0; i < _ports.n_total(); ++i) { - if (i < _ports.n_midi()) { - cairo_set_source_rgb (cr, - UINT_RGBA_R_FLT(midi_port_color), - UINT_RGBA_G_FLT(midi_port_color), - UINT_RGBA_B_FLT(midi_port_color)); - } else { - cairo_set_source_rgb (cr, - UINT_RGBA_R_FLT(audio_port_color), - UINT_RGBA_G_FLT(audio_port_color), - UINT_RGBA_B_FLT(audio_port_color)); - } - const float x = rintf(width * (.2f + .6f * i / (_ports.n_total() - 1.f))); - cairo_rectangle (cr, x-dx * .5, 0, 1+dx, height); - cairo_fill(cr); - } - } else if (_ports.n_total() == 1) { - if (_ports.n_midi() == 1) { - cairo_set_source_rgb (cr, - UINT_RGBA_R_FLT(midi_port_color), - UINT_RGBA_G_FLT(midi_port_color), - UINT_RGBA_B_FLT(midi_port_color)); - } else { - cairo_set_source_rgb (cr, - UINT_RGBA_R_FLT(audio_port_color), - UINT_RGBA_G_FLT(audio_port_color), - UINT_RGBA_B_FLT(audio_port_color)); - } - const float x = rintf(width * .5); - cairo_rectangle (cr, x-dx * .5, 0, 1+dx, height); + for (uint32_t i = 0; i < _ports.n_total(); ++i) { + set_routing_color (cr, i < _ports.n_midi()); + const double x = ProcessorEntry::RoutingIcon::pin_x_pos (i, width, _ports.n_total(), 0 , false); + cairo_rectangle (cr, x - .5 - dx * .5, 0, 1 + dx, height); cairo_fill(cr); - cairo_stroke(cr); } cairo_destroy(cr); return true; } +ProcessorEntry::RoutingIcon::RoutingIcon (bool input) + : _fed_by (false) + , _input (input) +{ + set_terminal (false); +} + +void +ProcessorEntry::RoutingIcon::set_terminal (bool b) { + _terminal = b; + int h = std::max (8.f, rintf(8.f * sqrt (UIConfiguration::instance().get_ui_scale()))); + if (_terminal) { + h += std::max (4.f, rintf(4.f * sqrt (UIConfiguration::instance().get_ui_scale()))); + } + set_size_request (-1, h); +} + +void +ProcessorEntry::RoutingIcon::set ( + const ARDOUR::ChanCount& in, + const ARDOUR::ChanCount& out, + const ARDOUR::ChanCount& sinks, + const ARDOUR::ChanCount& sources, + const ARDOUR::ChanMapping& in_map, + const ARDOUR::ChanMapping& out_map, + const ARDOUR::ChanMapping& thru_map) +{ + _in = in; + _out = out; + _sources = sources; + _sinks = sinks; + _in_map = in_map; + _out_map = out_map; + _thru_map = thru_map; +} + +bool +ProcessorEntry::RoutingIcon::in_identity () const { + if (_thru_map.n_total () > 0) { + return false; + } + if (!_in_map.is_monotonic () || !_in_map.is_identity ()) { + return false; + } + if (_in_map.n_total () != _sinks.n_total () || _in.n_total () != _sinks.n_total ()) { + return false; + } + return true; +} + +bool +ProcessorEntry::RoutingIcon::out_identity () const { + if (_thru_map.n_total () > 0) { + // TODO skip if trhu is not connected to any of next's inputs + return false; + } + if (!_out_map.is_monotonic () || !_out_map.is_identity ()) { + return false; + } + if (_out_map.n_total () != _sources.n_total () || _out.n_total () != _sources.n_total ()) { + return false; + } + return true; +} + +bool +ProcessorEntry::RoutingIcon::can_coalesce () const { + if (_thru_map.n_total () > 0) { + return false; + } + if (_fed_by && _f_out != _f_sources) { + return false; + } + if (_fed_by && !_f_out_map.is_identity () && !_in_map.is_identity ()) { + return false; + } + if (_input && _sinks == _in && (!_fed_by || _f_out == _in)) { + return true; + } + return false; +} + +void +ProcessorEntry::RoutingIcon::set_fed_by ( + const ARDOUR::ChanCount& out, + const ARDOUR::ChanCount& sources, + const ARDOUR::ChanMapping& out_map, + const ARDOUR::ChanMapping& thru_map) +{ + _f_out = out; + _f_sources = sources; + _f_out_map = out_map; + _f_thru_map = thru_map; + _fed_by = true; +} + +void +ProcessorEntry::RoutingIcon::set_feeding ( + const ARDOUR::ChanCount& in, + const ARDOUR::ChanCount& sinks, + const ARDOUR::ChanMapping& in_map, + const ARDOUR::ChanMapping& thru_map) +{ + _i_in = in; + _i_sinks = sinks; + _i_in_map = in_map; + _i_thru_map = thru_map; + _feeding = true; +} + +double +ProcessorEntry::RoutingIcon::pin_x_pos (uint32_t i, double width, uint32_t n_total, uint32_t n_midi, bool midi) +{ + if (!midi) { i += n_midi; } + if (n_total == 1) { + assert (i == 0); + return rint (width * .5) +.5; + } + return rint (width * (.15 + .7 * i / (n_total - 1))) + .5; +} + +void +ProcessorEntry::RoutingIcon::draw_gnd (cairo_t* cr, double x0, double y0, double height, bool midi) +{ + const double dx = 1 + rint (max(2., 2. * UIConfiguration::instance().get_ui_scale())); + const double y1 = rint (height * .66) + .5; + + cairo_save (cr); + cairo_translate (cr, x0, y0); + cairo_move_to (cr, 0, height); + cairo_line_to (cr, 0, y1); + cairo_move_to (cr, 0 - dx, y1); + cairo_line_to (cr, 0 + dx, y1); + + set_routing_color (cr, midi); + cairo_set_line_width (cr, 1.0); + cairo_stroke (cr); + cairo_restore (cr); +} + +void +ProcessorEntry::RoutingIcon::draw_sidechain (cairo_t* cr, double x0, double y0, double height, bool midi) +{ + const double dx = 1 + rint (max(2., 2. * UIConfiguration::instance().get_ui_scale())); + const double y1 = rint (height * .5) - .5; + + cairo_save (cr); + cairo_translate (cr, x0, y0); + cairo_move_to (cr, 0 - dx, height); + cairo_line_to (cr, 0, y1); + cairo_line_to (cr, 0 + dx, height); + cairo_close_path (cr); + + set_routing_color (cr, midi); + cairo_fill (cr); + cairo_restore (cr); +} + +void +ProcessorEntry::RoutingIcon::draw_thru_src (cairo_t* cr, double x0, double y0, double height, bool midi) +{ + const double rad = 1; + const double y1 = height - rad - 1.5; + + cairo_arc (cr, x0, y0 + y1, rad, 0, 2. * M_PI); + cairo_move_to (cr, x0, y0 + height - 1.5); + cairo_line_to (cr, x0, y0 + height); + set_routing_color (cr, midi); + cairo_set_line_width (cr, 1.0); + cairo_stroke (cr); +} + +void +ProcessorEntry::RoutingIcon::draw_thru_sink (cairo_t* cr, double x0, double y0, double height, bool midi) +{ + const double rad = 1; + const double y1 = rad + 1; + + cairo_arc (cr, x0, y0 + y1, rad, 0, 2. * M_PI); + cairo_move_to (cr, x0, y0); + cairo_line_to (cr, x0, y0 + 1); + set_routing_color (cr, midi); + cairo_set_line_width (cr, 1.0); + cairo_stroke (cr); +} + +void +ProcessorEntry::RoutingIcon::draw_connection (cairo_t* cr, double x0, double x1, double y0, double y1, bool midi, bool dashed) +{ + double bz = abs (y1 - y0); + + cairo_move_to (cr, x0, y0); + cairo_curve_to (cr, x0, y0 + bz, x1, y1 - bz, x1, y1); + cairo_set_line_width (cr, 1.0); + cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); + cairo_set_source_rgb (cr, 1, 0, 0); + if (dashed) { + const double dashes[] = { 2, 3 }; + cairo_set_dash (cr, dashes, 2, 0); + } + set_routing_color (cr, midi); + cairo_stroke (cr); + if (dashed) { + cairo_set_dash (cr, 0, 0, 0); + } +} + bool ProcessorEntry::RoutingIcon::on_expose_event (GdkEventExpose* ev) { @@ -1093,7 +1267,6 @@ ProcessorEntry::RoutingIcon::on_expose_event (GdkEventExpose* ev) cairo_rectangle (cr, ev->area.x, ev->area.y, ev->area.width, ev->area.height); cairo_clip (cr); - cairo_set_line_width (cr, max (1.f, UIConfiguration::instance().get_ui_scale())); cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); Gtk::Allocation a = get_allocation(); @@ -1106,120 +1279,256 @@ ProcessorEntry::RoutingIcon::on_expose_event (GdkEventExpose* ev) cairo_rectangle (cr, 0, 0, width, height); cairo_fill (cr); - Gdk::Color const fg = get_style()->get_fg (STATE_NORMAL); - cairo_set_source_rgb (cr, fg.get_red_p (), fg.get_green_p (), fg.get_blue_p ()); - - const uint32_t sources = _sources.n_total(); - const uint32_t sinks = _sinks.n_total(); - - const uint32_t midi_sources = _sources.n_midi(); - const uint32_t midi_sinks = _sinks.n_midi(); - const uint32_t audio_sources = _sources.n_audio(); - const uint32_t audio_sinks = _sinks.n_audio(); - - /* MIDI */ - cairo_set_source_rgb (cr, - UINT_RGBA_R_FLT(midi_port_color), - UINT_RGBA_G_FLT(midi_port_color), - UINT_RGBA_B_FLT(midi_port_color)); - if (midi_sources > 0 && midi_sinks > 0 && sinks > 1 && sources > 1) { - for (uint32_t i = 0 ; i < midi_sources; ++i) { - const float si_x = rintf(width * (.2f + .6f * i / (sinks - 1.f))) + .5f; - const float si_x0 = rintf(width * (.2f + .6f * i / (sources - 1.f))) + .5f; - cairo_move_to (cr, si_x, height); - cairo_curve_to (cr, si_x, 0, si_x0, height, si_x0, 0); - cairo_stroke (cr); + if (_input) { + if (can_coalesce ()) { + expose_coalesced_input_map (cr, width, height); + } else { + expose_input_map (cr, width, height); } - } else if (midi_sources == 1 && midi_sinks == 1 && sinks == 1 && sources == 1) { - const float si_x = rintf(width * .5f) + .5f; - cairo_move_to (cr, si_x, height); - cairo_line_to (cr, si_x, 0); - cairo_stroke (cr); - } else if (midi_sources == 1 && midi_sinks == 1) { - /* unusual cases -- removed synth, midi-track w/audio plugins */ - const float si_x = rintf(width * (sinks > 1 ? .2f : .5f)) + .5f; - const float si_x0 = rintf(width * (sources > 1 ? .2f : .5f)) + .5f; - cairo_move_to (cr, si_x, height); - cairo_curve_to (cr, si_x, 0, si_x0, height, si_x0, 0); - cairo_stroke (cr); - } else if (midi_sources == 0 && midi_sinks == 1) { - const double dx = 1 + rint(max(2., 2. * UIConfiguration::instance().get_ui_scale())); - // draw "T" - // TODO connect back to track-input of last midi-out if any, otherwise draw "X" - const float si_x = rintf(width * .2f) + .5f; - cairo_move_to (cr, si_x, height); - cairo_line_to (cr, si_x, height * .66); - cairo_move_to (cr, si_x - dx, height * .66); - cairo_line_to (cr, si_x + dx, height * .66); - cairo_stroke (cr); -#ifndef NDEBUG - } else if (midi_sources != 0 && midi_sinks != 0) { - PBD::warning << string_compose("Programming error: midi routing display: A %1 -> %2 | M %3 -> %4 | T %5 -> %6", - audio_sources, audio_sinks, midi_sources, midi_sinks, sources, sinks) << endmsg; -#endif + } else { + expose_output_map (cr, width, height); } - /* AUDIO */ - cairo_set_source_rgb (cr, - UINT_RGBA_R_FLT(audio_port_color), - UINT_RGBA_G_FLT(audio_port_color), - UINT_RGBA_B_FLT(audio_port_color)); - - if (_splitting) { - assert(audio_sources < 2); - assert(audio_sinks > 1); - /* assume there is only ever one MIDI port */ - const float si_x0 = rintf(width * (midi_sources > 0 ? .8f : .5f)) + .5f; - for (uint32_t i = midi_sinks; i < sinks; ++i) { - const float si_x = rintf(width * (.2f + .6f * i / (sinks - 1.f))) + .5f; - cairo_move_to (cr, si_x, height); - cairo_curve_to (cr, si_x, 0, si_x0, height, si_x0, 0); - cairo_stroke (cr); + cairo_destroy(cr); + return true; +} + +void +ProcessorEntry::RoutingIcon::expose_coalesced_input_map (cairo_t* cr, const double width, const double height) +{ + const uint32_t pc_in = _sinks.n_total(); + const uint32_t pc_in_midi = _sinks.n_midi(); + + for (uint32_t i = 0; i < pc_in; ++i) { + const bool is_midi = i < pc_in_midi; + bool valid_in; + uint32_t pn = is_midi ? i : i - pc_in_midi; + DataType dt = is_midi ? DataType::MIDI : DataType::AUDIO; + uint32_t idx = _in_map.get (dt, pn, &valid_in); + if (!valid_in) { + double x = pin_x_pos (i, width, pc_in, 0, is_midi); + draw_gnd (cr, x, 0, height, is_midi); + continue; } - } else if (audio_sources > 1 && sinks > 1) { - for (uint32_t i = 0 ; i < audio_sources; ++i) { - const float si_x = rintf(width * (.2f + .6f * (i + midi_sinks) / (sinks - 1.f))) + .5f; - const float si_x0 = rintf(width * (.2f + .6f * (i + midi_sources) / (sources - 1.f))) + .5f; - cairo_move_to (cr, si_x, height); - cairo_curve_to (cr, si_x, 0, si_x0, height, si_x0, 0); - cairo_stroke (cr); + if (idx >= _in.get (dt)) { + // side-chain, probably + double x = pin_x_pos (i, width, pc_in, 0, is_midi); + draw_sidechain (cr, x, 0, height, is_midi); + continue; } - } else if (audio_sources == 1 && audio_sinks > 0) { - float si_x, si_x0; - if (sinks == 1) { - si_x = rintf(width * .5f) + .5f; + double c_x0; + double c_x1 = pin_x_pos (i, width, pc_in, 0, false); + + if (_fed_by) { + bool valid_src; + uint32_t src = _f_out_map.get_src (dt, idx, &valid_src); + if (!valid_src) { + double x = pin_x_pos (i, width, pc_in, 0, false); + bool valid_thru; + _f_thru_map.get (dt, idx, &valid_thru); + if (valid_thru) { + draw_thru_src (cr, x, 0, height, is_midi); + } else { + draw_gnd (cr, x, 0, height, is_midi); + } + continue; + } + c_x0 = pin_x_pos (src, width, _f_sources.n_total(), _f_sources.n_midi(), is_midi); } else { - si_x = rintf(width * (.2f + .6f * midi_sinks / (sinks - 1.f))) + .5f; + c_x0 = pin_x_pos (idx, width, _in.n_total(), _in.n_midi(), is_midi); } - if (sources == 1) { - si_x0 = rintf(width * .5f) + .5f; - } else { - si_x0 = rintf(width * (.2f + .6f * midi_sources / (sources - 1.f))) + .5f; + draw_connection (cr, c_x0, c_x1, 0, height, is_midi); + } +} + +void +ProcessorEntry::RoutingIcon::expose_input_map (cairo_t* cr, const double width, const double height) +{ + const uint32_t n_in = _in.n_total(); + const uint32_t n_in_midi = _in.n_midi(); + const uint32_t pc_in = _sinks.n_total(); + const uint32_t pc_in_midi = _sinks.n_midi(); + + // draw inputs to this + for (uint32_t i = 0; i < pc_in; ++i) { + const bool is_midi = i < pc_in_midi; + bool valid_in; + uint32_t pn = is_midi ? i : i - pc_in_midi; + DataType dt = is_midi ? DataType::MIDI : DataType::AUDIO; + uint32_t idx = _in_map.get (dt, pn, &valid_in); + // check if it's fed + bool valid_src = true; + if (valid_in && idx < _in.get (dt) && _fed_by) { + bool valid_out; + bool valid_thru; + _f_out_map.get_src (dt, idx, &valid_out); + _f_thru_map.get (dt, idx, &valid_thru); + if (!valid_out && !valid_thru) { + valid_src = false; + } } - cairo_move_to (cr, si_x, height); - cairo_curve_to (cr, si_x, 0, si_x0, height, si_x0, 0); - cairo_stroke (cr); -#ifndef NDEBUG - } else if (audio_sources != 0 && audio_sinks != 0) { - PBD::warning << string_compose("Programming error: audio routing display: A %1 -> %2 | M %3 -> %4 | T %5 -> %6", - audio_sources, audio_sinks, midi_sources, midi_sinks, sources, sinks) << endmsg; -#endif + if (!valid_in || !valid_src) { + double x = pin_x_pos (i, width, pc_in, 0, is_midi); + draw_gnd (cr, x, 0, height, is_midi); + continue; + } + if (idx >= _in.get (dt)) { + // side-chain, probably + double x = pin_x_pos (i, width, pc_in, 0, is_midi); + draw_sidechain (cr, x, 0, height, is_midi); + continue; + } + double c_x1 = pin_x_pos (i, width, pc_in, 0, false); + double c_x0 = pin_x_pos (idx, width, n_in, n_in_midi, is_midi); + draw_connection (cr, c_x0, c_x1, 0, height, is_midi); + } + + // draw reverse thru + for (uint32_t i = 0; i < n_in; ++i) { + const bool is_midi = i < n_in_midi; + bool valid_thru; + uint32_t pn = is_midi ? i : i - n_in_midi; + DataType dt = is_midi ? DataType::MIDI : DataType::AUDIO; + _thru_map.get_src (dt, pn, &valid_thru); + if (!valid_thru) { + continue; + } + double x = pin_x_pos (i, width, n_in, 0, is_midi); + draw_thru_sink (cr, x, 0, height, is_midi); } - cairo_destroy(cr); - return true; } +void +ProcessorEntry::RoutingIcon::expose_output_map (cairo_t* cr, const double width, const double height) +{ + int dh = std::max (4.f, rintf(4.f * UIConfiguration::instance().get_ui_scale())); + double ht = _terminal ? height - dh : height; + + // draw outputs of this + const uint32_t pc_out = _sources.n_total(); + const uint32_t pc_out_midi = _sources.n_midi(); + const uint32_t n_out = _out.n_total(); + const uint32_t n_out_midi = _out.n_midi(); + + for (uint32_t i = 0; i < pc_out; ++i) { + const bool is_midi = i < pc_out_midi; + bool valid_out; + uint32_t pn = is_midi ? i : i - pc_out_midi; + DataType dt = is_midi ? DataType::MIDI : DataType::AUDIO; + uint32_t idx = _out_map.get (dt, pn, &valid_out); + if (!valid_out) { + continue; + } + // skip connections that are not used in the next's input + if (_feeding) { + bool valid_thru, valid_sink; + _i_in_map.get_src (dt, idx, &valid_sink); + _i_thru_map.get_src (dt, idx, &valid_thru); + if (!valid_thru && !valid_sink) { + if (!is_midi || i != 0) { // special case midi-bypass + continue; + } + } + } + double c_x0 = pin_x_pos (i, width, pc_out, 0, false); + double c_x1 = pin_x_pos (idx, width, n_out, n_out_midi, is_midi); + draw_connection (cr, c_x0, c_x1, 0, ht, is_midi); + } + + for (uint32_t i = 0; i < n_out; ++i) { + const bool is_midi = i < n_out_midi; + uint32_t pn = is_midi ? i : i - n_out_midi; + DataType dt = is_midi ? DataType::MIDI : DataType::AUDIO; + double x = pin_x_pos (i, width, n_out, 0, is_midi); + + if (!_terminal) { + bool valid_thru_f = false; + // skip connections that are not used in the next's input + if (_feeding) { + bool valid_sink; + _i_in_map.get_src (dt, pn, &valid_sink); + _i_thru_map.get_src (dt, pn, &valid_thru_f); + if (!valid_thru_f && !valid_sink) { + if (!is_midi || i != 0) { // special case midi-bypass + continue; + } + } + } + + bool valid_src; + _out_map.get_src (dt, pn, &valid_src); + if (!valid_src) { + bool valid_thru; + uint32_t idx = _thru_map.get (dt, pn, &valid_thru); + if (valid_thru) { + if (idx >= _in.get (dt)) { + draw_sidechain (cr, x, 0, height, is_midi); + } else { + draw_thru_src (cr, x, 0, height, is_midi); + } + } else if (valid_thru_f){ + // gnd is part of input, unless it's a thru input + // (also only true if !coalesced into one small display) + draw_gnd (cr, x, 0, height, is_midi); + } + } + } else { + // terminal node, add arrows + bool valid_src; + _out_map.get_src (dt, pn, &valid_src); + if (!valid_src) { + bool valid_thru; + uint32_t idx = _thru_map.get (dt, pn, &valid_thru); + if (valid_thru) { + if (idx >= _in.get (dt)) { + draw_sidechain (cr, x, 0, height - dh, is_midi); + } else { + draw_thru_src (cr, x, 0, height - dh, is_midi); + } + } else { + draw_gnd (cr, x, 0, height - dh, is_midi); + } + } + + set_routing_color (cr, is_midi); + cairo_set_line_width (cr, 1.0); + cairo_move_to (cr, x, height - dh); + cairo_line_to (cr, x, height - 2); + cairo_stroke (cr); + + const double ar = dh - 1; + cairo_move_to (cr, x - ar, height - ar); + cairo_line_to (cr, x , height - .5); + cairo_line_to (cr, x + ar, height - ar); + cairo_line_to (cr, x , height - ar * .5); + cairo_close_path (cr); + cairo_fill_preserve (cr); + cairo_stroke (cr); + } + } +} -ProcessorEntry::PluginDisplay::PluginDisplay (boost::shared_ptr p, uint32_t max_height) - : _plug (p) +ProcessorEntry::PluginDisplay::PluginDisplay (ProcessorEntry& e, boost::shared_ptr p, uint32_t max_height) + : _entry (e) + , _plug (p) , _surf (0) , _max_height (max_height) , _cur_height (1) , _scroll (false) { set_name ("processor prefader"); + add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK); _plug->QueueDraw.connect (_qdraw_connection, invalidator (*this), boost::bind (&Gtk::Widget::queue_draw, this), gui_context ()); + + std::string postfix = ""; + if (_plug->has_editor()) { + ARDOUR_UI_UTILS::set_tooltip (*this, + string_compose (_("%1\nDouble-click to show GUI.\n%2+double-click to show generic GUI.%3"), e.name (Wide), Keyboard::primary_modifier_name (), postfix)); + } else { + ARDOUR_UI_UTILS::set_tooltip (*this, + string_compose (_("%1\nDouble-click to show generic GUI.%2"), e.name (Wide), postfix)); + } } ProcessorEntry::PluginDisplay::~PluginDisplay () @@ -1229,8 +1538,33 @@ ProcessorEntry::PluginDisplay::~PluginDisplay () } } +bool +ProcessorEntry::PluginDisplay::on_button_press_event (GdkEventButton *ev) +{ + assert (_entry.processor ()); + + // consider some tweaks to pass this up to the DnDVBox somehow: + // select processor, then call (private) + //_entry._parent->processor_button_press_event (ev, &_entry); + if (Keyboard::is_edit_event (ev) || (ev->button == 1 && ev->type == GDK_2BUTTON_PRESS)) { + if (Keyboard::modifier_state_equals (ev->state, Keyboard::SecondaryModifier)) { + _entry._parent->generic_edit_processor (_entry.processor ()); + } else { + _entry._parent->edit_processor (_entry.processor ()); + } + return true; + } + return false; +} + +bool +ProcessorEntry::PluginDisplay::on_button_release_event (GdkEventButton *ev) +{ + return false; +} + void -ProcessorEntry::PluginDisplay::on_size_request (Gtk::Requisition* req) +ProcessorEntry::PluginDisplay::on_size_request (Requisition* req) { req->width = 56; req->height = _cur_height; @@ -1304,6 +1638,7 @@ ProcessorEntry::PluginDisplay::render_inline (cairo_t* cr, uint32_t width) } } + cairo_surface_flush(_surf); cairo_surface_mark_dirty(_surf); const double xc = floor ((width - dis->width) * .5); cairo_set_source_surface(cr, _surf, xc, 0); @@ -1363,8 +1698,8 @@ ProcessorEntry::PluginDisplay::on_expose_event (GdkEventExpose* ev) return true; } -ProcessorEntry::LuaPluginDisplay::LuaPluginDisplay (boost::shared_ptr p, uint32_t max_height) - : PluginDisplay (p, max_height) +ProcessorEntry::LuaPluginDisplay::LuaPluginDisplay (ProcessorEntry& e, boost::shared_ptr p, uint32_t max_height) + : PluginDisplay (e, p, max_height) , _luaproc (p) , _lua_render_inline (0) { @@ -1393,7 +1728,9 @@ ProcessorEntry::LuaPluginDisplay::render_inline (cairo_t *cr, uint32_t width) return h; } } catch (luabridge::LuaException const& e) { - ; +#ifndef NDEBUG + cerr << "LuaException:" << e.what () << endl; +#endif } return 0; } @@ -1404,7 +1741,7 @@ static std::list drop_targets() std::list tmp; tmp.push_back (Gtk::TargetEntry ("processor")); // from processor-box to processor-box tmp.push_back (Gtk::TargetEntry ("PluginInfoPtr")); // from plugin-manager - tmp.push_back (Gtk::TargetEntry ("PluginPresetPtr")); // from sidebar + tmp.push_back (Gtk::TargetEntry ("PluginFavoritePtr")); // from sidebar return tmp; } @@ -1574,7 +1911,7 @@ ProcessorBox::_drop_plugin_preset (Gtk::SelectionData const &data, Route::Proces boost::shared_ptr processor (new PluginInsert (*_session, p)); if (Config->get_new_plugins_active ()) { - processor->activate (); + processor->enable (true); } pl.push_back (processor); } @@ -1597,7 +1934,7 @@ ProcessorBox::_drop_plugin (Gtk::SelectionData const &data, Route::ProcessorList } boost::shared_ptr processor (new PluginInsert (*_session, p)); if (Config->get_new_plugins_active ()) { - processor->activate (); + processor->enable (true); } pl.push_back (processor); } @@ -1616,7 +1953,7 @@ ProcessorBox::plugin_drop (Gtk::SelectionData const &data, ProcessorEntry* posit if (data.get_target() == "PluginInfoPtr") { _drop_plugin (data, pl); } - else if (data.get_target() == "PluginPresetPtr") { + else if (data.get_target() == "PluginFavoritePtr") { _drop_plugin_preset (data, pl); } else { @@ -1649,6 +1986,11 @@ ProcessorBox::object_drop (DnDVBox* source, ProcessorEntry* posi PBD::ID id = pi->id(); XMLNode& state = otherproc->get_state (); + /* strip side-chain state (processor inside processor must be a side-chain) + * otherwise we'll end up with duplicate ports-names. + * (this needs a better solution which retains connections) + */ + state.remove_nodes ("Processor"); proc->set_state (state, Stateful::loading_state_version); boost::dynamic_pointer_cast(proc)->update_id (id); return; @@ -1790,19 +2132,22 @@ ProcessorBox::show_processor_menu (int arg) } } - Gtk::MenuItem* send_menu_item = dynamic_cast(ActionManager::get_widget("/ProcessorMenu/send_options")); - if (send_menu_item) { - if (single_selection && !_route->is_monitor()) { - Menu* m = single_selection->build_send_options_menu (); - if (m && !m->items().empty()) { - send_menu_item->set_submenu (*m); - send_menu_item->set_sensitive (true); + + if (!ARDOUR::Profile->get_mixbus()) { + Gtk::MenuItem* send_menu_item = dynamic_cast(ActionManager::get_widget("/ProcessorMenu/send_options")); + if (send_menu_item) { + if (single_selection && !_route->is_monitor()) { + Menu* m = single_selection->build_send_options_menu (); + if (m && !m->items().empty()) { + send_menu_item->set_submenu (*m); + send_menu_item->set_sensitive (true); + } else { + gtk_menu_item_set_submenu (send_menu_item->gobj(), 0); + send_menu_item->set_sensitive (false); + } } else { - gtk_menu_item_set_submenu (send_menu_item->gobj(), 0); send_menu_item->set_sensitive (false); } - } else { - send_menu_item->set_sensitive (false); } } @@ -1815,6 +2160,7 @@ ProcessorBox::show_processor_menu (int arg) cut_action->set_sensitive (sensitive && can_cut ()); copy_action->set_sensitive (sensitive); delete_action->set_sensitive (sensitive || stub_processor_selected ()); + backspace_action->set_sensitive (sensitive || stub_processor_selected ()); edit_action->set_sensitive (one_processor_can_be_edited ()); edit_generic_action->set_sensitive (one_processor_can_be_edited ()); @@ -1937,11 +2283,7 @@ ProcessorBox::processor_operation (ProcessorOperation op) case ProcessorsToggleActive: for (ProcSelection::iterator i = targets.begin(); i != targets.end(); ++i) { - if ((*i)->active()) { - (*i)->deactivate (); - } else { - (*i)->activate (); - } + (*i)->enable (!(*i)->enabled ()); } break; @@ -2033,12 +2375,7 @@ ProcessorBox::processor_button_release_event (GdkEventButton *ev, ProcessorEntry ) { /* button2-click with no/appropriate modifiers */ - - if (processor->active()) { - processor->deactivate (); - } else { - processor->activate (); - } + processor->enable (!processor->enabled ()); } return false; @@ -2070,49 +2407,6 @@ ProcessorBox::choose_plugin () _get_plugin_selector()->set_interested_object (*this); } -/** @return true if an error occurred, otherwise false */ -bool -ProcessorBox::choose_lua () -{ - LuaScriptInfoPtr spi; - - ScriptSelector ss (_("Add Lua DSP Processor"), LuaScriptInfo::DSP); - switch (ss.run ()) { - case Gtk::RESPONSE_ACCEPT: - spi = ss.script(); - break; - default: - return true; - } - ss.hide (); - - PluginPtr p; - try { - LuaPluginInfoPtr lpi (new LuaPluginInfo(spi)); - p = (lpi->load (*_session)); - } catch (...) { - string msg = _( - "Failed to instantiate Lua DSP Processor,\n" - "probably because the script is invalid (no dsp function)."); - MessageDialog am (msg); - am.run (); - return true; - } - - boost::shared_ptr processor (new PluginInsert (*_session, p)); - - Route::ProcessorStreams err_streams; - if (_route->add_processor_by_index (processor, _placement, &err_streams, Config->get_new_plugins_active ())) { - string msg = _( - "Failed to add Lua DSP Processor at the given position,\n" - "probably because the I/O configuration of the plugins\n" - "could not match the configuration of this track."); - MessageDialog am (msg); - am.run (); - } - return false; -} - /** @return true if an error occurred, otherwise false */ bool ProcessorBox::use_plugins (const SelectedPlugins& plugins) @@ -2199,11 +2493,10 @@ ProcessorBox::choose_insert () void ProcessorBox::choose_send () { - boost::shared_ptr sendpan(new Pannable (*_session)); - boost::shared_ptr send (new Send (*_session, sendpan, _route->mute_master())); + boost::shared_ptr send (new Send (*_session, _route->pannable (), _route->mute_master())); /* make an educated guess at the initial number of outputs for the send */ - ChanCount outs = (_session->master_out()) + ChanCount outs = (_route->n_outputs().n_audio() && _session->master_out()) ? _session->master_out()->n_outputs() : _route->n_outputs(); @@ -2335,6 +2628,7 @@ ProcessorBox::redisplay_processors () _route->foreach_processor (sigc::mem_fun (*this, &ProcessorBox::add_processor_to_display)); _route->foreach_processor (sigc::mem_fun (*this, &ProcessorBox::maybe_add_processor_to_ui_list)); _route->foreach_processor (sigc::mem_fun (*this, &ProcessorBox::maybe_add_processor_pin_mgr)); + setup_entry_positions (); } @@ -2400,18 +2694,13 @@ ProcessorBox::maybe_add_processor_pin_mgr (boost::weak_ptr w) PluginPinWindowProxy* wp = new PluginPinWindowProxy ( string_compose ("PM-%2-%3", _route->id(), p->id()), w); + wp->set_session (_session); const XMLNode* ui_xml = _session->extra_xml (X_("UI")); if (ui_xml) { wp->set_state (*ui_xml, 0); } - void* existing_ui = p->get_ui (); - - if (existing_ui) { - wp->use_window (*(reinterpret_cast(existing_ui))); - } - p->set_pingmgr_proxy (wp); WM::Manager::instance().register_window (wp); } @@ -2510,6 +2799,136 @@ ProcessorBox::reordered () setup_entry_positions (); } +void +ProcessorBox::setup_routing_feeds () +{ + list children = processor_display.children (); + /* first set the i/o maps for every processor */ + list::iterator prev = children.begin(); + + for (list::iterator i = children.begin(); i != children.end(); ++i) { + boost::shared_ptr p = (*i)->processor(); + boost::shared_ptr pi = boost::dynamic_pointer_cast (p); + + list::iterator next = i; + next++; + + if (pi) { + ChanCount sinks = pi->natural_input_streams (); + ChanCount sources = pi->natural_output_streams (); + uint32_t count = pi->get_count (); + ChanCount in, out; + pi->configured_io (in, out); + + ChanCount midi_thru; + ChanCount midi_bypass; + ChanMapping input_map (pi->input_map ()); + if (pi->has_midi_thru ()) { + midi_thru.set(DataType::MIDI, 1); + input_map.set (DataType::MIDI, 0, 0); + } + if (pi->has_midi_bypass ()) { + midi_bypass.set(DataType::MIDI, 1); + } + + (*i)->input_icon.set_ports (sinks * count + midi_thru); + (*i)->output_icon.set_ports (sources * count + midi_bypass); + + (*i)->routing_icon.set ( + in, out, + sinks * count + midi_thru, + sources * count + midi_bypass, + input_map, + pi->output_map (), + pi->thru_map ()); + + if (next != children.end()) { + (*next)->routing_icon.set_fed_by (out, sources * count + midi_bypass, + pi->output_map (), pi->thru_map ()); + } + + if (prev != i) { + (*prev)->routing_icon.set_feeding (in, sinks * count + midi_thru, + pi->input_map (), pi->thru_map ()); + } + + } else { + (*i)->input_icon.set_ports (p->input_streams()); + (*i)->output_icon.set_ports (p->output_streams()); + ChanMapping inmap (p->input_streams ()); + ChanMapping outmap (p->input_streams ()); + ChanMapping thrumap; + (*i)->routing_icon.set ( + p->input_streams(), + p->output_streams(), + p->input_streams(), + p->output_streams(), + inmap, outmap, thrumap); + + if (next != children.end()) { + (*next)->routing_icon.set_fed_by ( + p->output_streams(), + p->output_streams(), + outmap, thrumap); + } + if (prev != i) { + (*prev)->routing_icon.set_feeding ( + p->input_streams(), + p->output_streams(), + inmap, thrumap); + } + } + + if (i == children.begin()) { + (*i)->routing_icon.unset_fed_by (); + } + prev = i; + (*i)->input_icon.hide(); + } + + /* now set which icons need to be displayed */ + for (list::iterator i = children.begin(); i != children.end(); ++i) { + (*i)->output_routing_icon.copy_state ((*i)->routing_icon); + + if ((*i)->routing_icon.in_identity ()) { + (*i)->routing_icon.hide(); + if (i == children.begin()) { + (*i)->input_icon.show(); + } + } else { + (*i)->routing_icon.show(); + (*i)->routing_icon.queue_draw(); + (*i)->input_icon.show(); + } + + list::iterator next = i; + if (++next == children.end()) { + // last processor in the chain + (*i)->output_routing_icon.set_terminal(true); + (*i)->output_routing_icon.unset_feeding (); + if ((*i)->routing_icon.out_identity ()) { + (*i)->output_routing_icon.hide(); + } else { + (*i)->output_routing_icon.show(); + (*i)->output_routing_icon.queue_draw(); + } + } else { + (*i)->output_routing_icon.set_terminal(false); + if ( !(*i)->routing_icon.out_identity () + && !(*next)->routing_icon.in_identity () + && (*next)->routing_icon.can_coalesce ()) { + (*i)->output_routing_icon.hide(); + } else if (!(*i)->routing_icon.out_identity ()) { + (*i)->output_routing_icon.show(); + (*i)->output_routing_icon.queue_draw(); + (*next)->input_icon.show(); + } else { + (*i)->output_routing_icon.hide(); + } + } + } +} + void ProcessorBox::setup_entry_positions () { @@ -2530,6 +2949,7 @@ ProcessorBox::setup_entry_positions () } } } + setup_routing_feeds (); } void @@ -2925,8 +3345,22 @@ ProcessorBox::paste_processor_state (const XMLNodeList& nlist, boost::shared_ptr is a plugin. */ p.reset (new PluginInsert (*_session)); + /* we can't use RAII Stateful::ForceIDRegeneration + * because that'd void copying the state and wrongly bump + * the state-version counter. + * we need to load the state (incl external files) first and + * only then update the ID) + */ PBD::ID id = p->id(); - p->set_state (**niter, Stateful::current_state_version); + /* strip side-chain state (processor inside processor must be a side-chain) + * otherwise we'll end up with duplicate ports-names. + * (this needs a better solution which retains connections) + * We really would want Stateful::ForceIDRegeneration here :( + */ + XMLNode state (**niter); + state.remove_nodes ("Processor"); + + p->set_state (state, Stateful::current_state_version); boost::dynamic_pointer_cast(p)->update_id (id); } @@ -3207,8 +3641,6 @@ ProcessorBox::register_actions () myactions.register_action (processor_box_actions, X_("newplugin"), _("New Plugin"), sigc::ptr_fun (ProcessorBox::rb_choose_plugin)); - act = myactions.register_action (processor_box_actions, X_("newlua"), _("New Lua Proc"), - sigc::ptr_fun (ProcessorBox::rb_choose_lua)); act = myactions.register_action (processor_box_actions, X_("newinsert"), _("New Insert"), sigc::ptr_fun (ProcessorBox::rb_choose_insert)); ActionManager::engine_sensitive_actions.push_back (act); @@ -3236,10 +3668,13 @@ ProcessorBox::register_actions () sigc::ptr_fun (ProcessorBox::rb_copy)); delete_action = myactions.register_action (processor_box_actions, X_("delete"), _("Delete"), sigc::ptr_fun (ProcessorBox::rb_delete)); + backspace_action = myactions.register_action (processor_box_actions, X_("backspace"), _("Delete"), + sigc::ptr_fun (ProcessorBox::rb_delete)); ActionManager::plugin_selection_sensitive_actions.push_back (cut_action); ActionManager::plugin_selection_sensitive_actions.push_back (copy_action); ActionManager::plugin_selection_sensitive_actions.push_back (delete_action); + ActionManager::plugin_selection_sensitive_actions.push_back (backspace_action); paste_action = myactions.register_action (processor_box_actions, X_("paste"), _("Paste"), sigc::ptr_fun (ProcessorBox::rb_paste)); @@ -3260,7 +3695,7 @@ ProcessorBox::register_actions () sigc::ptr_fun (ProcessorBox::rb_ab_plugins)); manage_pins_action = myactions.register_action ( - processor_box_actions, X_("manage-pins"), _("Pin Management..."), + processor_box_actions, X_("manage-pins"), _("Pin Connections..."), sigc::ptr_fun (ProcessorBox::rb_manage_pins)); /* show editors */ @@ -3313,15 +3748,6 @@ ProcessorBox::rb_choose_plugin () _current_processor_box->choose_plugin (); } -void -ProcessorBox::rb_choose_lua () -{ - if (_current_processor_box == 0) { - return; - } - _current_processor_box->choose_lua (); -} - void ProcessorBox::rb_choose_insert () { @@ -3506,6 +3932,9 @@ ProcessorBox::edit_processor (boost::shared_ptr processor) if (edit_aux_send (processor)) { return; } + if (!_session->engine().connected()) { + return; + } ProcessorWindowProxy* proxy = find_window_proxy (processor); @@ -3524,6 +3953,9 @@ ProcessorBox::generic_edit_processor (boost::shared_ptr processor) if (edit_aux_send (processor)) { return; } + if (!_session->engine().connected()) { + return; + } ProcessorWindowProxy* proxy = find_window_proxy (processor); @@ -3766,7 +4198,7 @@ ProcessorWindowProxy::set_state (const XMLNode& node, int /*version*/) XMLNodeList children = node.children (); XMLNodeList::const_iterator i = children.begin (); while (i != children.end()) { - XMLProperty* prop = (*i)->property (X_("name")); + XMLProperty const * prop = (*i)->property (X_("name")); if ((*i)->name() == X_("Window") && prop && prop->value() == _name) { break; } @@ -3774,7 +4206,7 @@ ProcessorWindowProxy::set_state (const XMLNode& node, int /*version*/) } if (i != children.end()) { - XMLProperty* prop; + XMLProperty const * prop; if ((prop = (*i)->property (X_("custom-ui"))) != 0) { want_custom = PBD::string_is_affirmative (prop->value ()); } @@ -3807,8 +4239,8 @@ ProcessorWindowProxy::get (bool create) if (_window) { setup (); } + _window->show_all (); } - return _window; } @@ -3818,12 +4250,7 @@ ProcessorWindowProxy::show_the_right_window () if (_window && (is_custom != want_custom)) { /* drop existing window - wrong type */ drop_window (); - get (true); - setup (); - assert (_window); - is_custom = want_custom; } - toggle (); } @@ -3844,6 +4271,13 @@ PluginPinWindowProxy::~PluginPinWindowProxy() _window = 0; } +ARDOUR::SessionHandlePtr* +PluginPinWindowProxy::session_handle () +{ + ArdourWindow* aw = dynamic_cast (_window); + if (aw) { return aw; } + return 0; +} Gtk::Window* PluginPinWindowProxy::get (bool create) @@ -3859,9 +4293,12 @@ PluginPinWindowProxy::get (bool create) return 0; } _window = new PluginPinDialog (pi); + ArdourWindow* aw = dynamic_cast (_window); + if (aw) { + aw->set_session (_session); + } + _window->show_all (); } - - _window->show_all (); return _window; }