#include "i18n.h"
-#ifdef HAVE_AUDIOUNITS
+#ifdef AUDIOUNIT_SUPPORT
class AUPluginUI;
#endif
Glib::RefPtr<Gdk::Pixbuf> SendProcessorEntry::_slider;
ProcessorEntry::ProcessorEntry (boost::shared_ptr<Processor> p, Width w)
- : _position (PreFader)
+ : _button (ArdourButton::led_default_elements)
+ , _position (PreFader)
, _processor (p)
, _width (w)
, _visual_state (Gtk::STATE_NORMAL)
{
- _hbox.pack_start (_active, false, false);
- _event_box.add (_name);
- _hbox.pack_start (_event_box, true, true);
- _vbox.pack_start (_hbox);
- _frame.add (_vbox);
-
- /* without this, the border is mis-drawn on some systems */
- _vbox.set_border_width (1);
-
- _name.set_alignment (0, 0.5);
- _name.set_text (name ());
- _name.set_padding (2, 2);
-
- if (boost::dynamic_pointer_cast<Amp> (p)) {
- /* Fader processor gets a special look */
- _event_box.set_name ("ProcessorFader");
- _frame.set_name ("ProcessorFaderFrame");
- _name.set_padding (2, 4);
- }
-
- _active.set_active (_processor->active ());
- _active.signal_toggled().connect (sigc::mem_fun (*this, &ProcessorEntry::active_toggled));
-
- _frame.show ();
+ _vbox.pack_start (_button, true, true);
_vbox.show ();
- _hbox.show ();
- _event_box.show ();
- _name.show ();
- _active.show ();
+
+ if (_processor->active()) {
+ _button.set_active_state (Gtkmm2ext::Active);
+ }
+ _button.set_diameter (3);
+ _button.set_distinct_led_click (true);
+ _button.set_led_left (true);
+ _button.signal_led_clicked.connect (sigc::mem_fun (*this, &ProcessorEntry::led_clicked));
+ _button.set_text (name (_width));
+ _button.show ();
_processor->ActiveChanged.connect (active_connection, invalidator (*this), boost::bind (&ProcessorEntry::processor_active_changed, this), gui_context());
_processor->PropertyChanged.connect (name_connection, invalidator (*this), ui_bind (&ProcessorEntry::processor_property_changed, this, _1), gui_context());
+
+ setup_tooltip ();
+ setup_visuals ();
}
EventBox&
ProcessorEntry::action_widget ()
{
- return _event_box;
+ return _button;
}
Gtk::Widget&
ProcessorEntry::widget ()
{
- return _frame;
+ return _vbox;
}
string
ProcessorEntry::drag_text () const
{
- return name ();
+ return name (Wide);
}
void
-ProcessorEntry::set_visual_state (Gtk::StateType t)
+ProcessorEntry::set_position (Position p)
{
- _visual_state = t;
+ _position = p;
setup_visuals ();
}
void
-ProcessorEntry::set_position (Position p)
+ProcessorEntry::set_visual_state (Gtkmm2ext::VisualState s, bool yn)
{
- _position = p;
- setup_visuals ();
+ if (yn) {
+ _button.set_visual_state (Gtkmm2ext::VisualState (_button.visual_state() | s));
+ } else {
+ _button.set_visual_state (Gtkmm2ext::VisualState (_button.visual_state() & ~s));
+ }
}
void
{
switch (_position) {
case PreFader:
- _event_box.set_name ("ProcessorPreFader");
- if (_visual_state == Gtk::STATE_NORMAL) {
- _frame.set_name ("ProcessorPreFaderFrame");
- }
+ _button.set_name ("processor prefader");
break;
case Fader:
- _event_box.set_name ("ProcessorFader");
- if (_visual_state == Gtk::STATE_NORMAL) {
- _frame.set_name ("ProcessorFaderFrame");
- }
+ _button.set_name ("processor fader");
break;
case PostFader:
- _event_box.set_name ("ProcessorPostFader");
- if (_visual_state == Gtk::STATE_NORMAL) {
- _frame.set_name ("ProcessorPostFaderFrame");
- }
- break;
- }
-
- switch (_visual_state) {
- case Gtk::STATE_NORMAL:
- /* _frame has been set up above */
- _event_box.set_state (Gtk::STATE_NORMAL);
- break;
- case Gtk::STATE_SELECTED:
- _frame.set_name ("ProcessorFrameSelected");
- /* don't change the background of the box when it is selected */
- _event_box.set_state (Gtk::STATE_NORMAL);
- break;
- case Gtk::STATE_ACTIVE:
- _frame.set_name ("ProcessorFrameActiveSend");
- _event_box.set_state (Gtk::STATE_ACTIVE);
- break;
- default:
+ _button.set_name ("processor postfader");
break;
}
}
}
void
-ProcessorEntry::active_toggled ()
+ProcessorEntry::led_clicked()
{
- if (_active.get_active ()) {
- if (!_processor->active ()) {
- _processor->activate ();
- }
+ if (_button.active_state() == Gtkmm2ext::Active) {
+ _processor->deactivate ();
} else {
- if (_processor->active ()) {
- _processor->deactivate ();
- }
+ _processor->activate ();
}
}
void
ProcessorEntry::processor_active_changed ()
{
- if (_active.get_active () != _processor->active ()) {
- _active.set_active (_processor->active ());
+ if (_processor->active()) {
+ _button.set_active_state (Gtkmm2ext::Active);
+ } else {
+ _button.unset_active_state ();
}
}
ProcessorEntry::processor_property_changed (const PropertyChange& what_changed)
{
if (what_changed.contains (ARDOUR::Properties::name)) {
- _name.set_text (name ());
+ _button.set_text (name (_width));
+ setup_tooltip ();
}
}
+void
+ProcessorEntry::setup_tooltip ()
+{
+ ARDOUR_UI::instance()->set_tip (_button, name (Wide));
+}
+
string
-ProcessorEntry::name () const
+ProcessorEntry::name (Width w) const
{
boost::shared_ptr<Send> send;
string name_display;
lbracket = send->name().find ('[');
rbracket = send->name().find (']');
- switch (_width) {
+ switch (w) {
case Wide:
name_display += send->name().substr (lbracket+1, lbracket-rbracket-1);
break;
} else {
- switch (_width) {
+ switch (w) {
case Wide:
name_display += _processor->display_name();
break;
}
SendProcessorEntry::SendProcessorEntry (boost::shared_ptr<Send> s, Width w)
- : ProcessorEntry (s, w),
- _send (s),
- _adjustment (gain_to_slider_position_with_max (1.0, Config->get_max_gain()), 0, 1, 0.01, 0.1),
- _fader (_slider, &_adjustment, 0, false),
- _ignore_gain_change (false)
+ : ProcessorEntry (s, w)
+ , _send (s)
+ , _adjustment (gain_to_slider_position_with_max (1.0, Config->get_max_gain()), 0, 1, 0.01, 0.1)
+ , _fader (_slider, &_adjustment, 0, false)
+ , _ignore_gain_change (false)
+ , _data_type (DataType::AUDIO)
{
_fader.set_name ("SendFader");
_fader.set_controllable (_send->amp()->gain_control ());
_fader.show ();
_adjustment.signal_value_changed().connect (sigc::mem_fun (*this, &SendProcessorEntry::gain_adjusted));
- _send->amp()->gain_control()->Changed.connect (send_gain_connection, invalidator (*this), boost::bind (&SendProcessorEntry::show_gain, this), gui_context());
+
+ _send->amp()->gain_control()->Changed.connect (
+ _send_connections, invalidator (*this), boost::bind (&SendProcessorEntry::show_gain, this), gui_context()
+ );
+
+ _send->amp()->ConfigurationChanged.connect (
+ _send_connections, invalidator (*this), ui_bind (&SendProcessorEntry::setup_gain_adjustment, this), gui_context ()
+ );
+
+ setup_gain_adjustment ();
show_gain ();
}
+void
+SendProcessorEntry::setup_gain_adjustment ()
+{
+ if (_send->amp()->output_streams().n_midi() == 0) {
+ _data_type = DataType::AUDIO;
+ _adjustment.set_lower (0);
+ _adjustment.set_upper (1);
+ _adjustment.set_step_increment (0.01);
+ _adjustment.set_page_increment (0.1);
+ _fader.set_default_value (gain_to_slider_position (1));
+ } else {
+ _data_type = DataType::MIDI;
+ _adjustment.set_lower (0);
+ _adjustment.set_upper (2);
+ _adjustment.set_step_increment (0.05);
+ _adjustment.set_page_increment (0.1);
+ _fader.set_default_value (1);
+ }
+}
+
void
SendProcessorEntry::setup_slider_pix ()
{
void
SendProcessorEntry::show_gain ()
{
- float const value = gain_to_slider_position_with_max (_send->amp()->gain (), Config->get_max_gain());
+ gain_t value = 0;
+
+ switch (_data_type) {
+ case DataType::AUDIO:
+ value = gain_to_slider_position_with_max (_send->amp()->gain (), Config->get_max_gain());
+ break;
+ case DataType::MIDI:
+ value = _send->amp()->gain ();
+ break;
+ }
if (_adjustment.get_value() != value) {
_ignore_gain_change = true;
stringstream s;
s.precision (1);
s.setf (ios::fixed, ios::floatfield);
- s << accurate_coefficient_to_dB (_send->amp()->gain ()) << _("dB");
+ s << accurate_coefficient_to_dB (_send->amp()->gain ());
+ if (_data_type == DataType::AUDIO) {
+ s << _("dB");
+ }
+
_fader.set_tooltip_text (s.str ());
}
}
return;
}
- _send->amp()->set_gain (slider_position_to_gain_with_max (_adjustment.get_value(), Config->get_max_gain()), this);
+ gain_t value = 0;
+
+ switch (_data_type) {
+ case DataType::AUDIO:
+ value = slider_position_to_gain_with_max (_adjustment.get_value(), Config->get_max_gain());
+ break;
+ case DataType::MIDI:
+ value = _adjustment.get_value ();
+ }
+
+ _send->amp()->set_gain (value, this);
}
void
}
ProcessorBox::ProcessorBox (ARDOUR::Session* sess, boost::function<PluginSelector*()> get_plugin_selector,
- RouteRedirectSelection& rsel, MixerStrip* parent, bool owner_is_mixer)
+ RouteProcessorSelection& rsel, 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(PreFader)
+ , _placement (-1)
, _rr_selection(rsel)
{
set_session (sess);
_width = Wide;
processor_menu = 0;
- send_action_menu = 0;
no_processor_redisplay = false;
processor_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
processor_display.signal_enter_notify_event().connect (sigc::mem_fun(*this, &ProcessorBox::enter_notify), false);
processor_display.signal_leave_notify_event().connect (sigc::mem_fun(*this, &ProcessorBox::leave_notify), false);
- processor_display.signal_key_press_event().connect (sigc::mem_fun(*this, &ProcessorBox::processor_key_press_event));
- processor_display.signal_key_release_event().connect (sigc::mem_fun(*this, &ProcessorBox::processor_key_release_event));
-
processor_display.ButtonPress.connect (sigc::mem_fun (*this, &ProcessorBox::processor_button_press_event));
processor_display.ButtonRelease.connect (sigc::mem_fun (*this, &ProcessorBox::processor_button_release_event));
processor_display.Reordered.connect (sigc::mem_fun (*this, &ProcessorBox::reordered));
processor_display.DropFromAnotherBox.connect (sigc::mem_fun (*this, &ProcessorBox::object_drop));
- processor_display.SelectionChanged.connect (sigc::mem_fun (*this, &ProcessorBox::selection_changed));
processor_scroller.show ();
processor_display.show ();
ProcessorBox::~ProcessorBox ()
{
+ delete processor_menu;
}
void
if ((context->get_suggested_action() == Gdk::ACTION_MOVE) && source) {
ProcessorBox* other = reinterpret_cast<ProcessorBox*> (source->get_data ("processorbox"));
if (other) {
- cerr << "source was another processor box, delete the selected items\n";
other->delete_dragged_processors (procs);
}
}
redisplay_processors ();
}
-void
-ProcessorBox::build_send_action_menu ()
-{
- using namespace Menu_Helpers;
-
- send_action_menu = new Menu;
- send_action_menu->set_name ("ArdourContextMenu");
- MenuList& items = send_action_menu->items();
-
- items.push_back (MenuElem (_("New send"), sigc::mem_fun(*this, &ProcessorBox::new_send)));
- items.push_back (MenuElem (_("Show send controls"), sigc::mem_fun(*this, &ProcessorBox::show_send_controls)));
-}
-
Gtk::Menu*
ProcessorBox::build_possible_aux_menu ()
{
}
void
-ProcessorBox::show_processor_menu (gint arg)
+ProcessorBox::show_processor_menu (int arg)
{
if (processor_menu == 0) {
processor_menu = build_processor_menu ();
+ processor_menu->signal_unmap().connect (sigc::mem_fun (*this, &ProcessorBox::processor_menu_unmapped));
}
+ /* Sort out the plugin submenu */
+
Gtk::MenuItem* plugin_menu_item = dynamic_cast<Gtk::MenuItem*>(ActionManager::get_widget("/ProcessorMenu/newplugin"));
if (plugin_menu_item) {
plugin_menu_item->set_submenu (*_get_plugin_selector()->plugin_menu());
}
+ /* And the aux submenu */
+
Gtk::MenuItem* aux_menu_item = dynamic_cast<Gtk::MenuItem*>(ActionManager::get_widget("/ProcessorMenu/newaux"));
if (aux_menu_item) {
}
}
+ /* Sensitise actions as approprioate */
+
cut_action->set_sensitive (can_cut());
paste_action->set_sensitive (!_rr_selection.processors.empty());
+ const bool sensitive = !processor_display.selection().empty();
+ ActionManager::set_sensitive (ActionManager::plugin_selection_sensitive_actions, sensitive);
+ edit_action->set_sensitive (one_processor_can_be_edited ());
+
+ boost::shared_ptr<Processor> single_selection;
+ if (processor_display.selection().size() == 1) {
+ single_selection = processor_display.selection().front()->processor ();
+ }
+
+ boost::shared_ptr<PluginInsert> pi;
+ if (single_selection) {
+ pi = boost::dynamic_pointer_cast<PluginInsert> (single_selection);
+ }
+
+ /* enable gui for plugin inserts with editors */
+ controls_action->set_sensitive(pi && pi->plugin()->has_editor());
+
+ /* disallow rename for multiple selections, for plugin inserts and for the fader */
+ rename_action->set_sensitive (single_selection && !pi && !boost::dynamic_pointer_cast<Amp> (single_selection));
+
processor_menu->popup (1, arg);
+
+ /* Add a placeholder gap to the processor list to indicate where a processor would be
+ inserted were one chosen from the menu.
+ */
+ int x, y;
+ processor_display.get_pointer (x, y);
+ _placement = processor_display.add_placeholder (y);
}
bool
ProcessorBox::enter_notify (GdkEventCrossing*)
{
_current_processor_box = this;
- Keyboard::magic_widget_grab_focus ();
- processor_display.grab_focus ();
-
return false;
}
bool
ProcessorBox::leave_notify (GdkEventCrossing* ev)
{
- switch (ev->detail) {
- case GDK_NOTIFY_INFERIOR:
- break;
- default:
- Keyboard::magic_widget_drop_focus ();
- }
-
- return false;
-}
-
-bool
-ProcessorBox::processor_key_press_event (GdkEventKey *)
-{
- /* do real stuff on key release */
return false;
}
-bool
-ProcessorBox::processor_key_release_event (GdkEventKey *ev)
+void
+ProcessorBox::processor_operation (ProcessorOperation op)
{
- bool ret = false;
ProcSelection targets;
get_selected_processors (targets);
}
}
-
- switch (ev->keyval) {
- case GDK_a:
- if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
- processor_display.select_all ();
- ret = true;
- }
+ switch (op) {
+ case ProcessorsSelectAll:
+ processor_display.select_all ();
break;
- case GDK_c:
- if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
- copy_processors (targets);
- ret = true;
- }
+ case ProcessorsCopy:
+ copy_processors (targets);
break;
- case GDK_x:
- if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
- cut_processors (targets);
- ret = true;
- }
+ case ProcessorsCut:
+ cut_processors (targets);
break;
- case GDK_v:
- if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
- if (targets.empty()) {
- paste_processors ();
- } else {
- paste_processors (targets.front());
- }
- ret = true;
+ case ProcessorsPaste:
+ if (targets.empty()) {
+ paste_processors ();
+ } else {
+ paste_processors (targets.front());
}
break;
- case GDK_Up:
- break;
-
- case GDK_Down:
- break;
-
- case GDK_Delete:
- case GDK_BackSpace:
+ case ProcessorsDelete:
delete_processors (targets);
- ret = true;
break;
- case GDK_Return:
+ case ProcessorsToggleActive:
for (ProcSelection::iterator i = targets.begin(); i != targets.end(); ++i) {
if ((*i)->active()) {
(*i)->deactivate ();
(*i)->activate ();
}
}
- ret = true;
break;
- case GDK_slash:
+ case ProcessorsAB:
ab_plugins ();
- ret = true;
break;
default:
break;
}
-
- return ret;
}
bool
} else if (Keyboard::is_context_menu_event (ev)) {
- /* figure out if we are above or below the fader/amp processor,
- and set the next insert position appropriately.
- */
-
- if (processor) {
- if (_route->processor_is_prefader (processor)) {
- _placement = PreFader;
- } else {
- _placement = PostFader;
- }
- } else {
- _placement = PostFader;
- }
-
show_processor_menu (ev->time);
} else if (processor && Keyboard::is_button2_event (ev)
return processor_menu;
}
-void
-ProcessorBox::selection_changed ()
-{
- const bool sensitive = !processor_display.selection().empty();
- ActionManager::set_sensitive(ActionManager::plugin_selection_sensitive_actions,
- sensitive);
- edit_action->set_sensitive(one_processor_can_be_edited());
-
- const bool single_selection = (processor_display.selection().size() == 1);
-
- boost::shared_ptr<PluginInsert> pi;
- if (single_selection) {
- pi = boost::dynamic_pointer_cast<PluginInsert>(
- processor_display.selection().front()->processor());
- }
-
- /* enable gui for plugin inserts with editors */
- controls_action->set_sensitive(pi && pi->plugin()->has_editor());
-
- /* disallow rename for multiple selections and for plugin inserts */
- rename_action->set_sensitive(single_selection && pi);
-}
-
void
ProcessorBox::select_all_processors ()
{
Route::ProcessorStreams err_streams;
- if (_route->add_processor (processor, _placement, &err_streams, Config->get_new_plugins_active ())) {
+ if (_route->add_processor_by_index (processor, _placement, &err_streams, Config->get_new_plugins_active ())) {
weird_plugin_dialog (**p, err_streams);
return true;
// XXX SHAREDPTR delete plugin here .. do we even need to care?
ProcessorBox::choose_insert ()
{
boost::shared_ptr<Processor> processor (new PortInsert (*_session, _route->pannable(), _route->mute_master()));
- _route->add_processor (processor, _placement);
+ _route->add_processor_by_index (processor, _placement);
}
/* Caller must not hold process lock */
break;
case IOSelector::Accepted:
- _route->add_processor (processor, _placement);
+ _route->add_processor_by_index (processor, _placement);
if (Profile->get_sae()) {
processor->activate ();
}
break;
case IOSelector::Accepted:
- _route->add_processor (processor, _placement);
+ _route->add_processor_by_index (processor, _placement);
if (Profile->get_sae()) {
processor->activate ();
}
return false;
}
-void
-ProcessorBox::cut_processors ()
-{
- ProcSelection to_be_removed;
-
- get_selected_processors (to_be_removed);
-}
-
void
ProcessorBox::cut_processors (const ProcSelection& to_be_removed)
{
redisplay_processors ();
}
-void
-ProcessorBox::copy_processors ()
-{
- ProcSelection to_be_copied;
- get_selected_processors (to_be_copied);
- copy_processors (to_be_copied);
-}
-
void
ProcessorBox::copy_processors (const ProcSelection& to_be_copied)
{
}
void
-ProcessorBox::delete_processors ()
+ProcessorBox::processors_up ()
{
- ProcSelection to_be_deleted;
- get_selected_processors (to_be_deleted);
- delete_processors (to_be_deleted);
+ /* unimplemented */
}
+void
+ProcessorBox::processors_down ()
+{
+ /* unimplemented */
+}
+
+
void
ProcessorBox::delete_processors (const ProcSelection& targets)
{
}
void
-ProcessorBox::all_processors_active (bool state)
+ProcessorBox::all_visible_processors_active (bool state)
{
- _route->all_processors_active (_placement, state);
+ _route->all_visible_processors_active (state);
}
void
}
if (
- boost::dynamic_pointer_cast<Send> (processor) ||
+ (boost::dynamic_pointer_cast<Send> (processor) && !boost::dynamic_pointer_cast<InternalSend> (processor))||
boost::dynamic_pointer_cast<Return> (processor) ||
boost::dynamic_pointer_cast<PluginInsert> (processor) ||
boost::dynamic_pointer_cast<PortInsert> (processor)
_parent_strip->revert_to_default_display ();
}
- } else if ((internal_send = boost::dynamic_pointer_cast<InternalSend> (processor)) != 0) {
-
- if (!_session->engine().connected()) {
- return;
- }
-
- if (_parent_strip) {
- if (boost::dynamic_pointer_cast<Send> (_parent_strip->current_delivery()) == internal_send) {
- _parent_strip->revert_to_default_display ();
- } else {
- _parent_strip->show_send (internal_send);
- }
- }
-
} else if ((send = boost::dynamic_pointer_cast<Send> (processor)) != 0) {
if (!_session->engine().connected()) {
return;
}
- SendUIWindow* w = new SendUIWindow (send, _session);
- w->show ();
+ if (boost::dynamic_pointer_cast<InternalSend> (processor) == 0) {
+ SendUIWindow* w = new SendUIWindow (send, _session);
+ w->show ();
+ }
} else if ((retrn = boost::dynamic_pointer_cast<Return> (processor)) != 0) {
act = ActionManager::register_action (popup_act_grp, X_("newinsert"), _("New Insert"),
sigc::ptr_fun (ProcessorBox::rb_choose_insert));
ActionManager::jack_sensitive_actions.push_back (act);
- act = ActionManager::register_action (popup_act_grp, X_("newsend"), _("New Send ..."),
+ act = ActionManager::register_action (popup_act_grp, X_("newsend"), _("New External Send ..."),
sigc::ptr_fun (ProcessorBox::rb_choose_send));
ActionManager::jack_sensitive_actions.push_back (act);
/* activation etc. */
- ActionManager::register_action (popup_act_grp, X_("activate_all"), _("Activate all"),
+ ActionManager::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"),
+ ActionManager::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"),
sigc::ptr_fun (ProcessorBox::rb_ab_plugins));
return;
}
- _current_processor_box->cut_processors ();
+ _current_processor_box->processor_operation (ProcessorsCut);
}
void
return;
}
- _current_processor_box->delete_processors ();
+ _current_processor_box->processor_operation (ProcessorsDelete);
}
void
if (_current_processor_box == 0) {
return;
}
- _current_processor_box->copy_processors ();
+ _current_processor_box->processor_operation (ProcessorsCopy);
}
void
return;
}
- _current_processor_box->paste_processors ();
+ _current_processor_box->processor_operation (ProcessorsPaste);
}
void
return;
}
- _current_processor_box->select_all_processors ();
+ _current_processor_box->processor_operation (ProcessorsSelectAll);
}
void
return;
}
- _current_processor_box->all_processors_active (true);
+ _current_processor_box->all_visible_processors_active (true);
}
void
if (_current_processor_box == 0) {
return;
}
- _current_processor_box->all_processors_active (false);
+ _current_processor_box->all_visible_processors_active (false);
}
void
}
}
+void
+ProcessorBox::processor_menu_unmapped ()
+{
+ processor_display.remove_placeholder ();
+}
+
ProcessorWindowProxy::ProcessorWindowProxy (
string const & name,
XMLNode const * node,
projects / ardour.git / blobdiff