2007-06-27 16:23:48 -04:00
|
|
|
/*
|
|
|
|
Copyright (C) 2000-2004 Paul Davis
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
2009-07-12 20:26:28 -04:00
|
|
|
#ifdef WAF_BUILD
|
|
|
|
#include "gtk2ardour-config.h"
|
|
|
|
#endif
|
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
#include <cmath>
|
|
|
|
#include <iostream>
|
2008-09-10 11:03:30 -04:00
|
|
|
#include <set>
|
2007-06-27 16:23:48 -04:00
|
|
|
|
|
|
|
#include <sigc++/bind.h>
|
|
|
|
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/convert.h"
|
2007-06-27 16:23:48 -04:00
|
|
|
|
|
|
|
#include <glibmm/miscutils.h>
|
|
|
|
|
|
|
|
#include <gtkmm/messagedialog.h>
|
|
|
|
|
|
|
|
#include <gtkmm2ext/gtk_ui.h>
|
|
|
|
#include <gtkmm2ext/utils.h>
|
|
|
|
#include <gtkmm2ext/choice.h>
|
|
|
|
#include <gtkmm2ext/utils.h>
|
|
|
|
#include <gtkmm2ext/stop_signal.h>
|
|
|
|
#include <gtkmm2ext/doi.h>
|
|
|
|
#include <gtkmm2ext/window_title.h>
|
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
#include "ardour/amp.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/ardour.h"
|
|
|
|
#include "ardour/audio_diskstream.h"
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
#include "ardour/audio_track.h"
|
|
|
|
#include "ardour/audioengine.h"
|
2009-07-14 20:47:34 -04:00
|
|
|
#include "ardour/internal_send.h"
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
#include "ardour/ladspa_plugin.h"
|
|
|
|
#include "ardour/meter.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/plugin_insert.h"
|
|
|
|
#include "ardour/port_insert.h"
|
|
|
|
#include "ardour/profile.h"
|
2009-05-07 13:31:18 -04:00
|
|
|
#include "ardour/return.h"
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
#include "ardour/route.h"
|
|
|
|
#include "ardour/send.h"
|
|
|
|
#include "ardour/session.h"
|
2007-06-27 16:23:48 -04:00
|
|
|
|
2009-05-07 13:31:18 -04:00
|
|
|
#include "actions.h"
|
2007-06-27 16:23:48 -04:00
|
|
|
#include "ardour_dialog.h"
|
2009-05-07 13:31:18 -04:00
|
|
|
#include "ardour_ui.h"
|
|
|
|
#include "gui_thread.h"
|
|
|
|
#include "io_selector.h"
|
2007-06-27 16:23:48 -04:00
|
|
|
#include "keyboard.h"
|
|
|
|
#include "mixer_ui.h"
|
2009-05-16 22:08:13 -04:00
|
|
|
#include "mixer_strip.h"
|
2009-05-07 13:31:18 -04:00
|
|
|
#include "plugin_selector.h"
|
2007-06-27 16:23:48 -04:00
|
|
|
#include "plugin_ui.h"
|
2009-05-07 13:31:18 -04:00
|
|
|
#include "processor_box.h"
|
|
|
|
#include "public_editor.h"
|
|
|
|
#include "return_ui.h"
|
|
|
|
#include "route_processor_selection.h"
|
|
|
|
#include "send_ui.h"
|
2007-06-27 16:23:48 -04:00
|
|
|
#include "utils.h"
|
|
|
|
|
|
|
|
#include "i18n.h"
|
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
#ifdef HAVE_AUDIOUNITS
|
|
|
|
class AUPluginUI;
|
2007-06-27 16:23:48 -04:00
|
|
|
#endif
|
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
using namespace std;
|
2007-06-27 16:23:48 -04:00
|
|
|
using namespace sigc;
|
|
|
|
using namespace ARDOUR;
|
|
|
|
using namespace PBD;
|
|
|
|
using namespace Gtk;
|
|
|
|
using namespace Glib;
|
|
|
|
using namespace Gtkmm2ext;
|
|
|
|
|
|
|
|
ProcessorBox* ProcessorBox::_current_processor_box = 0;
|
|
|
|
RefPtr<Action> ProcessorBox::paste_action;
|
|
|
|
bool ProcessorBox::get_colors = true;
|
|
|
|
Gdk::Color* ProcessorBox::active_processor_color;
|
|
|
|
Gdk::Color* ProcessorBox::inactive_processor_color;
|
|
|
|
|
2009-07-12 20:26:28 -04:00
|
|
|
ProcessorBox::ProcessorBox (Session& sess, PluginSelector &plugsel,
|
2009-05-16 22:08:13 -04:00
|
|
|
RouteRedirectSelection & rsel, MixerStrip* parent, bool owner_is_mixer)
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
: _session(sess)
|
2009-05-16 22:08:13 -04:00
|
|
|
, _parent_strip (parent)
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
, _owner_is_mixer (owner_is_mixer)
|
2009-07-12 20:26:28 -04:00
|
|
|
, _placement(PreFader)
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
, _plugin_selector(plugsel)
|
|
|
|
, _rr_selection(rsel)
|
2007-06-27 16:23:48 -04:00
|
|
|
{
|
|
|
|
if (get_colors) {
|
|
|
|
active_processor_color = new Gdk::Color;
|
|
|
|
inactive_processor_color = new Gdk::Color;
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
set_color (*active_processor_color, rgba_from_style (
|
|
|
|
"ProcessorSelector", 0xff, 0, 0, 0, "fg", Gtk::STATE_ACTIVE, false ));
|
|
|
|
set_color (*inactive_processor_color, rgba_from_style (
|
|
|
|
"ProcessorSelector", 0xff, 0, 0, 0, "fg", Gtk::STATE_NORMAL, false ));
|
2007-06-27 16:23:48 -04:00
|
|
|
get_colors = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
_width = Wide;
|
|
|
|
processor_menu = 0;
|
|
|
|
send_action_menu = 0;
|
|
|
|
processor_drag_in_progress = false;
|
|
|
|
no_processor_redisplay = false;
|
|
|
|
ignore_delete = false;
|
|
|
|
|
|
|
|
model = ListStore::create(columns);
|
|
|
|
|
|
|
|
RefPtr<TreeSelection> selection = processor_display.get_selection();
|
|
|
|
selection->set_mode (Gtk::SELECTION_MULTIPLE);
|
|
|
|
selection->signal_changed().connect (mem_fun (*this, &ProcessorBox::selection_changed));
|
2009-05-15 22:51:17 -04:00
|
|
|
|
|
|
|
processor_display.set_data ("processorbox", this);
|
2007-06-27 16:23:48 -04:00
|
|
|
processor_display.set_model (model);
|
|
|
|
processor_display.append_column (X_("notshown"), columns.text);
|
2008-09-10 11:03:30 -04:00
|
|
|
processor_display.set_name ("ProcessorSelector");
|
2007-06-27 16:23:48 -04:00
|
|
|
processor_display.set_headers_visible (false);
|
|
|
|
processor_display.set_reorderable (true);
|
|
|
|
processor_display.set_size_request (-1, 40);
|
|
|
|
processor_display.get_column(0)->set_sizing(TREE_VIEW_COLUMN_FIXED);
|
|
|
|
processor_display.get_column(0)->set_fixed_width(48);
|
2008-09-10 11:03:30 -04:00
|
|
|
processor_display.add_object_drag (columns.processor.index(), "processors");
|
2009-07-13 19:09:16 -04:00
|
|
|
processor_display.set_enable_search (false);
|
2008-12-12 09:43:24 -05:00
|
|
|
processor_display.signal_drop.connect (mem_fun (*this, &ProcessorBox::object_drop));
|
2007-06-27 16:23:48 -04:00
|
|
|
|
|
|
|
TreeViewColumn* name_col = processor_display.get_column(0);
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
CellRendererText* renderer = dynamic_cast<CellRendererText*>(
|
|
|
|
processor_display.get_column_cell_renderer (0));
|
2007-06-27 16:23:48 -04:00
|
|
|
name_col->add_attribute(renderer->property_foreground_gdk(), columns.color);
|
|
|
|
|
|
|
|
processor_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
model->signal_row_deleted().connect (mem_fun (*this, &ProcessorBox::row_deleted));
|
|
|
|
|
|
|
|
processor_scroller.add (processor_display);
|
|
|
|
processor_eventbox.add (processor_scroller);
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
processor_scroller.set_size_request (-1, 40);
|
|
|
|
|
|
|
|
pack_start (processor_eventbox, true, true);
|
|
|
|
|
2009-07-13 19:09:16 -04:00
|
|
|
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));
|
2007-06-27 16:23:48 -04:00
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
processor_display.signal_button_press_event().connect (
|
2009-07-13 19:09:16 -04:00
|
|
|
mem_fun(*this, &ProcessorBox::processor_button_press_event), false);
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
processor_display.signal_button_release_event().connect (
|
2009-07-13 19:09:16 -04:00
|
|
|
mem_fun(*this, &ProcessorBox::processor_button_release_event));
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
ProcessorBox::~ProcessorBox ()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2008-12-08 11:07:28 -05:00
|
|
|
void
|
|
|
|
ProcessorBox::set_route (boost::shared_ptr<Route> r)
|
|
|
|
{
|
|
|
|
connections.clear ();
|
|
|
|
|
|
|
|
_route = r;
|
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
connections.push_back (_route->processors_changed.connect (
|
|
|
|
mem_fun(*this, &ProcessorBox::redisplay_processors)));
|
|
|
|
connections.push_back (_route->GoingAway.connect (
|
|
|
|
mem_fun (*this, &ProcessorBox::route_going_away)));
|
|
|
|
connections.push_back (_route->NameChanged.connect (
|
|
|
|
mem_fun(*this, &ProcessorBox::route_name_changed)));
|
2008-12-08 11:07:28 -05:00
|
|
|
|
|
|
|
redisplay_processors ();
|
|
|
|
}
|
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
void
|
|
|
|
ProcessorBox::route_going_away ()
|
|
|
|
{
|
|
|
|
/* don't keep updating display as processors are deleted */
|
|
|
|
no_processor_redisplay = true;
|
|
|
|
}
|
|
|
|
|
2008-12-12 09:43:24 -05:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
void
|
2009-07-15 16:29:02 -04:00
|
|
|
ProcessorBox::object_drop (const list<boost::shared_ptr<Processor> >& procs, Gtk::TreeView* source, int x, int y, Glib::RefPtr<Gdk::DragContext>& context)
|
2007-06-27 16:23:48 -04:00
|
|
|
{
|
2009-07-15 16:29:02 -04:00
|
|
|
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];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-15 22:51:17 -04:00
|
|
|
for (list<boost::shared_ptr<Processor> >::const_iterator i = procs.begin(); i != procs.end(); ++i) {
|
2009-02-14 14:45:30 -05:00
|
|
|
XMLNode& state = (*i)->get_state ();
|
|
|
|
XMLNodeList nlist;
|
|
|
|
nlist.push_back (&state);
|
2009-07-15 16:29:02 -04:00
|
|
|
paste_processor_state (nlist, p);
|
2009-02-14 14:45:30 -05:00
|
|
|
delete &state;
|
|
|
|
}
|
2009-05-15 22:51:17 -04:00
|
|
|
|
|
|
|
/* 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);
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::update()
|
|
|
|
{
|
|
|
|
redisplay_processors ();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::set_width (Width w)
|
|
|
|
{
|
|
|
|
if (_width == w) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
_width = w;
|
|
|
|
|
|
|
|
redisplay_processors ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::remove_processor_gui (boost::shared_ptr<Processor> processor)
|
|
|
|
{
|
|
|
|
boost::shared_ptr<Send> send;
|
2009-05-07 13:31:18 -04:00
|
|
|
boost::shared_ptr<Return> retrn;
|
2008-09-10 11:03:30 -04:00
|
|
|
boost::shared_ptr<PortInsert> port_insert;
|
|
|
|
|
|
|
|
if ((port_insert = boost::dynamic_pointer_cast<PortInsert> (processor)) != 0) {
|
|
|
|
PortInsertUI *io_selector = reinterpret_cast<PortInsertUI *> (port_insert->get_gui());
|
|
|
|
port_insert->set_gui (0);
|
|
|
|
delete io_selector;
|
2007-06-27 16:23:48 -04:00
|
|
|
} else if ((send = boost::dynamic_pointer_cast<Send> (processor)) != 0) {
|
|
|
|
SendUIWindow *sui = reinterpret_cast<SendUIWindow*> (send->get_gui());
|
|
|
|
send->set_gui (0);
|
|
|
|
delete sui;
|
2009-05-07 13:31:18 -04:00
|
|
|
} else if ((retrn = boost::dynamic_pointer_cast<Return> (processor)) != 0) {
|
|
|
|
ReturnUIWindow *rui = reinterpret_cast<ReturnUIWindow*> (retrn->get_gui());
|
|
|
|
retrn->set_gui (0);
|
|
|
|
delete rui;
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
void
|
2007-06-27 16:23:48 -04:00
|
|
|
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"), mem_fun(*this, &ProcessorBox::new_send)));
|
|
|
|
items.push_back (MenuElem (_("Show send controls"), mem_fun(*this, &ProcessorBox::show_send_controls)));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::show_send_controls ()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::new_send ()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::show_processor_menu (gint arg)
|
|
|
|
{
|
|
|
|
if (processor_menu == 0) {
|
|
|
|
processor_menu = build_processor_menu ();
|
|
|
|
}
|
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
Gtk::MenuItem* plugin_menu_item = dynamic_cast<Gtk::MenuItem*>(ActionManager::get_widget("/processormenu/newplugin"));
|
|
|
|
|
|
|
|
if (plugin_menu_item) {
|
|
|
|
plugin_menu_item->set_submenu (_plugin_selector.plugin_menu());
|
|
|
|
}
|
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
paste_action->set_sensitive (!_rr_selection.processors.empty());
|
|
|
|
|
|
|
|
processor_menu->popup (1, arg);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::processor_drag_begin (GdkDragContext *context)
|
|
|
|
{
|
|
|
|
processor_drag_in_progress = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::processor_drag_end (GdkDragContext *context)
|
|
|
|
{
|
|
|
|
processor_drag_in_progress = false;
|
|
|
|
}
|
|
|
|
|
2009-07-13 19:09:16 -04:00
|
|
|
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]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-15 16:29:02 -04:00
|
|
|
|
2009-07-13 19:09:16 -04:00
|
|
|
switch (ev->keyval) {
|
2009-07-15 16:29:02 -04:00
|
|
|
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;
|
|
|
|
|
2009-07-13 19:09:16 -04:00
|
|
|
case GDK_Delete:
|
|
|
|
case GDK_BackSpace:
|
2009-07-15 16:29:02 -04:00
|
|
|
delete_processors (targets);
|
2009-07-13 19:09:16 -04:00
|
|
|
ret = true;
|
|
|
|
break;
|
|
|
|
|
2009-07-13 21:24:16 -04:00
|
|
|
case GDK_slash:
|
2009-07-13 19:09:16 -04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
bool
|
|
|
|
ProcessorBox::processor_button_press_event (GdkEventButton *ev)
|
|
|
|
{
|
|
|
|
TreeIter iter;
|
|
|
|
TreeModel::Path path;
|
|
|
|
TreeViewColumn* column;
|
|
|
|
int cellx;
|
|
|
|
int celly;
|
|
|
|
boost::shared_ptr<Processor> processor;
|
|
|
|
int ret = false;
|
|
|
|
bool selected = 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];
|
|
|
|
selected = processor_display.get_selection()->is_selected (iter);
|
|
|
|
}
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (processor && (Keyboard::is_edit_event (ev) || (ev->button == 1 && ev->type == GDK_2BUTTON_PRESS))) {
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
if (_session.engine().connected()) {
|
|
|
|
/* XXX giving an error message here is hard, because we may be in the midst of a button press */
|
|
|
|
edit_processor (processor);
|
|
|
|
}
|
|
|
|
ret = true;
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
} else if (processor && ev->button == 1 && selected) {
|
|
|
|
|
2009-07-15 16:29:02 -04:00
|
|
|
// this is purely informational but necessary for route params UI
|
2008-09-10 11:03:30 -04:00
|
|
|
ProcessorSelected (processor); // emit
|
2008-12-12 09:43:24 -05:00
|
|
|
|
|
|
|
} else if (!processor && ev->button == 1 && ev->type == GDK_2BUTTON_PRESS) {
|
|
|
|
|
|
|
|
choose_plugin ();
|
|
|
|
_plugin_selector.show_manager ();
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
2008-12-12 09:43:24 -05:00
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ProcessorBox::processor_button_release_event (GdkEventButton *ev)
|
|
|
|
{
|
|
|
|
TreeIter iter;
|
|
|
|
TreeModel::Path path;
|
|
|
|
TreeViewColumn* column;
|
|
|
|
int cellx;
|
|
|
|
int celly;
|
|
|
|
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];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (processor && Keyboard::is_delete_event (ev)) {
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
|
|
|
Glib::signal_idle().connect (bind (
|
|
|
|
mem_fun(*this, &ProcessorBox::idle_delete_processor),
|
|
|
|
boost::weak_ptr<Processor>(processor)));
|
2007-06-27 16:23:48 -04:00
|
|
|
ret = true;
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
} else if (Keyboard::is_context_menu_event (ev)) {
|
|
|
|
|
2009-07-12 20:26:28 -04:00
|
|
|
/* 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);
|
2007-06-27 16:23:48 -04:00
|
|
|
ret = true;
|
|
|
|
|
2009-04-15 14:04:23 -04:00
|
|
|
} else if (processor && Keyboard::is_button2_event (ev)
|
|
|
|
#ifndef GTKOSX
|
|
|
|
&& (Keyboard::no_modifier_keys_pressed (ev) && ((ev->state & Gdk::BUTTON2_MASK) == Gdk::BUTTON2_MASK))
|
|
|
|
#endif
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
) {
|
2009-04-15 14:04:23 -04:00
|
|
|
|
|
|
|
/* button2-click with no/appropriate modifiers */
|
2008-09-10 11:03:30 -04:00
|
|
|
|
2009-01-30 02:40:13 -05:00
|
|
|
if (processor->active()) {
|
|
|
|
processor->deactivate ();
|
|
|
|
} else {
|
|
|
|
processor->activate ();
|
|
|
|
}
|
2007-06-27 16:23:48 -04:00
|
|
|
ret = true;
|
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
}
|
2007-06-27 16:23:48 -04:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
Menu *
|
|
|
|
ProcessorBox::build_processor_menu ()
|
|
|
|
{
|
2007-06-29 00:02:58 -04:00
|
|
|
processor_menu = dynamic_cast<Gtk::Menu*>(ActionManager::get_widget("/processormenu") );
|
2007-06-27 16:23:48 -04:00
|
|
|
processor_menu->set_name ("ArdourContextMenu");
|
|
|
|
|
|
|
|
show_all_children();
|
|
|
|
|
|
|
|
return processor_menu;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::selection_changed ()
|
|
|
|
{
|
|
|
|
bool sensitive = (processor_display.get_selection()->count_selected_rows()) ? true : false;
|
|
|
|
ActionManager::set_sensitive (ActionManager::plugin_selection_sensitive_actions, sensitive);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::select_all_processors ()
|
|
|
|
{
|
|
|
|
processor_display.get_selection()->select_all();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::deselect_all_processors ()
|
|
|
|
{
|
|
|
|
processor_display.get_selection()->unselect_all();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::choose_plugin ()
|
|
|
|
{
|
2008-09-10 11:03:30 -04:00
|
|
|
_plugin_selector.set_interested_object (*this);
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2008-09-10 11:03:30 -04:00
|
|
|
ProcessorBox::use_plugins (const SelectedPlugins& plugins)
|
2007-06-27 16:23:48 -04:00
|
|
|
{
|
2008-09-10 11:03:30 -04:00
|
|
|
for (SelectedPlugins::const_iterator p = plugins.begin(); p != plugins.end(); ++p) {
|
2007-06-27 16:23:48 -04:00
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
boost::shared_ptr<Processor> processor (new PluginInsert (_session, *p));
|
2007-06-27 16:23:48 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
Route::ProcessorStreams err_streams;
|
2008-12-12 09:43:24 -05:00
|
|
|
|
|
|
|
if (Config->get_new_plugins_active()) {
|
2009-01-30 02:40:13 -05:00
|
|
|
processor->activate ();
|
2008-12-12 09:43:24 -05:00
|
|
|
}
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2009-05-15 22:51:17 -04:00
|
|
|
if (_route->add_processor (processor, _placement, &err_streams)) {
|
2009-06-09 16:21:19 -04:00
|
|
|
weird_plugin_dialog (**p, err_streams);
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
// XXX SHAREDPTR delete plugin here .. do we even need to care?
|
2007-10-11 18:07:47 -04:00
|
|
|
} else {
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
if (Profile->get_sae()) {
|
2009-01-30 02:40:13 -05:00
|
|
|
processor->activate ();
|
2008-09-10 11:03:30 -04:00
|
|
|
}
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
processor->ActiveChanged.connect (bind (
|
|
|
|
mem_fun (*this, &ProcessorBox::show_processor_active),
|
|
|
|
boost::weak_ptr<Processor>(processor)));
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-06-09 16:21:19 -04:00
|
|
|
ProcessorBox::weird_plugin_dialog (Plugin& p, Route::ProcessorStreams streams)
|
2007-06-27 16:23:48 -04:00
|
|
|
{
|
|
|
|
ArdourDialog dialog (_("ardour: weird plugin dialog"));
|
|
|
|
Label label;
|
|
|
|
|
2009-05-04 11:50:51 -04:00
|
|
|
string text = string_compose(_("You attempted to add the plugin \"%1\" at index %2.\n"),
|
|
|
|
p.name(), streams.index);
|
|
|
|
|
|
|
|
bool has_midi = streams.count.n_midi() > 0 || p.get_info()->n_inputs.n_midi() > 0;
|
|
|
|
bool has_audio = streams.count.n_audio() > 0 || p.get_info()->n_inputs.n_audio() > 0;
|
|
|
|
|
|
|
|
text += _("\nThis plugin has:\n");
|
|
|
|
if (has_midi) {
|
|
|
|
text += string_compose("\t%1 ", p.get_info()->n_inputs.n_midi()) + _("MIDI input(s)\n");
|
|
|
|
}
|
|
|
|
if (has_audio) {
|
|
|
|
text += string_compose("\t%1 ", p.get_info()->n_inputs.n_audio()) + _("audio input(s)\n");
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
text += _("\nBut at the insertion point, there are:\n");
|
2009-05-04 11:50:51 -04:00
|
|
|
if (has_midi) {
|
|
|
|
text += string_compose("\t%1 ", streams.count.n_midi()) + _("MIDI channel(s)\n");
|
|
|
|
}
|
|
|
|
if (has_audio) {
|
|
|
|
text += string_compose("\t%1 ", streams.count.n_audio()) + _("audio channel(s)\n");
|
|
|
|
}
|
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
text += _("\nArdour is unable to insert this plugin here.\n");
|
2009-05-04 11:50:51 -04:00
|
|
|
label.set_text(text);
|
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
dialog.get_vbox()->pack_start (label);
|
|
|
|
dialog.add_button (Stock::OK, RESPONSE_ACCEPT);
|
|
|
|
|
|
|
|
dialog.set_name (X_("PluginIODialog"));
|
|
|
|
dialog.set_position (Gtk::WIN_POS_MOUSE);
|
|
|
|
dialog.set_modal (true);
|
|
|
|
dialog.show_all ();
|
|
|
|
|
|
|
|
dialog.run ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2008-09-10 11:03:30 -04:00
|
|
|
ProcessorBox::choose_insert ()
|
2007-06-27 16:23:48 -04:00
|
|
|
{
|
2009-06-09 16:21:19 -04:00
|
|
|
boost::shared_ptr<Processor> processor (new PortInsert (_session, _route->mute_master()));
|
2009-07-12 20:26:28 -04:00
|
|
|
processor->ActiveChanged.connect (bind (mem_fun(*this, &ProcessorBox::show_processor_active),
|
|
|
|
boost::weak_ptr<Processor>(processor)));
|
2009-05-13 17:34:09 -04:00
|
|
|
|
2009-05-15 22:51:17 -04:00
|
|
|
_route->add_processor (processor, _placement);
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::choose_send ()
|
|
|
|
{
|
2009-06-09 16:21:19 -04:00
|
|
|
boost::shared_ptr<Send> send (new Send (_session, _route->mute_master()));
|
2007-10-11 18:07:47 -04:00
|
|
|
|
|
|
|
/* make an educated guess at the initial number of outputs for the send */
|
2009-05-07 13:31:18 -04:00
|
|
|
ChanCount outs = (_session.master_out())
|
|
|
|
? _session.master_out()->n_outputs()
|
|
|
|
: _route->n_outputs();
|
2007-06-27 16:23:48 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
/* XXX need processor lock on route */
|
|
|
|
try {
|
2009-06-09 16:21:19 -04:00
|
|
|
send->output()->ensure_io (outs, false, this);
|
2008-09-10 11:03:30 -04:00
|
|
|
} catch (AudioEngine::PortRegistrationFailure& err) {
|
|
|
|
error << string_compose (_("Cannot set up new send: %1"), err.what()) << endmsg;
|
|
|
|
return;
|
|
|
|
}
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2009-05-07 13:31:18 -04:00
|
|
|
/* let the user adjust the IO setup before creation */
|
2009-06-09 16:21:19 -04:00
|
|
|
IOSelectorWindow *ios = new IOSelectorWindow (_session, send->output(), true);
|
2008-09-10 11:03:30 -04:00
|
|
|
ios->show_all ();
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2009-05-07 13:31:18 -04:00
|
|
|
/* keep a reference to the send so it doesn't get deleted while
|
2009-01-21 18:29:15 -05:00
|
|
|
the IOSelectorWindow is doing its stuff */
|
2009-05-07 13:31:18 -04:00
|
|
|
_processor_being_created = send;
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
|
|
|
ios->selector().Finished.connect (bind (
|
|
|
|
mem_fun(*this, &ProcessorBox::send_io_finished),
|
2009-05-07 13:31:18 -04:00
|
|
|
boost::weak_ptr<Processor>(send), ios));
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
void
|
|
|
|
ProcessorBox::send_io_finished (IOSelector::Result r, boost::weak_ptr<Processor> weak_processor, IOSelectorWindow* ios)
|
2007-06-27 16:23:48 -04:00
|
|
|
{
|
2008-09-10 11:03:30 -04:00
|
|
|
boost::shared_ptr<Processor> processor (weak_processor.lock());
|
|
|
|
|
2009-05-07 13:31:18 -04:00
|
|
|
/* drop our temporary reference to the new send */
|
|
|
|
_processor_being_created.reset ();
|
|
|
|
|
|
|
|
if (!processor) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (r) {
|
|
|
|
case IOSelector::Cancelled:
|
|
|
|
// processor will go away when all shared_ptrs to it vanish
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IOSelector::Accepted:
|
2009-05-15 22:51:17 -04:00
|
|
|
_route->add_processor (processor, _placement);
|
2009-05-07 13:31:18 -04:00
|
|
|
if (Profile->get_sae()) {
|
|
|
|
processor->activate ();
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
delete_when_idle (ios);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::choose_return ()
|
|
|
|
{
|
|
|
|
boost::shared_ptr<Return> retrn (new Return (_session));
|
|
|
|
|
|
|
|
/* assume user just wants a single audio input (sidechain) by default */
|
|
|
|
ChanCount ins(DataType::AUDIO, 1);
|
|
|
|
|
|
|
|
/* XXX need processor lock on route */
|
|
|
|
try {
|
2009-06-09 16:21:19 -04:00
|
|
|
retrn->input()->ensure_io (ins, false, this);
|
2009-05-07 13:31:18 -04:00
|
|
|
} 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 */
|
2009-06-09 16:21:19 -04:00
|
|
|
IOSelectorWindow *ios = new IOSelectorWindow (_session, retrn->output(), true);
|
2009-05-07 13:31:18 -04:00
|
|
|
ios->show_all ();
|
|
|
|
|
|
|
|
/* keep a reference to the send so it doesn't get deleted while
|
|
|
|
the IOSelectorWindow is doing its stuff */
|
|
|
|
_processor_being_created = retrn;
|
|
|
|
|
|
|
|
ios->selector().Finished.connect (bind (
|
|
|
|
mem_fun(*this, &ProcessorBox::return_io_finished),
|
|
|
|
boost::weak_ptr<Processor>(retrn), ios));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::return_io_finished (IOSelector::Result r, boost::weak_ptr<Processor> weak_processor, IOSelectorWindow* ios)
|
|
|
|
{
|
|
|
|
boost::shared_ptr<Processor> processor (weak_processor.lock());
|
|
|
|
|
|
|
|
/* drop our temporary reference to the new return */
|
|
|
|
_processor_being_created.reset ();
|
2009-01-21 18:29:15 -05:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
if (!processor) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (r) {
|
|
|
|
case IOSelector::Cancelled:
|
|
|
|
// processor will go away when all shared_ptrs to it vanish
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IOSelector::Accepted:
|
2009-05-15 22:51:17 -04:00
|
|
|
_route->add_processor (processor, _placement);
|
2008-12-12 09:43:24 -05:00
|
|
|
if (Profile->get_sae()) {
|
2009-01-30 02:40:13 -05:00
|
|
|
processor->activate ();
|
2008-12-12 09:43:24 -05:00
|
|
|
}
|
2008-09-10 11:03:30 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
delete_when_idle (ios);
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::redisplay_processors ()
|
|
|
|
{
|
2008-09-10 11:03:30 -04:00
|
|
|
ENSURE_GUI_THREAD (mem_fun(*this, &ProcessorBox::redisplay_processors));
|
2007-06-27 16:23:48 -04:00
|
|
|
|
|
|
|
if (no_processor_redisplay) {
|
|
|
|
return;
|
|
|
|
}
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
ignore_delete = true;
|
|
|
|
model->clear ();
|
|
|
|
ignore_delete = false;
|
|
|
|
|
|
|
|
processor_active_connections.clear ();
|
|
|
|
processor_name_connections.clear ();
|
|
|
|
|
2009-07-12 20:26:28 -04:00
|
|
|
_route->foreach_processor (mem_fun (*this, &ProcessorBox::add_processor_to_display));
|
2007-06-27 16:23:48 -04:00
|
|
|
|
2009-07-12 20:26:28 -04:00
|
|
|
build_processor_tooltip (processor_eventbox, _("Inserts, sends & plugins:"));
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2008-12-16 18:21:01 -05:00
|
|
|
ProcessorBox::add_processor_to_display (boost::weak_ptr<Processor> p)
|
2007-06-27 16:23:48 -04:00
|
|
|
{
|
2008-12-16 18:21:01 -05:00
|
|
|
boost::shared_ptr<Processor> processor (p.lock ());
|
|
|
|
if (!processor) {
|
|
|
|
return;
|
|
|
|
}
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2009-07-14 20:47:34 -04:00
|
|
|
if (!processor->visible()) {
|
2007-06-27 16:23:48 -04:00
|
|
|
return;
|
|
|
|
}
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
Gtk::TreeModel::Row row = *(model->append());
|
|
|
|
row[columns.text] = processor_name (processor);
|
|
|
|
row[columns.processor] = processor;
|
|
|
|
|
|
|
|
show_processor_active (processor);
|
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
processor_active_connections.push_back (processor->ActiveChanged.connect (bind (
|
|
|
|
mem_fun(*this, &ProcessorBox::show_processor_active),
|
|
|
|
boost::weak_ptr<Processor>(processor))));
|
|
|
|
processor_name_connections.push_back (processor->NameChanged.connect (bind (
|
|
|
|
mem_fun(*this, &ProcessorBox::show_processor_name),
|
|
|
|
boost::weak_ptr<Processor>(processor))));
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
string
|
|
|
|
ProcessorBox::processor_name (boost::weak_ptr<Processor> weak_processor)
|
|
|
|
{
|
|
|
|
boost::shared_ptr<Processor> processor (weak_processor.lock());
|
|
|
|
|
|
|
|
if (!processor) {
|
|
|
|
return string();
|
|
|
|
}
|
|
|
|
|
|
|
|
boost::shared_ptr<Send> send;
|
|
|
|
string name_display;
|
|
|
|
|
|
|
|
if (!processor->active()) {
|
|
|
|
name_display = " (";
|
|
|
|
}
|
|
|
|
|
2009-07-14 20:47:34 -04:00
|
|
|
if ((send = boost::dynamic_pointer_cast<Send> (processor)) != 0 &&
|
|
|
|
!boost::dynamic_pointer_cast<InternalSend>(processor)) {
|
2007-06-27 16:23:48 -04:00
|
|
|
|
|
|
|
name_display += '>';
|
|
|
|
|
|
|
|
/* grab the send name out of its overall name */
|
|
|
|
|
|
|
|
string::size_type lbracket, rbracket;
|
|
|
|
lbracket = send->name().find ('[');
|
|
|
|
rbracket = send->name().find (']');
|
2009-07-13 19:09:16 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
switch (_width) {
|
|
|
|
case Wide:
|
|
|
|
name_display += send->name().substr (lbracket+1, lbracket-rbracket-1);
|
|
|
|
break;
|
|
|
|
case Narrow:
|
|
|
|
name_display += PBD::short_version (send->name().substr (lbracket+1, lbracket-rbracket-1), 4);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
switch (_width) {
|
|
|
|
case Wide:
|
2009-07-13 19:09:16 -04:00
|
|
|
name_display += processor->display_name();
|
2007-06-27 16:23:48 -04:00
|
|
|
break;
|
|
|
|
case Narrow:
|
2009-07-13 19:09:16 -04:00
|
|
|
name_display += PBD::short_version (processor->display_name(), 5);
|
2007-06-27 16:23:48 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!processor->active()) {
|
|
|
|
name_display += ')';
|
|
|
|
}
|
|
|
|
|
|
|
|
return name_display;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::build_processor_tooltip (EventBox& box, string start)
|
|
|
|
{
|
|
|
|
string tip(start);
|
|
|
|
|
|
|
|
Gtk::TreeModel::Children children = model->children();
|
|
|
|
for(Gtk::TreeModel::Children::iterator iter = children.begin(); iter != children.end(); ++iter) {
|
|
|
|
Gtk::TreeModel::Row row = *iter;
|
|
|
|
tip += '\n';
|
2008-09-10 11:03:30 -04:00
|
|
|
tip += row[columns.text];
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
ARDOUR_UI::instance()->tooltips().set_tip (box, tip);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::show_processor_name (boost::weak_ptr<Processor> processor)
|
|
|
|
{
|
|
|
|
ENSURE_GUI_THREAD(bind (mem_fun(*this, &ProcessorBox::show_processor_name), processor));
|
|
|
|
show_processor_active (processor);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::show_processor_active (boost::weak_ptr<Processor> weak_processor)
|
|
|
|
{
|
|
|
|
boost::shared_ptr<Processor> processor (weak_processor.lock());
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
if (!processor) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
ENSURE_GUI_THREAD(bind (mem_fun(*this, &ProcessorBox::show_processor_active), weak_processor));
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
Gtk::TreeModel::Children children = model->children();
|
|
|
|
Gtk::TreeModel::Children::iterator iter = children.begin();
|
|
|
|
|
|
|
|
while (iter != children.end()) {
|
|
|
|
|
|
|
|
boost::shared_ptr<Processor> r = (*iter)[columns.processor];
|
|
|
|
|
|
|
|
if (r == processor) {
|
|
|
|
(*iter)[columns.text] = processor_name (r);
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
if (processor->active()) {
|
|
|
|
(*iter)[columns.color] = *active_processor_color;
|
|
|
|
} else {
|
|
|
|
(*iter)[columns.color] = *inactive_processor_color;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
iter++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::row_deleted (const Gtk::TreeModel::Path& path)
|
|
|
|
{
|
|
|
|
if (!ignore_delete) {
|
|
|
|
compute_processor_sort_keys ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::compute_processor_sort_keys ()
|
|
|
|
{
|
|
|
|
Gtk::TreeModel::Children children = model->children();
|
2009-05-15 22:51:17 -04:00
|
|
|
Route::ProcessorList our_processors;
|
2009-05-13 17:34:09 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
for (Gtk::TreeModel::Children::iterator iter = children.begin(); iter != children.end(); ++iter) {
|
2009-07-13 19:09:16 -04:00
|
|
|
boost::shared_ptr<Processor> p = (*iter)[columns.processor];
|
2009-05-15 22:51:17 -04:00
|
|
|
our_processors.push_back ((*iter)[columns.processor]);
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
|
2009-07-12 20:26:28 -04:00
|
|
|
if (_route->reorder_processors (our_processors)) {
|
2009-05-15 22:51:17 -04:00
|
|
|
|
|
|
|
/* reorder failed, so redisplay */
|
2007-06-27 16:23:48 -04:00
|
|
|
|
|
|
|
redisplay_processors ();
|
|
|
|
|
|
|
|
/* now tell them about the problem */
|
|
|
|
|
|
|
|
ArdourDialog dialog (_("ardour: weird plugin dialog"));
|
|
|
|
Label label;
|
|
|
|
|
|
|
|
label.set_text (_("\
|
|
|
|
You cannot reorder this set of processors\n\
|
|
|
|
in that way because the inputs and\n\
|
|
|
|
outputs do not work correctly."));
|
|
|
|
|
|
|
|
dialog.get_vbox()->pack_start (label);
|
|
|
|
dialog.add_button (Stock::OK, RESPONSE_ACCEPT);
|
|
|
|
|
|
|
|
dialog.set_name (X_("PluginIODialog"));
|
|
|
|
dialog.set_position (Gtk::WIN_POS_MOUSE);
|
|
|
|
dialog.set_modal (true);
|
|
|
|
dialog.show_all ();
|
|
|
|
|
|
|
|
dialog.run ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::rename_processors ()
|
|
|
|
{
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
ProcSelection to_be_renamed;
|
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
get_selected_processors (to_be_renamed);
|
|
|
|
|
|
|
|
if (to_be_renamed.empty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
for (ProcSelection::iterator i = to_be_renamed.begin(); i != to_be_renamed.end(); ++i) {
|
2007-06-27 16:23:48 -04:00
|
|
|
rename_processor (*i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::cut_processors ()
|
|
|
|
{
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
ProcSelection to_be_removed;
|
2007-08-01 18:18:46 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
get_selected_processors (to_be_removed);
|
2009-07-15 16:29:02 -04:00
|
|
|
}
|
2007-06-27 16:23:48 -04:00
|
|
|
|
2009-07-15 16:29:02 -04:00
|
|
|
void
|
|
|
|
ProcessorBox::cut_processors (const ProcSelection& to_be_removed)
|
|
|
|
{
|
2007-06-27 16:23:48 -04:00
|
|
|
if (to_be_removed.empty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-07-15 16:29:02 -04:00
|
|
|
XMLNode* node = new XMLNode (X_("cut"));
|
|
|
|
Route::ProcessorList to_cut;
|
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
no_processor_redisplay = true;
|
2009-07-15 16:29:02 -04:00
|
|
|
for (ProcSelection::const_iterator i = to_be_removed.begin(); i != to_be_removed.end(); ++i) {
|
|
|
|
// Cut only plugins, sends and returns
|
2008-12-12 09:43:24 -05:00
|
|
|
if (boost::dynamic_pointer_cast<PluginInsert>((*i)) != 0 ||
|
2009-07-15 16:29:02 -04:00
|
|
|
(boost::dynamic_pointer_cast<Send>((*i)) != 0) ||
|
|
|
|
(boost::dynamic_pointer_cast<Return>((*i)) != 0)) {
|
2007-08-01 18:18:46 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
void* gui = (*i)->get_gui ();
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
if (gui) {
|
|
|
|
static_cast<Gtk::Widget*>(gui)->hide ();
|
|
|
|
}
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-08-01 18:18:46 -04:00
|
|
|
XMLNode& child ((*i)->get_state());
|
2009-07-15 16:29:02 -04:00
|
|
|
node->add_child_nocopy (child);
|
|
|
|
to_cut.push_back (*i);
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
}
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
2009-07-15 16:29:02 -04:00
|
|
|
|
|
|
|
if (_route->remove_processors (to_cut) != 0) {
|
|
|
|
delete node;
|
|
|
|
no_processor_redisplay = false;
|
|
|
|
return;
|
|
|
|
}
|
2007-08-01 18:18:46 -04:00
|
|
|
|
|
|
|
_rr_selection.set (node);
|
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
no_processor_redisplay = false;
|
|
|
|
redisplay_processors ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::copy_processors ()
|
|
|
|
{
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
ProcSelection to_be_copied;
|
2007-06-27 16:23:48 -04:00
|
|
|
get_selected_processors (to_be_copied);
|
2009-07-15 16:29:02 -04:00
|
|
|
copy_processors (to_be_copied);
|
|
|
|
}
|
2007-06-27 16:23:48 -04:00
|
|
|
|
2009-07-15 16:29:02 -04:00
|
|
|
void
|
|
|
|
ProcessorBox::copy_processors (const ProcSelection& to_be_copied)
|
|
|
|
{
|
2007-06-27 16:23:48 -04:00
|
|
|
if (to_be_copied.empty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-07-15 16:29:02 -04:00
|
|
|
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
|
2008-12-12 09:43:24 -05:00
|
|
|
if (boost::dynamic_pointer_cast<PluginInsert>((*i)) != 0 ||
|
2009-07-15 16:29:02 -04:00
|
|
|
(boost::dynamic_pointer_cast<Send>((*i)) != 0) ||
|
|
|
|
(boost::dynamic_pointer_cast<Return>((*i)) != 0)) {
|
2007-08-01 18:18:46 -04:00
|
|
|
node->add_child_nocopy ((*i)->get_state());
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-08-01 18:18:46 -04:00
|
|
|
_rr_selection.set (node);
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::delete_processors ()
|
|
|
|
{
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
ProcSelection to_be_deleted;
|
2007-06-27 16:23:48 -04:00
|
|
|
get_selected_processors (to_be_deleted);
|
2009-07-15 16:29:02 -04:00
|
|
|
delete_processors (to_be_deleted);
|
|
|
|
}
|
2007-06-27 16:23:48 -04:00
|
|
|
|
2009-07-15 16:29:02 -04:00
|
|
|
void
|
|
|
|
ProcessorBox::delete_processors (const ProcSelection& targets)
|
|
|
|
{
|
|
|
|
if (targets.empty()) {
|
2007-06-27 16:23:48 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-05-15 22:51:17 -04:00
|
|
|
no_processor_redisplay = true;
|
|
|
|
|
2009-07-15 16:29:02 -04:00
|
|
|
for (ProcSelection::const_iterator i = targets.begin(); i != targets.end(); ++i) {
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
void* gui = (*i)->get_gui ();
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
if (gui) {
|
|
|
|
static_cast<Gtk::Widget*>(gui)->hide ();
|
|
|
|
}
|
|
|
|
|
|
|
|
_route->remove_processor(*i);
|
|
|
|
}
|
|
|
|
|
|
|
|
no_processor_redisplay = false;
|
|
|
|
redisplay_processors ();
|
|
|
|
}
|
|
|
|
|
2009-05-15 22:51:17 -04:00
|
|
|
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 ();
|
|
|
|
}
|
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
gint
|
|
|
|
ProcessorBox::idle_delete_processor (boost::weak_ptr<Processor> weak_processor)
|
|
|
|
{
|
|
|
|
boost::shared_ptr<Processor> processor (weak_processor.lock());
|
|
|
|
|
|
|
|
if (!processor) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* NOT copied to _mixer.selection() */
|
|
|
|
|
|
|
|
no_processor_redisplay = true;
|
|
|
|
_route->remove_processor (processor);
|
|
|
|
no_processor_redisplay = false;
|
|
|
|
redisplay_processors ();
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::rename_processor (boost::shared_ptr<Processor> processor)
|
|
|
|
{
|
|
|
|
ArdourPrompter name_prompter (true);
|
|
|
|
string result;
|
|
|
|
name_prompter.set_prompt (_("rename processor"));
|
|
|
|
name_prompter.set_initial_text (processor->name());
|
|
|
|
name_prompter.add_button (_("Rename"), Gtk::RESPONSE_ACCEPT);
|
|
|
|
name_prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
|
|
|
|
name_prompter.show_all ();
|
|
|
|
|
|
|
|
switch (name_prompter.run ()) {
|
|
|
|
|
|
|
|
case Gtk::RESPONSE_ACCEPT:
|
|
|
|
name_prompter.get_result (result);
|
|
|
|
if (result.length()) {
|
|
|
|
processor->set_name (result);
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
}
|
2007-06-27 16:23:48 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2007-08-01 18:18:46 -04:00
|
|
|
ProcessorBox::paste_processors ()
|
2007-06-27 16:23:48 -04:00
|
|
|
{
|
2007-08-01 18:18:46 -04:00
|
|
|
if (_rr_selection.processors.empty()) {
|
|
|
|
return;
|
|
|
|
}
|
2007-06-27 16:23:48 -04:00
|
|
|
|
2009-07-15 16:29:02 -04:00
|
|
|
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;
|
|
|
|
}
|
2007-06-27 16:23:48 -04:00
|
|
|
|
2009-07-15 16:29:02 -04:00
|
|
|
paste_processor_state (_rr_selection.processors.get_node().children(), before);
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-07-15 16:29:02 -04:00
|
|
|
ProcessorBox::paste_processor_state (const XMLNodeList& nlist, boost::shared_ptr<Processor> p)
|
2007-06-27 16:23:48 -04:00
|
|
|
{
|
2007-08-01 18:18:46 -04:00
|
|
|
XMLNodeConstIterator niter;
|
2007-06-27 16:23:48 -04:00
|
|
|
list<boost::shared_ptr<Processor> > copies;
|
|
|
|
|
2007-08-01 18:18:46 -04:00
|
|
|
if (nlist.empty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
|
2009-07-15 16:29:02 -04:00
|
|
|
|
2009-02-14 12:28:01 -05:00
|
|
|
XMLProperty const * type = (*niter)->property ("type");
|
|
|
|
assert (type);
|
2009-02-14 14:45:30 -05:00
|
|
|
|
|
|
|
boost::shared_ptr<Processor> p;
|
2007-08-01 18:18:46 -04:00
|
|
|
try {
|
2009-07-15 16:29:02 -04:00
|
|
|
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") {
|
|
|
|
|
2009-02-14 12:28:01 -05:00
|
|
|
XMLNode n (**niter);
|
|
|
|
Send::make_unique (n, _session);
|
2009-06-09 16:21:19 -04:00
|
|
|
p.reset (new Send (_session, _route->mute_master(), n));
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2009-07-15 16:29:02 -04:00
|
|
|
} else if (type->value() == "return") {
|
2009-07-01 09:36:50 -04:00
|
|
|
|
2009-07-15 16:29:02 -04:00
|
|
|
XMLNode n (**niter);
|
|
|
|
Return::make_unique (n, _session);
|
|
|
|
p.reset (new Return (_session, **niter));
|
2009-05-13 17:34:09 -04:00
|
|
|
|
2009-02-14 12:28:01 -05:00
|
|
|
} else {
|
2009-07-15 16:29:02 -04:00
|
|
|
/* XXX its a bit limiting to assume that everything else
|
|
|
|
is a plugin.
|
|
|
|
*/
|
2009-02-14 14:45:30 -05:00
|
|
|
p.reset (new PluginInsert (_session, **niter));
|
2009-02-14 12:28:01 -05:00
|
|
|
}
|
2009-02-14 14:45:30 -05:00
|
|
|
|
|
|
|
copies.push_back (p);
|
2007-08-01 18:18:46 -04:00
|
|
|
}
|
2009-07-15 16:29:02 -04:00
|
|
|
|
2007-08-01 18:18:46 -04:00
|
|
|
catch (...) {
|
|
|
|
cerr << "plugin insert constructor failed\n";
|
|
|
|
}
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
if (copies.empty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-07-15 16:29:02 -04:00
|
|
|
if (_route->add_processors (copies, p)) {
|
2007-06-27 16:23:48 -04:00
|
|
|
|
|
|
|
string msg = _(
|
|
|
|
"Copying the set of processors on the clipboard failed,\n\
|
|
|
|
probably because the I/O configuration of the plugins\n\
|
|
|
|
could not match the configuration of this track.");
|
|
|
|
MessageDialog am (msg);
|
|
|
|
am.run ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::activate_processor (boost::shared_ptr<Processor> r)
|
|
|
|
{
|
2009-01-30 02:40:13 -05:00
|
|
|
r->activate ();
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::deactivate_processor (boost::shared_ptr<Processor> r)
|
|
|
|
{
|
2009-01-30 02:40:13 -05:00
|
|
|
r->deactivate ();
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
ProcessorBox::get_selected_processors (ProcSelection& processors)
|
2007-06-27 16:23:48 -04:00
|
|
|
{
|
|
|
|
vector<Gtk::TreeModel::Path> pathlist = processor_display.get_selection()->get_selected_rows();
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
for (vector<Gtk::TreeModel::Path>::iterator iter = pathlist.begin(); iter != pathlist.end(); ++iter) {
|
|
|
|
processors.push_back ((*(model->get_iter(*iter)))[columns.processor]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2008-09-10 11:03:30 -04:00
|
|
|
ProcessorBox::for_selected_processors (void (ProcessorBox::*method)(boost::shared_ptr<Processor>))
|
2007-06-27 16:23:48 -04:00
|
|
|
{
|
|
|
|
vector<Gtk::TreeModel::Path> pathlist = processor_display.get_selection()->get_selected_rows();
|
|
|
|
|
|
|
|
for (vector<Gtk::TreeModel::Path>::iterator iter = pathlist.begin(); iter != pathlist.end(); ++iter) {
|
|
|
|
boost::shared_ptr<Processor> processor = (*(model->get_iter(*iter)))[columns.processor];
|
2008-09-10 11:03:30 -04:00
|
|
|
(this->*method)(processor);
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::all_processors_active (bool state)
|
|
|
|
{
|
|
|
|
_route->all_processors_active (_placement, state);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::ab_plugins ()
|
|
|
|
{
|
|
|
|
_route->ab_plugins (ab_direction);
|
|
|
|
ab_direction = !ab_direction;
|
|
|
|
}
|
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
void
|
|
|
|
ProcessorBox::clear_processors ()
|
|
|
|
{
|
|
|
|
string prompt;
|
|
|
|
vector<string> choices;
|
|
|
|
|
2009-07-15 16:29:02 -04:00
|
|
|
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());
|
2007-06-27 16:23:48 -04:00
|
|
|
} else {
|
2009-07-15 16:29:02 -04:00
|
|
|
prompt = string_compose (_("Do you really want to remove all post-fader processors from %1?\n"
|
|
|
|
"(this cannot be undone)"), _route->name());
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
choices.push_back (_("Cancel"));
|
|
|
|
choices.push_back (_("Yes, remove them all"));
|
|
|
|
|
|
|
|
Gtkmm2ext::Choice prompter (prompt, choices);
|
|
|
|
|
|
|
|
if (prompter.run () == 1) {
|
2009-07-15 16:29:02 -04:00
|
|
|
_route->clear_processors (p);
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::edit_processor (boost::shared_ptr<Processor> processor)
|
|
|
|
{
|
|
|
|
boost::shared_ptr<Send> send;
|
2009-05-07 13:31:18 -04:00
|
|
|
boost::shared_ptr<Return> retrn;
|
2008-09-10 11:03:30 -04:00
|
|
|
boost::shared_ptr<PluginInsert> plugin_insert;
|
|
|
|
boost::shared_ptr<PortInsert> port_insert;
|
|
|
|
Window* gidget = 0;
|
2007-06-27 16:23:48 -04:00
|
|
|
|
|
|
|
if (boost::dynamic_pointer_cast<AudioTrack>(_route) != 0) {
|
|
|
|
|
|
|
|
if (boost::dynamic_pointer_cast<AudioTrack> (_route)->freeze_state() == AudioTrack::Frozen) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-08-02 15:57:42 -04:00
|
|
|
if ((send = boost::dynamic_pointer_cast<Send> (processor)) != 0) {
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
if (!_session.engine().connected()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-05-16 22:08:13 -04:00
|
|
|
#ifdef OLD_SEND_EDITING
|
2007-06-27 16:23:48 -04:00
|
|
|
SendUIWindow *send_ui;
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
if (send->get_gui() == 0) {
|
|
|
|
send_ui = new SendUIWindow (send, _session);
|
|
|
|
|
|
|
|
WindowTitle title(Glib::get_application_name());
|
|
|
|
title += send->name();
|
|
|
|
send_ui->set_title (title.get_string());
|
|
|
|
|
|
|
|
send->set_gui (send_ui);
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
} else {
|
|
|
|
send_ui = reinterpret_cast<SendUIWindow *> (send->get_gui());
|
|
|
|
}
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
gidget = send_ui;
|
2009-05-16 22:08:13 -04:00
|
|
|
#else
|
|
|
|
if (_parent_strip) {
|
2009-06-09 16:21:19 -04:00
|
|
|
_parent_strip->gain_meter().set_controls (_route, send->meter(), send->amp()->gain_control(), send->amp());
|
|
|
|
_parent_strip->panner_ui().set_panner (send->panner());
|
2009-05-16 22:08:13 -04:00
|
|
|
}
|
|
|
|
#endif
|
2009-05-07 13:31:18 -04:00
|
|
|
|
|
|
|
} else if ((retrn = boost::dynamic_pointer_cast<Return> (processor)) != 0) {
|
|
|
|
|
|
|
|
if (!_session.engine().connected()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
boost::shared_ptr<Return> retrn = boost::dynamic_pointer_cast<Return> (processor);
|
|
|
|
|
|
|
|
ReturnUIWindow *return_ui;
|
|
|
|
|
|
|
|
if (retrn->get_gui() == 0) {
|
|
|
|
|
|
|
|
return_ui = new ReturnUIWindow (retrn, _session);
|
|
|
|
|
|
|
|
WindowTitle title(Glib::get_application_name());
|
|
|
|
title += retrn->name();
|
|
|
|
return_ui->set_title (title.get_string());
|
|
|
|
|
|
|
|
send->set_gui (return_ui);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
return_ui = reinterpret_cast<ReturnUIWindow *> (retrn->get_gui());
|
|
|
|
}
|
|
|
|
|
|
|
|
gidget = return_ui;
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
} else if ((plugin_insert = boost::dynamic_pointer_cast<PluginInsert> (processor)) != 0) {
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
PluginUIWindow *plugin_ui;
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
/* these are both allowed to be null */
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
Container* toplevel = get_toplevel();
|
|
|
|
Window* win = dynamic_cast<Gtk::Window*>(toplevel);
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
if (plugin_insert->get_gui() == 0) {
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
plugin_ui = new PluginUIWindow (win, plugin_insert);
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
WindowTitle title(Glib::get_application_name());
|
|
|
|
title += generate_processor_title (plugin_insert);
|
|
|
|
plugin_ui->set_title (title.get_string());
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
plugin_insert->set_gui (plugin_ui);
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
} else {
|
|
|
|
plugin_ui = reinterpret_cast<PluginUIWindow *> (plugin_insert->get_gui());
|
|
|
|
plugin_ui->set_parent (win);
|
|
|
|
}
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
gidget = plugin_ui;
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
} else if ((port_insert = boost::dynamic_pointer_cast<PortInsert> (processor)) != 0) {
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
if (!_session.engine().connected()) {
|
|
|
|
MessageDialog msg ( _("Not connected to JACK - no I/O changes are possible"));
|
|
|
|
msg.run ();
|
|
|
|
return;
|
|
|
|
}
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
PortInsertWindow *io_selector;
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
if (port_insert->get_gui() == 0) {
|
|
|
|
io_selector = new PortInsertWindow (_session, port_insert);
|
|
|
|
port_insert->set_gui (io_selector);
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
} else {
|
2008-09-10 11:03:30 -04:00
|
|
|
io_selector = reinterpret_cast<PortInsertWindow *> (port_insert->get_gui());
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
gidget = io_selector;
|
|
|
|
}
|
2007-06-27 16:23:48 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
if (gidget) {
|
|
|
|
if (gidget->is_visible()) {
|
|
|
|
gidget->get_window()->raise ();
|
2007-06-27 16:23:48 -04:00
|
|
|
} else {
|
2008-09-10 11:03:30 -04:00
|
|
|
gidget->show_all ();
|
|
|
|
gidget->present ();
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::register_actions ()
|
|
|
|
{
|
2007-06-29 00:02:58 -04:00
|
|
|
Glib::RefPtr<Gtk::ActionGroup> popup_act_grp = Gtk::ActionGroup::create(X_("processormenu"));
|
2007-06-27 16:23:48 -04:00
|
|
|
Glib::RefPtr<Action> act;
|
|
|
|
|
|
|
|
/* new stuff */
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
ActionManager::register_action (popup_act_grp, X_("newplugin"), _("New Plugin"),
|
|
|
|
sigc::ptr_fun (ProcessorBox::rb_choose_plugin));
|
2007-06-27 16:23:48 -04:00
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
act = ActionManager::register_action (popup_act_grp, X_("newinsert"), _("New Insert"),
|
|
|
|
sigc::ptr_fun (ProcessorBox::rb_choose_insert));
|
2007-06-27 16:23:48 -04:00
|
|
|
ActionManager::jack_sensitive_actions.push_back (act);
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
act = ActionManager::register_action (popup_act_grp, X_("newsend"), _("New Send ..."),
|
|
|
|
sigc::ptr_fun (ProcessorBox::rb_choose_send));
|
2007-06-27 16:23:48 -04:00
|
|
|
ActionManager::jack_sensitive_actions.push_back (act);
|
2009-05-07 13:31:18 -04:00
|
|
|
act = ActionManager::register_action (popup_act_grp, X_("newreturn"), _("New Return ..."),
|
|
|
|
sigc::ptr_fun (ProcessorBox::rb_choose_return));
|
|
|
|
ActionManager::jack_sensitive_actions.push_back (act);
|
2007-06-27 16:23:48 -04:00
|
|
|
|
2009-07-15 16:29:02 -04:00
|
|
|
ActionManager::register_action (popup_act_grp, X_("clear"), _("Clear (all)"),
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
sigc::ptr_fun (ProcessorBox::rb_clear));
|
2009-07-15 16:29:02 -04:00
|
|
|
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));
|
2007-06-27 16:23:48 -04:00
|
|
|
|
|
|
|
/* standard editing stuff */
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
act = ActionManager::register_action (popup_act_grp, X_("cut"), _("Cut"),
|
|
|
|
sigc::ptr_fun (ProcessorBox::rb_cut));
|
2007-06-27 16:23:48 -04:00
|
|
|
ActionManager::plugin_selection_sensitive_actions.push_back(act);
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
act = ActionManager::register_action (popup_act_grp, X_("copy"), _("Copy"),
|
|
|
|
sigc::ptr_fun (ProcessorBox::rb_copy));
|
2007-06-27 16:23:48 -04:00
|
|
|
ActionManager::plugin_selection_sensitive_actions.push_back(act);
|
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
act = ActionManager::register_action (popup_act_grp, X_("delete"), _("Delete"),
|
|
|
|
sigc::ptr_fun (ProcessorBox::rb_delete));
|
2007-06-27 16:23:48 -04:00
|
|
|
ActionManager::plugin_selection_sensitive_actions.push_back(act); // ??
|
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
paste_action = ActionManager::register_action (popup_act_grp, X_("paste"), _("Paste"),
|
|
|
|
sigc::ptr_fun (ProcessorBox::rb_paste));
|
|
|
|
act = ActionManager::register_action (popup_act_grp, X_("rename"), _("Rename"),
|
|
|
|
sigc::ptr_fun (ProcessorBox::rb_rename));
|
2007-06-27 16:23:48 -04:00
|
|
|
ActionManager::plugin_selection_sensitive_actions.push_back(act);
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
ActionManager::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"),
|
|
|
|
sigc::ptr_fun (ProcessorBox::rb_deselect_all));
|
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
/* activation */
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
act = ActionManager::register_action (popup_act_grp, X_("activate"), _("Activate"),
|
|
|
|
sigc::ptr_fun (ProcessorBox::rb_activate));
|
2007-06-27 16:23:48 -04:00
|
|
|
ActionManager::plugin_selection_sensitive_actions.push_back(act);
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
act = ActionManager::register_action (popup_act_grp, X_("deactivate"), _("Deactivate"),
|
|
|
|
sigc::ptr_fun (ProcessorBox::rb_deactivate));
|
2007-06-27 16:23:48 -04:00
|
|
|
ActionManager::plugin_selection_sensitive_actions.push_back(act);
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
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"),
|
|
|
|
sigc::ptr_fun (ProcessorBox::rb_deactivate_all));
|
2007-06-27 16:23:48 -04:00
|
|
|
|
|
|
|
/* show editors */
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
act = ActionManager::register_action (popup_act_grp, X_("edit"), _("Edit"),
|
|
|
|
sigc::ptr_fun (ProcessorBox::rb_edit));
|
2007-06-27 16:23:48 -04:00
|
|
|
ActionManager::plugin_selection_sensitive_actions.push_back(act);
|
|
|
|
|
|
|
|
ActionManager::add_action_group (popup_act_grp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::rb_choose_plugin ()
|
|
|
|
{
|
|
|
|
if (_current_processor_box == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
_current_processor_box->choose_plugin ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2008-09-10 11:03:30 -04:00
|
|
|
ProcessorBox::rb_choose_insert ()
|
2007-06-27 16:23:48 -04:00
|
|
|
{
|
|
|
|
if (_current_processor_box == 0) {
|
|
|
|
return;
|
|
|
|
}
|
2008-09-10 11:03:30 -04:00
|
|
|
_current_processor_box->choose_insert ();
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::rb_choose_send ()
|
|
|
|
{
|
|
|
|
if (_current_processor_box == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
_current_processor_box->choose_send ();
|
|
|
|
}
|
|
|
|
|
2009-05-07 13:31:18 -04:00
|
|
|
void
|
|
|
|
ProcessorBox::rb_choose_return ()
|
|
|
|
{
|
|
|
|
if (_current_processor_box == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
_current_processor_box->choose_return ();
|
|
|
|
}
|
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
void
|
|
|
|
ProcessorBox::rb_clear ()
|
|
|
|
{
|
|
|
|
if (_current_processor_box == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
_current_processor_box->clear_processors ();
|
|
|
|
}
|
|
|
|
|
2009-07-15 16:29:02 -04:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
void
|
|
|
|
ProcessorBox::rb_cut ()
|
|
|
|
{
|
|
|
|
if (_current_processor_box == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
_current_processor_box->cut_processors ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::rb_delete ()
|
|
|
|
{
|
|
|
|
if (_current_processor_box == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
_current_processor_box->delete_processors ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::rb_copy ()
|
|
|
|
{
|
|
|
|
if (_current_processor_box == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
_current_processor_box->copy_processors ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::rb_paste ()
|
|
|
|
{
|
|
|
|
if (_current_processor_box == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
_current_processor_box->paste_processors ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::rb_rename ()
|
|
|
|
{
|
|
|
|
if (_current_processor_box == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
_current_processor_box->rename_processors ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::rb_select_all ()
|
|
|
|
{
|
|
|
|
if (_current_processor_box == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
_current_processor_box->select_all_processors ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::rb_deselect_all ()
|
|
|
|
{
|
|
|
|
if (_current_processor_box == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
_current_processor_box->deselect_all_processors ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::rb_activate ()
|
|
|
|
{
|
|
|
|
if (_current_processor_box == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
_current_processor_box->for_selected_processors (&ProcessorBox::activate_processor);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::rb_deactivate ()
|
|
|
|
{
|
|
|
|
if (_current_processor_box == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
_current_processor_box->for_selected_processors (&ProcessorBox::deactivate_processor);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::rb_activate_all ()
|
|
|
|
{
|
|
|
|
if (_current_processor_box == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
_current_processor_box->all_processors_active (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::rb_deactivate_all ()
|
|
|
|
{
|
|
|
|
if (_current_processor_box == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
_current_processor_box->all_processors_active (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ProcessorBox::rb_edit ()
|
|
|
|
{
|
|
|
|
if (_current_processor_box == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
_current_processor_box->for_selected_processors (&ProcessorBox::edit_processor);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-03-07 09:06:19 -05:00
|
|
|
ProcessorBox::route_name_changed ()
|
2007-06-27 16:23:48 -04:00
|
|
|
{
|
2009-03-07 09:06:19 -05:00
|
|
|
ENSURE_GUI_THREAD (mem_fun (*this, &ProcessorBox::route_name_changed));
|
|
|
|
|
|
|
|
boost::shared_ptr<Processor> processor;
|
|
|
|
boost::shared_ptr<PluginInsert> plugin_insert;
|
|
|
|
boost::shared_ptr<Send> send;
|
|
|
|
|
|
|
|
Gtk::TreeModel::Children children = model->children();
|
|
|
|
|
|
|
|
for (Gtk::TreeModel::Children::iterator iter = children.begin(); iter != children.end(); ++iter) {
|
|
|
|
Gtk::TreeModel::Row row = *iter;
|
|
|
|
|
|
|
|
processor= row[columns.processor];
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2009-03-07 09:06:19 -05:00
|
|
|
void* gui = processor->get_gui();
|
|
|
|
|
|
|
|
if (!gui) {
|
|
|
|
continue;
|
|
|
|
}
|
2008-09-10 11:03:30 -04:00
|
|
|
|
2009-03-07 09:06:19 -05:00
|
|
|
/* rename editor windows for sends and plugins */
|
2007-06-27 16:23:48 -04:00
|
|
|
|
2009-03-07 09:06:19 -05:00
|
|
|
WindowTitle title (Glib::get_application_name());
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2009-03-07 09:06:19 -05:00
|
|
|
if ((send = boost::dynamic_pointer_cast<Send> (processor)) != 0) {
|
|
|
|
title += send->name();
|
|
|
|
static_cast<Window*>(gui)->set_title (title.get_string());
|
|
|
|
} else if ((plugin_insert = boost::dynamic_pointer_cast<PluginInsert> (processor)) != 0) {
|
|
|
|
title += generate_processor_title (plugin_insert);
|
|
|
|
static_cast<Window*>(gui)->set_title (title.get_string());
|
|
|
|
}
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
string
|
2007-06-27 16:23:48 -04:00
|
|
|
ProcessorBox::generate_processor_title (boost::shared_ptr<PluginInsert> pi)
|
|
|
|
{
|
2008-01-19 00:06:33 -05:00
|
|
|
string maker = pi->plugin()->maker() ? pi->plugin()->maker() : "";
|
2007-06-27 16:23:48 -04:00
|
|
|
string::size_type email_pos;
|
|
|
|
|
|
|
|
if ((email_pos = maker.find_first_of ('<')) != string::npos) {
|
|
|
|
maker = maker.substr (0, email_pos - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (maker.length() > 32) {
|
|
|
|
maker = maker.substr (0, 32);
|
|
|
|
maker += " ...";
|
|
|
|
}
|
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
return string_compose(_("%1: %2 (by %3)"), _route->name(), pi->name(), maker);
|
2007-06-27 16:23:48 -04:00
|
|
|
}
|
|
|
|
|