*/
+#ifdef WAF_BUILD
+#include "gtk2ardour-config.h"
+#endif
+
#include <cmath>
#include <iostream>
#include <set>
#include "ardour/audio_diskstream.h"
#include "ardour/audio_track.h"
#include "ardour/audioengine.h"
+#include "ardour/internal_send.h"
#include "ardour/ladspa_plugin.h"
#include "ardour/meter.h"
#include "ardour/plugin_insert.h"
#include "io_selector.h"
#include "keyboard.h"
#include "mixer_ui.h"
+#include "mixer_strip.h"
#include "plugin_selector.h"
#include "plugin_ui.h"
#include "processor_box.h"
Gdk::Color* ProcessorBox::active_processor_color;
Gdk::Color* ProcessorBox::inactive_processor_color;
-ProcessorBox::ProcessorBox (Placement pcmnt, Session& sess, PluginSelector &plugsel,
- RouteRedirectSelection & rsel, bool owner_is_mixer)
+ProcessorBox::ProcessorBox (Session& sess, PluginSelector &plugsel,
+ RouteRedirectSelection & rsel, MixerStrip* parent, bool owner_is_mixer)
: _session(sess)
+ , _parent_strip (parent)
, _owner_is_mixer (owner_is_mixer)
- , _placement(pcmnt)
+ , _placement(PreFader)
, _plugin_selector(plugsel)
, _rr_selection(rsel)
{
RefPtr<TreeSelection> selection = processor_display.get_selection();
selection->set_mode (Gtk::SELECTION_MULTIPLE);
selection->signal_changed().connect (mem_fun (*this, &ProcessorBox::selection_changed));
-
+
+ processor_display.set_data ("processorbox", this);
processor_display.set_model (model);
processor_display.append_column (X_("notshown"), columns.text);
processor_display.set_name ("ProcessorSelector");
processor_display.get_column(0)->set_sizing(TREE_VIEW_COLUMN_FIXED);
processor_display.get_column(0)->set_fixed_width(48);
processor_display.add_object_drag (columns.processor.index(), "processors");
+ processor_display.set_enable_search (false);
processor_display.signal_drop.connect (mem_fun (*this, &ProcessorBox::object_drop));
TreeViewColumn* name_col = processor_display.get_column(0);
pack_start (processor_eventbox, true, true);
- processor_eventbox.signal_enter_notify_event().connect (bind (
- sigc::ptr_fun (ProcessorBox::enter_box),
- this));
+ processor_display.signal_enter_notify_event().connect (mem_fun(*this, &ProcessorBox::enter_notify), false);
+ processor_display.signal_leave_notify_event().connect (mem_fun(*this, &ProcessorBox::leave_notify), false);
+
+ processor_display.signal_key_press_event().connect (mem_fun(*this, &ProcessorBox::processor_key_press_event));
+ processor_display.signal_key_release_event().connect (mem_fun(*this, &ProcessorBox::processor_key_release_event));
processor_display.signal_button_press_event().connect (
- mem_fun(*this, &ProcessorBox::processor_button_press_event), false);
+ mem_fun(*this, &ProcessorBox::processor_button_press_event), false);
processor_display.signal_button_release_event().connect (
- mem_fun(*this, &ProcessorBox::processor_button_release_event));
+ mem_fun(*this, &ProcessorBox::processor_button_release_event));
}
ProcessorBox::~ProcessorBox ()
void
-ProcessorBox::object_drop (const list<boost::shared_ptr<Processor> >& procs)
+ProcessorBox::object_drop (const list<boost::shared_ptr<Processor> >& procs, Gtk::TreeView* source, int x, int y, Glib::RefPtr<Gdk::DragContext>& context)
{
- for (std::list<boost::shared_ptr<Processor> >::const_iterator i = procs.begin();
- i != procs.end(); ++i) {
+ TreeIter iter;
+ TreeModel::Path path;
+ TreeViewColumn* column;
+ int cellx;
+ int celly;
+ boost::shared_ptr<Processor> p;
+
+ if (processor_display.get_path_at_pos (x, y, path, column, cellx, celly)) {
+ if ((iter = model->get_iter (path))) {
+ p = (*iter)[columns.processor];
+ }
+ }
+
+ for (list<boost::shared_ptr<Processor> >::const_iterator i = procs.begin(); i != procs.end(); ++i) {
XMLNode& state = (*i)->get_state ();
XMLNodeList nlist;
nlist.push_back (&state);
- paste_processor_state (nlist);
+ paste_processor_state (nlist, p);
delete &state;
}
+
+ /* since the treeview doesn't take care of this properly, we have to delete the originals
+ ourselves.
+ */
+
+ 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);
+ }
+ }
+
+ context->drag_finish (true, (context->get_suggested_action() == Gdk::ACTION_MOVE), 0);
}
void
processor_drag_in_progress = false;
}
+bool
+ProcessorBox::enter_notify (GdkEventCrossing* ev)
+{
+ _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 *ev)
+{
+ /* do real stuff on key release */
+ return false;
+}
+
+bool
+ProcessorBox::processor_key_release_event (GdkEventKey *ev)
+{
+ bool ret = false;
+ ProcSelection targets;
+
+ get_selected_processors (targets);
+
+ if (targets.empty()) {
+
+ int x, y;
+ TreeIter iter;
+ TreeModel::Path path;
+ TreeViewColumn* column;
+ int cellx;
+ int celly;
+
+ processor_display.get_pointer (x, y);
+
+ if (processor_display.get_path_at_pos (x, y, path, column, cellx, celly)) {
+ if ((iter = model->get_iter (path))) {
+ targets.push_back ((*iter)[columns.processor]);
+ }
+ }
+ }
+
+
+ switch (ev->keyval) {
+ case GDK_c:
+ if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
+ copy_processors (targets);
+ }
+ break;
+
+ case GDK_x:
+ if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
+ 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());
+ }
+ }
+ break;
+
+ case GDK_Delete:
+ case GDK_BackSpace:
+ delete_processors (targets);
+ ret = true;
+ break;
+
+ case GDK_slash:
+ for (ProcSelection::iterator i = targets.begin(); i != targets.end(); ++i) {
+ if ((*i)->active()) {
+ (*i)->deactivate ();
+ } else {
+ (*i)->activate ();
+ }
+ }
+ ret = true;
+ break;
+
+ default:
+ break;
+ }
+
+ return ret;
+}
+
bool
ProcessorBox::processor_button_press_event (GdkEventButton *ev)
{
} else if (processor && ev->button == 1 && selected) {
- // this is purely informational but necessary
+ // this is purely informational but necessary for route params UI
ProcessorSelected (processor); // emit
} else if (!processor && ev->button == 1 && ev->type == GDK_2BUTTON_PRESS) {
boost::shared_ptr<Processor> processor;
int ret = false;
-
if (processor_display.get_path_at_pos ((int)ev->x, (int)ev->y, path, column, cellx, celly)) {
if ((iter = model->get_iter (path))) {
processor = (*iter)[columns.processor];
} else if (Keyboard::is_context_menu_event (ev)) {
- show_processor_menu(ev->time);
+ /* 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);
ret = true;
} else if (processor && Keyboard::is_button2_event (ev)
processor->activate ();
}
- assign_default_sort_key (processor);
-
- if (_route->add_processor (processor, &err_streams)) {
- weird_plugin_dialog (**p, err_streams, _route);
+ if (_route->add_processor (processor, _placement, &err_streams)) {
+ weird_plugin_dialog (**p, err_streams);
// XXX SHAREDPTR delete plugin here .. do we even need to care?
} else {
}
void
-ProcessorBox::weird_plugin_dialog (Plugin& p, Route::ProcessorStreams streams, boost::shared_ptr<IO> io)
+ProcessorBox::weird_plugin_dialog (Plugin& p, Route::ProcessorStreams streams)
{
ArdourDialog dialog (_("ardour: weird plugin dialog"));
Label label;
void
ProcessorBox::choose_insert ()
{
- boost::shared_ptr<Processor> processor (new PortInsert (_session));
- processor->ActiveChanged.connect (bind (
- mem_fun(*this, &ProcessorBox::show_processor_active),
- boost::weak_ptr<Processor>(processor)));
+ boost::shared_ptr<Processor> processor (new PortInsert (_session, _route->mute_master()));
+ processor->ActiveChanged.connect (bind (mem_fun(*this, &ProcessorBox::show_processor_active),
+ boost::weak_ptr<Processor>(processor)));
- assign_default_sort_key (processor);
- _route->add_processor (processor);
+ _route->add_processor (processor, _placement);
}
void
ProcessorBox::choose_send ()
{
- boost::shared_ptr<Send> send (new Send (_session));
+ boost::shared_ptr<Send> send (new Send (_session, _route->mute_master()));
/* make an educated guess at the initial number of outputs for the send */
ChanCount outs = (_session.master_out())
/* XXX need processor lock on route */
try {
- send->io()->ensure_io (ChanCount::ZERO, outs, false, this);
+ send->output()->ensure_io (outs, false, this);
} catch (AudioEngine::PortRegistrationFailure& err) {
error << string_compose (_("Cannot set up new send: %1"), err.what()) << endmsg;
return;
}
/* let the user adjust the IO setup before creation */
- IOSelectorWindow *ios = new IOSelectorWindow (_session, send->io(), false, true);
+ IOSelectorWindow *ios = new IOSelectorWindow (_session, send->output(), true);
ios->show_all ();
/* keep a reference to the send so it doesn't get deleted while
break;
case IOSelector::Accepted:
- assign_default_sort_key (processor);
- _route->add_processor (processor);
+ _route->add_processor (processor, _placement);
if (Profile->get_sae()) {
processor->activate ();
}
/* XXX need processor lock on route */
try {
- retrn->io()->ensure_io (ins, ChanCount::ZERO, false, this);
+ retrn->input()->ensure_io (ins, false, this);
} catch (AudioEngine::PortRegistrationFailure& err) {
error << string_compose (_("Cannot set up new return: %1"), err.what()) << endmsg;
return;
}
/* let the user adjust the IO setup before creation */
- IOSelectorWindow *ios = new IOSelectorWindow (_session, retrn->io(), true, true);
+ IOSelectorWindow *ios = new IOSelectorWindow (_session, retrn->output(), true);
ios->show_all ();
/* keep a reference to the send so it doesn't get deleted while
break;
case IOSelector::Accepted:
- assign_default_sort_key (processor);
- _route->add_processor (processor);
+ _route->add_processor (processor, _placement);
if (Profile->get_sae()) {
processor->activate ();
}
processor_active_connections.clear ();
processor_name_connections.clear ();
- _route->foreach_processor (_placement, mem_fun (*this, &ProcessorBox::add_processor_to_display));
+ _route->foreach_processor (mem_fun (*this, &ProcessorBox::add_processor_to_display));
- switch (_placement) {
- case PreFader:
- build_processor_tooltip (processor_eventbox, _("Pre-fader inserts, sends & plugins:"));
- break;
- case PostFader:
- build_processor_tooltip (processor_eventbox, _("Post-fader inserts, sends & plugins:"));
- break;
- }
+ build_processor_tooltip (processor_eventbox, _("Inserts, sends & plugins:"));
}
void
return;
}
- if (processor == _route->amp()) {
+ if (!processor->visible()) {
return;
}
name_display = " (";
}
- if ((send = boost::dynamic_pointer_cast<Send> (processor)) != 0) {
+ if ((send = boost::dynamic_pointer_cast<Send> (processor)) != 0 &&
+ !boost::dynamic_pointer_cast<InternalSend>(processor)) {
name_display += '>';
string::size_type lbracket, rbracket;
lbracket = send->name().find ('[');
rbracket = send->name().find (']');
-
+
switch (_width) {
case Wide:
name_display += send->name().substr (lbracket+1, lbracket-rbracket-1);
switch (_width) {
case Wide:
- name_display += processor->name();
+ name_display += processor->display_name();
break;
case Narrow:
- name_display += PBD::short_version (processor->name(), 5);
+ name_display += PBD::short_version (processor->display_name(), 5);
break;
}
void
ProcessorBox::compute_processor_sort_keys ()
{
- uint32_t sort_key;
Gtk::TreeModel::Children children = model->children();
-
- if (_placement == PreFader) {
- sort_key = 0;
- } else {
- sort_key = _route->fader_sort_key() + 1;
- }
+ Route::ProcessorList our_processors;
for (Gtk::TreeModel::Children::iterator iter = children.begin(); iter != children.end(); ++iter) {
- boost::shared_ptr<Processor> r = (*iter)[columns.processor];
- r->set_sort_key (sort_key);
- sort_key++;
+ boost::shared_ptr<Processor> p = (*iter)[columns.processor];
+ our_processors.push_back ((*iter)[columns.processor]);
}
- if (_route->sort_processors ()) {
+ if (_route->reorder_processors (our_processors)) {
+
+ /* reorder failed, so redisplay */
redisplay_processors ();
ProcessorBox::cut_processors ()
{
ProcSelection to_be_removed;
- XMLNode* node = new XMLNode (X_("cut"));
get_selected_processors (to_be_removed);
+}
+void
+ProcessorBox::cut_processors (const ProcSelection& to_be_removed)
+{
if (to_be_removed.empty()) {
return;
}
+ XMLNode* node = new XMLNode (X_("cut"));
+ Route::ProcessorList to_cut;
+
no_processor_redisplay = true;
- for (ProcSelection::iterator i = to_be_removed.begin(); i != to_be_removed.end(); ++i) {
- // Do not cut inserts
+ for (ProcSelection::const_iterator i = to_be_removed.begin(); i != to_be_removed.end(); ++i) {
+ // Cut only plugins, sends and returns
if (boost::dynamic_pointer_cast<PluginInsert>((*i)) != 0 ||
- (boost::dynamic_pointer_cast<Send>((*i)) != 0)) {
+ (boost::dynamic_pointer_cast<Send>((*i)) != 0) ||
+ (boost::dynamic_pointer_cast<Return>((*i)) != 0)) {
void* gui = (*i)->get_gui ();
}
XMLNode& child ((*i)->get_state());
-
- if (_route->remove_processor (*i) == 0) {
- /* success */
- node->add_child_nocopy (child);
- } else {
- delete &child;
- }
+ node->add_child_nocopy (child);
+ to_cut.push_back (*i);
}
}
+
+ if (_route->remove_processors (to_cut) != 0) {
+ delete node;
+ no_processor_redisplay = false;
+ return;
+ }
_rr_selection.set (node);
ProcessorBox::copy_processors ()
{
ProcSelection to_be_copied;
- XMLNode* node = new XMLNode (X_("copy"));
-
get_selected_processors (to_be_copied);
+ copy_processors (to_be_copied);
+}
+void
+ProcessorBox::copy_processors (const ProcSelection& to_be_copied)
+{
if (to_be_copied.empty()) {
return;
}
- for (ProcSelection::iterator i = to_be_copied.begin(); i != to_be_copied.end(); ++i) {
- // Do not copy inserts
+ XMLNode* node = new XMLNode (X_("copy"));
+
+ for (ProcSelection::const_iterator i = to_be_copied.begin(); i != to_be_copied.end(); ++i) {
+ // Copy only plugins, sends, returns
if (boost::dynamic_pointer_cast<PluginInsert>((*i)) != 0 ||
- (boost::dynamic_pointer_cast<Send>((*i)) != 0)) {
+ (boost::dynamic_pointer_cast<Send>((*i)) != 0) ||
+ (boost::dynamic_pointer_cast<Return>((*i)) != 0)) {
node->add_child_nocopy ((*i)->get_state());
}
}
ProcessorBox::delete_processors ()
{
ProcSelection to_be_deleted;
-
get_selected_processors (to_be_deleted);
+ delete_processors (to_be_deleted);
+}
- if (to_be_deleted.empty()) {
+void
+ProcessorBox::delete_processors (const ProcSelection& targets)
+{
+ if (targets.empty()) {
return;
}
- for (ProcSelection::iterator i = to_be_deleted.begin(); i != to_be_deleted.end(); ++i) {
+ no_processor_redisplay = true;
+
+ for (ProcSelection::const_iterator i = targets.begin(); i != targets.end(); ++i) {
void* gui = (*i)->get_gui ();
redisplay_processors ();
}
+void
+ProcessorBox::delete_dragged_processors (const list<boost::shared_ptr<Processor> >& procs)
+{
+ list<boost::shared_ptr<Processor> >::const_iterator x;
+
+ no_processor_redisplay = true;
+ for (x = procs.begin(); x != procs.end(); ++x) {
+
+ void* gui = (*x)->get_gui ();
+
+ if (gui) {
+ static_cast<Gtk::Widget*>(gui)->hide ();
+ }
+
+ _route->remove_processor(*x);
+ }
+
+ no_processor_redisplay = false;
+ redisplay_processors ();
+}
+
gint
ProcessorBox::idle_delete_processor (boost::weak_ptr<Processor> weak_processor)
{
return;
}
- cerr << "paste from node called " << _rr_selection.processors.get_node().name() << endl;
+ paste_processor_state (_rr_selection.processors.get_node().children(), boost::shared_ptr<Processor>());
+}
+
+void
+ProcessorBox::paste_processors (boost::shared_ptr<Processor> before)
+{
+
+ if (_rr_selection.processors.empty()) {
+ return;
+ }
- paste_processor_state (_rr_selection.processors.get_node().children());
+ paste_processor_state (_rr_selection.processors.get_node().children(), before);
}
void
-ProcessorBox::paste_processor_state (const XMLNodeList& nlist)
+ProcessorBox::paste_processor_state (const XMLNodeList& nlist, boost::shared_ptr<Processor> p)
{
XMLNodeConstIterator niter;
list<boost::shared_ptr<Processor> > copies;
- cerr << "Pasting processor selection containing " << nlist.size() << endl;
-
if (nlist.empty()) {
return;
}
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
- cerr << "try using " << (*niter)->name() << endl;
+
XMLProperty const * type = (*niter)->property ("type");
assert (type);
boost::shared_ptr<Processor> p;
try {
- if (type->value() == "send") {
+ if (type->value() == "meter" ||
+ type->value() == "main-outs" ||
+ type->value() == "amp" ||
+ type->value() == "intsend" || type->value() == "intreturn") {
+ /* do not paste meter, main outs, amp or internal send/returns */
+ continue;
+
+ } else if (type->value() == "send") {
+
XMLNode n (**niter);
Send::make_unique (n, _session);
- p.reset (new Send (_session, n));
-
- } else if (type->value() == "meter") {
- p = _route->shared_peak_meter();
+ p.reset (new Send (_session, _route->mute_master(), n));
- } else if (type->value() == "main-outs") {
- /* do not copy-n-paste main outs */
- continue;
-
- } else if (type->value() == "amp") {
- /* do not copy-n-paste amp */
- continue;
+ } else if (type->value() == "return") {
- } else if (type->value() == "listen") {
- p.reset (new Delivery (_session, **niter));
+ XMLNode n (**niter);
+ Return::make_unique (n, _session);
+ p.reset (new Return (_session, **niter));
} else {
+ /* XXX its a bit limiting to assume that everything else
+ is a plugin.
+ */
p.reset (new PluginInsert (_session, **niter));
}
copies.push_back (p);
}
+
catch (...) {
cerr << "plugin insert constructor failed\n";
}
return;
}
- assign_default_sort_key (copies.front());
-
- if (_route->add_processors (copies, 0, copies.front()->sort_key())) {
+ if (_route->add_processors (copies, p)) {
string msg = _(
"Copying the set of processors on the clipboard failed,\n\
string prompt;
vector<string> choices;
- if (boost::dynamic_pointer_cast<AudioTrack>(_route) != 0) {
- if (_placement == PreFader) {
- prompt = _("Do you really want to remove all pre-fader processors from this track?\n"
- "(this cannot be undone)");
- } else {
- prompt = _("Do you really want to remove all post-fader processors from this track?\n"
- "(this cannot be undone)");
- }
+ prompt = string_compose (_("Do you really want to remove all processors from %1?\n"
+ "(this cannot be undone)"), _route->name());
+
+ choices.push_back (_("Cancel"));
+ choices.push_back (_("Yes, remove them all"));
+
+ Gtkmm2ext::Choice prompter (prompt, choices);
+
+ if (prompter.run () == 1) {
+ _route->clear_processors (PreFader);
+ _route->clear_processors (PostFader);
+ }
+}
+
+void
+ProcessorBox::clear_processors (Placement p)
+{
+ string prompt;
+ vector<string> choices;
+
+ if (p == PreFader) {
+ prompt = string_compose (_("Do you really want to remove all pre-fader processors from %1?\n"
+ "(this cannot be undone)"), _route->name());
} else {
- if (_placement == PreFader) {
- prompt = _("Do you really want to remove all pre-fader processors from this bus?\n"
- "(this cannot be undone)");
- } else {
- prompt = _("Do you really want to remove all post-fader processors from this bus?\n"
- "(this cannot be undone)");
- }
+ prompt = string_compose (_("Do you really want to remove all post-fader processors from %1?\n"
+ "(this cannot be undone)"), _route->name());
}
choices.push_back (_("Cancel"));
Gtkmm2ext::Choice prompter (prompt, choices);
if (prompter.run () == 1) {
- _route->clear_processors (_placement);
+ _route->clear_processors (p);
}
}
return;
}
- boost::shared_ptr<Send> send = boost::dynamic_pointer_cast<Send> (processor);
-
+#ifdef OLD_SEND_EDITING
SendUIWindow *send_ui;
if (send->get_gui() == 0) {
-
send_ui = new SendUIWindow (send, _session);
WindowTitle title(Glib::get_application_name());
}
gidget = send_ui;
+#else
+ if (_parent_strip) {
+ _parent_strip->gain_meter().set_controls (_route, send->meter(), send->amp()->gain_control(), send->amp());
+ _parent_strip->panner_ui().set_panner (send->panner());
+ }
+#endif
} else if ((retrn = boost::dynamic_pointer_cast<Return> (processor)) != 0) {
}
}
-bool
-ProcessorBox::enter_box (GdkEventCrossing *ev, ProcessorBox* rb)
-{
- switch (ev->detail) {
- case GDK_NOTIFY_INFERIOR:
- break;
-
- case GDK_NOTIFY_VIRTUAL:
- /* fallthru */
-
- default:
- _current_processor_box = rb;
- }
-
- return false;
-}
-
void
ProcessorBox::register_actions ()
{
sigc::ptr_fun (ProcessorBox::rb_choose_return));
ActionManager::jack_sensitive_actions.push_back (act);
- ActionManager::register_action (popup_act_grp, X_("clear"), _("Clear"),
+ ActionManager::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)"),
+ sigc::ptr_fun (ProcessorBox::rb_clear_pre));
+ ActionManager::register_action (popup_act_grp, X_("clear_post"), _("Clear (post-fader)"),
+ sigc::ptr_fun (ProcessorBox::rb_clear_post));
/* standard editing stuff */
act = ActionManager::register_action (popup_act_grp, X_("cut"), _("Cut"),
_current_processor_box->clear_processors ();
}
+
+void
+ProcessorBox::rb_clear_pre ()
+{
+ if (_current_processor_box == 0) {
+ return;
+ }
+
+ _current_processor_box->clear_processors (PreFader);
+}
+
+
+void
+ProcessorBox::rb_clear_post ()
+{
+ if (_current_processor_box == 0) {
+ return;
+ }
+
+ _current_processor_box->clear_processors (PostFader);
+}
+
void
ProcessorBox::rb_cut ()
{
return string_compose(_("%1: %2 (by %3)"), _route->name(), pi->name(), maker);
}
-void
-ProcessorBox::assign_default_sort_key (boost::shared_ptr<Processor> p)
-{
- p->set_sort_key (_placement == PreFader ? 0 : 9999);
- cerr << "default sort key for "
- << _placement << " = " << p->sort_key()
- << endl;
-}
-
projects / ardour.git / blobdiff