#include "route_processor_selection.h"
#include "send_ui.h"
#include "timers.h"
+#include "tooltips.h"
+#include "new_plugin_preset_dialog.h"
#include "i18n.h"
class AUPluginUI;
#endif
+#ifndef NDEBUG
+bool ProcessorBox::show_all_processors = false;
+#endif
+
using namespace std;
using namespace ARDOUR;
using namespace PBD;
, _output_icon(false)
{
_vbox.show ();
-
+
_button.set_distinct_led_click (true);
_button.set_fallthrough_to_parent(true);
_button.set_led_left (true);
_button.set_elements(ArdourButton::Element(_button.elements() & ~ArdourButton::Indicator));
_unknown_processor = true;
}
+ {
+ boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (_processor);
+ if (pi && pi->plugin()) {
+ _plugin_preset_pointer = PluginPresetPtr (new PluginPreset (pi->plugin()->get_info()));
+ }
+ }
if (_processor) {
_vbox.pack_start (_routing_icon);
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 (boost::dynamic_pointer_cast<Send> (_processor)) {
}
Control* c = new Control (_processor->automation_control (*i), label);
-
+
_controls.push_back (c);
if (boost::dynamic_pointer_cast<Amp> (_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);
}
}
{
return name (Wide);
}
+bool
+ProcessorEntry::drag_data_get (Glib::RefPtr<Gdk::DragContext> const, Gtk::SelectionData &data)
+{
+ if (data.get_target() == "PluginPresetPtr") {
+ boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (_processor);
+
+ if (!_plugin_preset_pointer || !pi) {
+ data.set (data.get_target(), 8, NULL, 0);
+ return true;
+ }
+
+ boost::shared_ptr<ARDOUR::Plugin> 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)
}
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->deactivate ();
+ }
+ }
+ else {
+ _processor->deactivate ();
+ }
+
} else {
- _processor->activate ();
+ if (ctrl_shift_pressed) {
+ _parent->all_visible_processors_active(true);
+
+ if (_position == Fader) {
+ _processor->activate ();
+ }
+ }
+ else {
+ _processor->activate ();
+ }
}
}
}
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 (_("<b>%1</b>\nDouble-click to show GUI.\nAlt+double-click to show generic GUI.%2"), name (Wide), postfix));
+ 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));
} else {
- ARDOUR_UI::instance()->set_tip (_button,
+ ARDOUR_UI_UTILS::set_tooltip (_button,
string_compose (_("<b>%1</b>\nDouble-click to show generic GUI.%2"), name (Wide), postfix));
}
return;
return;
}
}
- ARDOUR_UI::instance()->set_tip (_button, string_compose ("<b>%1</b>", name (Wide)));
+ ARDOUR_UI_UTILS::set_tooltip (_button, string_compose ("<b>%1</b>", name (Wide)));
}
string
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))
);
if (!_controls.empty ()) {
items.push_back (SeparatorElem ());
}
-
+
for (list<Control*>::iterator i = _controls.begin(); i != _controls.end(); ++i) {
items.push_back (CheckMenuElem ((*i)->name ()));
Gtk::CheckMenuItem* c = dynamic_cast<Gtk::CheckMenuItem*> (&items.back ());
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)
- , _slider (&_adjustment, boost::shared_ptr<PBD::Controllable>(), 0, max(13.f, rintf(13.f * ARDOUR_UI::ui_scale)))
+ , _slider (&_adjustment, boost::shared_ptr<PBD::Controllable>(), 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)
_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));
+ _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 ());
} else {
-
+
_slider.set_name ("ProcessorControlSlider");
_slider.set_text (_name);
_adjustment.set_step_increment (smallstep);
_adjustment.set_page_increment (largestep);
_slider.set_default_value (normal);
-
+
_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 ());
// 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 ();
snprintf (tmp, sizeof(tmp), "%s: %.2f", _name.c_str(), c->internal_to_user (c->get_value ()));
}
- string sm = Glib::Markup::escape_text (tmp);
+ string sm = Gtkmm2ext::markup_escape_text (tmp);
_slider_persistant_tooltip.set_tip (sm);
- ARDOUR_UI::instance()->set_tip (_button, sm);
+ ARDOUR_UI_UTILS::set_tooltip (_button, sm);
}
void
if (_ignore_ui_adjustment) {
return;
}
-
+
boost::shared_ptr<AutomationControl> 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 ();
}
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_changed ()
{
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.
set_tooltip ();
}
}
-
+
_ignore_ui_adjustment = false;
}
} else {
box.hide ();
}
-
+
_visible = v;
}
* 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
+ * The *next* processor below this one will only see the
* actual available streams (it cannot know the real outputs
* of this plugin).
*
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_size_request (-1, std::max (7.f, rintf(7.f * UIConfiguration::instance().get_ui_scale())));
_routing_icon.set_visible(true);
_input_icon.show();
} else {
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
cairo_rectangle (cr, 0, 0, width, height);
cairo_fill (cr);
- const double dx = rint(max(2., 2. * ARDOUR_UI::ui_scale));
+ const double dx = rint(max(2., 2. * UIConfiguration::instance().get_ui_scale()));
if (_ports.n_total() > 1) {
for (uint32_t i = 0; i < _ports.n_total(); ++i) {
if (i < _ports.n_midi()) {
cairo_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_width (cr, max (1.f, UIConfiguration::instance().get_ui_scale()));
cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
Gtk::Allocation a = get_allocation();
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));
+ const double dx = 1 + rint(max(2., 2. * UIConfiguration::instance().get_ui_scale()));
// draw "T"
// TODO connect back to track-input of last midi-out if any, otherwise draw "X"
const float si_x = rintf(width * .2f) + .5f;
cairo_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",
+ 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
}
cairo_stroke (cr);
#ifndef NDEBUG
} else if (audio_sources != 0 && audio_sinks != 0) {
- PBD::warning << string_compose("Programming error: audio routing display: A %1 -> %2 | M %3 -> %4 | T %5 -> %6",
+ PBD::warning << string_compose("Programming error: audio routing display: A %1 -> %2 | M %3 -> %4 | T %5 -> %6",
audio_sources, audio_sinks, midi_sources, midi_sinks, sources, sinks) << endmsg;
#endif
}
return true;
}
+static std::list<Gtk::TargetEntry> drop_targets()
+{
+ 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
+ return tmp;
+}
+
+static std::list<Gtk::TargetEntry> drag_targets()
+{
+ std::list<Gtk::TargetEntry> 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<Gtk::TargetEntry> drag_targets_noplugin()
+{
+ std::list<Gtk::TargetEntry> tmp;
+ tmp.push_back (Gtk::TargetEntry ("processor")); // to processor box (sends, faders re-order)
+ return tmp;
+}
+
ProcessorBox::ProcessorBox (ARDOUR::Session* sess, boost::function<PluginSelector*()> get_plugin_selector,
RouteProcessorSelection& rsel, MixerStrip* parent, bool owner_is_mixer)
: _parent_strip (parent)
, _placement (-1)
, _visible_prefader_processors (0)
, _rr_selection(rsel)
+ , processor_display (drop_targets())
, _redisplay_pending (false)
{
processor_display.Reordered.connect (sigc::mem_fun (*this, &ProcessorBox::reordered));
processor_display.DropFromAnotherBox.connect (sigc::mem_fun (*this, &ProcessorBox::object_drop));
+ processor_display.DropFromExternal.connect (sigc::mem_fun (*this, &ProcessorBox::plugin_drop));
processor_scroller.show ();
processor_display.show ();
);
}
- ARDOUR_UI::instance()->set_tip (processor_display, _("Right-click to add/remove/edit\nplugins,inserts,sends and more"));
+ ARDOUR_UI_UTILS::set_tooltip (processor_display, _("Right-click to add/remove/edit\nplugins,inserts,sends and more"));
}
ProcessorBox::~ProcessorBox ()
_route.reset ();
}
-void
-ProcessorBox::object_drop(DnDVBox<ProcessorEntry>* source, ProcessorEntry* position, Glib::RefPtr<Gdk::DragContext> const & context)
+boost::shared_ptr<Processor>
+ProcessorBox::find_drop_position (ProcessorEntry* position)
{
boost::shared_ptr<Processor> 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<ProcessorEntry*> c = processor_display.children ();
list<ProcessorEntry*>::iterator i = c.begin ();
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<ARDOUR::PluginPresetPtr>* tv = reinterpret_cast<const Gtkmm2ext::DnDTreeView<ARDOUR::PluginPresetPtr>*>(d);
+
+ PluginPresetList nfos;
+ TreeView* source;
+ tv->get_object_drag_data (nfos, &source);
+
+ for (list<PluginPresetPtr>::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> processor (new PluginInsert (*_session, p));
+ if (Config->get_new_plugins_active ()) {
+ processor->activate ();
+ }
+ pl.push_back (processor);
+ }
+}
+
+void
+ProcessorBox::_drop_plugin (Gtk::SelectionData const &data, Route::ProcessorList &pl)
+{
+ const void * d = data.get_data();
+ const Gtkmm2ext::DnDTreeView<ARDOUR::PluginInfoPtr>* tv = reinterpret_cast<const Gtkmm2ext::DnDTreeView<ARDOUR::PluginInfoPtr>*>(d);
+ PluginInfoList nfos;
+
+ TreeView* source;
+ tv->get_object_drag_data (nfos, &source);
+
+ for (list<PluginInfoPtr>::const_iterator i = nfos.begin(); i != nfos.end(); ++i) {
+ PluginPtr p = (*i)->load (*_session);
+ if (!p) {
+ continue;
+ }
+ boost::shared_ptr<Processor> processor (new PluginInsert (*_session, p));
+ if (Config->get_new_plugins_active ()) {
+ processor->activate ();
+ }
+ pl.push_back (processor);
+ }
+}
+
+void
+ProcessorBox::plugin_drop (Gtk::SelectionData const &data, ProcessorEntry* position, Glib::RefPtr<Gdk::DragContext> const & context)
+{
+ if (!_session) {
+ return;
+ }
+
+ boost::shared_ptr<Processor> p = find_drop_position (position);
+ Route::ProcessorList pl;
+
+ if (data.get_target() == "PluginInfoPtr") {
+ _drop_plugin (data, pl);
+ }
+ else if (data.get_target() == "PluginPresetPtr") {
+ _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<ProcessorEntry>* source, ProcessorEntry* position, Glib::RefPtr<Gdk::DragContext> const & context)
+{
+ boost::shared_ptr<Processor> p = find_drop_position (position);
list<ProcessorEntry*> children = source->selection ();
list<boost::shared_ptr<Processor> > procs;
return 0;
}
+ if (_route->is_monitor ()) {
+ return 0;
+ }
+
using namespace Menu_Helpers;
Menu* menu = manage (new Menu);
MenuList& items = menu->items();
}
}
+ 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();
Gtk::MenuItem* send_menu_item = dynamic_cast<Gtk::MenuItem*>(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);
}
bool
-ProcessorBox::processor_operation (ProcessorOperation op)
+ProcessorBox::processor_operation (ProcessorOperation op)
{
ProcSelection targets;
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 ();
default:
break;
}
-
+
return true;
}
-ProcessorWindowProxy*
+ProcessorWindowProxy*
ProcessorBox::find_window_proxy (boost::shared_ptr<Processor> processor) const
{
return processor->window_proxy();
} else if (Keyboard::is_context_menu_event (ev)) {
show_processor_menu (ev->time);
-
+
ret = true;
} else if (processor && ev->button == 1 && selected) {
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 && Config->get_open_gui_after_adding_plugin()) {
+ if (_session->engine().connected () && processor_can_be_edited (processor)) {
+ if ((*p)->has_editor ()) {
+ edit_processor (processor);
+ } else {
+ generic_edit_processor (processor);
+ }
}
}
}
_visible_prefader_processors = 0;
fader_seen = false;
- _route->foreach_processor (sigc::bind (sigc::mem_fun (*this, &ProcessorBox::help_count_visible_prefader_processors),
+ _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));
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) {
{
boost::shared_ptr<Processor> processor (p.lock ());
- if (processor && processor->display_to_user()) {
+ if (processor && ( processor->display_to_user()
+#ifndef NDEBUG
+ || show_all_processors
+#endif
+ )
+ ) {
- if (boost::dynamic_pointer_cast<Amp>(processor)) {
+ 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) {
{
boost::shared_ptr<Processor> 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<PluginInsert> plugin_insert = boost::dynamic_pointer_cast<PluginInsert> (processor);
-
+
ProcessorEntry* e = 0;
if (plugin_insert) {
e = new PluginInsertProcessorEntry (this, plugin_insert, _width);
boost::shared_ptr<Send> send = boost::dynamic_pointer_cast<Send> (processor);
boost::shared_ptr<PortInsert> ext = boost::dynamic_pointer_cast<PortInsert> (processor);
boost::shared_ptr<UnknownProcessor> stub = boost::dynamic_pointer_cast<UnknownProcessor> (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);
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
uint32_t num = 0;
for (list<ProcessorEntry*>::iterator i = children.begin(); i != children.end(); ++i) {
- if (boost::dynamic_pointer_cast<Amp>((*i)->processor())) {
+ if (boost::dynamic_pointer_cast<Amp>((*i)->processor()) &&
+ boost::dynamic_pointer_cast<Amp>((*i)->processor())->gain_control()->parameter().type() == GainAutomation) {
pre_fader = false;
(*i)->set_position (ProcessorEntry::Fader, num++);
} else {
continue;
} else if (type->value() == "intsend") {
-
+
/* aux sends are OK, but those used for
* other purposes, are not.
*/
-
+
assert (role);
if (role->value() != "Aux") {
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;
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);
} else {
* 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.
*/
}
}
- if (boost::dynamic_pointer_cast<Amp> (processor)) {
+ if (boost::dynamic_pointer_cast<Amp> (processor) && boost::dynamic_pointer_cast<Amp> (processor)->gain_control()->parameter().type() == GainAutomation) {
if (_parent_strip) {
_parent_strip->revert_to_default_display ();
void
ProcessorBox::register_actions ()
{
- Glib::RefPtr<Gtk::ActionGroup> popup_act_grp = Gtk::ActionGroup::create(X_("ProcessorMenu"));
+ Glib::RefPtr<Gtk::ActionGroup> popup_act_grp = Actions.create_action_group (X_("ProcessorMenu"));
Glib::RefPtr<Action> act;
/* new stuff */
- ActionManager::register_action (popup_act_grp, X_("newplugin"), _("New Plugin"),
+ Actions.register_action (popup_act_grp, X_("newplugin"), _("New Plugin"),
sigc::ptr_fun (ProcessorBox::rb_choose_plugin));
- act = ActionManager::register_action (popup_act_grp, X_("newinsert"), _("New Insert"),
+ act = Actions.register_action (popup_act_grp, 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 = Actions.register_action (popup_act_grp, 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 ..."));
+ Actions.register_action (popup_act_grp, 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"));
+ Actions.register_action (popup_act_grp, X_("controls"), _("Controls"));
+ Actions.register_action (popup_act_grp, X_("send_options"), _("Send Options"));
- ActionManager::register_action (popup_act_grp, X_("clear"), _("Clear (all)"),
+ Actions.register_action (popup_act_grp, X_("clear"), _("Clear (all)"),
sigc::ptr_fun (ProcessorBox::rb_clear));
- ActionManager::register_action (popup_act_grp, X_("clear_pre"), _("Clear (pre-fader)"),
+ Actions.register_action (popup_act_grp, 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)"),
+ Actions.register_action (popup_act_grp, 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 = Actions.register_action (popup_act_grp, X_("cut"), _("Cut"),
+ sigc::ptr_fun (ProcessorBox::rb_cut));
+ copy_action = Actions.register_action (popup_act_grp, X_("copy"), _("Copy"),
+ sigc::ptr_fun (ProcessorBox::rb_copy));
+ delete_action = Actions.register_action (popup_act_grp, X_("delete"), _("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);
+
+ paste_action = processor_box_actions.register_action (popup_act_grp, X_("paste"), _("Paste"),
sigc::ptr_fun (ProcessorBox::rb_paste));
- rename_action = ActionManager::register_action (popup_act_grp, X_("rename"), _("Rename"),
+ rename_action = Actions.register_action (popup_act_grp, X_("rename"), _("Rename"),
sigc::ptr_fun (ProcessorBox::rb_rename));
- ActionManager::register_action (popup_act_grp, X_("selectall"), _("Select All"),
+ Actions.register_action (popup_act_grp, X_("selectall"), _("Select All"),
sigc::ptr_fun (ProcessorBox::rb_select_all));
- ActionManager::register_action (popup_act_grp, X_("deselectall"), _("Deselect All"),
+ Actions.register_action (popup_act_grp, X_("deselectall"), _("Deselect All"),
sigc::ptr_fun (ProcessorBox::rb_deselect_all));
/* activation etc. */
- ActionManager::register_action (popup_act_grp, X_("activate_all"), _("Activate All"),
+ Actions.register_action (popup_act_grp, X_("activate_all"), _("Activate All"),
sigc::ptr_fun (ProcessorBox::rb_activate_all));
- ActionManager::register_action (popup_act_grp, X_("deactivate_all"), _("Deactivate All"),
+ Actions.register_action (popup_act_grp, X_("deactivate_all"), _("Deactivate All"),
sigc::ptr_fun (ProcessorBox::rb_deactivate_all));
- ActionManager::register_action (popup_act_grp, X_("ab_plugins"), _("A/B Plugins"),
+ Actions.register_action (popup_act_grp, X_("ab_plugins"), _("A/B Plugins"),
sigc::ptr_fun (ProcessorBox::rb_ab_plugins));
/* show editors */
- edit_action = ActionManager::register_action (
+ edit_action = Actions.register_action (
popup_act_grp, X_("edit"), _("Edit..."),
sigc::ptr_fun (ProcessorBox::rb_edit));
- edit_generic_action = ActionManager::register_action (
+ edit_generic_action = Actions.register_action (
popup_act_grp, X_("edit-generic"), _("Edit with generic controls..."),
sigc::ptr_fun (ProcessorBox::rb_edit_generic));
-
- ActionManager::add_action_group (popup_act_grp);
}
void
if (proxy) {
proxy->set_custom_ui_mode (true);
- proxy->toggle ();
+ proxy->show_the_right_window ();
}
}
if (proxy) {
proxy->set_custom_ui_mode (false);
- proxy->toggle ();
+ proxy->show_the_right_window ();
}
}
}
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());
}
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();
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 ();
}
}
- ProxyBase::set_state(node);
+ return ProxyBase::set_state (node, 0);
}
Gtk::Window*
if (!create) {
return 0;
}
-
+
is_custom = want_custom;
_window = _processor_box->get_editor_window (p, is_custom);
}
void
-ProcessorWindowProxy::toggle ()
+ProcessorWindowProxy::show_the_right_window ()
{
if (_window && (is_custom != want_custom)) {
/* drop existing window - wrong type */
drop_window ();
+ get (true);
+ setup ();
+ assert (_window);
+ is_custom = want_custom;
}
- is_custom = want_custom;
- WM::ProxyBase::toggle ();
+ toggle ();
}