X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fprocessor_box.cc;h=95b21c826c085be96addaaebbe9eb42d7a566b78;hb=0034f246cb283cea1ad100bfe383ad7801140da9;hp=f6ce27a0c91115f16f7bbf2fd741854240cdb4ab;hpb=11f51497f365ca55065834e86169ddd6605e4f9b;p=ardour.git diff --git a/gtk2_ardour/processor_box.cc b/gtk2_ardour/processor_box.cc index f6ce27a0c9..f496070537 100644 --- a/gtk2_ardour/processor_box.cc +++ b/gtk2_ardour/processor_box.cc @@ -27,24 +27,29 @@ #include -#include "pbd/convert.h" - #include +#include #include -#include -#include -#include -#include -#include -#include +#include "gtkmm2ext/colors.h" +#include "gtkmm2ext/gtk_ui.h" +#include "gtkmm2ext/menu_elems.h" +#include "gtkmm2ext/utils.h" +#include "gtkmm2ext/doi.h" +#include "gtkmm2ext/rgb_macros.h" + +#include "widgets/choice.h" +#include "widgets/prompter.h" +#include "widgets/tooltips.h" #include "ardour/amp.h" #include "ardour/audio_track.h" #include "ardour/audioengine.h" #include "ardour/internal_return.h" #include "ardour/internal_send.h" +#include "ardour/luaproc.h" +#include "ardour/luascripting.h" #include "ardour/meter.h" #include "ardour/panner_shell.h" #include "ardour/plugin_insert.h" @@ -56,6 +61,9 @@ #include "ardour/send.h" #include "ardour/session.h" #include "ardour/types.h" +#include "ardour/value_as_string.h" + +#include "LuaBridge/LuaBridge.h" #include "actions.h" #include "ardour_dialog.h" @@ -63,57 +71,91 @@ #include "gui_thread.h" #include "io_selector.h" #include "keyboard.h" +#include "luainstance.h" #include "mixer_ui.h" #include "mixer_strip.h" +#include "plugin_pin_dialog.h" #include "plugin_selector.h" #include "plugin_ui.h" #include "port_insert_ui.h" #include "processor_box.h" +#include "processor_selection.h" #include "public_editor.h" #include "return_ui.h" -#include "route_processor_selection.h" +#include "script_selector.h" #include "send_ui.h" #include "timers.h" +#include "new_plugin_preset_dialog.h" -#include "i18n.h" +#include "pbd/i18n.h" #ifdef AUDIOUNIT_SUPPORT class AUPluginUI; #endif +#ifndef NDEBUG +bool ProcessorBox::show_all_processors = false; +#endif + using namespace std; using namespace ARDOUR; using namespace PBD; using namespace Gtk; using namespace Glib; using namespace Gtkmm2ext; +using namespace ArdourWidgets; -ProcessorBox* ProcessorBox::_current_processor_box = 0; +ProcessorBox* ProcessorBox::_current_processor_box = 0; RefPtr ProcessorBox::paste_action; 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; +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 (); - + _button.set_distinct_led_click (true); _button.set_fallthrough_to_parent(true); _button.set_led_left (true); @@ -127,22 +169,49 @@ ProcessorEntry::ProcessorEntry (ProcessorBox* parent, boost::shared_ptr pi = boost::dynamic_pointer_cast (_processor); + 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); - _vbox.pack_end (_output_icon); - _button.set_active (_processor->active()); + 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 PluginInlineDisplay (*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 (*this, boost::dynamic_pointer_cast(pi->plugin()), + std::max (60.f, rintf(112.f * UIConfiguration::instance().get_ui_scale()))); + } + _vbox.pack_start (*_plugin_display); + _plugin_display->set_no_show_all (true); + if (UIConfiguration::instance().get_show_inline_display_by_default ()) { + _plugin_display->show (); + } + } + _vbox.pack_end (output_routing_icon); + _vbox.pack_end (output_icon); - _routing_icon.set_no_show_all(true); - _input_icon.set_no_show_all(true); + _button.set_active (_processor->enabled ()); + + 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()); @@ -150,7 +219,7 @@ ProcessorEntry::ProcessorEntry (ProcessorBox* parent, boost::shared_ptr p = _processor->what_can_be_automated (); for (set::iterator i = p.begin(); i != p.end(); ++i) { - + std::string label = _processor->describe_parameter (*i); if (boost::dynamic_pointer_cast (_processor)) { @@ -160,21 +229,15 @@ ProcessorEntry::ProcessorEntry (ProcessorBox* parent, boost::shared_ptrautomation_control (*i), label); - + _controls.push_back (c); if (boost::dynamic_pointer_cast (_processor) == 0) { - /* Add non-Amp controls to the processor box */ + /* Add non-Amp (Fader & Trim) controls to the processor box */ _vbox.pack_start (c->box); } } - _input_icon.set_ports(_processor->input_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 { @@ -187,6 +250,7 @@ ProcessorEntry::~ProcessorEntry () for (list::iterator i = _controls.begin(); i != _controls.end(); ++i) { delete *i; } + delete _plugin_display; } EventBox& @@ -207,18 +271,99 @@ ProcessorEntry::drag_text () const return name (Wide); } +bool +ProcessorEntry::can_copy_state (Gtkmm2ext::DnDVBoxChild* o) const +{ + ProcessorEntry *other = dynamic_cast (o); + if (!other) { + return false; + } + boost::shared_ptr otherproc = other->processor(); + boost::shared_ptr my_pi = boost::dynamic_pointer_cast (_processor); + boost::shared_ptr ot_pi = boost::dynamic_pointer_cast (otherproc); + if (boost::dynamic_pointer_cast (_processor)) { + return false; + } + if (boost::dynamic_pointer_cast (otherproc)) { + return false; + } + if (!my_pi || !ot_pi) { + return false; + } + if (my_pi->type() != ot_pi->type()) { + return false; + } + boost::shared_ptr my_p = my_pi->plugin(); + boost::shared_ptr ot_p = ot_pi->plugin(); + if (!my_p || !ot_p) { + return false; + } + if (my_p->unique_id() != ot_p->unique_id()) { + return false; + } + return true; +} + +bool +ProcessorEntry::drag_data_get (Glib::RefPtr const, Gtk::SelectionData &data) +{ + if (data.get_target() == "PluginPresetPtr") { + boost::shared_ptr pi = boost::dynamic_pointer_cast (_processor); + + if (!_plugin_preset_pointer || !pi) { + data.set (data.get_target(), 8, NULL, 0); + return true; + } + + boost::shared_ptr plugin = pi->plugin(); + assert (plugin); + + PluginManager& manager (PluginManager::instance()); + bool fav = manager.get_status (_plugin_preset_pointer->_pip) == PluginManager::Favorite; + + NewPluginPresetDialog d (plugin, + string_compose(_("New Favorite Preset for \"%1\""),_plugin_preset_pointer->_pip->name), !fav); + + _plugin_preset_pointer->_preset.valid = false; + + switch (d.run ()) { + case Gtk::RESPONSE_CANCEL: + data.set (data.get_target(), 8, NULL, 0); + return true; + break; + + case Gtk::RESPONSE_NO: + break; + + case Gtk::RESPONSE_ACCEPT: + if (d.name().empty()) { + break; + } + + if (d.replace ()) { + plugin->remove_preset (d.name ()); + } + + Plugin::PresetRecord const r = plugin->save_preset (d.name()); + + if (!r.uri.empty ()) { + _plugin_preset_pointer->_preset.uri = r.uri; + _plugin_preset_pointer->_preset.label = r.label; + _plugin_preset_pointer->_preset.user = r.user; + _plugin_preset_pointer->_preset.valid = r.valid; + } + } + data.set (data.get_target(), 8, (const guchar *) &_plugin_preset_pointer, sizeof (PluginPresetPtr)); + return true; + } + return false; +} + void 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 (); } @@ -239,9 +384,25 @@ 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; + } + } + + boost::shared_ptr aux; + if ((aux = boost::dynamic_pointer_cast (_processor))) { + if (aux->allow_feedback ()) { + _button.set_name ("processor auxfeedback"); + return; + } + } switch (_position) { case PreFader: + if (_plugin_display) { _plugin_display->set_name ("processor prefader"); } _button.set_name ("processor prefader"); break; @@ -250,6 +411,7 @@ ProcessorEntry::setup_visuals () break; case PostFader: + if (_plugin_display) { _plugin_display->set_name ("processor postfader"); } _button.set_name ("processor postfader"); break; } @@ -259,6 +421,9 @@ ProcessorEntry::setup_visuals () boost::shared_ptr ProcessorEntry::processor () const { + if (!_processor) { + return boost::shared_ptr(); + } return _processor; } @@ -270,13 +435,39 @@ ProcessorEntry::set_enum_width (Width w) } void -ProcessorEntry::led_clicked() +ProcessorEntry::led_clicked(GdkEventButton *ev) { + bool ctrl_shift_pressed = false; + Keyboard::ModifierMask ctrl_shift_mask = Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier); + + if (Keyboard::modifier_state_equals (ev->state, ctrl_shift_mask)) { + ctrl_shift_pressed = true; + } + if (_processor) { if (_button.get_active ()) { - _processor->deactivate (); + if (ctrl_shift_pressed) { + _parent->all_visible_processors_active(false); + + if (_position == Fader) { + _processor->enable (false); + } + } + else { + _processor->enable (false); + } + } else { - _processor->activate (); + if (ctrl_shift_pressed) { + _parent->all_visible_processors_active(true); + + if (_position == Fader) { + _processor->enable (true); + } + } + else { + _processor->enable (true); + } } } } @@ -285,7 +476,7 @@ void ProcessorEntry::processor_active_changed () { if (_processor) { - _button.set_active (_processor->active()); + _button.set_active (_processor->enabled ()); } } @@ -301,13 +492,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 @@ -318,14 +507,20 @@ ProcessorEntry::setup_tooltip () if (pi) { std::string postfix = ""; uint32_t replicated; + + if (pi->plugin()->has_inline_display()) { + postfix += string_compose(_("\n%1+double-click to toggle inline-display"), Keyboard::tertiary_modifier_name ()); + } + if ((replicated = pi->get_count()) > 1) { - postfix = string_compose(_("\nThis mono plugin has been replicated %1 times."), replicated); + postfix += string_compose(_("\nThis mono plugin has been replicated %1 times."), replicated); } + if (pi->plugin()->has_editor()) { - ARDOUR_UI::instance()->set_tip (_button, - string_compose (_("%1\nDouble-click to show GUI.\nAlt+double-click to show generic GUI.%2"), name (Wide), postfix)); + set_tooltip (_button, + string_compose (_("%1\nDouble-click to show GUI.\n%2+double-click to show generic GUI.%3"), name (Wide), Keyboard::secondary_modifier_name (), postfix)); } else { - ARDOUR_UI::instance()->set_tip (_button, + set_tooltip (_button, string_compose (_("%1\nDouble-click to show generic GUI.%2"), name (Wide), postfix)); } return; @@ -335,8 +530,18 @@ 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 ()) { + set_tooltip (_button, string_compose ("> %1\nThis (sidechain) send will be removed when disconnected.", _processor->name())); + } else { + set_tooltip (_button, string_compose ("> %1", _processor->name())); + } + return; + } } - ARDOUR_UI::instance()->set_tip (_button, string_compose ("%1", name (Wide))); + set_tooltip (_button, string_compose ("%1", name (Wide))); } string @@ -353,19 +558,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; } @@ -418,6 +656,13 @@ ProcessorEntry::add_control_state (XMLNode* node) const for (list::const_iterator i = _controls.begin(); i != _controls.end(); ++i) { (*i)->add_state (node); } + + if (_plugin_display) { + XMLNode* c = new XMLNode (X_("Object")); + c->set_property (X_("id"), X_("InlineDisplay")); + c->set_property (X_("visible"), _plugin_display->is_visible ()); + node->add_child_nocopy (*c); + } } void @@ -426,6 +671,20 @@ ProcessorEntry::set_control_state (XMLNode const * node) for (list::const_iterator i = _controls.begin(); i != _controls.end(); ++i) { (*i)->set_state (node); } + + if (_plugin_display) { + XMLNode* n = GUIObjectState::get_node (node, X_("InlineDisplay")); + if (!n) return; + + bool visible; + if (n->get_property (X_("visible"), visible)) { + if (visible) { + _plugin_display->show (); + } else { + _plugin_display->hide (); + } + } + } } string @@ -450,10 +709,18 @@ ProcessorEntry::build_controls_menu () Menu* menu = manage (new Menu); MenuList& items = menu->items (); + if (_plugin_display) { + items.push_back (CheckMenuElem (_("Inline Display"))); + Gtk::CheckMenuItem* c = dynamic_cast (&items.back ()); + c->set_active (_plugin_display->is_visible ()); + c->signal_toggled().connect (sigc::mem_fun (*this, &ProcessorEntry::toggle_inline_display_visibility)); + items.push_back (SeparatorElem ()); + } + items.push_back ( MenuElem (_("Show All Controls"), sigc::mem_fun (*this, &ProcessorEntry::show_all_controls)) ); - + items.push_back ( MenuElem (_("Hide All Controls"), sigc::mem_fun (*this, &ProcessorEntry::hide_all_controls)) ); @@ -461,9 +728,9 @@ ProcessorEntry::build_controls_menu () if (!_controls.empty ()) { items.push_back (SeparatorElem ()); } - + for (list::iterator i = _controls.begin(); i != _controls.end(); ++i) { - items.push_back (CheckMenuElem ((*i)->name ())); + items.push_back (CheckMenuElemNoMnemonic ((*i)->name ())); Gtk::CheckMenuItem* c = dynamic_cast (&items.back ()); c->set_active ((*i)->visible ()); c->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &ProcessorEntry::toggle_control_visibility), *i)); @@ -472,6 +739,17 @@ ProcessorEntry::build_controls_menu () return menu; } +void +ProcessorEntry::toggle_inline_display_visibility () +{ + if (_plugin_display->is_visible ()) { + _plugin_display->hide(); + } else { + _plugin_display->show(); + } + _parent->update_gui_object_state (this); +} + void ProcessorEntry::toggle_control_visibility (Control* c) { @@ -486,14 +764,22 @@ ProcessorEntry::build_send_options_menu () Menu* menu = manage (new Menu); MenuList& items = menu->items (); - boost::shared_ptr send = boost::dynamic_pointer_cast (_processor); - if (send) { + if (!ARDOUR::Profile->get_mixbus()) { + boost::shared_ptr send = boost::dynamic_pointer_cast (_processor); + if (send) { + items.push_back (CheckMenuElem (_("Link panner controls"))); + Gtk::CheckMenuItem* c = dynamic_cast (&items.back ()); + c->set_active (send->panner_shell()->is_linked_to_route()); + c->signal_toggled().connect (sigc::mem_fun (*this, &ProcessorEntry::toggle_panner_link)); + } + } - items.push_back (CheckMenuElem (_("Link panner controls"))); + boost::shared_ptr aux = boost::dynamic_pointer_cast (_processor); + if (aux) { + items.push_back (CheckMenuElem (_("Allow Feedback Loop"))); Gtk::CheckMenuItem* c = dynamic_cast (&items.back ()); - c->set_active (send->panner_shell()->is_linked_to_route()); - c->signal_toggled().connect (sigc::mem_fun (*this, &ProcessorEntry::toggle_panner_link)); - + c->set_active (aux->allow_feedback()); + c->signal_toggled().connect (sigc::mem_fun (*this, &ProcessorEntry::toggle_allow_feedback)); } return menu; } @@ -507,10 +793,19 @@ ProcessorEntry::toggle_panner_link () } } +void +ProcessorEntry::toggle_allow_feedback () +{ + boost::shared_ptr aux = boost::dynamic_pointer_cast (_processor); + if (aux) { + aux->set_allow_feedback (!aux->allow_feedback ()); + } +} + ProcessorEntry::Control::Control (boost::shared_ptr c, string const & n) : _control (c) , _adjustment (gain_to_slider_position_with_max (1.0, Config->get_max_gain()), 0, 1, 0.01, 0.1) - , _slider (&_adjustment, boost::shared_ptr(), 0, max(13.f, rintf(13.f * ARDOUR_UI::ui_scale))) + , _slider (&_adjustment, boost::shared_ptr(), 0, max(13.f, rintf(13.f * UIConfiguration::instance().get_ui_scale()))) , _slider_persistant_tooltip (&_slider) , _button (ArdourButton::led_default_elements) , _ignore_ui_adjustment (false) @@ -528,12 +823,15 @@ ProcessorEntry::Control::Control (boost::shared_ptr c, string _button.show (); _button.signal_clicked.connect (sigc::mem_fun (*this, &Control::button_clicked)); - _button.signal_led_clicked.connect (sigc::mem_fun (*this, &Control::button_clicked)); - // dup. currently timers are used :( - //c->Changed.connect (_connection, MISSING_INVALIDATOR, boost::bind (&Control::control_changed, this), gui_context ()); + _button.signal_led_clicked.connect (sigc::mem_fun (*this, &Control::button_clicked_event)); + c->Changed.connect (_connections, invalidator (*this), boost::bind (&Control::control_changed, this), gui_context ()); + if (c->alist ()) { + c->alist()->automation_state_changed.connect (_connections, invalidator (*this), boost::bind (&Control::control_automation_state_changed, this), gui_context()); + control_automation_state_changed (); + } } else { - + _slider.set_name ("ProcessorControlSlider"); _slider.set_text (_name); @@ -541,39 +839,29 @@ ProcessorEntry::Control::Control (boost::shared_ptr c, string _slider.show (); const ARDOUR::ParameterDescriptor& desc = c->desc(); - double const lo = c->internal_to_interface(desc.lower); - double const up = c->internal_to_interface(desc.upper); - double const normal = c->internal_to_interface(desc.normal); - double smallstep = desc.smallstep; - double largestep = desc.largestep; - - if (smallstep == 0.0) { - smallstep = up / 1000.; - } else { - smallstep = c->internal_to_interface(desc.lower + smallstep); - } - - if (largestep == 0.0) { - largestep = up / 40.; - } else { - largestep = c->internal_to_interface(desc.lower + largestep); - } + double const lo = c->internal_to_interface (desc.lower); + double const up = c->internal_to_interface (desc.upper); + double const normal = c->internal_to_interface (desc.normal); + double const smallstep = c->internal_to_interface (desc.lower + desc.smallstep); + double const largestep = c->internal_to_interface (desc.lower + desc.largestep); _adjustment.set_lower (lo); _adjustment.set_upper (up); _adjustment.set_step_increment (smallstep); _adjustment.set_page_increment (largestep); _slider.set_default_value (normal); - + + _slider.StartGesture.connect(sigc::mem_fun(*this, &Control::start_touch)); + _slider.StopGesture.connect(sigc::mem_fun(*this, &Control::end_touch)); + _adjustment.signal_value_changed().connect (sigc::mem_fun (*this, &Control::slider_adjusted)); - // dup. currently timers are used :( - //c->Changed.connect (_connection, MISSING_INVALIDATOR, boost::bind (&Control::control_changed, this), gui_context ()); + c->Changed.connect (_connections, invalidator (*this), boost::bind (&Control::control_changed, this), gui_context ()); + if (c->alist ()) { + c->alist()->automation_state_changed.connect (_connections, invalidator (*this), boost::bind (&Control::control_automation_state_changed, this), gui_context()); + control_automation_state_changed (); + } } - // yuck, do we really need to do this? - // according to c404374 this is only needed for send automation - timer_connection = Timers::rapid_connect (sigc::mem_fun (*this, &Control::control_changed)); - control_changed (); set_tooltip (); @@ -583,7 +871,6 @@ ProcessorEntry::Control::Control (boost::shared_ptr c, string ProcessorEntry::Control::~Control () { - timer_connection.disconnect (); } void @@ -594,16 +881,10 @@ ProcessorEntry::Control::set_tooltip () if (!c) { return; } - char tmp[256]; - if (c->toggled ()) { - snprintf (tmp, sizeof(tmp), "%s: %s", _name.c_str(), c->get_value() > 0.5 ? _("on") : _("off")); - } else { - snprintf (tmp, sizeof(tmp), "%s: %.2f", _name.c_str(), c->internal_to_user (c->get_value ())); - } - - string sm = Glib::Markup::escape_text (tmp); + std::string tt = _name + ": " + ARDOUR::value_as_string (c->desc(), c->get_value ()); + string sm = Gtkmm2ext::markup_escape_text (tt); _slider_persistant_tooltip.set_tip (sm); - ARDOUR_UI::instance()->set_tip (_button, sm); + ArdourWidgets::set_tooltip (_button, sm); } void @@ -612,17 +893,37 @@ ProcessorEntry::Control::slider_adjusted () if (_ignore_ui_adjustment) { return; } - + boost::shared_ptr c = _control.lock (); if (!c) { return; } - c->set_value ( c->interface_to_internal(_adjustment.get_value ()) ); + c->set_value ( c->interface_to_internal(_adjustment.get_value ()) , Controllable::NoGroup); set_tooltip (); } +void +ProcessorEntry::Control::start_touch () +{ + boost::shared_ptr c = _control.lock (); + if (!c) { + return; + } + c->start_touch (c->session().transport_frame()); +} + +void +ProcessorEntry::Control::end_touch () +{ + boost::shared_ptr c = _control.lock (); + if (!c) { + return; + } + c->stop_touch (c->session().transport_frame()); +} + void ProcessorEntry::Control::button_clicked () { @@ -634,11 +935,34 @@ ProcessorEntry::Control::button_clicked () bool const n = _button.get_active (); - c->set_value (n ? 0 : 1); + c->set_value (n ? 0 : 1, Controllable::NoGroup); _button.set_active (!n); set_tooltip (); } +void +ProcessorEntry::Control::button_clicked_event (GdkEventButton *ev) +{ + (void) ev; + + button_clicked (); +} + +void +ProcessorEntry::Control::control_automation_state_changed () +{ + boost::shared_ptr c = _control.lock (); + if (!c) { + return; + } + bool x = c->alist()->automation_state() & Play; + if (c->toggled ()) { + _button.set_sensitive (!x); + } else { + _slider.set_sensitive (!x); + } +} + void ProcessorEntry::Control::control_changed () { @@ -650,19 +974,16 @@ ProcessorEntry::Control::control_changed () _ignore_ui_adjustment = true; if (c->toggled ()) { - _button.set_active (c->get_value() > 0.5); - } else { - // as long as rapid timers are used, only update the tooltip - // if the value has changed. + // Note: the _slider watches the controllable by itself const double nval = c->internal_to_interface (c->get_value ()); if (_adjustment.get_value() != nval) { _adjustment.set_value (nval); set_tooltip (); } } - + _ignore_ui_adjustment = false; } @@ -670,8 +991,8 @@ void ProcessorEntry::Control::add_state (XMLNode* node) const { XMLNode* c = new XMLNode (X_("Object")); - c->add_property (X_("id"), state_id ()); - c->add_property (X_("visible"), _visible); + c->set_property (X_("id"), state_id ()); + c->set_property (X_("visible"), _visible); node->add_child_nocopy (*c); } @@ -680,8 +1001,10 @@ ProcessorEntry::Control::set_state (XMLNode const * node) { XMLNode* n = GUIObjectState::get_node (node, state_id ()); if (n) { - XMLProperty* p = n->property (X_("visible")); - set_visible (p && string_is_affirmative (p->value ())); + bool visible; + if (n->get_property (X_("visible"), visible)) { + set_visible (visible); + } } else { set_visible (false); } @@ -695,7 +1018,7 @@ ProcessorEntry::Control::set_visible (bool v) } else { box.hide (); } - + _visible = v; } @@ -724,100 +1047,34 @@ 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 * ARDOUR_UI::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) { _input = input; _ports = ARDOUR::ChanCount(ARDOUR::DataType::AUDIO, 1); - set_size_request (-1, std::max (2.f, rintf(2.f * ARDOUR_UI::ui_scale))); + set_size_request (-1, std::max (2.f, rintf(2.f * UIConfiguration::instance().get_ui_scale()))); } bool @@ -838,46 +1095,225 @@ ProcessorEntry::PortIcon::on_expose_event (GdkEventExpose* ev) cairo_rectangle (cr, 0, 0, width, height); cairo_fill (cr); - const double dx = rint(max(2., 2. * ARDOUR_UI::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); + const double dx = rint(max(2., 2. * UIConfiguration::instance().get_ui_scale())); + 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) { @@ -886,7 +1322,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, ARDOUR_UI::ui_scale)); cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); Gtk::Allocation a = get_allocation(); @@ -899,123 +1334,407 @@ 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. * ARDOUR_UI::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; + 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; + } + } + 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); + } +} + +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::PluginInlineDisplay::PluginInlineDisplay (ProcessorEntry& e, boost::shared_ptr p, uint32_t max_height) + : PluginDisplay (p, max_height) + , _entry (e) + , _scroll (false) +{ + std::string postfix = string_compose(_("\n%1+double-click to toggle inline-display"), Keyboard::tertiary_modifier_name ()); + + if (_plug->has_editor()) { + 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 { + set_tooltip (*this, + string_compose (_("%1\nDouble-click to show generic GUI.%2"), e.name (Wide), postfix)); + } +} + + +bool +ProcessorEntry::PluginInlineDisplay::on_button_press_event (GdkEventButton *ev) +{ + assert (_entry.processor ()); + + boost::shared_ptr pi = boost::dynamic_pointer_cast (_entry.processor()); + // duplicated code :( + // 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 (pi && pi->plugin() && pi->plugin()->has_inline_display() + && Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier) + && ev->button == 1 + && ev->type == GDK_2BUTTON_PRESS) { + _entry.toggle_inline_display_visibility (); + return true; + } + else 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 { - si_x0 = rintf(width * (.2f + .6f * midi_sources / (sources - 1.f))) + .5f; + _entry._parent->edit_processor (_entry.processor ()); } - cairo_move_to (cr, si_x, height); - cairo_curve_to (cr, si_x, 0, si_x0, height, si_x0, 0); - cairo_stroke (cr); + return true; + } + return false; +} + +void +ProcessorEntry::PluginInlineDisplay::on_size_request (Requisition* req) +{ + req->width = 56; + req->height = _cur_height; +} + + +void +ProcessorEntry::PluginInlineDisplay::update_height_alloc (uint32_t inline_height) +{ + /* work-around scroll-bar + aspect ratio + * show inline-view -> height changes -> scrollbar gets added + * -> width changes -> inline-view, fixed aspect ratio -> height changes + * -> scroll bar is removed [-> width changes ; repeat ] + */ + uint32_t shm = std::min (_max_height, inline_height); + bool sc = false; + Gtk::Container* pr = get_parent(); + for (uint32_t i = 0; i < 4 && pr; ++i) { + // VBox, EventBox, ViewPort, ScrolledWindow + pr = pr->get_parent(); + } + Gtk::ScrolledWindow* sw = dynamic_cast (pr); + if (sw) { + const Gtk::VScrollbar* vsb = sw->get_vscrollbar(); + sc = vsb && vsb->is_visible(); + } + + if (shm != _cur_height) { + if (_scroll == sc || _cur_height < shm) { + queue_resize (); + } + _cur_height = shm; + } + _scroll = sc; +} + +void +ProcessorEntry::PluginInlineDisplay::display_frame (cairo_t* cr, double w, double h) +{ + Gtkmm2ext::rounded_rectangle (cr, .5, -1.5, w - 1, h + 1, 7); +} + +ProcessorEntry::LuaPluginDisplay::LuaPluginDisplay (ProcessorEntry& e, boost::shared_ptr p, uint32_t max_height) + : PluginInlineDisplay (e, p, max_height) + , _luaproc (p) + , _lua_render_inline (0) +{ + p->setup_lua_inline_gui (&lua_gui); + + lua_State* LG = lua_gui.getState (); + LuaInstance::bind_cairo (LG); + luabridge::LuaRef lua_render = luabridge::getGlobal (LG, "render_inline"); + assert (lua_render.isFunction ()); + _lua_render_inline = new luabridge::LuaRef (lua_render); +} + +ProcessorEntry::LuaPluginDisplay::~LuaPluginDisplay () +{ + delete (_lua_render_inline); +} + +uint32_t +ProcessorEntry::LuaPluginDisplay::render_inline (cairo_t *cr, uint32_t width) +{ + Cairo::Context ctx (cr); + try { + luabridge::LuaRef rv = (*_lua_render_inline)((Cairo::Context *)&ctx, width, _max_height); + lua_gui.collect_garbage_step (); + if (rv.isTable ()) { + uint32_t h = rv[2]; + return h; + } + } catch (luabridge::LuaException const& e) { #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; + cerr << "LuaException:" << e.what () << endl; #endif - } - cairo_destroy(cr); - return true; + } catch (...) { } + return 0; +} + + +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 ("PluginFavoritePtr")); // from sidebar + return tmp; +} + +static std::list drag_targets() +{ + std::list tmp; + tmp.push_back (Gtk::TargetEntry ("PluginPresetPtr")); // to sidebar (optional preset) + tmp.push_back (Gtk::TargetEntry ("processor")); // to processor-box (copy) + return tmp; +} + +static std::list drag_targets_noplugin() +{ + std::list tmp; + tmp.push_back (Gtk::TargetEntry ("processor")); // to processor box (sends, faders re-order) + return tmp; } ProcessorBox::ProcessorBox (ARDOUR::Session* sess, boost::function get_plugin_selector, - RouteProcessorSelection& rsel, MixerStrip* parent, bool owner_is_mixer) + ProcessorSelection& psel, MixerStrip* parent, bool owner_is_mixer) : _parent_strip (parent) , _owner_is_mixer (owner_is_mixer) , ab_direction (true) , _get_plugin_selector (get_plugin_selector) , _placement (-1) - , _visible_prefader_processors (0) - , _rr_selection(rsel) + , _p_selection(psel) + , processor_display (drop_targets()) , _redisplay_pending (false) - { set_session (sess); + /* ProcessorBox actions and bindings created statically by call to + * ProcessorBox::register_actions(), made by ARDOUR_UI so that actions + * are available for context menus. + */ + + processor_display.set_data ("ardour-bindings", bindings); + _width = Wide; processor_menu = 0; no_processor_redisplay = false; @@ -1038,6 +1757,7 @@ ProcessorBox::ProcessorBox (ARDOUR::Session* sess, boost::functionset_tip (processor_display, _("Right-click to add/remove/edit\nplugins,inserts,sends and more")); + set_tooltip (processor_display, _("Right-click to add/remove/edit\nplugins,inserts,sends and more")); } ProcessorBox::~ProcessorBox () @@ -1100,16 +1820,16 @@ ProcessorBox::route_going_away () _route.reset (); } -void -ProcessorBox::object_drop(DnDVBox* source, ProcessorEntry* position, Glib::RefPtr const & context) +boost::shared_ptr +ProcessorBox::find_drop_position (ProcessorEntry* position) { boost::shared_ptr p; if (position) { p = position->processor (); if (!p) { /* dropped on the blank entry (which will be before the - fader), so use the first non-blank child as our - `dropped on' processor */ + fader), so use the first non-blank child as our + `dropped on' processor */ list c = processor_display.children (); list::iterator i = c.begin (); @@ -1118,8 +1838,121 @@ ProcessorBox::object_drop(DnDVBox* source, ProcessorEntry* posit assert (p); } } + return p; +} + +void +ProcessorBox::_drop_plugin_preset (Gtk::SelectionData const &data, Route::ProcessorList &pl) +{ + const void * d = data.get_data(); + const Gtkmm2ext::DnDTreeView* tv = reinterpret_cast*>(d); + + PluginPresetList nfos; + TreeView* source; + tv->get_object_drag_data (nfos, &source); + + for (list::const_iterator i = nfos.begin(); i != nfos.end(); ++i) { + PluginPresetPtr ppp = (*i); + PluginInfoPtr pip = ppp->_pip; + PluginPtr p = pip->load (*_session); + if (!p) { + continue; + } + + if (ppp->_preset.valid) { + p->load_preset (ppp->_preset); + } + + boost::shared_ptr processor (new PluginInsert (*_session, p)); + if (Config->get_new_plugins_active ()) { + processor->enable (true); + } + pl.push_back (processor); + } +} + +void +ProcessorBox::_drop_plugin (Gtk::SelectionData const &data, Route::ProcessorList &pl) +{ + const void * d = data.get_data(); + const Gtkmm2ext::DnDTreeView* tv = reinterpret_cast*>(d); + PluginInfoList nfos; + + TreeView* source; + tv->get_object_drag_data (nfos, &source); + + for (list::const_iterator i = nfos.begin(); i != nfos.end(); ++i) { + PluginPtr p = (*i)->load (*_session); + if (!p) { + continue; + } + boost::shared_ptr processor (new PluginInsert (*_session, p)); + if (Config->get_new_plugins_active ()) { + processor->enable (true); + } + pl.push_back (processor); + } +} + +void +ProcessorBox::plugin_drop (Gtk::SelectionData const &data, ProcessorEntry* position, Glib::RefPtr const & context) +{ + if (!_session) { + return; + } - list children = source->selection (); + boost::shared_ptr p = find_drop_position (position); + Route::ProcessorList pl; + + if (data.get_target() == "PluginInfoPtr") { + _drop_plugin (data, pl); + } + else if (data.get_target() == "PluginFavoritePtr") { + _drop_plugin_preset (data, pl); + } + else { + return; + } + + Route::ProcessorStreams err; + if (_route->add_processors (pl, p, &err)) { + string msg = _( + "Processor Drag/Drop failed. Probably because\n\ +the I/O configuration of the plugins could\n\ +not match the configuration of this track."); + MessageDialog am (msg); + am.run (); + } +} + +void +ProcessorBox::object_drop (DnDVBox* source, ProcessorEntry* position, Glib::RefPtr const & context) +{ + if (Gdk::ACTION_LINK == context->get_selected_action()) { + list children = source->selection (); + assert (children.size() == 1); + ProcessorEntry* other = *children.begin(); + assert (other->can_copy_state (position)); + boost::shared_ptr otherproc = other->processor(); + boost::shared_ptr proc = position->processor(); + boost::shared_ptr pi = boost::dynamic_pointer_cast (proc); + assert (otherproc && proc && pi); + + 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_and_delete ("Processor"); + proc->set_state (state, Stateful::loading_state_version); + boost::dynamic_pointer_cast(proc)->update_id (id); + return; + } + + boost::shared_ptr p = find_drop_position (position); + + list children = source->selection (true); list > procs; for (list::const_iterator i = children.begin(); i != children.end(); ++i) { if ((*i)->processor ()) { @@ -1177,13 +2010,17 @@ ProcessorBox::build_possible_aux_menu () return 0; } + if (_route->is_monitor ()) { + return 0; + } + using namespace Menu_Helpers; Menu* menu = manage (new Menu); MenuList& items = menu->items(); for (RouteList::iterator r = rl->begin(); r != rl->end(); ++r) { if (!_route->internal_send_for (*r) && *r != _route) { - items.push_back (MenuElem ((*r)->name(), sigc::bind (sigc::ptr_fun (ProcessorBox::rb_choose_aux), boost::weak_ptr(*r)))); + items.push_back (MenuElemNoMnemonic ((*r)->name(), sigc::bind (sigc::ptr_fun (ProcessorBox::rb_choose_aux), boost::weak_ptr(*r)))); } } @@ -1222,6 +2059,9 @@ ProcessorBox::show_processor_menu (int arg) } } + ActionManager::get_action (X_("ProcessorMenu"), "newinsert")->set_sensitive (!_route->is_monitor ()); + ActionManager::get_action (X_("ProcessorMenu"), "newsend")->set_sensitive (!_route->is_monitor ()); + ProcessorEntry* single_selection = 0; if (processor_display.selection().size() == 1) { single_selection = processor_display.selection().front(); @@ -1246,9 +2086,10 @@ 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) { + 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); @@ -1267,10 +2108,11 @@ ProcessorBox::show_processor_menu (int arg) const bool sensitive = !processor_display.selection().empty() && ! stub_processor_selected (); - paste_action->set_sensitive (!_rr_selection.processors.empty()); + paste_action->set_sensitive (!_p_selection.processors.empty()); 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 ()); @@ -1280,6 +2122,8 @@ ProcessorBox::show_processor_menu (int arg) pi = boost::dynamic_pointer_cast (single_selection->processor ()); } + manage_pins_action->set_sensitive (pi != 0); + /* allow editing with an Ardour-generated UI for plugin inserts with editors */ edit_action->set_sensitive (pi && pi->plugin()->has_editor ()); @@ -1297,27 +2141,35 @@ ProcessorBox::show_processor_menu (int arg) int x, y; processor_display.get_pointer (x, y); _placement = processor_display.add_placeholder (y); - - if (_visible_prefader_processors == 0 && _placement > 0) { - --_placement; - } } bool ProcessorBox::enter_notify (GdkEventCrossing*) { + processor_display.grab_focus (); _current_processor_box = this; return false; } bool -ProcessorBox::leave_notify (GdkEventCrossing*) +ProcessorBox::leave_notify (GdkEventCrossing* ev) { + if (ev->detail == GDK_NOTIFY_INFERIOR) { + return false; + } + + Widget* top = get_toplevel(); + + if (top->is_toplevel()) { + Window* win = dynamic_cast (top); + gtk_window_set_focus (win->gobj(), 0); + } + return false; } bool -ProcessorBox::processor_operation (ProcessorOperation op) +ProcessorBox::processor_operation (ProcessorOperation op) { ProcSelection targets; @@ -1336,9 +2188,10 @@ ProcessorBox::processor_operation (ProcessorOperation op) } */ - if ( (op == ProcessorsDelete) && targets.empty() ) + if ((op == ProcessorsDelete) && targets.empty()) { return false; //nothing to delete. return false so the editor-mixer, because the user was probably intending to delete something in the editor - + } + switch (op) { case ProcessorsSelectAll: processor_display.select_all (); @@ -1357,6 +2210,14 @@ ProcessorBox::processor_operation (ProcessorOperation op) break; case ProcessorsPaste: + // some processors are not selectable (e.g fader, meter), target is empty. + if (targets.empty() && _placement >= 0) { + assert (_route); + boost::shared_ptr proc = _route->before_processor_for_index (_placement); + if (proc) { + targets.push_back (proc); + } + } if (targets.empty()) { paste_processors (); } else { @@ -1370,11 +2231,19 @@ 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 (); + if (!(*i)->display_to_user ()) { + assert (0); // these should not be selectable to begin with. + continue; + } + if (!boost::dynamic_pointer_cast (*i)) { + continue; } +#ifdef MIXBUS + if (boost::dynamic_pointer_cast (*i)->is_channelstrip()) { + continue; + } +#endif + (*i)->enable (!(*i)->enabled ()); } break; @@ -1385,11 +2254,11 @@ ProcessorBox::processor_operation (ProcessorOperation op) default: break; } - + return true; } -ProcessorWindowProxy* +ProcessorWindowProxy* ProcessorBox::find_window_proxy (boost::shared_ptr processor) const { return processor->window_proxy(); @@ -1407,6 +2276,15 @@ ProcessorBox::processor_button_press_event (GdkEventButton *ev, ProcessorEntry* int ret = false; bool selected = processor_display.selected (child); + boost::shared_ptr pi = boost::dynamic_pointer_cast (processor); + if (pi && pi->plugin() && pi->plugin()->has_inline_display() + && Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier) + && ev->button == 1 + && ev->type == GDK_2BUTTON_PRESS) { + child->toggle_inline_display_visibility (); + return true; + } + if (processor && (Keyboard::is_edit_event (ev) || (ev->button == 1 && ev->type == GDK_2BUTTON_PRESS))) { if (_session->engine().connected()) { @@ -1428,7 +2306,7 @@ ProcessorBox::processor_button_press_event (GdkEventButton *ev, ProcessorEntry* } else if (Keyboard::is_context_menu_event (ev)) { show_processor_menu (ev->time); - + ret = true; } else if (processor && ev->button == 1 && selected) { @@ -1460,18 +2338,13 @@ ProcessorBox::processor_button_release_event (GdkEventButton *ev, ProcessorEntry boost::weak_ptr(processor))); } else if (processor && Keyboard::is_button2_event (ev) -#ifndef GTKOSX +#ifndef __APPLE__ && (Keyboard::no_modifier_keys_pressed (ev) && ((ev->state & Gdk::BUTTON2_MASK) == Gdk::BUTTON2_MASK)) #endif ) { /* button2-click with no/appropriate modifiers */ - - if (processor->active()) { - processor->deactivate (); - } else { - processor->activate (); - } + processor->enable (!processor->enabled ()); } return false; @@ -1517,12 +2390,22 @@ ProcessorBox::use_plugins (const SelectedPlugins& plugins) weird_plugin_dialog (**p, err_streams); return true; // XXX SHAREDPTR delete plugin here .. do we even need to care? - } else { - - if (Profile->get_sae()) { - processor->activate (); + } else if (plugins.size() == 1 && UIConfiguration::instance().get_open_gui_after_adding_plugin()) { + if (boost::dynamic_pointer_cast(processor)->plugin()->has_inline_display() && UIConfiguration::instance().get_prefer_inline_over_gui()) { + ; + } else if (_session->engine().connected () && processor_can_be_edited (processor)) { + if ((*p)->has_editor ()) { + edit_processor (processor); + } else if (boost::dynamic_pointer_cast(processor)->plugin()->parameter_count() > 0) { + generic_edit_processor (processor); + } } } + /* add next processor below the currently added. + * Note: placement < 0: add the bottom */ + if (_placement >= 0) { + ++_placement; + } } return false; @@ -1531,6 +2414,16 @@ ProcessorBox::use_plugins (const SelectedPlugins& plugins) void ProcessorBox::weird_plugin_dialog (Plugin& p, Route::ProcessorStreams streams) { + /* XXX this needs to be re-worked! + * + * With new pin-management "streams" is no longer correct. + * p.get_info () is also incorrect for variable i/o plugins (always -1,-1). + * + * Since pin-management was added, this dialog will only show in a very rare + * condition (non-replicated variable i/o configuration failed). + * + * TODO: simplify the message after the string-freeze is lifted. + */ ArdourDialog dialog (_("Plugin Incompatibility")); Label label; @@ -1584,11 +2477,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(); @@ -1641,9 +2533,6 @@ ProcessorBox::send_io_finished (IOSelector::Result r, boost::weak_ptr case IOSelector::Accepted: _route->add_processor_by_index (processor, _placement); - if (Profile->get_sae()) { - processor->activate (); - } break; } @@ -1669,9 +2558,6 @@ ProcessorBox::return_io_finished (IOSelector::Result r, boost::weak_ptradd_processor_by_index (processor, _placement); - if (Profile->get_sae()) { - processor->activate (); - } break; } @@ -1709,7 +2595,6 @@ void ProcessorBox::redisplay_processors () { ENSURE_GUI_THREAD (*this, &ProcessorBox::redisplay_processors); - bool fader_seen; if (no_processor_redisplay) { return; @@ -1717,14 +2602,10 @@ ProcessorBox::redisplay_processors () processor_display.clear (); - _visible_prefader_processors = 0; - fader_seen = false; - - _route->foreach_processor (sigc::bind (sigc::mem_fun (*this, &ProcessorBox::help_count_visible_prefader_processors), - &_visible_prefader_processors, &fader_seen)); - _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 (); } @@ -1767,34 +2648,32 @@ ProcessorBox::maybe_add_processor_to_ui_list (boost::weak_ptr w) const XMLNode* ui_xml = _session->extra_xml (X_("UI")); if (ui_xml) { - wp->set_state (*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_window_proxy (wp); WM::Manager::instance().register_window (wp); } void -ProcessorBox::help_count_visible_prefader_processors (boost::weak_ptr p, uint32_t* cnt, bool* amp_seen) +ProcessorBox::maybe_add_processor_pin_mgr (boost::weak_ptr w) { - boost::shared_ptr processor (p.lock ()); + boost::shared_ptr p = w.lock (); + if (!p || p->pinmgr_proxy ()) { + return; + } - if (processor && processor->display_to_user()) { + PluginPinWindowProxy* wp = new PluginPinWindowProxy ( + string_compose ("PM-%2-%3", _route->id(), p->id()), w); + wp->set_session (_session); - if (boost::dynamic_pointer_cast(processor)) { - *amp_seen = true; - } else { - if (!*amp_seen) { - (*cnt)++; - } - } + const XMLNode* ui_xml = _session->extra_xml (X_("UI")); + if (ui_xml) { + wp->set_state (*ui_xml, 0); } + + p->set_pingmgr_proxy (wp); + WM::Manager::instance().register_window (wp); } void @@ -1802,12 +2681,17 @@ ProcessorBox::add_processor_to_display (boost::weak_ptr p) { boost::shared_ptr processor (p.lock ()); - if (!processor || !processor->display_to_user()) { + if (!processor || ( !processor->display_to_user() +#ifndef NDEBUG + && !show_all_processors +#endif + ) + ) { return; } boost::shared_ptr plugin_insert = boost::dynamic_pointer_cast (processor); - + ProcessorEntry* e = 0; if (plugin_insert) { e = new PluginInsertProcessorEntry (this, plugin_insert, _width); @@ -1818,7 +2702,7 @@ ProcessorBox::add_processor_to_display (boost::weak_ptr p) boost::shared_ptr send = boost::dynamic_pointer_cast (processor); boost::shared_ptr ext = boost::dynamic_pointer_cast (processor); boost::shared_ptr stub = boost::dynamic_pointer_cast (processor); - + //faders and meters are not deletable, copy/paste-able, so they shouldn't be selectable if (!send && !plugin_insert && !ext && !stub) e->set_selectable(false); @@ -1845,7 +2729,16 @@ ProcessorBox::add_processor_to_display (boost::weak_ptr p) e->show_all_controls (); } - processor_display.add_child (e); + if (plugin_insert +#ifdef MIXBUS + && !plugin_insert->plugin(0)->is_channelstrip() +#endif + ) + { + processor_display.add_child (e, drag_targets()); + } else { + processor_display.add_child (e, drag_targets_noplugin()); + } } void @@ -1855,6 +2748,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->output_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 () { @@ -1863,7 +2886,8 @@ ProcessorBox::setup_entry_positions () uint32_t num = 0; for (list::iterator i = children.begin(); i != children.end(); ++i) { - if (boost::dynamic_pointer_cast((*i)->processor())) { + if (boost::dynamic_pointer_cast((*i)->processor()) && + boost::dynamic_pointer_cast((*i)->processor())->gain_control()->parameter().type() == GainAutomation) { pre_fader = false; (*i)->set_position (ProcessorEntry::Fader, num++); } else { @@ -1874,6 +2898,7 @@ ProcessorBox::setup_entry_positions () } } } + setup_routing_feeds (); } void @@ -2014,7 +3039,7 @@ ProcessorBox::cut_processors (const ProcSelection& to_be_removed) return; } - _rr_selection.set (node); + _p_selection.set (node); no_processor_redisplay = false; redisplay_processors (); @@ -2036,9 +3061,9 @@ ProcessorBox::copy_processors (const ProcSelection& to_be_copied) (boost::dynamic_pointer_cast((*i)) != 0)) { node->add_child_nocopy ((*i)->get_state()); } - } + } - _rr_selection.set (node); + _p_selection.set (node); } void @@ -2108,7 +3133,7 @@ ProcessorBox::idle_delete_processor (boost::weak_ptr weak_processor) void ProcessorBox::rename_processor (boost::shared_ptr processor) { - ArdourPrompter name_prompter (true); + Prompter name_prompter (true); string result; name_prompter.set_title (_("Rename Processor")); name_prompter.set_prompt (_("New name:")); @@ -2123,26 +3148,26 @@ ProcessorBox::rename_processor (boost::shared_ptr processor) name_prompter.get_result (result); if (result.length()) { - int tries = 0; - string test = result; + int tries = 0; + string test = result; - while (tries < 100) { - if (_session->io_name_is_legal (test)) { - result = test; - break; - } - tries++; + while (tries < 100) { + if (_session->io_name_is_legal (test)) { + result = test; + break; + } + tries++; - test = string_compose ("%1-%2", result, tries); - } + test = string_compose ("%1-%2", result, tries); + } - if (tries < 100) { - processor->set_name (result); - } else { - /* unlikely! */ - ARDOUR_UI::instance()->popup_error - (string_compose (_("At least 100 IO objects exist with a name like %1 - name not changed"), result)); - } + if (tries < 100) { + processor->set_name (result); + } else { + /* unlikely! */ + ARDOUR_UI::instance()->popup_error + (string_compose (_("At least 100 IO objects exist with a name like %1 - name not changed"), result)); + } } break; } @@ -2153,22 +3178,22 @@ ProcessorBox::rename_processor (boost::shared_ptr processor) void ProcessorBox::paste_processors () { - if (_rr_selection.processors.empty()) { + if (_p_selection.processors.empty()) { return; } - paste_processor_state (_rr_selection.processors.get_node().children(), boost::shared_ptr()); + paste_processor_state (_p_selection.processors.get_node().children(), boost::shared_ptr()); } void ProcessorBox::paste_processors (boost::shared_ptr before) { - if (_rr_selection.processors.empty()) { + if (_p_selection.processors.empty()) { return; } - paste_processor_state (_rr_selection.processors.get_node().children(), before); + paste_processor_state (_p_selection.processors.get_node().children(), before); } void @@ -2197,11 +3222,11 @@ ProcessorBox::paste_processor_state (const XMLNodeList& nlist, boost::shared_ptr continue; } else if (type->value() == "intsend") { - + /* aux sends are OK, but those used for * other purposes, are not. */ - + assert (role); if (role->value() != "Aux") { @@ -2215,10 +3240,10 @@ ProcessorBox::paste_processor_state (const XMLNodeList& nlist, boost::shared_ptr IOProcessor::prepare_for_reset (n, s->name()); - if (s->set_state (n, Stateful::loading_state_version)) { - delete s; - return; - } + if (s->set_state (n, Stateful::loading_state_version)) { + delete s; + return; + } p.reset (s); @@ -2230,25 +3255,25 @@ ProcessorBox::paste_processor_state (const XMLNodeList& nlist, boost::shared_ptr Send* s = new Send (*_session, _route->pannable(), _route->mute_master()); IOProcessor::prepare_for_reset (n, s->name()); - - if (s->set_state (n, Stateful::loading_state_version)) { - delete s; - return; - } + + if (s->set_state (n, Stateful::loading_state_version)) { + delete s; + return; + } p.reset (s); } else if (type->value() == "return") { XMLNode n (**niter); - Return* r = new Return (*_session); + Return* r = new Return (*_session); IOProcessor::prepare_for_reset (n, r->name()); - if (r->set_state (n, Stateful::loading_state_version)) { - delete r; - return; - } + if (r->set_state (n, Stateful::loading_state_version)) { + delete r; + return; + } p.reset (r); @@ -2256,22 +3281,35 @@ ProcessorBox::paste_processor_state (const XMLNodeList& nlist, boost::shared_ptr XMLNode n (**niter); PortInsert* pi = new PortInsert (*_session, _route->pannable (), _route->mute_master ()); - + IOProcessor::prepare_for_reset (n, pi->name()); - + if (pi->set_state (n, Stateful::loading_state_version)) { return; } - - p.reset (pi); + p.reset (pi); } else { /* XXX its a bit limiting to assume that everything else 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_and_delete ("Processor"); + + p->set_state (state, Stateful::current_state_version); boost::dynamic_pointer_cast(p)->update_id (id); } @@ -2301,7 +3339,7 @@ could not match the configuration of this track."); void ProcessorBox::get_selected_processors (ProcSelection& processors) const { - const list selection = processor_display.selection (); + const list selection = processor_display.selection (true); for (list::const_iterator i = selection.begin(); i != selection.end(); ++i) { processors.push_back ((*i)->processor ()); } @@ -2342,7 +3380,7 @@ ProcessorBox::clear_processors () choices.push_back (_("Cancel")); choices.push_back (_("Yes, remove them all")); - Gtkmm2ext::Choice prompter (_("Remove processors"), prompt, choices); + ArdourWidgets::Choice prompter (_("Remove processors"), prompt, choices); if (prompter.run () == 1) { _route->clear_processors (PreFader); @@ -2367,7 +3405,7 @@ ProcessorBox::clear_processors (Placement p) choices.push_back (_("Cancel")); choices.push_back (_("Yes, remove them all")); - Gtkmm2ext::Choice prompter (_("Remove processors"), prompt, choices); + ArdourWidgets::Choice prompter (_("Remove processors"), prompt, choices); if (prompter.run () == 1) { _route->clear_processors (p); @@ -2424,7 +3462,7 @@ ProcessorBox::get_editor_window (boost::shared_ptr processor, bool us * will be forced back into a model where the fader controls the main gain. * If the processor is a send, then we map the send controls onto the * strip. - * + * * Plugins and others will return a window for control. */ @@ -2435,7 +3473,7 @@ ProcessorBox::get_editor_window (boost::shared_ptr processor, bool us } } - if (boost::dynamic_pointer_cast (processor)) { + if (boost::dynamic_pointer_cast (processor) && boost::dynamic_pointer_cast (processor)->gain_control()->parameter().type() == GainAutomation) { if (_parent_strip) { _parent_strip->revert_to_default_display (); @@ -2544,68 +3582,81 @@ ProcessorBox::get_generic_editor_window (boost::shared_ptr processor) void ProcessorBox::register_actions () { - Glib::RefPtr popup_act_grp = Gtk::ActionGroup::create(X_("ProcessorMenu")); + processor_box_actions = myactions.create_action_group (X_("ProcessorMenu")); + Glib::RefPtr act; /* new stuff */ - ActionManager::register_action (popup_act_grp, X_("newplugin"), _("New Plugin"), + myactions.register_action (processor_box_actions, X_("newplugin"), _("New Plugin"), sigc::ptr_fun (ProcessorBox::rb_choose_plugin)); - act = ActionManager::register_action (popup_act_grp, X_("newinsert"), _("New Insert"), + 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); - act = ActionManager::register_action (popup_act_grp, X_("newsend"), _("New External Send ..."), + act = myactions.register_action (processor_box_actions, X_("newsend"), _("New External Send ..."), sigc::ptr_fun (ProcessorBox::rb_choose_send)); ActionManager::engine_sensitive_actions.push_back (act); - ActionManager::register_action (popup_act_grp, X_("newaux"), _("New Aux Send ...")); + myactions.register_action (processor_box_actions, X_("newaux"), _("New Aux Send ...")); - ActionManager::register_action (popup_act_grp, X_("controls"), _("Controls")); - ActionManager::register_action (popup_act_grp, X_("send_options"), _("Send Options")); + myactions.register_action (processor_box_actions, X_("controls"), _("Controls")); + myactions.register_action (processor_box_actions, X_("send_options"), _("Send Options")); - ActionManager::register_action (popup_act_grp, X_("clear"), _("Clear (all)"), + myactions.register_action (processor_box_actions, X_("clear"), _("Clear (all)"), sigc::ptr_fun (ProcessorBox::rb_clear)); - ActionManager::register_action (popup_act_grp, X_("clear_pre"), _("Clear (pre-fader)"), + myactions.register_action (processor_box_actions, X_("clear_pre"), _("Clear (pre-fader)"), sigc::ptr_fun (ProcessorBox::rb_clear_pre)); - ActionManager::register_action (popup_act_grp, X_("clear_post"), _("Clear (post-fader)"), + myactions.register_action (processor_box_actions, X_("clear_post"), _("Clear (post-fader)"), sigc::ptr_fun (ProcessorBox::rb_clear_post)); /* standard editing stuff */ - cut_action = ActionManager::register_action (popup_act_grp, X_("cut"), _("Cut"), - sigc::ptr_fun (ProcessorBox::rb_cut)); - copy_action = ActionManager::register_action (popup_act_grp, X_("copy"), _("Copy"), - sigc::ptr_fun (ProcessorBox::rb_copy)); - delete_action = ActionManager::register_action (popup_act_grp, X_("delete"), _("Delete"), - sigc::ptr_fun (ProcessorBox::rb_delete)); - - paste_action = ActionManager::register_action (popup_act_grp, X_("paste"), _("Paste"), + + cut_action = myactions.register_action (processor_box_actions, X_("cut"), _("Cut"), + sigc::ptr_fun (ProcessorBox::rb_cut)); + copy_action = myactions.register_action (processor_box_actions, X_("copy"), _("Copy"), + 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)); - rename_action = ActionManager::register_action (popup_act_grp, X_("rename"), _("Rename"), + rename_action = myactions.register_action (processor_box_actions, X_("rename"), _("Rename"), sigc::ptr_fun (ProcessorBox::rb_rename)); - ActionManager::register_action (popup_act_grp, X_("selectall"), _("Select All"), + myactions.register_action (processor_box_actions, X_("selectall"), _("Select All"), sigc::ptr_fun (ProcessorBox::rb_select_all)); - ActionManager::register_action (popup_act_grp, X_("deselectall"), _("Deselect All"), + myactions.register_action (processor_box_actions, X_("deselectall"), _("Deselect All"), sigc::ptr_fun (ProcessorBox::rb_deselect_all)); /* activation etc. */ - ActionManager::register_action (popup_act_grp, X_("activate_all"), _("Activate All"), + myactions.register_action (processor_box_actions, X_("activate_all"), _("Activate All"), sigc::ptr_fun (ProcessorBox::rb_activate_all)); - ActionManager::register_action (popup_act_grp, X_("deactivate_all"), _("Deactivate All"), + myactions.register_action (processor_box_actions, X_("deactivate_all"), _("Deactivate All"), sigc::ptr_fun (ProcessorBox::rb_deactivate_all)); - ActionManager::register_action (popup_act_grp, X_("ab_plugins"), _("A/B Plugins"), + myactions.register_action (processor_box_actions, X_("ab_plugins"), _("A/B Plugins"), sigc::ptr_fun (ProcessorBox::rb_ab_plugins)); + manage_pins_action = myactions.register_action ( + processor_box_actions, X_("manage-pins"), _("Pin Connections..."), + sigc::ptr_fun (ProcessorBox::rb_manage_pins)); + /* show editors */ - edit_action = ActionManager::register_action ( - popup_act_grp, X_("edit"), _("Edit..."), + edit_action = myactions.register_action ( + processor_box_actions, X_("edit"), _("Edit..."), sigc::ptr_fun (ProcessorBox::rb_edit)); - edit_generic_action = ActionManager::register_action ( - popup_act_grp, X_("edit-generic"), _("Edit with generic controls..."), + edit_generic_action = myactions.register_action ( + processor_box_actions, X_("edit-generic"), _("Edit with generic controls..."), sigc::ptr_fun (ProcessorBox::rb_edit_generic)); - ActionManager::add_action_group (popup_act_grp); + load_bindings (); } void @@ -2628,6 +3679,15 @@ ProcessorBox::rb_ab_plugins () _current_processor_box->ab_plugins (); } +void +ProcessorBox::rb_manage_pins () +{ + if (_current_processor_box == 0) { + return; + } + + _current_processor_box->for_selected_processors (&ProcessorBox::manage_pins); +} void ProcessorBox::rb_choose_plugin () { @@ -2821,12 +3881,15 @@ ProcessorBox::edit_processor (boost::shared_ptr processor) if (edit_aux_send (processor)) { return; } + if (!_session->engine().connected()) { + return; + } ProcessorWindowProxy* proxy = find_window_proxy (processor); if (proxy) { proxy->set_custom_ui_mode (true); - proxy->toggle (); + proxy->show_the_right_window (); } } @@ -2839,15 +3902,32 @@ 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); if (proxy) { proxy->set_custom_ui_mode (false); - proxy->toggle (); + proxy->show_the_right_window (); } } +void +ProcessorBox::manage_pins (boost::shared_ptr processor) +{ + if (!processor) { + return; + } + PluginPinWindowProxy* proxy = processor->pinmgr_proxy (); + if (proxy) { + proxy->get (true); + proxy->present(); + } +} + + void ProcessorBox::route_property_changed (const PropertyChange& what_changed) { @@ -2865,7 +3945,7 @@ ProcessorBox::route_property_changed (const PropertyChange& what_changed) for (list::iterator iter = children.begin(); iter != children.end(); ++iter) { - processor = (*iter)->processor (); + processor = (*iter)->processor (); if (!processor) { continue; @@ -2932,7 +4012,6 @@ void ProcessorBox::set_processor_ui (boost::shared_ptr p, Gtk::Window* w) { assert (p->window_proxy()); - p->set_ui (w); p->window_proxy()->use_window (*w); } @@ -2971,6 +4050,10 @@ void ProcessorBox::processor_menu_unmapped () { processor_display.remove_placeholder (); + /* make all possibly-desensitized actions sensitive again so that + they be activated by other means (e.g. bindings) + */ + ActionManager::set_sensitive (ActionManager::plugin_selection_sensitive_actions, true); } XMLNode * @@ -2981,7 +4064,7 @@ ProcessorBox::entry_gui_object_state (ProcessorEntry* entry) } GUIObjectState& st = _parent_strip->gui_object_state (); - + XMLNode* strip = st.get_or_add_node (_parent_strip->state_id ()); assert (strip); return st.get_or_add_node (strip, entry->state_id()); @@ -3010,14 +4093,18 @@ ProcessorWindowProxy::ProcessorWindowProxy (string const & name, ProcessorBox* b : WM::ProxyBase (name, string()) , _processor_box (box) , _processor (processor) - , is_custom (false) - , want_custom (false) + , is_custom (true) + , want_custom (true) { boost::shared_ptr p = _processor.lock (); if (!p) { return; } p->DropReferences.connect (going_away_connection, MISSING_INVALIDATOR, boost::bind (&ProcessorWindowProxy::processor_going_away, this), gui_context()); + + p->ToggleUI.connect (gui_connections, invalidator (*this), boost::bind (&ProcessorWindowProxy::show_the_right_window, this, false), gui_context()); + p->ShowUI.connect (gui_connections, invalidator (*this), boost::bind (&ProcessorWindowProxy::show_the_right_window, this, true), gui_context()); + p->HideUI.connect (gui_connections, invalidator (*this), boost::bind (&ProcessorWindowProxy::hide, this), gui_context()); } ProcessorWindowProxy::~ProcessorWindowProxy() @@ -3032,6 +4119,7 @@ ProcessorWindowProxy::~ProcessorWindowProxy() void ProcessorWindowProxy::processor_going_away () { + gui_connections.drop_connections (); delete _window; _window = 0; WM::Manager::instance().remove (this); @@ -3039,45 +4127,43 @@ ProcessorWindowProxy::processor_going_away () send DropReferences is about to be deleted, but lets do it anyway. */ going_away_connection.disconnect(); + delete this; } ARDOUR::SessionHandlePtr* -ProcessorWindowProxy::session_handle() +ProcessorWindowProxy::session_handle() { /* we don't care */ return 0; } XMLNode& -ProcessorWindowProxy::get_state () const +ProcessorWindowProxy::get_state () { XMLNode *node; node = &ProxyBase::get_state(); - node->add_property (X_("custom-ui"), is_custom? X_("yes") : X_("no")); + node->set_property (X_("custom-ui"), is_custom); return *node; } -void -ProcessorWindowProxy::set_state (const XMLNode& node) +int +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")); - if ((*i)->name() == X_("Window") && prop && prop->value() == _name) { + std::string name; + if ((*i)->name() == X_("Window") && (*i)->get_property (X_("name"), name) && name == _name) { break; } ++i; } if (i != children.end()) { - XMLProperty* prop; - if ((prop = (*i)->property (X_("custom-ui"))) != 0) { - want_custom = PBD::string_is_affirmative (prop->value ()); - } + (*i)->get_property (X_("custom-ui"), want_custom); } - ProxyBase::set_state(node); + return ProxyBase::set_state (node, 0); } Gtk::Window* @@ -3090,6 +4176,7 @@ ProcessorWindowProxy::get (bool create) } if (_window && (is_custom != want_custom)) { /* drop existing window - wrong type */ + set_state_mask (Gtkmm2ext::WindowProxy::StateMask (state_mask () & ~WindowProxy::Size)); drop_window (); } @@ -3097,26 +4184,92 @@ ProcessorWindowProxy::get (bool create) if (!create) { return 0; } - + is_custom = want_custom; _window = _processor_box->get_editor_window (p, is_custom); if (_window) { setup (); + _window->show_all (); } } - return _window; } void -ProcessorWindowProxy::toggle () +ProcessorWindowProxy::show_the_right_window (bool show_not_toggle) { if (_window && (is_custom != want_custom)) { /* drop existing window - wrong type */ + set_state_mask (Gtkmm2ext::WindowProxy::StateMask (state_mask () & ~WindowProxy::Size)); drop_window (); } - is_custom = want_custom; + if (_window && fully_visible () && show_not_toggle) { + return; + } + toggle (); +} + + +PluginPinWindowProxy::PluginPinWindowProxy(std::string const &name, boost::weak_ptr processor) + : WM::ProxyBase (name, string()) + , _processor (processor) +{ + boost::shared_ptr p = _processor.lock (); + if (!p) { + return; + } + p->DropReferences.connect (going_away_connection, MISSING_INVALIDATOR, boost::bind (&PluginPinWindowProxy::processor_going_away, this), gui_context()); +} + +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) +{ + boost::shared_ptr p = _processor.lock (); + boost::shared_ptr pi = boost::dynamic_pointer_cast (p); + if (!p || !pi) { + return 0; + } + + if (!_window) { + if (!create) { + return 0; + } + _window = new PluginPinDialog (pi); + ArdourWindow* aw = dynamic_cast (_window); + if (aw) { + aw->set_session (_session); + } + _window->show_all (); + } + return _window; +} + +void +PluginPinWindowProxy::processor_going_away () +{ + delete _window; + _window = 0; + WM::Manager::instance().remove (this); + going_away_connection.disconnect(); + delete this; +} - WM::ProxyBase::toggle (); +void +ProcessorBox::load_bindings () +{ + bindings = Bindings::get_bindings (X_("Processor Box"), myactions); }