#include <sigc++/bind.h>
-#include "pbd/convert.h"
-#include "canvas/utils.h"
-
#include <glibmm/miscutils.h>
#include <glibmm/fileutils.h>
#include <gtkmm/messagedialog.h>
-#include <gtkmm2ext/gtk_ui.h>
-#include <gtkmm2ext/utils.h>
-#include <gtkmm2ext/choice.h>
-#include <gtkmm2ext/utils.h>
-#include <gtkmm2ext/doi.h>
-#include <gtkmm2ext/rgb_macros.h>
+#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/send.h"
#include "ardour/session.h"
#include "ardour/types.h"
+#include "ardour/value_as_string.h"
#include "LuaBridge/LuaBridge.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 "tooltips.h"
#include "new_plugin_preset_dialog.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
#ifdef AUDIOUNIT_SUPPORT
class AUPluginUI;
using namespace Gtk;
using namespace Glib;
using namespace Gtkmm2ext;
+using namespace ArdourWidgets;
ProcessorBox* ProcessorBox::_current_processor_box = 0;
RefPtr<Action> ProcessorBox::paste_action;
RefPtr<Action> ProcessorBox::copy_action;
RefPtr<Action> ProcessorBox::rename_action;
RefPtr<Action> ProcessorBox::delete_action;
+RefPtr<Action> ProcessorBox::backspace_action;
RefPtr<Action> ProcessorBox::manage_pins_action;
+RefPtr<Action> ProcessorBox::disk_io_action;
RefPtr<Action> ProcessorBox::edit_action;
RefPtr<Action> ProcessorBox::edit_generic_action;
RefPtr<ActionGroup> ProcessorBox::processor_box_actions;
}
{
boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (_processor);
- if (pi && pi->plugin() && pi->plugin()->get_info()->type != ARDOUR::Lua) {
+ if (pi && pi->plugin()) {
_plugin_preset_pointer = PluginPresetPtr (new PluginPreset (pi->plugin()->get_info()));
}
}
boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (_processor);
if (pi && pi->plugin() && pi->plugin()->has_inline_display()) {
if (pi->plugin()->get_info()->type != ARDOUR::Lua) {
- _plugin_display = new PluginDisplay (pi->plugin(),
+ _plugin_display = new PluginInlineDisplay (*this, pi->plugin(),
std::max (60.f, rintf(112.f * UIConfiguration::instance().get_ui_scale())));
} else {
assert (boost::dynamic_pointer_cast<LuaProc>(pi->plugin()));
- _plugin_display = new LuaPluginDisplay (boost::dynamic_pointer_cast<LuaProc>(pi->plugin()),
+ _plugin_display = new LuaPluginDisplay (*this, boost::dynamic_pointer_cast<LuaProc>(pi->plugin()),
std::max (60.f, rintf(112.f * UIConfiguration::instance().get_ui_scale())));
}
_vbox.pack_start (*_plugin_display);
_vbox.pack_end (output_routing_icon);
_vbox.pack_end (output_icon);
- _button.set_active (_processor->active());
+ _button.set_active (_processor->enabled ());
input_icon.set_no_show_all(true);
routing_icon.set_no_show_all(true);
_processor->PropertyChanged.connect (name_connection, invalidator (*this), boost::bind (&ProcessorEntry::processor_property_changed, this, _1), gui_context());
_processor->ConfigurationChanged.connect (config_connection, invalidator (*this), boost::bind (&ProcessorEntry::processor_configuration_changed, this, _1, _2), gui_context());
+ const uint32_t limit_inline_controls = UIConfiguration::instance().get_max_inline_controls ();
+
set<Evoral::Parameter> p = _processor->what_can_be_automated ();
for (set<Evoral::Parameter>::iterator i = p.begin(); i != p.end(); ++i) {
std::string label = _processor->describe_parameter (*i);
+ if (label == X_("hidden")) {
+ continue;
+ }
+
if (boost::dynamic_pointer_cast<Send> (_processor)) {
label = _("Send");
} else if (boost::dynamic_pointer_cast<Return> (_processor)) {
/* Add non-Amp (Fader & Trim) controls to the processor box */
_vbox.pack_start (c->box);
}
+
+ if (limit_inline_controls > 0 && _controls.size() >= limit_inline_controls) {
+ break;
+ }
}
setup_tooltip ();
_button.set_name ("processor stub");
return;
}
+ boost::shared_ptr<Send> send;
+ if ((send = boost::dynamic_pointer_cast<Send> (_processor))) {
+ if (send->remove_on_disconnect ()) {
+ _button.set_name ("processor sidechain");
+ return;
+ }
+ }
+
+ boost::shared_ptr<InternalSend> aux;
+ if ((aux = boost::dynamic_pointer_cast<InternalSend> (_processor))) {
+ if (aux->allow_feedback ()) {
+ _button.set_name ("processor auxfeedback");
+ return;
+ }
+ }
switch (_position) {
case PreFader:
_parent->all_visible_processors_active(false);
if (_position == Fader) {
- _processor->deactivate ();
+ _processor->enable (false);
}
}
else {
- _processor->deactivate ();
+ _processor->enable (false);
}
} else {
_parent->all_visible_processors_active(true);
if (_position == Fader) {
- _processor->activate ();
+ _processor->enable (true);
}
}
else {
- _processor->activate ();
+ _processor->enable (true);
}
}
}
ProcessorEntry::processor_active_changed ()
{
if (_processor) {
- _button.set_active (_processor->active());
+ _button.set_active (_processor->enabled ());
}
}
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_UTILS::set_tooltip (_button,
- string_compose (_("<b>%1</b>\nDouble-click to show GUI.\n%2+double-click to show generic GUI.%3"), name (Wide), Keyboard::primary_modifier_name (), postfix));
+ set_tooltip (_button,
+ string_compose (_("<b>%1</b>\nDouble-click to show GUI.\n%2+double-click to show generic GUI.%3"), name (Wide), Keyboard::secondary_modifier_name (), postfix));
} else {
- ARDOUR_UI_UTILS::set_tooltip (_button,
+ set_tooltip (_button,
string_compose (_("<b>%1</b>\nDouble-click to show generic GUI.%2"), name (Wide), postfix));
}
return;
string_compose (_("<b>%1</b>\nThe Plugin is not available on this system\nand has been replaced by a stub."), name (Wide)));
return;
}
+ boost::shared_ptr<Send> send;
+ if ((send = boost::dynamic_pointer_cast<Send> (_processor)) != 0 &&
+ !boost::dynamic_pointer_cast<InternalSend>(_processor)) {
+ if (send->remove_on_disconnect ()) {
+ set_tooltip (_button, string_compose ("<b>> %1</b>\nThis (sidechain) send will be removed when disconnected.", _processor->name()));
+ } else {
+ set_tooltip (_button, string_compose ("<b>> %1</b>", _processor->name()));
+ }
+ return;
+ }
}
- ARDOUR_UI_UTILS::set_tooltip (_button, string_compose ("<b>%1</b>", name (Wide)));
+ set_tooltip (_button, string_compose ("<b>%1</b>", name (Wide)));
}
string
!boost::dynamic_pointer_cast<InternalSend>(_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<string> connections;
+ if (i->get_connections (connections)) {
+ vector<string>::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;
}
if (_plugin_display) {
XMLNode* c = new XMLNode (X_("Object"));
- c->add_property (X_("id"), X_("InlineDisplay"));
- c->add_property (X_("visible"), _plugin_display->is_visible ());
+ c->set_property (X_("id"), X_("InlineDisplay"));
+ c->set_property (X_("visible"), _plugin_display->is_visible ());
node->add_child_nocopy (*c);
}
}
if (_plugin_display) {
XMLNode* n = GUIObjectState::get_node (node, X_("InlineDisplay"));
- XMLProperty* p = n ? n->property (X_("visible")) : NULL;
- if (p) {
- if (string_is_affirmative (p->value ())) {
- _plugin_display->show();
+ if (!n) return;
+
+ bool visible;
+ if (n->get_property (X_("visible"), visible)) {
+ if (visible) {
+ _plugin_display->show ();
} else {
- _plugin_display->hide();
+ _plugin_display->hide ();
}
}
}
ProcessorEntry::build_controls_menu ()
{
using namespace Menu_Helpers;
+
+ if (!_plugin_display && _controls.empty ()) {
+ return NULL;
+ }
+
Menu* menu = manage (new Menu);
MenuList& items = menu->items ();
Gtk::CheckMenuItem* c = dynamic_cast<Gtk::CheckMenuItem*> (&items.back ());
c->set_active (_plugin_display->is_visible ());
c->signal_toggled().connect (sigc::mem_fun (*this, &ProcessorEntry::toggle_inline_display_visibility));
+ }
+
+ if (_controls.empty ()) {
+ return menu;
+ } else {
items.push_back (SeparatorElem ());
}
MenuElem (_("Hide All Controls"), sigc::mem_fun (*this, &ProcessorEntry::hide_all_controls))
);
- if (!_controls.empty ()) {
- items.push_back (SeparatorElem ());
- }
+ items.push_back (SeparatorElem ());
for (list<Control*>::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<Gtk::CheckMenuItem*> (&items.back ());
c->set_active ((*i)->visible ());
c->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &ProcessorEntry::toggle_control_visibility), *i));
Menu* menu = manage (new Menu);
MenuList& items = menu->items ();
- boost::shared_ptr<Send> send = boost::dynamic_pointer_cast<Send> (_processor);
- if (send) {
+ if (!ARDOUR::Profile->get_mixbus()) {
+ boost::shared_ptr<Send> send = boost::dynamic_pointer_cast<Send> (_processor);
+ if (send) {
+ items.push_back (CheckMenuElem (_("Link panner controls")));
+ Gtk::CheckMenuItem* c = dynamic_cast<Gtk::CheckMenuItem*> (&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<InternalSend> aux = boost::dynamic_pointer_cast<InternalSend> (_processor);
+ if (aux) {
+ items.push_back (CheckMenuElem (_("Allow Feedback Loop")));
Gtk::CheckMenuItem* c = dynamic_cast<Gtk::CheckMenuItem*> (&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;
}
}
}
+void
+ProcessorEntry::toggle_allow_feedback ()
+{
+ boost::shared_ptr<InternalSend> aux = boost::dynamic_pointer_cast<InternalSend> (_processor);
+ if (aux) {
+ aux->set_allow_feedback (!aux->allow_feedback ());
+ }
+}
+
ProcessorEntry::Control::Control (boost::shared_ptr<AutomationControl> 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)
_button.signal_clicked.connect (sigc::mem_fun (*this, &Control::button_clicked));
_button.signal_led_clicked.connect (sigc::mem_fun (*this, &Control::button_clicked_event));
- // 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 ();
+ }
} else {
_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_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 ();
ProcessorEntry::Control::~Control ()
{
- timer_connection.disconnect ();
}
void
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 = Gtkmm2ext::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_UTILS::set_tooltip (_button, sm);
+ ArdourWidgets::set_tooltip (_button, Gtkmm2ext::markup_escape_text (sm));
}
void
set_tooltip ();
}
+void
+ProcessorEntry::Control::start_touch ()
+{
+ boost::shared_ptr<AutomationControl> c = _control.lock ();
+ if (!c) {
+ return;
+ }
+ c->start_touch (c->session().transport_sample());
+}
+
+void
+ProcessorEntry::Control::end_touch ()
+{
+ boost::shared_ptr<AutomationControl> c = _control.lock ();
+ if (!c) {
+ return;
+ }
+ c->stop_touch (c->session().transport_sample());
+}
+
void
ProcessorEntry::Control::button_clicked ()
{
button_clicked ();
}
+void
+ProcessorEntry::Control::control_automation_state_changed ()
+{
+ boost::shared_ptr<AutomationControl> 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 ()
{
_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);
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);
}
{
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);
}
cairo_fill (cr);
const double dx = rint(max(2., 2. * UIConfiguration::instance().get_ui_scale()));
- if (_ports.n_total() > 1) {
- for (uint32_t i = 0; i < _ports.n_total(); ++i) {
- set_routing_color (cr, i < _ports.n_midi());
- 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) {
- set_routing_color (cr, _ports.n_midi() == 1);
- const float x = rintf(width * .5);
- cairo_rectangle (cr, x-dx * .5, 0, 1+dx, height);
+ for (uint32_t i = 0; i < _ports.n_total(); ++i) {
+ set_routing_color (cr, i < _ports.n_midi());
+ const double x = ProcessorEntry::RoutingIcon::pin_x_pos (i, width, _ports.n_total(), 0 , false);
+ cairo_rectangle (cr, x - .5 - dx * .5, 0, 1 + dx, height);
cairo_fill(cr);
}
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;
}
assert (i == 0);
return rint (width * .5) +.5;
}
- return rint (width * (.2 + .6 * i / (n_total - 1))) + .5;
+ return rint (width * (.15 + .7 * i / (n_total - 1))) + .5;
}
void
void
ProcessorEntry::RoutingIcon::draw_thru_src (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 - .5, y1);
- cairo_line_to (cr, 0 + dx + .5, y1 - 2);
-
- cairo_move_to (cr, 0 - dx - .5, y1 + 2);
- cairo_line_to (cr, 0 + dx + .5, y1);
-
- cairo_move_to (cr, 0, y1 + 1);
- cairo_line_to (cr, 0, height);
+ 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);
- cairo_restore (cr);
}
void
ProcessorEntry::RoutingIcon::draw_thru_sink (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 - .5, y1);
- cairo_line_to (cr, 0 + dx + .5, y1 - 2);
-
- cairo_move_to (cr, 0 - dx - .5, y1 + 2);
- cairo_line_to (cr, 0 + dx + .5, y1);
-
- cairo_move_to (cr, 0, y1 - 1);
- cairo_line_to (cr, 0, 0);
+ 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);
- cairo_restore (cr);
}
void
_i_in_map.get_src (dt, idx, &valid_sink);
_i_thru_map.get_src (dt, idx, &valid_thru);
if (!valid_thru && !valid_sink) {
- continue;
+ if (!is_midi || i != 0) { // special case midi-bypass
+ continue;
+ }
}
}
double c_x0 = pin_x_pos (i, width, pc_out, 0, false);
double x = pin_x_pos (i, width, n_out, 0, is_midi);
if (!_terminal) {
- // only check thru (gnd is part of input)
- bool valid_thru;
- uint32_t idx = _thru_map.get (dt, pn, &valid_thru);
- if (!valid_thru) {
- continue;
- }
-
- // skip connections that are not used in the next's input :(
+ 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);
- if (!valid_thru && !valid_sink) {
- continue;
+ _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;
+ }
}
}
- if (idx >= _in.get (dt)) {
- draw_sidechain (cr, x, 0, ht, is_midi);
- } else {
- draw_thru_src (cr, x, 0, ht, is_midi);
+ 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;
}
}
-ProcessorEntry::PluginDisplay::PluginDisplay (boost::shared_ptr<ARDOUR::Plugin> p, uint32_t max_height)
- : _plug (p)
- , _surf (0)
- , _max_height (max_height)
- , _cur_height (1)
+ProcessorEntry::PluginInlineDisplay::PluginInlineDisplay (ProcessorEntry& e, boost::shared_ptr<ARDOUR::Plugin> p, uint32_t max_height)
+ : PluginDisplay (p, max_height)
+ , _entry (e)
, _scroll (false)
+ , _given_max_height (max_height)
{
- set_name ("processor prefader");
- _plug->QueueDraw.connect (_qdraw_connection, invalidator (*this),
- boost::bind (&Gtk::Widget::queue_draw, this), gui_context ());
+ 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 (_("<b>%1</b>\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 (_("<b>%1</b>\nDouble-click to show generic GUI.%2"), e.name (Wide), postfix));
+ }
}
-ProcessorEntry::PluginDisplay::~PluginDisplay ()
-{
- if (_surf) {
- cairo_surface_destroy (_surf);
+
+bool
+ProcessorEntry::PluginInlineDisplay::on_button_press_event (GdkEventButton *ev)
+{
+ assert (_entry.processor ());
+
+ boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (_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 {
+ _entry._parent->edit_processor (_entry.processor ());
+ }
+ return true;
+ }
+ return false;
}
void
-ProcessorEntry::PluginDisplay::on_size_request (Gtk::Requisition* req)
+ProcessorEntry::PluginInlineDisplay::on_size_request (Requisition* req)
{
req->width = 56;
req->height = _cur_height;
void
-ProcessorEntry::PluginDisplay::update_height_alloc (uint32_t inline_height)
+ProcessorEntry::PluginInlineDisplay::update_height_alloc (uint32_t inline_height)
{
/* work-around scroll-bar + aspect ratio
* show inline-view -> height changes -> scrollbar gets added
}
if (shm != _cur_height) {
- if (_scroll == sc || _cur_height < shm) {
- queue_resize ();
+ queue_resize ();
+ if (!_scroll && sc) {
+ _max_height = shm;
+ } else {
+ _max_height = _given_max_height;
}
_cur_height = shm;
}
- _scroll = sc;
-}
-uint32_t
-ProcessorEntry::PluginDisplay::render_inline (cairo_t* cr, uint32_t width)
-{
- Plugin::Display_Image_Surface* dis = _plug->render_inline_display (width, _max_height);
- if (!dis) {
- return 0;
- }
-
- /* allocate a local image-surface,
- * We cannot re-use the data via cairo_image_surface_create_for_data(),
- * since pixman keeps a reference to it.
- * we'd need to hand over the data and ha cairo_surface_destroy to free it.
- * it might be possible to work around via cairo_surface_set_user_data().
- */
- if (!_surf
- || dis->width != cairo_image_surface_get_width (_surf)
- || dis->height != cairo_image_surface_get_height (_surf)
- ) {
- if (_surf) {
- cairo_surface_destroy (_surf);
- }
- _surf = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, dis->width, dis->height);
- }
-
- if (cairo_image_surface_get_stride (_surf) == dis->stride) {
- memcpy (cairo_image_surface_get_data (_surf), dis->data, dis->stride * dis->height);
- } else {
- unsigned char *src = dis->data;
- unsigned char *dst = cairo_image_surface_get_data (_surf);
- const int dst_stride = cairo_image_surface_get_stride (_surf);
- for (int y = 0; y < dis->height; ++y) {
- memcpy (dst, src, dis->width * 4 /*ARGB32*/);
- src += dis->stride;
- dst += dst_stride;
- }
- }
-
- cairo_surface_mark_dirty(_surf);
- const double xc = floor ((width - dis->width) * .5);
- cairo_set_source_surface(cr, _surf, xc, 0);
- cairo_paint (cr);
-
- return dis->height;
+ _scroll = sc;
}
-bool
-ProcessorEntry::PluginDisplay::on_expose_event (GdkEventExpose* ev)
+void
+ProcessorEntry::PluginInlineDisplay::display_sample (cairo_t* cr, double w, double h)
{
- Gtk::Allocation a = get_allocation();
- double const width = a.get_width();
- double const height = a.get_height();
-
- cairo_t* cr = gdk_cairo_create (get_window()->gobj());
- cairo_rectangle (cr, ev->area.x, ev->area.y, ev->area.width, ev->area.height);
- cairo_clip (cr);
-
- Gdk::Color const bg = get_style()->get_bg (STATE_NORMAL);
- cairo_set_source_rgb (cr, bg.get_red_p (), bg.get_green_p (), bg.get_blue_p ());
- cairo_rectangle (cr, 0, 0, width, height);
- cairo_fill (cr);
-
- cairo_save (cr);
- cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
- Gtkmm2ext::rounded_rectangle (cr, .5, -1.5, width - 1, height + 1, 7);
- cairo_clip (cr);
- cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
-
- uint32_t ht = render_inline (cr, width);
- cairo_restore (cr);
-
- if (ht == 0) {
- hide ();
- if (_cur_height != 1) {
- _cur_height = 1;
- queue_resize ();
- }
- cairo_destroy (cr);
- return true;
- } else {
- update_height_alloc (ht);
- }
-
- bool failed = false;
- std::string name = get_name();
- ArdourCanvas::Color fill_color = UIConfiguration::instance().color (string_compose ("%1: fill active", name), &failed);
-
- Gtkmm2ext::rounded_rectangle (cr, .5, -1.5, width - 1, height + 1, 7);
- cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
- cairo_set_line_width(cr, 1.0);
- ArdourCanvas::set_source_rgb_a (cr, fill_color, 1.0);
- cairo_stroke (cr);
-
- cairo_destroy(cr);
- return true;
+ Gtkmm2ext::rounded_rectangle (cr, .5, -1.5, w - 1, h + 1, 7);
}
-ProcessorEntry::LuaPluginDisplay::LuaPluginDisplay (boost::shared_ptr<ARDOUR::LuaProc> p, uint32_t max_height)
- : PluginDisplay (p, max_height)
+ProcessorEntry::LuaPluginDisplay::LuaPluginDisplay (ProcessorEntry& e, boost::shared_ptr<ARDOUR::LuaProc> p, uint32_t max_height)
+ : PluginInlineDisplay (e, p, max_height)
, _luaproc (p)
, _lua_render_inline (0)
{
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
+ cerr << "LuaException:" << e.what () << endl;
+#endif
+ } catch (...) { }
return 0;
}
std::list<Gtk::TargetEntry> tmp;
tmp.push_back (Gtk::TargetEntry ("processor")); // from processor-box to processor-box
tmp.push_back (Gtk::TargetEntry ("PluginInfoPtr")); // from plugin-manager
- tmp.push_back (Gtk::TargetEntry ("PluginPresetPtr")); // from sidebar
+ tmp.push_back (Gtk::TargetEntry ("PluginFavoritePtr")); // from sidebar
return tmp;
}
}
ProcessorBox::ProcessorBox (ARDOUR::Session* sess, boost::function<PluginSelector*()> 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)
{
);
}
- ARDOUR_UI_UTILS::set_tooltip (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 ()
boost::shared_ptr<Processor> processor (new PluginInsert (*_session, p));
if (Config->get_new_plugins_active ()) {
- processor->activate ();
+ processor->enable (true);
}
pl.push_back (processor);
}
}
boost::shared_ptr<Processor> processor (new PluginInsert (*_session, p));
if (Config->get_new_plugins_active ()) {
- processor->activate ();
+ processor->enable (true);
}
pl.push_back (processor);
}
if (data.get_target() == "PluginInfoPtr") {
_drop_plugin (data, pl);
}
- else if (data.get_target() == "PluginPresetPtr") {
+ else if (data.get_target() == "PluginFavoritePtr") {
_drop_plugin_preset (data, pl);
}
else {
* otherwise we'll end up with duplicate ports-names.
* (this needs a better solution which retains connections)
*/
- state.remove_nodes ("Processor");
+ state.remove_nodes_and_delete ("Processor");
proc->set_state (state, Stateful::loading_state_version);
boost::dynamic_pointer_cast<PluginInsert>(proc)->update_id (id);
return;
boost::shared_ptr<Processor> p = find_drop_position (position);
- list<ProcessorEntry*> children = source->selection ();
+ list<ProcessorEntry*> children = source->selection (true);
list<boost::shared_ptr<Processor> > procs;
for (list<ProcessorEntry*>::const_iterator i = children.begin(); i != children.end(); ++i) {
if ((*i)->processor ()) {
return 0;
}
- if (_route->is_monitor ()) {
+ if (_route->is_monitor () || _route->is_foldbackbus ()) {
+ 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 ((*r)->is_master() || (*r)->is_monitor () || *r == _route) {
+ /* don't allow sending to master or monitor or to self */
+ continue;
+ }
+ if ((*r)->is_foldbackbus ()) {
+ continue;
+ }
+ if (_route->internal_send_for (*r)) {
+ /* aux-send to target already exists */
+ continue;
+ }
+ items.push_back (MenuElemNoMnemonic ((*r)->name(), sigc::bind (sigc::ptr_fun (ProcessorBox::rb_choose_aux), boost::weak_ptr<Route>(*r))));
+ }
+
+ return menu;
+}
+
+Gtk::Menu*
+ProcessorBox::build_possible_listener_menu ()
+{
+ boost::shared_ptr<RouteList> rl = _session->get_routes_with_internal_returns();
+
+ if (rl->empty()) {
+ /* No aux sends if there are no busses */
+ return 0;
+ }
+
+ if (_route->is_monitor () || _route->is_foldbackbus ()) {
return 0;
}
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<Route>(*r))));
+ if ((*r)->is_master() || (*r)->is_monitor () || *r == _route) {
+ /* don't allow sending to master or monitor or to self */
+ continue;
+ }
+ if (!(*r)->is_foldbackbus ()) {
+ continue;
}
+ if (_route->internal_send_for (*r)) {
+ /* aux-send to target already exists */
+ continue;
+ }
+ items.push_back (MenuElemNoMnemonic ((*r)->name(), sigc::bind (sigc::ptr_fun (ProcessorBox::rb_choose_aux), boost::weak_ptr<Route>(*r))));
+ }
+
+ return menu;
+}
+
+Gtk::Menu*
+ProcessorBox::build_possible_remove_listener_menu ()
+{
+ boost::shared_ptr<RouteList> rl = _session->get_routes_with_internal_returns();
+
+ if (rl->empty()) {
+ /* No aux sends if there are no busses */
+ return 0;
+ }
+
+ if (_route->is_monitor () || _route->is_foldbackbus ()) {
+ 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 ((*r)->is_master() || (*r)->is_monitor () || *r == _route) {
+ /* don't allow sending to master or monitor or to self */
+ continue;
+ }
+ if (!(*r)->is_foldbackbus ()) {
+ continue;
+ }
+ if (!_route->internal_send_for (*r)) {
+ /* aux-send to target already exists */
+ continue;
+ }
+ items.push_back (MenuElemNoMnemonic ((*r)->name(), sigc::bind (sigc::ptr_fun (ProcessorBox::rb_remove_aux), boost::weak_ptr<Route>(*r))));
}
return menu;
}
}
- ActionManager::get_action (X_("ProcessorMenu"), "newinsert")->set_sensitive (!_route->is_monitor ());
- ActionManager::get_action (X_("ProcessorMenu"), "newsend")->set_sensitive (!_route->is_monitor ());
+ Gtk::MenuItem* listen_menu_item = dynamic_cast<Gtk::MenuItem*>(ActionManager::get_widget("/ProcessorMenu/newlisten"));
+
+ if (listen_menu_item) {
+ Menu* m = build_possible_listener_menu();
+ if (m && !m->items().empty()) {
+ listen_menu_item->set_submenu (*m);
+ listen_menu_item->set_sensitive (true);
+ } else {
+ /* stupid gtkmm: we need to pass a null reference here */
+ gtk_menu_item_set_submenu (listen_menu_item->gobj(), 0);
+ listen_menu_item->set_sensitive (false);
+ }
+ }
+
+ Gtk::MenuItem* remove_listen_menu_item = dynamic_cast<Gtk::MenuItem*>(ActionManager::get_widget("/ProcessorMenu/removelisten"));
+
+ if (remove_listen_menu_item) {
+ Menu* m = build_possible_remove_listener_menu();
+ if (m && !m->items().empty()) {
+ remove_listen_menu_item->set_submenu (*m);
+ remove_listen_menu_item->set_sensitive (true);
+ } else {
+ /* stupid gtkmm: we need to pass a null reference here */
+ gtk_menu_item_set_submenu (remove_listen_menu_item->gobj(), 0);
+ remove_listen_menu_item->set_sensitive (false);
+ }
+ }
+
+ ActionManager::get_action (X_("ProcessorMenu"), "newinsert")->set_sensitive (!_route->is_monitor () && !_route->is_foldbackbus ());
+ ActionManager::get_action (X_("ProcessorMenu"), "newsend")->set_sensitive (!_route->is_monitor () && !_route->is_foldbackbus ());
ProcessorEntry* single_selection = 0;
if (processor_display.selection().size() == 1) {
}
}
+
Gtk::MenuItem* send_menu_item = dynamic_cast<Gtk::MenuItem*>(ActionManager::get_widget("/ProcessorMenu/send_options"));
if (send_menu_item) {
if (single_selection && !_route->is_monitor()) {
/* Sensitise actions as approprioate */
-
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 ());
}
manage_pins_action->set_sensitive (pi != 0);
+ if (boost::dynamic_pointer_cast<Track>(_route)) {
+ disk_io_action->set_sensitive (true);
+ } else {
+ disk_io_action->set_sensitive (false);
+ }
/* allow editing with an Ardour-generated UI for plugin inserts with editors */
edit_action->set_sensitive (pi && pi->plugin()->has_editor ());
int x, y;
processor_display.get_pointer (x, y);
_placement = processor_display.add_placeholder (y);
-
- if (_visible_prefader_processors == 0 && _placement > 0) {
- --_placement;
- }
}
bool
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<PluginInsert> (*i)) {
+ continue;
+ }
+#ifdef MIXBUS
+ if (boost::dynamic_pointer_cast<PluginInsert> (*i)->is_channelstrip()) {
+ continue;
}
+#endif
+ (*i)->enable (!(*i)->enabled ());
}
break;
int ret = false;
bool selected = processor_display.selected (child);
- if (processor && (Keyboard::is_edit_event (ev) || (ev->button == 1 && ev->type == GDK_2BUTTON_PRESS))) {
+ boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (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 (_session->engine().connected()) {
- /* XXX giving an error message here is hard, because we may be in the midst of a button press */
+ if (processor && (Keyboard::is_edit_event (ev) || (ev->button == 1 && ev->type == GDK_2BUTTON_PRESS))) {
- if (!one_processor_can_be_edited ()) {
- return true;
- }
+ if (!one_processor_can_be_edited ()) {
+ return true;
+ }
+ if (!ARDOUR_UI_UTILS::engine_is_running ()) {
+ return true;
+ }
- if (Keyboard::modifier_state_equals (ev->state, Keyboard::SecondaryModifier)) {
- generic_edit_processor (processor);
- } else {
- edit_processor (processor);
- }
+ if (Keyboard::modifier_state_equals (ev->state, Keyboard::SecondaryModifier)) {
+ generic_edit_processor (processor);
+ } else {
+ edit_processor (processor);
}
ret = true;
) {
/* button2-click with no/appropriate modifiers */
-
- if (processor->active()) {
- processor->deactivate ();
- } else {
- processor->activate ();
- }
+ processor->enable (!processor->enabled ());
}
return false;
_get_plugin_selector()->set_interested_object (*this);
}
-/** @return true if an error occurred, otherwise false */
-bool
-ProcessorBox::choose_lua ()
-{
- LuaScriptInfoPtr spi;
-
- ScriptSelector ss (_("Add Lua DSP Processor"), LuaScriptInfo::DSP);
- switch (ss.run ()) {
- case Gtk::RESPONSE_ACCEPT:
- spi = ss.script();
- break;
- default:
- return true;
- }
- ss.hide ();
-
- PluginPtr p;
- try {
- LuaPluginInfoPtr lpi (new LuaPluginInfo(spi));
- p = (lpi->load (*_session));
- } catch (...) {
- string msg = _(
- "Failed to instantiate Lua DSP Processor,\n"
- "probably because the script is invalid (no dsp function).");
- MessageDialog am (msg);
- am.run ();
- return true;
- }
-
- boost::shared_ptr<Processor> processor (new PluginInsert (*_session, p));
-
- Route::ProcessorStreams err_streams;
- if (_route->add_processor_by_index (processor, _placement, &err_streams, Config->get_new_plugins_active ())) {
- string msg = _(
- "Failed to add Lua DSP Processor at the given position,\n"
- "probably because the I/O configuration of the plugins\n"
- "could not match the configuration of this track.");
- MessageDialog am (msg);
- am.run ();
- }
- return false;
-}
-
/** @return true if an error occurred, otherwise false */
bool
ProcessorBox::use_plugins (const SelectedPlugins& plugins)
return true;
// XXX SHAREDPTR delete plugin here .. do we even need to care?
} else if (plugins.size() == 1 && UIConfiguration::instance().get_open_gui_after_adding_plugin()) {
- if (boost::dynamic_pointer_cast<PluginInsert>(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 ()) {
+ if (processor->what_can_be_automated ().size () == 0) {
+ ; /* plugin without controls, don't show ui */
+ }
+ else if (boost::dynamic_pointer_cast<PluginInsert>(processor)->plugin()->has_inline_display() && UIConfiguration::instance().get_prefer_inline_over_gui()) {
+ ; /* only show inline display */
+ }
+ else if (processor_can_be_edited (processor)) {
+ if (!ARDOUR_UI_UTILS::engine_is_running()) {
+ return true;
+ } else if ((*p)->has_editor ()) {
edit_processor (processor);
- } else {
+ } else if (boost::dynamic_pointer_cast<PluginInsert>(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;
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;
void
ProcessorBox::choose_send ()
{
- boost::shared_ptr<Pannable> sendpan(new Pannable (*_session));
- boost::shared_ptr<Send> send (new Send (*_session, sendpan, _route->mute_master()));
+ boost::shared_ptr<Send> 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();
return;
}
- _session->add_internal_send (target, _placement, _route);
+ if (target->is_foldbackbus ()) {
+ _route->add_foldback_send (target);
+ } else {
+ _session->add_internal_send (target, _placement, _route);
+ }
+}
+
+void
+ProcessorBox::remove_aux (boost::weak_ptr<Route> wr)
+{
+ if (!_route) {
+ return;
+ }
+
+ boost::shared_ptr<Route> target = wr.lock();
+
+ if (!target) {
+ return;
+ }
+ boost::shared_ptr<Send> send = _route->internal_send_for (target);
+ boost::shared_ptr<Processor> proc = boost::dynamic_pointer_cast<Processor> (send);
+ _route->remove_processor (proc);
+
}
void
ProcessorBox::redisplay_processors ()
{
ENSURE_GUI_THREAD (*this, &ProcessorBox::redisplay_processors);
- bool fader_seen;
if (no_processor_redisplay) {
return;
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));
return;
}
- /* not on the list; add it */
+ /* see also ProcessorBox::get_editor_window */
+ bool have_ui = false;
- string loc;
-#if 0 // is this still needed? Why?
- if (_parent_strip) {
- if (_parent_strip->mixer_owned()) {
- loc = X_("M");
- } else {
- loc = X_("R");
+ if (boost::dynamic_pointer_cast<PluginInsert> (p)) {
+ have_ui = true;
+ }
+ else if (boost::dynamic_pointer_cast<PortInsert> (p)) {
+ have_ui = true;
+ }
+ else if (boost::dynamic_pointer_cast<Send> (p)) {
+ if (!boost::dynamic_pointer_cast<InternalSend> (p)) {
+ have_ui = true;
+ }
+ }
+ else if (boost::dynamic_pointer_cast<Return> (p)) {
+ if (!boost::dynamic_pointer_cast<InternalReturn> (p)) {
+ have_ui = true;
}
- } else {
- loc = X_("P");
}
-#else
- loc = X_("P");
-#endif
+
+ if (!have_ui) {
+ return;
+ }
ProcessorWindowProxy* wp = new ProcessorWindowProxy (
- string_compose ("%1-%2-%3", loc, _route->id(), p->id()),
- this,
- w);
+ string_compose ("P-%1-%2", _route->id(), p->id()),
+ this,
+ w);
const XMLNode* ui_xml = _session->extra_xml (X_("UI"));
wp->set_state (*ui_xml, 0);
}
- void* existing_ui = p->get_ui ();
-
- if (existing_ui) {
- wp->use_window (*(reinterpret_cast<Gtk::Window*>(existing_ui)));
- }
-
p->set_window_proxy (wp);
WM::Manager::instance().register_window (wp);
}
if (!p || p->pinmgr_proxy ()) {
return;
}
+ if (!boost::dynamic_pointer_cast<PluginInsert> (p)) {
+ return;
+ }
PluginPinWindowProxy* wp = new PluginPinWindowProxy (
- string_compose ("PM-%2-%3", _route->id(), p->id()), w);
+ string_compose ("PM-%1-%2", _route->id(), p->id()), w);
wp->set_session (_session);
const XMLNode* ui_xml = _session->extra_xml (X_("UI"));
wp->set_state (*ui_xml, 0);
}
- void* existing_ui = p->get_ui ();
-
- if (existing_ui) {
- wp->use_window (*(reinterpret_cast<Gtk::Window*>(existing_ui)));
- }
-
p->set_pingmgr_proxy (wp);
WM::Manager::instance().register_window (wp);
}
-void
-ProcessorBox::help_count_visible_prefader_processors (boost::weak_ptr<Processor> p, uint32_t* cnt, bool* amp_seen)
-{
- boost::shared_ptr<Processor> processor (p.lock ());
-
- if (processor && ( processor->display_to_user()
-#ifndef NDEBUG
- || show_all_processors
-#endif
- )
- ) {
-
- if (boost::dynamic_pointer_cast<Amp>(processor) &&
- boost::dynamic_pointer_cast<Amp>(processor)->gain_control()->parameter().type() == GainAutomation) {
- *amp_seen = true;
- } else {
- if (!*amp_seen) {
- (*cnt)++;
- }
- }
- }
-}
void
ProcessorBox::add_processor_to_display (boost::weak_ptr<Processor> p)
(*i)->input_icon.set_ports (p->input_streams());
(*i)->output_icon.set_ports (p->output_streams());
ChanMapping inmap (p->input_streams ());
- ChanMapping outmap (p->input_streams ());
+ ChanMapping outmap (p->output_streams ());
ChanMapping thrumap;
(*i)->routing_icon.set (
p->input_streams(),
(*i)->routing_icon.unset_fed_by ();
}
prev = i;
+ (*i)->input_icon.hide();
}
/* now set which icons need to be displayed */
(*i)->routing_icon.hide();
if (i == children.begin()) {
(*i)->input_icon.show();
- } else {
- (*i)->input_icon.hide();
}
} else {
(*i)->routing_icon.show();
}
} else {
(*i)->output_routing_icon.set_terminal(false);
- if (!(*i)->routing_icon.out_identity ()
- && !(*i)->routing_icon.in_identity ()
- && (*i)->routing_icon.can_coalesce ()) {
+ 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();
}
return;
}
- _rr_selection.set (node);
+ _p_selection.set (node);
no_processor_redisplay = false;
redisplay_processors ();
}
}
- _rr_selection.set (node);
+ _p_selection.set (node);
}
void
void
ProcessorBox::rename_processor (boost::shared_ptr<Processor> processor)
{
- ArdourPrompter name_prompter (true);
+ Prompter name_prompter (true);
string result;
name_prompter.set_title (_("Rename Processor"));
name_prompter.set_prompt (_("New name:"));
name_prompter.get_result (result);
if (result.length()) {
- int tries = 0;
- string test = result;
-
- while (tries < 100) {
- if (_session->io_name_is_legal (test)) {
- result = test;
- break;
- }
- 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));
- }
+ int tries = 0;
+ string test = result;
+
+ while (tries < 100) {
+ if (_session->io_name_is_legal (test)) {
+ result = test;
+ break;
+ }
+ 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));
+ }
}
break;
}
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<Processor>());
+ paste_processor_state (_p_selection.processors.get_node().children(), boost::shared_ptr<Processor>());
}
void
ProcessorBox::paste_processors (boost::shared_ptr<Processor> 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
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);
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);
* We really would want Stateful::ForceIDRegeneration here :(
*/
XMLNode state (**niter);
- state.remove_nodes ("Processor");
+ state.remove_nodes_and_delete ("Processor");
p->set_state (state, Stateful::current_state_version);
boost::dynamic_pointer_cast<PluginInsert>(p)->update_id (id);
void
ProcessorBox::get_selected_processors (ProcSelection& processors) const
{
- const list<ProcessorEntry*> selection = processor_display.selection ();
+ const list<ProcessorEntry*> selection = processor_display.selection (true);
for (list<ProcessorEntry*>::const_iterator i = selection.begin(); i != selection.end(); ++i) {
processors.push_back ((*i)->processor ());
}
ab_direction = !ab_direction;
}
+void
+ProcessorBox::set_disk_io_position (DiskIOPoint diop)
+{
+ boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (_route);
+ if (t) {
+ t->set_disk_io_point (diop);
+ }
+}
void
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);
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);
} else if ((send = boost::dynamic_pointer_cast<Send> (processor)) != 0) {
- if (!_session->engine().connected()) {
+ if (!ARDOUR_UI_UTILS::engine_is_running ()) {
return 0;
}
return 0;
}
- if (!_session->engine().connected()) {
+ if (!ARDOUR_UI_UTILS::engine_is_running ()) {
return 0;
}
} else if ((port_insert = boost::dynamic_pointer_cast<PortInsert> (processor)) != 0) {
- if (!_session->engine().connected()) {
- MessageDialog msg ( _("Not connected to audio engine - no I/O changes are possible"));
- msg.run ();
+ if (!ARDOUR_UI_UTILS::engine_is_running ()) {
return 0;
}
myactions.register_action (processor_box_actions, X_("newplugin"), _("New Plugin"),
sigc::ptr_fun (ProcessorBox::rb_choose_plugin));
- act = myactions.register_action (processor_box_actions, X_("newlua"), _("New Lua DSP"),
- sigc::ptr_fun (ProcessorBox::rb_choose_lua));
act = myactions.register_action (processor_box_actions, X_("newinsert"), _("New Insert"),
sigc::ptr_fun (ProcessorBox::rb_choose_insert));
ActionManager::engine_sensitive_actions.push_back (act);
ActionManager::engine_sensitive_actions.push_back (act);
myactions.register_action (processor_box_actions, X_("newaux"), _("New Aux Send ..."));
+ myactions.register_action (processor_box_actions, X_("newlisten"), _("New Monitor Send ..."));
+ myactions.register_action (processor_box_actions, X_("removelisten"), _("Remove Monitor Send ..."));
myactions.register_action (processor_box_actions, X_("controls"), _("Controls"));
myactions.register_action (processor_box_actions, X_("send_options"), _("Send Options"));
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));
processor_box_actions, X_("manage-pins"), _("Pin Connections..."),
sigc::ptr_fun (ProcessorBox::rb_manage_pins));
+ /* Disk IO stuff */
+ disk_io_action = myactions.register_action (processor_box_actions, X_("disk-io-menu"), _("Disk I/O ..."));
+ myactions.register_action (processor_box_actions, X_("disk-io-prefader"), _("Pre-Fader."), sigc::bind (sigc::ptr_fun (ProcessorBox::rb_set_disk_io_position), DiskIOPreFader));
+ myactions.register_action (processor_box_actions, X_("disk-io-postfader"), _("Post-Fader."), sigc::bind (sigc::ptr_fun (ProcessorBox::rb_set_disk_io_position), DiskIOPostFader));
+ myactions.register_action (processor_box_actions, X_("disk-io-custom"), _("Custom."), sigc::bind (sigc::ptr_fun (ProcessorBox::rb_set_disk_io_position), DiskIOCustom));
+
/* show editors */
edit_action = myactions.register_action (
processor_box_actions, X_("edit"), _("Edit..."),
}
void
-ProcessorBox::rb_manage_pins ()
+ProcessorBox::rb_set_disk_io_position (DiskIOPoint diop)
{
if (_current_processor_box == 0) {
return;
}
- _current_processor_box->for_selected_processors (&ProcessorBox::manage_pins);
+ _current_processor_box->set_disk_io_position (diop);
}
+
void
-ProcessorBox::rb_choose_plugin ()
+ProcessorBox::rb_manage_pins ()
{
if (_current_processor_box == 0) {
return;
}
- _current_processor_box->choose_plugin ();
-}
+ _current_processor_box->for_selected_processors (&ProcessorBox::manage_pins);
+}
void
-ProcessorBox::rb_choose_lua ()
+ProcessorBox::rb_choose_plugin ()
{
if (_current_processor_box == 0) {
return;
}
- _current_processor_box->choose_lua ();
+ _current_processor_box->choose_plugin ();
}
void
_current_processor_box->choose_aux (wr);
}
+void
+ProcessorBox::rb_remove_aux (boost::weak_ptr<Route> wr)
+{
+ if (_current_processor_box == 0) {
+ return;
+ }
+
+ _current_processor_box->remove_aux (wr);
+}
+
void
ProcessorBox::rb_clear ()
{
if (edit_aux_send (processor)) {
return;
}
+ if (!ARDOUR_UI_UTILS::engine_is_running ()) {
+ return;
+ }
ProcessorWindowProxy* proxy = find_window_proxy (processor);
if (edit_aux_send (processor)) {
return;
}
+ if (!ARDOUR_UI_UTILS::engine_is_running ()) {
+ return;
+ }
ProcessorWindowProxy* proxy = find_window_proxy (processor);
ProcessorBox::set_processor_ui (boost::shared_ptr<Processor> p, Gtk::Window* w)
{
assert (p->window_proxy());
- p->set_ui (w);
p->window_proxy()->use_window (*w);
}
: WM::ProxyBase (name, string())
, _processor_box (box)
, _processor (processor)
- , is_custom (false)
- , want_custom (false)
+ , is_custom (true)
+ , want_custom (true)
{
boost::shared_ptr<Processor> 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()
void
ProcessorWindowProxy::processor_going_away ()
{
+ gui_connections.drop_connections ();
delete _window;
_window = 0;
WM::Manager::instance().remove (this);
send DropReferences is about to be deleted, but lets do it anyway.
*/
going_away_connection.disconnect();
+ delete this;
}
ARDOUR::SessionHandlePtr*
{
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;
}
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);
}
return ProxyBase::set_state (node, 0);
}
if (_window && (is_custom != want_custom)) {
/* drop existing window - wrong type */
+ set_state_mask (Gtkmm2ext::WindowProxy::StateMask (state_mask () & ~WindowProxy::Size));
drop_window ();
}
if (_window) {
setup ();
+ _window->show_all ();
}
}
- _window->show_all ();
return _window;
}
void
-ProcessorWindowProxy::show_the_right_window ()
+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 ();
- get (true);
- setup ();
- assert (_window);
- is_custom = want_custom;
}
-
+ if (_window && fully_visible () && show_not_toggle) {
+ return;
+ }
toggle ();
}
if (aw) {
aw->set_session (_session);
}
+ _window->show_all ();
}
-
- _window->show_all ();
return _window;
}
_window = 0;
WM::Manager::instance().remove (this);
going_away_connection.disconnect();
+ delete this;
}
void