audio_clock.cc
audio_time_axis.cc
audio_region_editor.cc
-automation_gain_line.cc
-automation_midi_cc_line.cc
automation_line.cc
-automation_pan_line.cc
automation_time_axis.cc
automation_controller.cc
midi_time_axis.cc
export_session_dialog.cc
export_region_dialog.cc
export_range_markers_dialog.cc
-gain_automation_time_axis.cc
-midi_controller_time_axis.cc
gain_meter.cc
ghostregion.cc
gtk-custom-hruler.c
new_session_dialog.cc
option_editor.cc
opts.cc
-pan_automation_time_axis.cc
panner.cc
panner2d.cc
panner_ui.cc
plugin_ui.cc
prompter.cc
public_editor.cc
-processor_automation_line.cc
-processor_automation_time_axis.cc
processor_box.cc
region_gain_line.cc
region_selection.cc
#include "ardour_ui.h"
#include "audio_time_axis.h"
-#include "automation_gain_line.h"
-#include "automation_pan_line.h"
+#include "automation_line.h"
#include "canvas_impl.h"
#include "crossfade_view.h"
#include "enums.h"
-#include "gain_automation_time_axis.h"
+#include "automation_time_axis.h"
#include "keyboard.h"
-#include "pan_automation_time_axis.h"
#include "playlist_selector.h"
#include "prompter.h"
#include "public_editor.h"
return;
}
- GainAutomationTimeAxisView* gain_track = new GainAutomationTimeAxisView (_session,
- _route,
+ boost::shared_ptr<AutomationTimeAxisView> gain_track(new AutomationTimeAxisView (_session,
+ _route, _route, c,
editor,
*this,
parent_canvas,
_route->describe_parameter(param),
- c);
-
- AutomationLine* line = new AutomationGainLine ("automation gain",
- *gain_track,
- *gain_track->canvas_display,
- c->list());
-
- line->set_line_color (ARDOUR_UI::config()->canvasvar_AutomationLine.get());
-
- gain_track->add_line (*line);
+ c->list()->param_id().to_string() /* FIXME: correct state name? */));
add_automation_child(ParamID(GainAutomation), gain_track);
} else if (param.type() == PanAutomation) {
-
- PanAutomationTimeAxisView* pan_track = new PanAutomationTimeAxisView (_session,
- _route,
- editor,
- *this,
- parent_canvas,
- _route->describe_parameter(param));
ensure_xml_node ();
-
- add_automation_child(ParamID(PanAutomation), pan_track);
-
update_pans ();
} else {
AudioTimeAxisView::update_pans ()
{
Panner::iterator p;
-
- RouteAutomationNode* ran = automation_track(PanAutomation);
- if (!ran) {
- warning << _route << " has no pan automation track" << endmsg;
- return;
- }
- AutomationTimeAxisView* pan_track = ran->track;
-
- pan_track->clear_lines ();
-
- /* we don't draw lines for "greater than stereo" panning.
- */
+ /* This is a filthy kludge until the panner stuff gets up to speed. */
+
+ /* Remove all our old automation tracks. Slowly. */
+ while (true) {
+ bool found = false;
+ for (AutomationTracks::iterator i = _automation_tracks.begin(); i != _automation_tracks.end(); ++i) {
+ if (i->first.type() == PanAutomation) {
+ _automation_tracks.erase(i);
+ found = true;
+ break;
+ }
+ }
- if (_route->n_outputs().n_audio() > 2) {
- return;
+ if ( ! found)
+ break;
}
-
+
+ /* Man I hate that damn stereo->stereo panner */
for (p = _route->panner().begin(); p != _route->panner().end(); ++p) {
-
- AutomationLine* line;
-
- line = new AutomationPanLine ("automation pan", *pan_track,
- *pan_track->canvas_display,
- (*p)->automation());
-
- if (p == _route->panner().begin()) {
- /* first line is a nice orange */
- line->set_line_color (ARDOUR_UI::config()->canvasvar_AutomationLine.get());
- } else {
- /* second line is a nice blue */
- line->set_line_color (ARDOUR_UI::config()->canvasvar_AutomationLine.get());
- }
-
- pan_track->add_line (*line);
+ boost::shared_ptr<AutomationTimeAxisView> pan_track(new AutomationTimeAxisView (_session,
+ _route, _route/*FIXME*/, (*p)->pan_control(),
+ editor,
+ *this,
+ parent_canvas,
+ _route->describe_parameter((*p)->pan_control()->list()->param_id()),
+ (*p)->pan_control()->list()->param_id().to_string() /* FIXME: correct state name? */));
}
}
*/
#include <pbd/error.h>
-#include "automation_controller.h"
#include "ardour/automation_event.h"
#include "ardour/automation_control.h"
#include "ardour_ui.h"
#include "utils.h"
+#include "automation_controller.h"
+#include "gui_thread.h"
#include "i18n.h"
_screen_update_connection = ARDOUR_UI::RapidScreenUpdate.connect (
mem_fun (*this, &AutomationController::display_effective_value));
+
+ ac->Changed.connect (mem_fun(*this, &AutomationController::value_changed));
}
AutomationController::~AutomationController()
void
AutomationController::update_label(char* label, int label_len)
{
- //cerr << "Controller label: " << label << endl;
+ if (label && label_len)
+ snprintf(label, label_len, "%.3f", _controllable->get_value());
}
void
AutomationController::display_effective_value()
{
- if ( ! _controllable->list()->automation_playback())
- return;
+ //if ( ! _controllable->list()->automation_playback())
+ // return;
float value = _controllable->get_value();
{
_controllable->list()->stop_touch();
}
+
+void
+AutomationController::automation_state_changed ()
+{
+ ENSURE_GUI_THREAD(mem_fun(*this, &AutomationController::automation_state_changed));
+
+ bool x = (_controllable->list()->automation_state() != Off);
+
+ /* start watching automation so that things move */
+
+ _screen_update_connection.disconnect();
+
+ if (x) {
+ _screen_update_connection = ARDOUR_UI::RapidScreenUpdate.connect (
+ mem_fun (*this, &AutomationController::display_effective_value));
+ }
+}
+
+void
+AutomationController::value_changed ()
+{
+ Gtkmm2ext::UI::instance()->call_slot (
+ mem_fun(*this, &AutomationController::display_effective_value));
+}
+
~AutomationController();
boost::shared_ptr<ARDOUR::AutomationControl> controllable() { return _controllable; }
+
+ Gtk::Adjustment* adjustment() { return _adjustment; }
void update_label(char* label, int label_len);
void display_effective_value();
void start_touch();
void end_touch();
+ void value_changed();
+ void automation_state_changed();
+
bool _ignore_change;
boost::shared_ptr<ARDOUR::AutomationControl> _controllable;
Gtk::Adjustment* _adjustment;
+++ /dev/null
-/*
- Copyright (C) 2000-2003 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.
-
-*/
-
-#include <sigc++/signal.h>
-
-#include <ardour/curve.h>
-#include <pbd/fastlog.h>
-
-#include "public_editor.h"
-#include "automation_gain_line.h"
-#include "utils.h"
-
-using namespace std;
-using namespace ARDOUR;
-using namespace PBD;
-
-AutomationGainLine::AutomationGainLine (const string & name, TimeAxisView& tv, ArdourCanvas::Group& parent, boost::shared_ptr<AutomationList> l)
-
- : AutomationLine (name, tv, parent, l)
-{
- set_verbose_cursor_uses_gain_mapping (true);
-}
-
-void
-AutomationGainLine::view_to_model_y (double& y)
-{
- y = slider_position_to_gain (y);
- y = max (0.0, y);
- y = min (2.0, y);
-}
-
-void
-AutomationGainLine::model_to_view_y (double& y)
-{
- y = gain_to_slider_position (y);
-}
-
-
-
+++ /dev/null
-/*
- Copyright (C) 2000-2007 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.
-
-*/
-
-#ifndef __ardour_gtk_automation_gain_line_h__
-#define __ardour_gtk_automation_gain_line_h__
-
-#include <ardour/ardour.h>
-
-#include "canvas.h"
-#include "automation_line.h"
-
-class TimeAxisView;
-
-class AutomationGainLine : public AutomationLine
-{
- public:
- AutomationGainLine (const string & name, TimeAxisView&, ArdourCanvas::Group& parent, boost::shared_ptr<ARDOUR::AutomationList>);
-
- void view_to_model_y (double&);
- void model_to_view_y (double&);
-};
-
-
-#endif /* __ardour_gtk_automation_gain_line_h__ */
-
-
alist->StateChanged.connect (mem_fun(*this, &AutomationLine::list_changed));
trackview.session().register_with_memento_command_factory(alist->id(), this);
+
+ if (alist->param_id().type() == GainAutomation)
+ set_verbose_cursor_uses_gain_mapping (true);
}
AutomationLine::~AutomationLine ()
/* function as a proxy for the model */
return alist->set_state (node);
}
+
+void
+AutomationLine::view_to_model_y (double& y)
+{
+ if (alist->param_id().type() == GainAutomation) {
+ y = slider_position_to_gain (y);
+ y = max (0.0, y);
+ y = min (2.0, y);
+ } else if (alist->param_id().type() == PanAutomation) {
+ // vertical coordinate axis reversal
+ y = 1.0 - y;
+ } else if (alist->param_id().type() == MidiCCAutomation) {
+ y = (int)(y * 127.0);
+ }
+}
+
+void
+AutomationLine::model_to_view_y (double& y)
+{
+ if (alist->param_id().type() == GainAutomation) {
+ y = gain_to_slider_position (y);
+ } else if (alist->param_id().type() == PanAutomation) {
+ // vertical coordinate axis reversal
+ y = 1.0 - y;
+ } else if (alist->param_id().type() == MidiCCAutomation) {
+ y = y / 127.0;
+ } else if (alist->param_id().type() == PluginAutomation) {
+ y = (y - alist->get_min_y()) / (double)(alist->get_max_y()- alist->get_min_y());
+ }
+}
+
void hide_selection ();
virtual string get_verbose_cursor_string (float);
- virtual void view_to_model_y (double&) = 0;
- virtual void model_to_view_y (double&) = 0;
+ virtual void view_to_model_y (double&);
+ virtual void model_to_view_y (double&);
boost::shared_ptr<ARDOUR::AutomationList> the_list() const { return alist; }
+++ /dev/null
-/*
- Copyright (C) 2000-2007 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.
-
-*/
-
-#include <sigc++/signal.h>
-
-#include <ardour/curve.h>
-
-#include "automation_midi_cc_line.h"
-
-using namespace std;
-using namespace ARDOUR;
-using namespace PBD;
-
-AutomationMidiCCLine::AutomationMidiCCLine (const string & name, TimeAxisView& tv, ArdourCanvas::Group& parent, boost::shared_ptr<AutomationList> l)
-
- : AutomationLine (name, tv, parent, l)
-{
- set_verbose_cursor_uses_gain_mapping (true);
-}
-
-void
-AutomationMidiCCLine::view_to_model_y (double& y)
-{
- assert(y >= 0);
- assert(y <= 1);
-
- y = (int)(y * 127.0);
-
- assert(y >= 0);
- assert(y <= 127);
-}
-
-void
-AutomationMidiCCLine::model_to_view_y (double& y)
-{
- assert(y >= 0);
- assert(y <= 127);
-
- y = y / 127.0;
-
- assert(y >= 0);
- assert(y <= 1);
-}
-
-string
-AutomationMidiCCLine::get_verbose_cursor_string (float fraction)
-{
- static const size_t MAX_VAL_LEN = 4; // 4 for "127\0"
- char buf[MAX_VAL_LEN];
-
- double cc_val = fraction;
- view_to_model_y(cc_val); // 0..127
-
- snprintf (buf, MAX_VAL_LEN, "%u", (unsigned)cc_val);
-
- return buf;
-}
-
-
-
+++ /dev/null
-/*
- Copyright (C) 2000-2007 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.
-
-*/
-
-#ifndef __ardour_gtk_automation_midi_cc_line_h__
-#define __ardour_gtk_automation_midi_cc_line_h__
-
-#include <ardour/ardour.h>
-
-#include "canvas.h"
-#include "automation_line.h"
-
-class TimeAxisView;
-
-class AutomationMidiCCLine : public AutomationLine
-{
- public:
- AutomationMidiCCLine (const string & name, TimeAxisView&, ArdourCanvas::Group& parent, boost::shared_ptr<ARDOUR::AutomationList>);
-
- void view_to_model_y (double&);
- void model_to_view_y (double&);
-
- string get_verbose_cursor_string (float);
-};
-
-
-#endif /* __ardour_gtk_automation_midi_cc_line_h__ */
-
-
+++ /dev/null
-/*
- Copyright (C) 2000-2003 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.
-
-*/
-
-#include <sigc++/signal.h>
-
-#include <ardour/curve.h>
-
-#include "canvas_impl.h"
-#include "public_editor.h"
-#include "automation_pan_line.h"
-#include "utils.h"
-#include <cmath>
-
-using namespace ARDOUR;
-using namespace PBD;
-
-AutomationPanLine::AutomationPanLine (const string & name, TimeAxisView& tv, ArdourCanvas::Group& parent, boost::shared_ptr<AutomationList> l)
-
- : AutomationLine (name, tv, parent, l)
-{
-}
-
-void
-AutomationPanLine::view_to_model_y (double& y)
-{
- // vertical coordinate axis reversal
- y = 1.0 - y;
-}
-
-void
-AutomationPanLine::model_to_view_y (double& y)
-{
- // vertical coordinate axis reversal
- y = 1.0 - y;
-}
-
-
+++ /dev/null
-/*
- Copyright (C) 2000-2007 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.
-
-*/
-
-#ifndef __ardour_gtk_automation_pan_line_h__
-#define __ardour_gtk_automation_pan_line_h__
-
-#include <ardour/ardour.h>
-
-#include "canvas.h"
-#include "automation_line.h"
-
-class TimeAxisView;
-
-class AutomationPanLine : public AutomationLine
-{
- public:
- AutomationPanLine (const string & name, TimeAxisView&, ArdourCanvas::Group& parent, boost::shared_ptr<ARDOUR::AutomationList>);
-
- void view_to_model_y (double&);
- void model_to_view_y (double&);
-
- private:
- vector<ArdourCanvas::Item*> lines;
-};
-
-
-#endif /* __ardour_gtk_automation_pan_line_h__ */
-
-
Pango::FontDescription AutomationTimeAxisView::name_font;
bool AutomationTimeAxisView::have_name_font = false;
-AutomationTimeAxisView::AutomationTimeAxisView (Session& s, boost::shared_ptr<Route> r, PublicEditor& e, TimeAxisView& rent,
- ArdourCanvas::Canvas& canvas, const string & nom,
- const string & state_name, const string & nomparent)
+AutomationTimeAxisView::AutomationTimeAxisView (Session& s, boost::shared_ptr<Route> r,
+ boost::shared_ptr<Automatable> a, boost::shared_ptr<AutomationControl> c,
+ PublicEditor& e, TimeAxisView& rent,
+ ArdourCanvas::Canvas& canvas, const string & nom,
+ const string & state_name, const string & nomparent)
: AxisView (s),
TimeAxisView (s, e, &rent, canvas),
- route (r),
+ _route (r),
+ _control (c),
+ _automatable (a),
+ _controller(AutomationController::create(s, c->list(), c)),
+ _base_rect (0),
+ _xml_node (0),
_name (nom),
_state_name (state_name),
height_button (_("h")),
ignore_state_request = false;
first_call_to_set_height = true;
- base_rect = new SimpleRect(*canvas_display);
- base_rect->property_x1() = 0.0;
- base_rect->property_y1() = 0.0;
- base_rect->property_x2() = editor.frame_to_pixel (max_frames);
- base_rect->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_AutomationTrackOutline.get();
+ _base_rect = new SimpleRect(*canvas_display);
+ _base_rect->property_x1() = 0.0;
+ _base_rect->property_y1() = 0.0;
+ _base_rect->property_x2() = editor.frame_to_pixel (max_frames);
+ _base_rect->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_AutomationTrackOutline.get();
+
/* outline ends and bottom */
- base_rect->property_outline_what() = (guint32) (0x1|0x2|0x8);
- base_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_AutomationTrackFill.get();
- //base_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_EnteredControlPoint.get();
+ _base_rect->property_outline_what() = (guint32) (0x1|0x2|0x8);
+ _base_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_AutomationTrackFill.get();
- base_rect->set_data ("trackview", this);
+ _base_rect->set_data ("trackview", this);
- base_rect->signal_event().connect (bind (mem_fun (editor, &PublicEditor::canvas_automation_track_event),
- base_rect, this));
+ _base_rect->signal_event().connect (bind (mem_fun (editor, &PublicEditor::canvas_automation_track_event),
+ _base_rect, this));
hide_button.add (*(manage (new Gtk::Image (::get_icon("hide")))));
if (xml_node) {
set_state (*xml_node);
}
+
+ boost::shared_ptr<AutomationLine> line(new AutomationLine (
+ _control->list()->param_id().to_string(),
+ *this,
+ *canvas_display,
+ _control->list()));
+
+ line->set_line_color (ARDOUR_UI::config()->canvasvar_ProcessorAutomationLine.get());
+ line->queue_reset ();
+ add_line (line);
/* make sure labels etc. are correct */
AutomationTimeAxisView::set_automation_state (AutoState state)
{
if (!ignore_state_request) {
- for (Lines::iterator i = lines.begin(); i != lines.end(); ++i) {
- route->set_parameter_automation_state (
- i->second->controllable()->list()->param_id(),
+ if (_route == _automatable) { // FIXME: ew
+ _route->set_parameter_automation_state (
+ _control->list()->param_id(),
state);
}
+
+ _control->list()->set_automation_state(state);
+
}
}
/* update button label */
- if (lines.empty()) {
+ if (!_line) {
state = Off;
} else {
- state = lines.front().first->the_list()->automation_state ();
+ state = _control->list()->automation_state ();
}
switch (state & (Off|Play|Touch|Write)) {
AutomationTimeAxisView::clear_clicked ()
{
_session.begin_reversible_command (_("clear automation"));
- for (Lines::iterator i = lines.begin(); i != lines.end(); ++i) {
- i->first->clear ();
- }
+ _line->clear ();
_session.commit_reversible_command ();
}
XMLNode* xml_node = state_parent->get_child_xml_node (_state_name);
TimeAxisView::set_height (ht);
- base_rect->property_y2() = h;
+ _base_rect->property_y2() = h;
- for (Lines::iterator i = lines.begin(); i != lines.end(); ++i) {
- i->first->set_y_position_and_height (0, h);
- }
+ if (_line)
+ _line->set_y_position_and_height (0, h);
for (list<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
(*i)->set_height ();
//if (changed_between_small_and_normal || first_call_to_set_height) {
first_call_to_set_height = false;
- unsigned control_cnt = 0;
switch (ht) {
case Largest:
case Large:
case Larger:
- for (Lines::iterator i = lines.begin(); i != lines.end(); ++i) {
- i->second->show ();
- controls_table.attach (*i->second.get(), 0, 8, 2 + control_cnt, 3 + control_cnt, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
- ++control_cnt;
- }
+ _controller->show ();
+ controls_table.attach (*_controller.get(), 0, 8, 2, 3, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
case Normal:
if (changed) {
/* only emit the signal if the height really changed */
- route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */
+ _route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */
}
}
{
TimeAxisView::set_samples_per_unit (editor.get_current_zoom());
- for (Lines::iterator i = lines.begin(); i != lines.end(); ++i) {
- i->first->reset ();
- }
+ _line->reset ();
}
void
automation_state_changed ();
}
-bool
-AutomationTimeAxisView::cut_copy_clear (Selection& selection, CutCopyOp op)
+void
+AutomationTimeAxisView::add_automation_event (ArdourCanvas::Item* item, GdkEvent* event, nframes_t when, double y)
{
- bool ret = false;
+ double x = 0;
- for (Lines::iterator i = lines.begin(); i != lines.end(); ++i) {
- ret = cut_copy_clear_one (*i->first, selection, op);
- }
+ canvas_display->w2i (x, y);
- return ret;
+ /* compute vertical fractional position */
+
+ y = 1.0 - (y / height);
+
+ /* map using line */
+
+ _line->view_to_model_y (y);
+
+ _session.begin_reversible_command (_("add automation event"));
+ XMLNode& before = _control->list()->get_state();
+
+ _control->list()->add (when, y);
+
+ XMLNode& after = _control->list()->get_state();
+ _session.commit_reversible_command (new MementoCommand<ARDOUR::AutomationList>(*_control->list().get(), &before, &after));
+
+ _session.set_dirty ();
+}
+
+
+bool
+AutomationTimeAxisView::cut_copy_clear (Selection& selection, CutCopyOp op)
+{
+ return cut_copy_clear_one (*_line, selection, op);
}
bool
void
AutomationTimeAxisView::reset_objects (PointSelection& selection)
{
- for (Lines::iterator i = lines.begin(); i != lines.end(); ++i) {
- reset_objects_one (*i->first, selection);
- }
+ reset_objects_one (*_line, selection);
}
void
bool
AutomationTimeAxisView::cut_copy_clear_objects (PointSelection& selection, CutCopyOp op)
{
- bool ret = false;
-
- for (Lines::iterator i = lines.begin(); i != lines.end(); ++i) {
- ret = cut_copy_clear_objects_one (*i->first, selection, op);
- }
-
- return ret;
+ return cut_copy_clear_objects_one (*_line, selection, op);
}
bool
bool
AutomationTimeAxisView::paste (nframes_t pos, float times, Selection& selection, size_t nth)
{
- bool ret = true;
-
- for (Lines::iterator i = lines.begin(); i != lines.end(); ++i) {
- ret = paste_one (*i->first, pos, times, selection, nth);
- }
-
- return ret;
+ return paste_one (*_line, pos, times, selection, nth);
}
bool
void
AutomationTimeAxisView::get_selectables (nframes_t start, nframes_t end, double top, double bot, list<Selectable*>& results)
{
- if (!lines.empty() && touched (top, bot)) {
+ if (_line && touched (top, bot)) {
double topfrac;
double botfrac;
botfrac = 1.0 - ((bot - y_position) / height);
}
- for (Lines::iterator i = lines.begin(); i != lines.end(); ++i) {
- i->first->get_selectables (start, end, botfrac, topfrac, results);
- }
+ _line->get_selectables (start, end, botfrac, topfrac, results);
}
}
void
AutomationTimeAxisView::get_inverted_selectables (Selection& sel, list<Selectable*>& result)
{
- for (Lines::iterator i = lines.begin(); i != lines.end(); ++i) {
- i->first->get_inverted_selectables (sel, result);
- }
+ _line->get_inverted_selectables (sel, result);
}
void
AutomationTimeAxisView::set_selected_points (PointSelection& points)
{
- for (Lines::iterator i = lines.begin(); i != lines.end(); ++i) {
- i->first->set_selected_points (points);
- }
+ _line->set_selected_points (points);
}
void
AutomationTimeAxisView::clear_lines ()
{
- for (Lines::iterator i = lines.begin(); i != lines.end(); ++i)
- delete i->first;
-
- lines.clear ();
+ _line.reset();
automation_connection.disconnect ();
}
void
-AutomationTimeAxisView::add_line (AutomationLine& line)
+AutomationTimeAxisView::add_line (boost::shared_ptr<AutomationLine> line)
{
- bool get = false;
+ assert(line);
+ assert(!_line);
+ assert(line->the_list() == _control->list());
- if (lines.empty()) {
- /* first line is the Model for automation state */
- automation_connection = line.the_list()->automation_state_changed.connect
- (mem_fun(*this, &AutomationTimeAxisView::automation_state_changed));
- get = true;
- }
+ automation_connection = _control->list()->automation_state_changed.connect
+ (mem_fun(*this, &AutomationTimeAxisView::automation_state_changed));
- lines.push_back (std::make_pair(&line,
- AutomationController::create(_session, line.the_list(),
- route->control(line.the_list()->param_id()))));
+ _line = line;
+ //_controller = AutomationController::create(_session, line->the_list(), _control);
- line.set_y_position_and_height (0, height);
+ line->set_y_position_and_height (0, height);
- if (get) {
- /* pick up the current state */
- automation_state_changed ();
- }
+ /* pick up the current state */
+ automation_state_changed ();
- line.show();
+ line->show();
}
void
AutomationTimeAxisView::show_all_control_points ()
{
- for (Lines::iterator i = lines.begin(); i != lines.end(); ++i) {
- i->first->show_all_control_points ();
- }
+ _line->show_all_control_points ();
}
void
AutomationTimeAxisView::hide_all_but_selected_control_points ()
{
- for (Lines::iterator i = lines.begin(); i != lines.end(); ++i) {
- i->first->hide_all_but_selected_control_points ();
- }
+ _line->hide_all_but_selected_control_points ();
}
void
(*i)->set_colors();
}
- for (Lines::iterator i=lines.begin(); i != lines.end(); i++ ) {
- i->first->set_colors();
- }
+ _line->set_colors();
}
void
AutomationTimeAxisView::set_state (const XMLNode& node)
{
TimeAxisView::set_state (node);
+
+ XMLNodeList kids;
+ XMLNodeConstIterator iter;
+
+ kids = node.children ();
+
+ //snprintf (buf, sizeof(buf), "Port_%" PRIu32, param.id());
+
+ for (iter = kids.begin(); iter != kids.end(); ++iter) {
+ if ((*iter)->name() == _control->list()->param_id().to_string()) {
+
+ XMLProperty *shown = (*iter)->property("shown_editor");
+
+ if (shown && shown->value() == "yes") {
+ set_marked_for_display(true);
+ canvas_display->show(); /* FIXME: necessary? show_at? */
+ }
+ break;
+ }
+ }
+
+ if (!_marked_for_display)
+ hide();
+
+ // FIXME: _xml_node = &node?
}
XMLNode*
return 0;
}
}
+
+void
+AutomationTimeAxisView::ensure_xml_node ()
+{
+ if ((_automatable != _route) && _xml_node == 0) {
+ if ((_xml_node = _automatable->extra_xml ("GUI")) == 0) {
+ _xml_node = new XMLNode ("GUI");
+ _automatable->add_extra_xml (*_xml_node);
+ }
+ }
+}
+
+void
+AutomationTimeAxisView::update_extra_xml_shown (bool editor_shown)
+{
+ if (_automatable == _route)
+ return;
+
+ char buf[32];
+
+ ensure_xml_node ();
+
+ XMLNodeList nlist = _xml_node->children ();
+ XMLNodeConstIterator i;
+ XMLNode * port_node = 0;
+
+ /* FIXME: these parsed XML node names need to go */
+ //snprintf (buf, sizeof(buf), "Port_%" PRIu32, _param.id());
+
+ for (i = nlist.begin(); i != nlist.end(); ++i) {
+ /* FIXME: legacy session loading */
+ if ((*i)->name() == _control->list()->param_id().to_string()) {
+ port_node = (*i);
+ break;
+ }
+ }
+
+ if (!port_node) {
+ port_node = new XMLNode(buf);
+ _xml_node->add_child_nocopy(*port_node);
+ }
+
+ port_node->add_property ("shown_editor", editor_shown ? "yes": "no");
+}
+
+guint32
+AutomationTimeAxisView::show_at (double y, int& nth, Gtk::VBox *parent)
+{
+ update_extra_xml_shown (true);
+
+ return TimeAxisView::show_at (y, nth, parent);
+}
+
+void
+AutomationTimeAxisView::hide ()
+{
+ update_extra_xml_shown (false);
+
+ TimeAxisView::hide ();
+}
+
#include <boost/shared_ptr.hpp>
#include <ardour/types.h>
+#include <ardour/automatable.h>
#include "canvas.h"
#include "time_axis_view.h"
class Selection;
class Selectable;
-/** TODO: All the derived types of this can probably be merged into this cleanly.
- */
+
class AutomationTimeAxisView : public TimeAxisView {
public:
AutomationTimeAxisView (ARDOUR::Session&,
boost::shared_ptr<ARDOUR::Route>,
+ boost::shared_ptr<ARDOUR::Automatable>,
+ boost::shared_ptr<ARDOUR::AutomationControl>,
PublicEditor&,
TimeAxisView& parent,
ArdourCanvas::Canvas& canvas,
~AutomationTimeAxisView();
- virtual void set_height (TimeAxisView::TrackHeight);
+ void set_height (TimeAxisView::TrackHeight);
void set_samples_per_unit (double);
std::string name() const { return _name; }
- virtual void add_automation_event (ArdourCanvas::Item *item, GdkEvent *event, nframes_t, double) = 0;
-
- virtual void clear_lines ();
- virtual void add_line (AutomationLine&);
+ void add_automation_event (ArdourCanvas::Item *item, GdkEvent *event, nframes_t, double);
- typedef vector<std::pair<AutomationLine*,boost::shared_ptr<AutomationController> > > Lines;
- Lines lines;
+ void clear_lines ();
+ boost::shared_ptr<AutomationLine> line() { return _line; }
void set_selected_points (PointSelection&);
void get_selectables (nframes_t start, nframes_t end, double top, double bot, list<Selectable *>&);
void hide_all_but_selected_control_points ();
void set_state (const XMLNode&);
XMLNode* get_state_node ();
+
+ guint32 show_at (double y, int& nth, Gtk::VBox *parent);
+ void hide ();
protected:
- boost::shared_ptr<ARDOUR::Route> route;
- ArdourCanvas::SimpleRect* base_rect;
+ boost::shared_ptr<ARDOUR::Route> _route; ///< Parent route
+ boost::shared_ptr<ARDOUR::AutomationControl> _control; ///< Control
+ boost::shared_ptr<ARDOUR::Automatable> _automatable; ///< Control owner, maybe = _route
+
+ boost::shared_ptr<AutomationController> _controller;
+
+ ArdourCanvas::SimpleRect* _base_rect;
+ boost::shared_ptr<AutomationLine> _line;
+
+ XMLNode* _xml_node;
+
string _name;
string _state_name;
bool in_destructor;
Gtk::CheckMenuItem* auto_touch_item;
Gtk::CheckMenuItem* auto_write_item;
+ void add_line (boost::shared_ptr<AutomationLine>);
+
void clear_clicked ();
void height_clicked ();
void hide_clicked ();
void auto_clicked ();
- virtual void build_display_menu ();
+ void build_display_menu ();
list<GhostRegion*> ghosts;
void automation_state_changed ();
sigc::connection automation_connection;
+ void ensure_xml_node ();
+ void update_extra_xml_shown (bool editor_shown);
+
void entered ();
void exited ();
#include "crossfade_view.h"
#include "audio_time_axis.h"
#include "region_gain_line.h"
-#include "automation_gain_line.h"
-#include "automation_pan_line.h"
-#include "automation_midi_cc_line.h"
+#include "automation_line.h"
#include "automation_time_axis.h"
-#include "processor_automation_line.h"
+#include "automation_line.h"
#include "canvas_impl.h"
#include "simplerect.h"
bool
Editor::canvas_control_point_event (GdkEvent *event, ArdourCanvas::Item* item, ControlPoint* cp)
{
- ItemType type;
-
switch (event->type) {
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
break;
}
- if (dynamic_cast<AudioRegionGainLine*> (&cp->line) != 0) {
- type = GainControlPointItem;
- } else if (dynamic_cast<AutomationGainLine*> (&cp->line) != 0) {
- type = GainAutomationControlPointItem;
- } else if (dynamic_cast<AutomationPanLine*> (&cp->line) != 0) {
- type = PanAutomationControlPointItem;
- } else if (dynamic_cast<ProcessorAutomationLine*> (&cp->line) != 0) {
- type = RedirectAutomationControlPointItem;
- } else if (dynamic_cast<AutomationMidiCCLine*> (&cp->line) != 0) {
- type = MidiCCAutomationControlPointItem;
- } else {
- return false;
- }
-
- return typed_event (item, event, type);
+ return typed_event (item, event, ControlPointItem);
}
bool
if (dynamic_cast<AudioRegionGainLine*> (al) != 0) {
type = GainLineItem;
- } else if (dynamic_cast<AutomationGainLine*> (al) != 0) {
- type = GainAutomationLineItem;
- } else if (dynamic_cast<AutomationPanLine*> (al) != 0) {
- type = PanAutomationLineItem;
- } else if (dynamic_cast<ProcessorAutomationLine*> (al) != 0) {
- type = ProcessorAutomationLineItem;
- } else if (dynamic_cast<AutomationMidiCCLine*> (al) != 0) {
- type = MidiCCAutomationLineItem;
} else {
- return false;
+ type = AutomationLineItem;
}
return typed_event (item, event, type);
RangeMarkerBarItem,
TransportMarkerBarItem,
SelectionItem,
- GainControlPointItem,
+ ControlPointItem,
GainLineItem,
- GainAutomationControlPointItem,
- GainAutomationLineItem,
- PanAutomationControlPointItem,
- PanAutomationLineItem,
- RedirectAutomationControlPointItem,
- ProcessorAutomationLineItem,
- MidiCCAutomationControlPointItem,
- MidiCCAutomationLineItem,
+ AutomationLineItem,
MeterMarkerItem,
TempoMarkerItem,
MeterBarItem,
commit = set_selected_track_from_click (press, op, false);
break;
- case GainAutomationControlPointItem:
- case PanAutomationControlPointItem:
- case RedirectAutomationControlPointItem:
- case MidiCCAutomationControlPointItem:
+ case ControlPointItem:
commit = set_selected_track_from_click (press, op, true);
if (mouse_mode != MouseRange) {
commit |= set_selected_control_point_from_click (op, false);
return true;
break;
- case GainAutomationControlPointItem:
- case PanAutomationControlPointItem:
- case RedirectAutomationControlPointItem:
- case MidiCCAutomationControlPointItem:
+ case ControlPointItem:
start_control_point_grab (item, event);
return true;
break;
- case GainAutomationLineItem:
- case PanAutomationLineItem:
- case ProcessorAutomationLineItem:
- case MidiCCAutomationLineItem:
+ case AutomationLineItem:
start_line_grab_from_line (item, event);
return true;
break;
// start_line_grab_from_regionview (item, event);
break;
- case GainControlPointItem:
- start_control_point_grab (item, event);
- return true;
-
case GainLineItem:
start_line_grab_from_line (item, event);
return true;
- case GainAutomationControlPointItem:
- case PanAutomationControlPointItem:
- case RedirectAutomationControlPointItem:
- case MidiCCAutomationControlPointItem:
+ case ControlPointItem:
start_control_point_grab (item, event);
return true;
break;
break;
switch (item_type) {
- case GainAutomationControlPointItem:
- case PanAutomationControlPointItem:
- case RedirectAutomationControlPointItem:
- case MidiCCAutomationControlPointItem:
+ case ControlPointItem:
start_control_point_grab (item, event);
break;
- case GainAutomationLineItem:
- case PanAutomationLineItem:
- case ProcessorAutomationLineItem:
- case MidiCCAutomationLineItem:
+ case AutomationLineItem:
start_line_grab_from_line (item, event);
break;
}
break;
- case GainAutomationControlPointItem:
- case PanAutomationControlPointItem:
- case RedirectAutomationControlPointItem:
- case MidiCCAutomationControlPointItem:
+ case ControlPointItem:
start_control_point_grab (item, event);
return true;
break;
}
break;
- case GainControlPointItem:
+ case ControlPointItem:
if (mouse_mode == MouseGain) {
remove_gain_control_point (item, event);
+ } else {
+ remove_control_point (item, event);
}
break;
- case GainAutomationControlPointItem:
- case PanAutomationControlPointItem:
- case RedirectAutomationControlPointItem:
- case MidiCCAutomationControlPointItem:
- remove_control_point (item, event);
- break;
-
default:
break;
}
case PlayheadCursorItem:
case MarkerItem:
case GainLineItem:
- case GainAutomationLineItem:
- case PanAutomationLineItem:
- case ProcessorAutomationLineItem:
- case MidiCCAutomationLineItem:
+ case AutomationLineItem:
case StartSelectionTrimItem:
case EndSelectionTrimItem:
return true;
double fraction;
switch (item_type) {
- case GainControlPointItem:
- if (mouse_mode == MouseGain) {
- cp = static_cast<ControlPoint*>(item->get_data ("control_point"));
- cp->set_visible (true);
-
- double at_x, at_y;
- at_x = cp->get_x();
- at_y = cp->get_y ();
- cp->item->i2w (at_x, at_y);
- at_x += 20.0;
- at_y += 20.0;
-
- fraction = 1.0 - ((cp->get_y() - cp->line.y_position()) / cp->line.height());
-
- set_verbose_canvas_cursor (cp->line.get_verbose_cursor_string (fraction), at_x, at_y);
- show_verbose_canvas_cursor ();
-
- if (is_drawable()) {
- track_canvas.get_window()->set_cursor (*fader_cursor);
- }
- }
- break;
-
- case GainAutomationControlPointItem:
- case PanAutomationControlPointItem:
- case RedirectAutomationControlPointItem:
- case MidiCCAutomationControlPointItem:
+ case ControlPointItem:
if (mouse_mode == MouseGain || mouse_mode == MouseObject) {
cp = static_cast<ControlPoint*>(item->get_data ("control_point"));
cp->set_visible (true);
}
break;
- case GainAutomationLineItem:
- case ProcessorAutomationLineItem:
- case MidiCCAutomationLineItem:
- case PanAutomationLineItem:
+ case AutomationLineItem:
if (mouse_mode == MouseGain || mouse_mode == MouseObject) {
{
ArdourCanvas::Line *line = dynamic_cast<ArdourCanvas::Line *> (item);
switch (item_type) {
case GainLineItem:
- case GainAutomationLineItem:
- case ProcessorAutomationLineItem:
- case MidiCCAutomationLineItem:
- case PanAutomationLineItem:
- case GainControlPointItem:
- case GainAutomationControlPointItem:
- case PanAutomationControlPointItem:
- case RedirectAutomationControlPointItem:
- case MidiCCAutomationControlPointItem:
+ case AutomationLineItem:
+ case ControlPointItem:
/* these do not affect the current entered track state */
clear_entered_track = false;
break;
bool is_start;
switch (item_type) {
- case GainControlPointItem:
- case GainAutomationControlPointItem:
- case PanAutomationControlPointItem:
- case RedirectAutomationControlPointItem:
- case MidiCCAutomationControlPointItem:
+ case ControlPointItem:
cp = reinterpret_cast<ControlPoint*>(item->get_data ("control_point"));
if (cp->line.npoints() > 1) {
if (!cp->selected) {
break;
case GainLineItem:
- case GainAutomationLineItem:
- case ProcessorAutomationLineItem:
- case MidiCCAutomationLineItem:
- case PanAutomationLineItem:
+ case AutomationLineItem:
al = reinterpret_cast<AutomationLine*> (item->get_data ("line"));
{
ArdourCanvas::Line *line = dynamic_cast<ArdourCanvas::Line *> (item);
case PlayheadCursorItem:
case EditCursorItem:
case MarkerItem:
- case GainControlPointItem:
- case RedirectAutomationControlPointItem:
- case MidiCCAutomationControlPointItem:
- case GainAutomationControlPointItem:
- case PanAutomationControlPointItem:
+ case ControlPointItem:
case TempoMarkerItem:
case MeterMarkerItem:
case RegionViewNameHighlight:
case EndSelectionTrimItem:
case SelectionItem:
case GainLineItem:
- case ProcessorAutomationLineItem:
- case MidiCCAutomationLineItem:
- case GainAutomationLineItem:
- case PanAutomationLineItem:
+ case AutomationLineItem:
case FadeInHandleItem:
case FadeOutHandleItem:
TimeAxisView *tracklist_timeview;
tracklist_timeview = (*i);
RouteTimeAxisView* rtv2 = dynamic_cast<RouteTimeAxisView*>(tracklist_timeview);
- list<TimeAxisView*> children_list;
+ TimeAxisView::Children children_list;
/* zeroes are audio tracks. ones are other types. */
height_list[rtv2->order] = (*i)->height;
children = 1;
if ((children_list = rtv2->get_child_list()).size() > 0) {
- for (list<TimeAxisView*>::iterator j = children_list.begin(); j != children_list.end(); ++j) {
+ for (TimeAxisView::Children::iterator j = children_list.begin(); j != children_list.end(); ++j) {
tracks = tracks |= (0x01 << (rtv2->order + children));
height_list[rtv2->order + children] = (*j)->height;
numtracks++;
+++ /dev/null
-/*
- Copyright (C) 2003 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.
-
-*/
-
-#include <ardour/automation_event.h>
-#include <ardour/route.h>
-#include <pbd/memento_command.h>
-
-#include "gain_automation_time_axis.h"
-#include "automation_line.h"
-#include "canvas.h"
-
-#include "i18n.h"
-
-using namespace ARDOUR;
-using namespace PBD;
-using namespace Gtk;
-
-GainAutomationTimeAxisView::GainAutomationTimeAxisView (Session& s, boost::shared_ptr<Route> r,
- PublicEditor& e, TimeAxisView& parent,
- ArdourCanvas::Canvas& canvas, const string & n,
- boost::shared_ptr<ARDOUR::AutomationControl> c)
-
- : AxisView (s),
- AutomationTimeAxisView (s, r, e, parent, canvas, n, X_("gain"), ""),
- _control (c)
-{
-}
-
-GainAutomationTimeAxisView::~GainAutomationTimeAxisView ()
-{
-}
-
-void
-GainAutomationTimeAxisView::add_automation_event (ArdourCanvas::Item* item, GdkEvent* event, nframes_t when, double y)
-{
- double x = 0;
-
- canvas_display->w2i (x, y);
-
- /* compute vertical fractional position */
-
- y = 1.0 - (y / height);
-
- /* map using line */
-
- lines.front().first->view_to_model_y (y);
-
- _session.begin_reversible_command (_("add gain automation event"));
- XMLNode& before = _control->list()->get_state();
- _control->list()->add (when, y);
- XMLNode& after = _control->list()->get_state();
- _session.commit_reversible_command (new MementoCommand<ARDOUR::AutomationList>(*_control->list(), &before, &after));
- _session.set_dirty ();
-}
-
+++ /dev/null
-/*
- Copyright (C) 2000-2007 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.
-
-*/
-
-#ifndef __ardour_gtk_gain_automation_time_axis_h__
-#define __ardour_gtk_gain_automation_time_axis_h__
-
-#include "canvas.h"
-#include "automation_time_axis.h"
-
-namespace ARDOUR {
- class AutomationList;
- class AutomationControl;
-}
-
-class GainAutomationTimeAxisView : public AutomationTimeAxisView
-{
- public:
- GainAutomationTimeAxisView (ARDOUR::Session&,
- boost::shared_ptr<ARDOUR::Route>,
- PublicEditor&,
- TimeAxisView& parent_axis,
- ArdourCanvas::Canvas& canvas,
- const string & name,
- boost::shared_ptr<ARDOUR::AutomationControl> control);
-
- ~GainAutomationTimeAxisView();
-
- void add_automation_event (ArdourCanvas::Item *item, GdkEvent *event, nframes_t, double);
-
- private:
- boost::shared_ptr<ARDOUR::AutomationControl> _control;
-
- void automation_changed ();
-};
-
-#endif /* __ardour_gtk_gain_automation_time_axis_h__ */
#include "plugin_ui.h"
#include "utils.h"
#include "gui_thread.h"
+#include "automation_controller.h"
#include "i18n.h"
}
}
- if ((cui = build_control_ui (i, plugin->get_nth_control (i))) == 0) {
+ if ((cui = build_control_ui (i, insert->control(ParamID(PluginAutomation, i)))) == 0) {
error << string_compose(_("Plugin Editor: could not build control element for port %1"), i) << endmsg;
continue;
}
ignore_change = 0;
display = 0;
button = 0;
- control = 0;
clickbox = 0;
- adjustment = 0;
meterinfo = 0;
}
LadspaPluginUI::ControlUI::~ControlUI()
{
- if (adjustment) {
- delete adjustment;
- }
-
if (meterinfo) {
delete meterinfo->meter;
delete meterinfo;
{
/* update button label */
- switch (insert->get_parameter_automation_state (ParamID(PluginAutomation, cui->port_index))
+ // don't lock to avoid deadlock because we're triggered by
+ // AutomationControl::Changed() while the automation lock is taken
+ switch (insert->get_parameter_automation_state (cui->param_id(), false)
& (Off|Play|Touch|Write)) {
case Off:
cui->automate_button.set_label (_("Manual"));
}
LadspaPluginUI::ControlUI*
-LadspaPluginUI::build_control_ui (guint32 port_index, PBD::Controllable* mcontrol)
-
+LadspaPluginUI::build_control_ui (guint32 port_index, boost::shared_ptr<AutomationControl> mcontrol)
{
ControlUI* control_ui;
Plugin::ParameterDescriptor desc;
plugin->get_parameter_descriptor (port_index, desc);
control_ui = manage (new ControlUI ());
- control_ui->adjustment = 0;
control_ui->combo = 0;
control_ui->combo_map = 0;
- control_ui->port_index = port_index;
+ control_ui->control = mcontrol;
control_ui->update_pending = false;
control_ui->label.set_text (desc.label);
control_ui->label.set_alignment (0.0, 0.5);
//control_ui->combo->set_value_in_list(true, false);
set_popdown_strings (*control_ui->combo, setup_scale_values(port_index, control_ui));
control_ui->combo->signal_changed().connect (bind (mem_fun(*this, &LadspaPluginUI::control_combo_changed), control_ui));
- plugin->ParameterChanged.connect (bind (mem_fun (*this, &LadspaPluginUI::parameter_changed), control_ui));
+ mcontrol->Changed.connect (bind (mem_fun (*this, &LadspaPluginUI::parameter_changed), control_ui));
control_ui->pack_start(control_ui->label, true, true);
control_ui->pack_start(*control_ui->combo, false, true);
return control_ui;
}
- control_ui->adjustment = new Adjustment (0, 0, 0, 0, 0);
-
/* XXX this code is not right yet, because it doesn't handle
the absence of bounds in any sensible fashion.
*/
- control_ui->adjustment->set_lower (desc.lower);
- control_ui->adjustment->set_upper (desc.upper);
+#if 0
+ control_ui->controller->adjustment()->set_lower (desc.lower);
+ control_ui->controller->adjustment()->set_upper (desc.upper);
control_ui->logarithmic = desc.logarithmic;
if (control_ui->logarithmic) {
- if (control_ui->adjustment->get_lower() == 0.0) {
- control_ui->adjustment->set_lower (control_ui->adjustment->get_upper()/10000);
+ if (control_ui->controller->adjustment()->get_lower() == 0.0) {
+ control_ui->controller->adjustment()->set_lower (control_ui->controller->adjustment()->get_upper()/10000);
}
- control_ui->adjustment->set_upper (log(control_ui->adjustment->get_upper()));
- control_ui->adjustment->set_lower (log(control_ui->adjustment->get_lower()));
+ control_ui->controller->adjustment()->set_upper (log(control_ui->controller->adjustment()->get_upper()));
+ control_ui->controller->adjustment()->set_lower (log(control_ui->controller->adjustment()->get_lower()));
}
+
float delta = desc.upper - desc.lower;
- control_ui->adjustment->set_page_size (delta/100.0);
- control_ui->adjustment->set_step_increment (desc.step);
- control_ui->adjustment->set_page_increment (desc.largestep);
+ control_ui->controller->adjustment()->set_page_size (delta/100.0);
+ control_ui->controller->adjustment()->set_step_increment (desc.step);
+ control_ui->controller->adjustment()->set_page_increment (desc.largestep);
+#endif
if (desc.integer_step) {
- control_ui->clickbox = new ClickBox (control_ui->adjustment, "PluginUIClickBox");
+ control_ui->clickbox = new ClickBox (control_ui->controller->adjustment(), "PluginUIClickBox");
Gtkmm2ext::set_size_request_to_display_given_text (*control_ui->clickbox, "g9999999", 2, 2);
control_ui->clickbox->set_print_func (integer_printer, 0);
} else {
- sigc::slot<void,char*,uint32_t> pslot = sigc::bind (mem_fun(*this, &LadspaPluginUI::print_parameter), (uint32_t) port_index);
+ //sigc::slot<void,char*,uint32_t> pslot = sigc::bind (mem_fun(*this, &LadspaPluginUI::print_parameter), (uint32_t) port_index);
- control_ui->control = new BarController (*control_ui->adjustment, *mcontrol, pslot);
- control_ui->control->set_size_request (200, req.height);
- control_ui->control->set_name (X_("PluginSlider"));
- control_ui->control->set_style (BarController::LeftToRight);
- control_ui->control->set_use_parent (true);
+ control_ui->controller = AutomationController::create(insert->session(), mcontrol->list(), mcontrol);
+ control_ui->controller->set_size_request (200, req.height);
+ control_ui->controller->set_name (X_("PluginSlider"));
+ control_ui->controller->set_style (BarController::LeftToRight);
+ control_ui->controller->set_use_parent (true);
- control_ui->control->StartGesture.connect (bind (mem_fun(*this, &LadspaPluginUI::start_touch), control_ui));
- control_ui->control->StopGesture.connect (bind (mem_fun(*this, &LadspaPluginUI::stop_touch), control_ui));
+ control_ui->controller->StartGesture.connect (bind (mem_fun(*this, &LadspaPluginUI::start_touch), control_ui));
+ control_ui->controller->StopGesture.connect (bind (mem_fun(*this, &LadspaPluginUI::stop_touch), control_ui));
}
if (control_ui->logarithmic) {
- control_ui->adjustment->set_value(log(plugin->get_parameter(port_index)));
+ control_ui->controller->adjustment()->set_value(log(plugin->get_parameter(port_index)));
} else{
- control_ui->adjustment->set_value(plugin->get_parameter(port_index));
+ control_ui->controller->adjustment()->set_value(plugin->get_parameter(port_index));
}
/* XXX memory leak: SliderController not destroyed by ControlUI
if (desc.integer_step) {
control_ui->pack_start (*control_ui->clickbox, false, false);
} else {
- control_ui->pack_start (*control_ui->control, false, false);
+ control_ui->pack_start (*control_ui->controller, false, false);
}
control_ui->pack_start (control_ui->automate_button, false, false);
- control_ui->adjustment->signal_value_changed().connect (bind (mem_fun(*this, &LadspaPluginUI::control_adjustment_changed), control_ui));
control_ui->automate_button.signal_clicked().connect (bind (mem_fun(*this, &LadspaPluginUI::astate_clicked), control_ui, (uint32_t) port_index));
automation_state_changed (control_ui);
- plugin->ParameterChanged.connect (bind (mem_fun(*this, &LadspaPluginUI::parameter_changed), control_ui));
- insert->control (ParamID(PluginAutomation, port_index))->list()->automation_state_changed.connect
+ mcontrol->Changed.connect (bind (mem_fun (*this, &LadspaPluginUI::parameter_changed), control_ui));
+ mcontrol->list()->automation_state_changed.connect
(bind (mem_fun(*this, &LadspaPluginUI::automation_state_changed), control_ui));
} else if (plugin->parameter_is_output (port_index)) {
output_controls.push_back (control_ui);
}
- plugin->ParameterChanged.connect (bind (mem_fun(*this, &LadspaPluginUI::parameter_changed), control_ui));
+ mcontrol->Changed.connect (bind (mem_fun (*this, &LadspaPluginUI::parameter_changed), control_ui));
+
return control_ui;
}
void
LadspaPluginUI::start_touch (LadspaPluginUI::ControlUI* cui)
{
- insert->control (ParamID(PluginAutomation, cui->port_index))->list()->start_touch ();
+ cui->control->list()->start_touch ();
}
void
LadspaPluginUI::stop_touch (LadspaPluginUI::ControlUI* cui)
{
- insert->control (ParamID(PluginAutomation, cui->port_index))->list()->stop_touch ();
+ cui->control->list()->stop_touch ();
}
void
void
LadspaPluginUI::set_automation_state (AutoState state, ControlUI* cui)
{
- insert->set_parameter_automation_state (ParamID(PluginAutomation, cui->port_index), state);
-}
-
-void
-LadspaPluginUI::control_adjustment_changed (ControlUI* cui)
-{
- if (cui->ignore_change) {
- return;
- }
-
- double value = cui->adjustment->get_value();
-
- if (cui->logarithmic) {
- value = exp(value);
- }
-
- insert->set_parameter (ParamID(PluginAutomation, cui->port_index), (float) value);
+ insert->set_parameter_automation_state (cui->param_id(), state);
}
void
-LadspaPluginUI::parameter_changed (uint32_t abs_port_id, float val, ControlUI* cui)
+LadspaPluginUI::parameter_changed (ControlUI* cui)
{
- if (cui->port_index == abs_port_id) {
- if (!cui->update_pending) {
- cui->update_pending = true;
- Gtkmm2ext::UI::instance()->call_slot (bind (mem_fun(*this, &LadspaPluginUI::update_control_display), cui));
- }
+ if (!cui->update_pending) {
+ cui->update_pending = true;
+ Gtkmm2ext::UI::instance()->call_slot (bind (mem_fun(*this, &LadspaPluginUI::update_control_display), cui));
}
}
cui->update_pending = false;
- float val = plugin->get_parameter (cui->port_index);
+ float val = cui->control->get_value();
cui->ignore_change++;
if (cui->combo) {
break;
}
}
- } else if (cui->adjustment == 0) {
+ } else if (cui->button) {
if (val > 0.5) {
cui->button->set_active (true);
} else {
cui->button->set_active (false);
}
+ }
+
+ cui->controller->display_effective_value();
- } else {
+
+ /*} else {
if (cui->logarithmic) {
val = log(val);
}
if (val != cui->adjustment->get_value()) {
cui->adjustment->set_value (val);
}
- }
+ }*/
cui->ignore_change--;
}
LadspaPluginUI::control_port_toggled (ControlUI* cui)
{
if (!cui->ignore_change) {
- insert->set_parameter (ParamID(PluginAutomation, cui->port_index), cui->button->get_active());
+ insert->set_parameter (cui->param_id(), cui->button->get_active());
}
}
if (!cui->ignore_change) {
string value = cui->combo->get_active_text();
std::map<string,float> mapping = *cui->combo_map;
- insert->set_parameter (ParamID(PluginAutomation, cui->port_index), mapping[value]);
+ insert->set_parameter (cui->param_id(), mapping[value]);
}
}
LadspaPluginUI::output_update ()
{
for (vector<ControlUI*>::iterator i = output_controls.begin(); i != output_controls.end(); ++i) {
- float val = plugin->get_parameter ((*i)->port_index);
+ float val = plugin->get_parameter ((*i)->param_id().id());
char buf[32];
snprintf (buf, sizeof(buf), "%.2f", val);
(*i)->display_label->set_text (buf);
+++ /dev/null
-/*
- Copyright (C) 2003 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.
-
-*/
-
-#include <ardour/automation_event.h>
-#include <ardour/route.h>
-#include <pbd/memento_command.h>
-#include <pbd/controllable.h>
-
-#include "midi_controller_time_axis.h"
-#include "automation_line.h"
-#include "canvas.h"
-
-#include "i18n.h"
-
-using namespace ARDOUR;
-using namespace PBD;
-using namespace Gtk;
-
-MidiControllerTimeAxisView::MidiControllerTimeAxisView (Session& s, boost::shared_ptr<Route> r,
- PublicEditor& e, TimeAxisView& parent,
- ArdourCanvas::Canvas& canvas, const string & n,
- boost::shared_ptr<AutomationControl> c)
- : AxisView (s),
- AutomationTimeAxisView (s, r, e, parent, canvas, n, c->list()->param_id().to_string(), ""),
- _control (c)
-{
-}
-
-MidiControllerTimeAxisView::~MidiControllerTimeAxisView ()
-{
-}
-
-void
-MidiControllerTimeAxisView::add_automation_event (ArdourCanvas::Item* item, GdkEvent* event, nframes_t when, double y)
-{
- double x = 0;
-
- canvas_display->w2i (x, y);
-
- /* compute vertical fractional position */
-
- y = 1.0 - (y / height);
-
- /* map using line */
-
- lines.front().first->view_to_model_y (y);
-
- _session.begin_reversible_command (_("add midi controller automation event"));
- XMLNode& before = _control->list()->get_state();
- _control->list()->add (when, y);
- XMLNode& after = _control->list()->get_state();
- _session.commit_reversible_command (new MementoCommand<ARDOUR::AutomationList>(*_control->list().get(), &before, &after));
- _session.set_dirty ();
-}
-
+++ /dev/null
-/*
- Copyright (C) 2000-2007 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.
-
-*/
-
-#ifndef __ardour_gtk_midi_controller_time_axis_h__
-#define __ardour_gtk_midi_controller_time_axis_h__
-
-#include "canvas.h"
-#include "automation_time_axis.h"
-
-namespace ARDOUR {
- class AutomationList;
-}
-
-class MidiControllerTimeAxisView : public AutomationTimeAxisView
-{
- public:
- MidiControllerTimeAxisView (ARDOUR::Session&,
- boost::shared_ptr<ARDOUR::Route>,
- PublicEditor&,
- TimeAxisView& parent_axis,
- ArdourCanvas::Canvas& canvas,
- const string & name,
- boost::shared_ptr<ARDOUR::AutomationControl> c);
-
- ~MidiControllerTimeAxisView();
-
- void add_automation_event (ArdourCanvas::Item *item, GdkEvent *event, nframes_t, double);
-
- private:
- boost::shared_ptr<ARDOUR::AutomationControl> _control;
-
- void automation_changed ();
-};
-
-#endif /* __ardour_gtk_midi_controller_time_axis_h__ */
#include "ardour_ui.h"
#include "midi_time_axis.h"
#include "automation_time_axis.h"
-#include "automation_midi_cc_line.h"
+#include "automation_line.h"
#include "add_midi_cc_track_dialog.h"
#include "canvas_impl.h"
#include "crossfade_view.h"
#include "point_selection.h"
#include "prompter.h"
#include "public_editor.h"
-#include "processor_automation_line.h"
-#include "processor_automation_time_axis.h"
-#include "midi_controller_time_axis.h"
#include "region_view.h"
#include "rgb_macros.h"
#include "selection.h"
_route->add_control(c);
}
- MidiControllerTimeAxisView* track = new MidiControllerTimeAxisView (_session,
- _route,
+ boost::shared_ptr<AutomationTimeAxisView> track(new AutomationTimeAxisView (_session,
+ _route, _route, c,
editor,
*this,
parent_canvas,
_route->describe_parameter(param),
- c);
-
- AutomationMidiCCLine* line = new AutomationMidiCCLine (param.to_string(),
- *track,
- *track->canvas_display,
- c->list());
-
- line->set_line_color (ARDOUR_UI::config()->canvasvar_AutomationLine.get());
-
- track->add_line(*line);
-
+ c->list()->param_id().to_string() /* FIXME: correct state name? */));
add_automation_child(param, track);
} else {
if (!_route->panner().empty()) {
StreamPanner* sp = _route->panner().front();
- panstate_connection = sp->automation()->automation_state_changed.connect (mem_fun(panners, &PannerUI::pan_automation_state_changed));
- panstyle_connection = sp->automation()->automation_style_changed.connect (mem_fun(panners, &PannerUI::pan_automation_style_changed));
+ panstate_connection = sp->pan_control()->list()->automation_state_changed.connect (mem_fun(panners, &PannerUI::pan_automation_state_changed));
+ panstyle_connection = sp->pan_control()->list()->automation_style_changed.connect (mem_fun(panners, &PannerUI::pan_automation_style_changed));
}
panners.pan_changed (this);
+++ /dev/null
-/*
- Copyright (C) 2003 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.
-
-*/
-
-#include <ardour/curve.h>
-#include <ardour/route.h>
-#include <ardour/panner.h>
-
-#include <gtkmm2ext/popup.h>
-#include <pbd/memento_command.h>
-
-#include "pan_automation_time_axis.h"
-#include "automation_line.h"
-#include "canvas_impl.h"
-#include "route_ui.h"
-
-#include "i18n.h"
-
-using namespace ARDOUR;
-using namespace PBD;
-using namespace Gtk;
-
-PanAutomationTimeAxisView::PanAutomationTimeAxisView (Session& s, boost::shared_ptr<Route> r, PublicEditor& e,
- TimeAxisView& parent, Canvas& canvas, std::string n)
-
- : AxisView (s),
- AutomationTimeAxisView (s, r, e, parent, canvas, n, X_("pan"), "")
-{
- multiline_selector.set_name ("PanAutomationLineSelector");
-
- controls_table.attach (multiline_selector, 1, 5, 1, 2, Gtk::EXPAND, Gtk::EXPAND);
-}
-
-PanAutomationTimeAxisView::~PanAutomationTimeAxisView ()
-{
-}
-
-void
-PanAutomationTimeAxisView::add_automation_event (ArdourCanvas::Item* item, GdkEvent* event, nframes_t when, double y)
-{
- if (lines.empty()) {
- /* no data, possibly caused by no outputs/inputs */
- Gtkmm2ext::PopUp* msg = new Gtkmm2ext::PopUp (Gtk::WIN_POS_MOUSE, 5000, true);
-
- msg->set_text (_("Pan automation track has no lines, unable to add point\n(is track pannable?)"));
- msg->touch ();
-
- return;
- }
-
- int line_index = 0;
-
- if (lines.size() > 1) {
- line_index = multiline_selector.get_active_row_number();
-
- if (line_index < 0 || line_index >= (int)lines.size()) {
- Gtkmm2ext::PopUp* msg = new Gtkmm2ext::PopUp (Gtk::WIN_POS_MOUSE, 5000, true);
-
- msg->set_text (_("You need to select which line to edit"));
- msg->touch ();
-
- return;
- }
- }
-
- double x = 0;
-
- canvas_display->w2i (x, y);
-
- /* compute vertical fractional position */
-
- y = 1.0 - (y / height);
-
- /* map using line */
-
- lines.front().first->view_to_model_y (y);
-
- boost::shared_ptr<AutomationList> alist (lines[line_index].first->the_list());
-
- _session.begin_reversible_command (_("add pan automation event"));
- XMLNode &before = alist->get_state();
- alist->add (when, y);
- XMLNode &after = alist->get_state();
- _session.add_command(new MementoCommand<AutomationList>(*alist.get(), &before, &after));
- _session.commit_reversible_command ();
- _session.set_dirty ();
-}
-
-void
-PanAutomationTimeAxisView::clear_lines ()
-{
- AutomationTimeAxisView::clear_lines();
- multiline_selector.clear();
-}
-
-void
-PanAutomationTimeAxisView::add_line (AutomationLine& line)
-{
- char buf[32];
- snprintf(buf,32,"Line %zu",lines.size()+1);
- multiline_selector.append_text(buf);
-
- if (lines.empty()) {
- multiline_selector.set_active(0);
- }
-
- if (lines.size() + 1 > 1 && (height_style != Small && height_style != Smaller)) {
- multiline_selector.show();
- } else {
- multiline_selector.hide();
-
- }
-
- AutomationTimeAxisView::add_line(line);
-}
-
-void
-PanAutomationTimeAxisView::set_height (TimeAxisView::TrackHeight th)
-{
- AutomationTimeAxisView::set_height(th);
-
- switch (th) {
- case Largest:
- case Large:
- case Larger:
- case Normal:
- if (lines.size() > 1) {
- multiline_selector.show();
- break;
- }
- default:
- multiline_selector.hide();
- }
-}
+++ /dev/null
-/*
- Copyright (C) 2000-2007 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.
-
-*/
-
-#ifndef __ardour_gtk_pan_automation_time_axis_h__
-#define __ardour_gtk_pan_automation_time_axis_h__
-
-#include "canvas.h"
-#include "automation_time_axis.h"
-
-#include <gtkmm/comboboxtext.h>
-
-namespace ARDOUR {
- class IOProcessor;
-}
-
-class PanAutomationTimeAxisView : public AutomationTimeAxisView
-{
- public:
- PanAutomationTimeAxisView (ARDOUR::Session&,
- boost::shared_ptr<ARDOUR::Route>,
- PublicEditor&,
- TimeAxisView& parent_axis,
- ArdourCanvas::Canvas& canvas,
- std::string name);
-
- ~PanAutomationTimeAxisView();
-
- void add_automation_event (ArdourCanvas::Item *item, GdkEvent *event, nframes_t, double);
-
- void clear_lines ();
- void add_line (AutomationLine&);
- void set_height (TimeAxisView::TrackHeight);
-
- protected:
- Gtk::ComboBoxText multiline_selector;
-
- private:
- void automation_changed ();
-};
-
-#endif /* __ardour_gtk_pan_automation_time_axis_h__ */
}
pan_adjustments.push_back (new Adjustment (x, 0, 1.0, 0.05, 0.1));
- bc = new PannerBar (*pan_adjustments[asz], _io->panner()[asz]->control());
+ bc = new PannerBar (*pan_adjustments[asz], _io->panner()[asz]->pan_control());
/* now set adjustment with current value of panner, then connect the signals */
pan_adjustments.back()->set_value(rx);
float xpos, val;
if (only_if_aplay) {
- boost::shared_ptr<AutomationList> alist (_io->panner()[n]->automation());
+ boost::shared_ptr<AutomationList> alist (_io->panner()[n]->pan_control()->list());
if (!alist->automation_playback()) {
continue;
return;
}
- x = (_io->panner().front()->automation()->automation_state() != Off);
+ x = (_io->panner().front()->pan_control()->list()->automation_state() != Off);
if (pan_automation_state_button.get_active() != x) {
ignore_toggle = true;
#include <gtkmm/scrolledwindow.h>
#include <gtkmm/label.h>
#include <gtkmm/menu.h>
-#include <gtkmm/adjustment.h>
#include <gtkmm/togglebutton.h>
#include <gtkmm/socket.h>
#include <gtkmm/comboboxtext.h>
#include <ardour/types.h>
#include "latency_gui.h"
+#include "automation_controller.h"
namespace ARDOUR {
class PluginInsert;
static const int32_t initial_output_rows = 1;
static const int32_t initial_output_cols = 4;
- /* TODO: pull this out of PluginUI and make it generic.
- * Sticking this in the track controls of an automation track would
- * make a handy touch controller for anything.
- */
+ /* FIXME: Unify with AutomationController */
struct ControlUI : public Gtk::HBox {
- uint32_t port_index;
+ boost::shared_ptr<ARDOUR::AutomationControl> control;
+
+ ARDOUR::ParamID param_id() { return control->list()->param_id(); }
/* input */
- Gtk::Adjustment* adjustment;
Gtk::ComboBoxText* combo;
std::map<string, float>* combo_map;
Gtk::ToggleButton* button;
- Gtkmm2ext::BarController* control;
+ boost::shared_ptr<AutomationController> controller;
Gtkmm2ext::ClickBox* clickbox;
Gtk::Label label;
bool logarithmic;
void output_update();
void build ();
- ControlUI* build_control_ui (guint32 port_index, PBD::Controllable *);
+ ControlUI* build_control_ui (guint32 port_index, boost::shared_ptr<ARDOUR::AutomationControl>);
std::vector<string> setup_scale_values(guint32 port_index, ControlUI* cui);
- void control_adjustment_changed (ControlUI* cui);
- void parameter_changed (uint32_t, float, ControlUI* cui);
+ void parameter_changed (ControlUI* cui);
void update_control_display (ControlUI* cui);
void control_port_toggled (ControlUI* cui);
void control_combo_changed (ControlUI* cui);
+++ /dev/null
-/*
- Copyright (C) 2002-2003 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.
-
-*/
-
-#include "public_editor.h"
-#include "processor_automation_line.h"
-#include "audio_time_axis.h"
-#include "utils.h"
-
-#include <ardour/ladspa_plugin.h>
-#include <ardour/plugin_insert.h>
-#include <ardour/curve.h>
-
-#include "i18n.h"
-
-using namespace std;
-using namespace ARDOUR;
-using namespace PBD;
-
-ProcessorAutomationLine::ProcessorAutomationLine (const string & name, Processor& proc,
- TimeAxisView& tv, ArdourCanvas::Group& parent, boost::shared_ptr<AutomationList> l)
-
- : AutomationLine (name, tv, parent, l),
- _processor(proc)
-{
- set_verbose_cursor_uses_gain_mapping (false);
-
- PluginInsert *pi;
- Plugin::ParameterDescriptor desc;
-
- if ((pi = dynamic_cast<PluginInsert*>(&_processor)) == 0) {
- fatal << _("insert automation created for non-plugin") << endmsg;
- /*NOTREACHED*/
- }
-
- pi->plugin()->get_parameter_descriptor (l->param_id(), desc);
-
- _upper = desc.upper;
- _lower = desc.lower;
-
- if (desc.toggled) {
- no_draw = true;
- return;
- }
-
- no_draw = false;
- _range = _upper - _lower;
-
- /* XXX set min/max for underlying curve ??? */
-}
-
-string
-ProcessorAutomationLine::get_verbose_cursor_string (float fraction)
-{
- char buf[32];
-
- snprintf (buf, sizeof (buf), "%.2f", _lower + (fraction * _range));
- return buf;
-}
-
-void
-ProcessorAutomationLine::view_to_model_y (double& y)
-{
- y = _lower + (y * _range);
-}
-
-void
-ProcessorAutomationLine::model_to_view_y (double& y)
-{
- y = (y - _lower) / _range;
- y = max (0.0, y);
- y = min (y, 1.0);
-}
-
+++ /dev/null
-/*
- Copyright (C) 2000 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.
-
-*/
-
-#ifndef __ardour_gtk_processor_automation_line_h__
-#define __ardour_gtk_processor_automation_line_h__
-
-#include <ardour/ardour.h>
-
-#include "automation_line.h"
-
-namespace ARDOUR {
- class Processor;
-}
-
-class TimeAxisView;
-
-class ProcessorAutomationLine : public AutomationLine
-{
- public:
- ProcessorAutomationLine (const string & name, ARDOUR::Processor&,
- TimeAxisView&, ArdourCanvas::Group& parent, boost::shared_ptr<ARDOUR::AutomationList>);
-
- ARDOUR::Processor& processor() const { return _processor; }
-
- string get_verbose_cursor_string (float);
-
- private:
- ARDOUR::Processor& _processor;
-
- float _upper;
- float _lower;
- float _range;
-
- void view_to_model_y (double&);
- void model_to_view_y (double&);
-};
-
-#endif /* __ardour_gtk_region_gain_line_h__ */
+++ /dev/null
-/*
- Copyright (C) 2003 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.
-
-*/
-
-#include <ardour/processor.h>
-#include <ardour/session.h>
-#include <cstdlib>
-#include <pbd/memento_command.h>
-
-#include "processor_automation_time_axis.h"
-#include "automation_line.h"
-#include "canvas_impl.h"
-
-#include "i18n.h"
-
-using namespace ARDOUR;
-using namespace PBD;
-using namespace Gtk;
-
-ProcessorAutomationTimeAxisView::ProcessorAutomationTimeAxisView (Session& s, boost::shared_ptr<Route> r,
- PublicEditor& e, TimeAxisView& parent, Canvas& canvas, std::string n,
- ParamID param, Processor& proc, string state_name)
-
- : AxisView (s),
- AutomationTimeAxisView (s, r, e, parent, canvas, n, state_name, proc.name()),
- _processor(proc),
- _param (param)
-
-{
- char buf[32];
- _xml_node = 0;
- _marked_for_display = false;
-
- ensure_xml_node ();
-
- XMLNodeList kids;
- XMLNodeConstIterator iter;
-
- kids = _xml_node->children ();
-
- snprintf (buf, sizeof(buf), "Port_%" PRIu32, param.id());
-
- for (iter = kids.begin(); iter != kids.end(); ++iter) {
- if ((*iter)->name() == buf) {
-
- XMLProperty *shown = (*iter)->property("shown_editor");
-
- if (shown && shown->value() == "yes") {
- _marked_for_display = true;
- }
- break;
- }
- }
-}
-
-ProcessorAutomationTimeAxisView::~ProcessorAutomationTimeAxisView ()
-{
-}
-
-void
-ProcessorAutomationTimeAxisView::add_automation_event (ArdourCanvas::Item* item, GdkEvent* event, nframes_t when, double y)
-{
- double x = 0;
-
- canvas_display->w2i (x, y);
-
- /* compute vertical fractional position */
-
- if (y < 0)
- y = 0;
- else if (y > height)
- y = height;
-
- y = 1.0 - (y / height);
-
- /* map to model space */
-
- if (!lines.empty()) {
- boost::shared_ptr<AutomationList> alist (_processor.control(_param, true)->list());
- string description = _("add automation event to ");
- description += _processor.describe_parameter (_param);
-
- lines.front().first->view_to_model_y (y);
-
- _session.begin_reversible_command (description);
- XMLNode &before = alist->get_state();
- alist->add (when, y);
- XMLNode &after = alist->get_state();
- _session.add_command(new MementoCommand<AutomationList>(*alist, &before, &after));
- _session.commit_reversible_command ();
- _session.set_dirty ();
- }
-}
-
-void
-ProcessorAutomationTimeAxisView::ensure_xml_node ()
-{
- if (_xml_node == 0) {
- if ((_xml_node = _processor.extra_xml ("GUI")) == 0) {
- _xml_node = new XMLNode ("GUI");
- _processor.add_extra_xml (*_xml_node);
- }
- }
-}
-
-guint32
-ProcessorAutomationTimeAxisView::show_at (double y, int& nth, Gtk::VBox *parent)
-{
- ensure_xml_node ();
- update_extra_xml_shown (true);
-
- return TimeAxisView::show_at (y, nth, parent);
-}
-
-void
-ProcessorAutomationTimeAxisView::hide ()
-{
- ensure_xml_node ();
- update_extra_xml_shown (false);
-
- TimeAxisView::hide ();
-}
-
-
-void
-ProcessorAutomationTimeAxisView::update_extra_xml_shown (bool editor_shown)
-{
- char buf[32];
-
- XMLNodeList nlist = _xml_node->children ();
- XMLNodeConstIterator i;
- XMLNode * port_node = 0;
-
- snprintf (buf, sizeof(buf), "Port_%" PRIu32, _param.id());
-
- for (i = nlist.begin(); i != nlist.end(); ++i) {
- if ((*i)->name() == buf) {
- port_node = (*i);
- break;
- }
- }
-
- if (!port_node) {
- port_node = new XMLNode(buf);
- _xml_node->add_child_nocopy(*port_node);
- }
-
- port_node->add_property ("shown_editor", editor_shown ? "yes": "no");
-
-}
-
-void
-ProcessorAutomationTimeAxisView::set_automation_state (AutoState state)
-{
- if (!ignore_state_request) {
- _processor.control (_param, true)->list()->set_automation_state (state);
- }
-}
-
-void
-ProcessorAutomationTimeAxisView::add_line (AutomationLine& line)
-{
- bool get = false;
-
- if (lines.empty()) {
- /* first line is the Model for automation state */
- automation_connection = line.the_list()->automation_state_changed.connect
- (mem_fun(*this, &ProcessorAutomationTimeAxisView::automation_state_changed));
- get = true;
- }
-
- lines.push_back (std::make_pair(&line,
- AutomationController::create(_session, line.the_list(),
- _processor.control(line.the_list()->param_id()))));
-
- line.set_y_position_and_height (0, height);
-
- if (get) {
- /* pick up the current state */
- automation_state_changed ();
- }
-
- line.show();
-}
-
+++ /dev/null
-/*
- Copyright (C) 2000-2007 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.
-
-*/
-
-#ifndef __ardour_gtk_processor_automation_time_axis_h__
-#define __ardour_gtk_processor_automation_time_axis_h__
-
-#include <pbd/xml++.h>
-
-#include "canvas.h"
-#include "automation_time_axis.h"
-#include <ardour/param_id.h>
-
-namespace ARDOUR {
- class Processor;
-}
-
-class ProcessorAutomationTimeAxisView : public AutomationTimeAxisView
-{
- public:
- ProcessorAutomationTimeAxisView (ARDOUR::Session&,
- boost::shared_ptr<ARDOUR::Route>,
- PublicEditor&,
- TimeAxisView& parent,
- ArdourCanvas::Canvas& canvas,
- std::string name,
- ARDOUR::ParamID param,
- ARDOUR::Processor& i,
- std::string state_name);
-
- ~ProcessorAutomationTimeAxisView();
-
- void add_automation_event (ArdourCanvas::Item *item, GdkEvent *event, nframes_t, double);
- void add_line (AutomationLine&);
-
- guint32 show_at (double y, int& nth, Gtk::VBox *parent);
- void hide ();
-
-
- private:
- ARDOUR::Processor& _processor;
- ARDOUR::ParamID _param;
- XMLNode* _xml_node;
-
- void ensure_xml_node();
- void update_extra_xml_shown (bool editor_shown);
-
- void set_automation_state (ARDOUR::AutoState);
-};
-
-#endif /* __ardour_gtk_processor_automation_time_axis_h__ */
#include "ardour_ui.h"
#include "route_time_axis.h"
#include "automation_time_axis.h"
-#include "processor_automation_time_axis.h"
-#include "processor_automation_line.h"
#include "canvas_impl.h"
#include "crossfade_view.h"
#include "enums.h"
{
GoingAway (); /* EMIT_SIGNAL */
- vector_delete (&processor_automation_curves);
-
- for (list<InsertAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
+ for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
delete *i;
}
}
i->second->menu_item->set_active(show_automation(i->second->param));
+ //i->second->menu_item->set_active(false);
}
}
void
RouteTimeAxisView::set_selected_points (PointSelection& points)
{
- for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
+ for (Children::iterator i = children.begin(); i != children.end(); ++i) {
(*i)->set_selected_points (points);
}
}
/* pick up visible automation tracks */
- for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
+ for (Children::iterator i = children.begin(); i != children.end(); ++i) {
if (!(*i)->hidden()) {
(*i)->get_selectables (start_adjusted, end_adjusted, top, bot, results);
}
_view->get_inverted_selectables (sel, results);
}
- for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
+ for (Children::iterator i = children.begin(); i != children.end(); ++i) {
if (!(*i)->hidden()) {
(*i)->get_inverted_selectables (sel, results);
}
}
-list<TimeAxisView*>
+TimeAxisView::Children
RouteTimeAxisView::get_child_list()
{
- list<TimeAxisView*> redirect_children;
+ TimeAxisView::Children redirect_children;
- for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
+ for (Children::iterator i = children.begin(); i != children.end(); ++i) {
if (!(*i)->hidden()) {
redirect_children.push_back(*i);
}
/* Show processor automation */
- for (list<InsertAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
- for (vector<InsertAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
+ for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
+ for (vector<ProcessorAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
if ((*ii)->view == 0) {
add_processor_automation_curve ((*i)->processor, (*ii)->what);
}
map<ARDOUR::ParamID, RouteAutomationNode*>::iterator i;
for (i = _automation_tracks.begin(); i != _automation_tracks.end(); ++i) {
- // FIXME: only shown if /first/ line has points
- if (!i->second->track->lines.empty() && i->second->track->lines[0].first->npoints() > 0) {
+ if (i->second->track->line() && i->second->track->line()->npoints() > 0) {
i->second->track->set_marked_for_display (true);
i->second->track->canvas_display->show();
i->second->track->get_state_node()->add_property ("shown", X_("yes"));
/* Show processor automation */
- for (list<InsertAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
- for (vector<InsertAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
- if ((*ii)->view != 0) {
+ for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
+ for (vector<ProcessorAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
+ if ((*ii)->view != 0 && (*i)->processor->control((*ii)->what)->list()->size() > 0) {
(*ii)->menu_item->set_active (true);
}
}
{
no_redraw = true;
- for (list<InsertAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
- for (vector<InsertAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
+ for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
+ for (vector<ProcessorAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
(*ii)->menu_item->set_active (false);
}
}
+ _show_automation.clear();
+
no_redraw = false;
_route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */
}
void
RouteTimeAxisView::region_view_added (RegionView* rv)
{
- for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
- AutomationTimeAxisView* atv;
+ for (Children::iterator i = children.begin(); i != children.end(); ++i) {
+ boost::shared_ptr<AutomationTimeAxisView> atv;
- if ((atv = dynamic_cast<AutomationTimeAxisView*> (*i)) != 0) {
- rv->add_ghost (*atv);
+ if ((atv = boost::dynamic_pointer_cast<AutomationTimeAxisView> (*i)) != 0) {
+ rv->add_ghost (*atv.get());
}
}
}
void
-RouteTimeAxisView::add_ghost_to_processor (RegionView* rv, AutomationTimeAxisView* atv)
+RouteTimeAxisView::add_ghost_to_processor (RegionView* rv, boost::shared_ptr<AutomationTimeAxisView> atv)
{
- rv->add_ghost (*atv);
+ rv->add_ghost (*atv.get());
}
-RouteTimeAxisView::InsertAutomationInfo::~InsertAutomationInfo ()
+RouteTimeAxisView::ProcessorAutomationInfo::~ProcessorAutomationInfo ()
{
- for (vector<InsertAutomationNode*>::iterator i = lines.begin(); i != lines.end(); ++i) {
+ for (vector<ProcessorAutomationNode*>::iterator i = lines.begin(); i != lines.end(); ++i) {
delete *i;
}
}
-RouteTimeAxisView::InsertAutomationNode::~InsertAutomationNode ()
+RouteTimeAxisView::ProcessorAutomationNode::~ProcessorAutomationNode ()
{
- parent.remove_ran (this);
-
- if (view) {
- delete view;
- }
+ parent.remove_processor_automation_node (this);
}
void
-RouteTimeAxisView::remove_ran (InsertAutomationNode* ran)
+RouteTimeAxisView::remove_processor_automation_node (ProcessorAutomationNode* pan)
{
- if (ran->view) {
- remove_child (ran->view);
+ if (pan->view) {
+ remove_child (pan->view);
}
}
-RouteTimeAxisView::InsertAutomationNode*
+RouteTimeAxisView::ProcessorAutomationNode*
RouteTimeAxisView::find_processor_automation_node (boost::shared_ptr<Processor> processor, ParamID what)
{
- for (list<InsertAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
+ for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
if ((*i)->processor == processor) {
- for (vector<InsertAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
+ for (vector<ProcessorAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
if ((*ii)->what == what) {
return *ii;
}
void
RouteTimeAxisView::add_processor_automation_curve (boost::shared_ptr<Processor> processor, ParamID what)
{
- ProcessorAutomationLine* ral;
string name;
- InsertAutomationNode* ran;
+ ProcessorAutomationNode* pan;
- if ((ran = find_processor_automation_node (processor, what)) == 0) {
+ if ((pan = find_processor_automation_node (processor, what)) == 0) {
fatal << _("programming error: ")
<< string_compose (X_("processor automation curve for %1:%2 not registered with track!"),
processor->name(), what)
return;
}
- if (ran->view) {
+ if (pan->view) {
return;
}
char state_name[256];
snprintf (state_name, sizeof (state_name), "Redirect-%s-%" PRIu32, legalize_for_xml_node (processor->name()).c_str(), what.id());
- ran->view = new ProcessorAutomationTimeAxisView (_session, _route, editor, *this, parent_canvas, name, what, *processor, state_name);
+ boost::shared_ptr<AutomationControl> control = processor->control(what, true);
- ral = new ProcessorAutomationLine (name,
- *processor, *ran->view, *ran->view->canvas_display,
- processor->control (what, true)->list());
-
- ral->set_line_color (ARDOUR_UI::config()->canvasvar_ProcessorAutomationLine.get());
- ral->queue_reset ();
-
- ran->view->add_line (*ral);
+ pan->view = boost::shared_ptr<AutomationTimeAxisView>(
+ new AutomationTimeAxisView (_session, _route, processor, control,
+ editor, *this, parent_canvas, name, state_name));
- ran->view->Hiding.connect (bind (mem_fun(*this, &RouteTimeAxisView::processor_automation_track_hidden), ran, processor));
+ pan->view->Hiding.connect (bind (mem_fun(*this, &RouteTimeAxisView::processor_automation_track_hidden), pan, processor));
- if (!ran->view->marked_for_display()) {
- ran->view->hide ();
+ if (!pan->view->marked_for_display()) {
+ pan->view->hide ();
} else {
- ran->menu_item->set_active (true);
+ pan->menu_item->set_active (true);
}
- add_child (ran->view);
+ add_child (pan->view);
if (_view) {
- _view->foreach_regionview (bind (mem_fun(*this, &RouteTimeAxisView::add_ghost_to_processor), ran->view));
+ _view->foreach_regionview (bind (mem_fun(*this, &RouteTimeAxisView::add_ghost_to_processor), pan->view));
}
processor->mark_automation_visible (what, true);
}
void
-RouteTimeAxisView::processor_automation_track_hidden (RouteTimeAxisView::
InsertAutomationNode* ran, boost::shared_ptr<Processor> i)
+RouteTimeAxisView::processor_automation_track_hidden (RouteTimeAxisView::
ProcessorAutomationNode* pan, boost::shared_ptr<Processor> i)
{
if (!_hidden) {
- ran->menu_item->set_active (false);
+ pan->menu_item->set_active (false);
}
- i->mark_automation_visible (ran->what, false);
+ i->mark_automation_visible (pan->what, false);
_route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */
}
RouteTimeAxisView::add_existing_processor_automation_curves (boost::shared_ptr<Processor> processor)
{
set<ParamID> s;
- ProcessorAutomationLine *ral;
+ boost::shared_ptr<AutomationLine> al;
processor->what_has_visible_automation (s);
for (set<ParamID>::iterator i = s.begin(); i != s.end(); ++i) {
- if ((ral = find_processor_automation_curve (processor, *i)) != 0) {
- ral->queue_reset ();
+ if ((al = find_processor_automation_curve (processor, *i)) != 0) {
+ al->queue_reset ();
} else {
add_processor_automation_curve (processor, (*i));
}
}
void
-RouteTimeAxisView::add_automation_child(ParamID param, AutomationTimeAxisView* track)
+RouteTimeAxisView::add_automation_child(ParamID param, boost::shared_ptr<AutomationTimeAxisView> track)
{
using namespace Menu_Helpers;
RouteTimeAxisView::add_processor_to_subplugin_menu (boost::shared_ptr<Processor> processor)
{
using namespace Menu_Helpers;
- InsertAutomationInfo *rai;
- list<InsertAutomationInfo*>::iterator x;
+ ProcessorAutomationInfo *rai;
+ list<ProcessorAutomationInfo*>::iterator x;
const std::set<ParamID>& automatable = processor->what_can_be_automated ();
std::set<ParamID> has_visible_automation;
if (x == processor_automation.end()) {
- rai = new InsertAutomationInfo (processor);
+ rai = new ProcessorAutomationInfo (processor);
processor_automation.push_back (rai);
} else {
for (std::set<ParamID>::const_iterator i = automatable.begin(); i != automatable.end(); ++i) {
- InsertAutomationNode* ran;
+ ProcessorAutomationNode* pan;
CheckMenuItem* mitem;
string name = processor->describe_parameter (*i);
mitem->set_active(true);
}
- if ((ran = find_processor_automation_node (processor, *i)) == 0) {
+ if ((pan = find_processor_automation_node (processor, *i)) == 0) {
/* new item */
- ran = new InsertAutomationNode (*i, mitem, *this);
+ pan = new ProcessorAutomationNode (*i, mitem, *this);
- rai->lines.push_back (ran);
+ rai->lines.push_back (pan);
} else {
- ran->menu_item = mitem;
+ pan->menu_item = mitem;
}
- mitem->signal_toggled().connect (bind (mem_fun(*this, &RouteTimeAxisView::processor_menu_item_toggled), rai, ran));
+ mitem->signal_toggled().connect (bind (mem_fun(*this, &RouteTimeAxisView::processor_menu_item_toggled), rai, pan));
}
/* add the menu for this processor, because the subplugin
}
void
-RouteTimeAxisView::processor_menu_item_toggled (RouteTimeAxisView::InsertAutomationInfo* rai,
- RouteTimeAxisView::InsertAutomationNode* ran)
+RouteTimeAxisView::processor_menu_item_toggled (RouteTimeAxisView::ProcessorAutomationInfo* rai,
+ RouteTimeAxisView::ProcessorAutomationNode* pan)
{
- bool showit = ran->menu_item->get_active();
+ bool showit = pan->menu_item->get_active();
bool redraw = false;
- if (ran->view == 0 && showit) {
- add_processor_automation_curve (rai->processor, ran->what);
+ if (pan->view == 0 && showit) {
+ add_processor_automation_curve (rai->processor, pan->what);
redraw = true;
}
- if (showit != ran->view->marked_for_display()) {
+ if (showit != pan->view->marked_for_display()) {
if (showit) {
- ran->view->set_marked_for_display (true);
- ran->view->canvas_display->show();
+ pan->view->set_marked_for_display (true);
+ pan->view->canvas_display->show();
} else {
- rai->processor->mark_automation_visible (ran->what, true);
- ran->view->set_marked_for_display (false);
- ran->view->hide ();
+ rai->processor->mark_automation_visible (pan->what, true);
+ pan->view->set_marked_for_display (false);
+ pan->view->hide ();
}
redraw = true;
{
using namespace Menu_Helpers;
- for (list<InsertAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
+ for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
(*i)->valid = false;
}
_route->foreach_processor (this, &RouteTimeAxisView::add_processor_to_subplugin_menu);
_route->foreach_processor (this, &RouteTimeAxisView::add_existing_processor_automation_curves);
- for (list<InsertAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ) {
+ for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ) {
- list<InsertAutomationInfo*>::iterator tmp;
+ list<ProcessorAutomationInfo*>::iterator tmp;
tmp = i;
++tmp;
_route->gui_changed ("track_height", this);
}
-ProcessorAutomationLine *
+boost::shared_ptr<AutomationLine>
RouteTimeAxisView::find_processor_automation_curve (boost::shared_ptr<Processor> processor, ParamID what)
{
- InsertAutomationNode* ran;
+ ProcessorAutomationNode* pan;
- if ((ran = find_processor_automation_node (processor, what)) != 0) {
- if (ran->view) {
- return dynamic_cast<ProcessorAutomationLine*> (ran->view->lines.front().first);
+ if ((pan = find_processor_automation_node (processor, what)) != 0) {
+ if (pan->view) {
+ pan->view->line();
}
}
- return 0;
+ return boost::shared_ptr<AutomationLine>();
}
void
RouteTimeAxisView::reset_processor_automation_curves ()
{
- for (vector<ProcessorAutomationLine*>::iterator i = processor_automation_curves.begin(); i != processor_automation_curves.end(); ++i) {
+ for (ProcessorAutomationCurves::iterator i = processor_automation_curves.begin(); i != processor_automation_curves.end(); ++i) {
(*i)->reset();
}
}
bool cut_copy_clear (Selection&, Editing::CutCopyOp);
bool paste (nframes_t, float times, Selection&, size_t nth);
- list<TimeAxisView*> get_child_list();
+ TimeAxisView::Children get_child_list();
/* The editor calls these when mapping an operation across multiple tracks */
void use_new_playlist (bool prompt);
friend class StreamView;
struct RouteAutomationNode {
- ARDOUR::ParamID param;
- Gtk::CheckMenuItem* menu_item;
- AutomationTimeAxisView* track;
+ ARDOUR::ParamID param;
+ Gtk::CheckMenuItem* menu_item;
+ boost::shared_ptr<AutomationTimeAxisView> track;
- RouteAutomationNode (ARDOUR::ParamID par, Gtk::CheckMenuItem* mi, AutomationTimeAxisView* tr)
+ RouteAutomationNode (ARDOUR::ParamID par, Gtk::CheckMenuItem* mi, boost::shared_ptr<AutomationTimeAxisView> tr)
: param (par), menu_item (mi), track (tr) {}
};
- struct InsertAutomationNode {
- ARDOUR::ParamID what;
- Gtk::CheckMenuItem* menu_item;
- AutomationTimeAxisView* view;
- RouteTimeAxisView& parent;
+ struct ProcessorAutomationNode {
+ ARDOUR::ParamID what;
+ Gtk::CheckMenuItem* menu_item;
+ boost::shared_ptr<AutomationTimeAxisView> view;
+ RouteTimeAxisView& parent;
- InsertAutomationNode (ARDOUR::ParamID w, Gtk::CheckMenuItem* mitem, RouteTimeAxisView& p)
- : what (w), menu_item (mitem), view (0), parent (p) {}
+ ProcessorAutomationNode (ARDOUR::ParamID w, Gtk::CheckMenuItem* mitem, RouteTimeAxisView& p)
+ : what (w), menu_item (mitem), parent (p) {}
- ~InsertAutomationNode ();
+ ~ProcessorAutomationNode ();
};
- struct InsertAutomationInfo {
+ struct ProcessorAutomationInfo {
boost::shared_ptr<ARDOUR::Processor> processor;
bool valid;
Gtk::Menu* menu;
- vector<InsertAutomationNode*> lines;
+ vector<ProcessorAutomationNode*> lines;
-
InsertAutomationInfo (boost::shared_ptr<ARDOUR::Processor> i)
+
ProcessorAutomationInfo (boost::shared_ptr<ARDOUR::Processor> i)
: processor (i), valid (true), menu (0) {}
- ~InsertAutomationInfo ();
+ ~ProcessorAutomationInfo ();
};
void processors_changed ();
void add_processor_to_subplugin_menu (boost::shared_ptr<ARDOUR::Processor>);
- void remove_ran (InsertAutomationNode* ran);
+ void remove_processor_automation_node (ProcessorAutomationNode* pan);
- void processor_menu_item_toggled (RouteTimeAxisView::InsertAutomationInfo*,
- RouteTimeAxisView::InsertAutomationNode*);
+ void processor_menu_item_toggled (RouteTimeAxisView::ProcessorAutomationInfo*,
+ RouteTimeAxisView::ProcessorAutomationNode*);
- void processor_automation_track_hidden (InsertAutomationNode*,
+ void processor_automation_track_hidden (ProcessorAutomationNode*,
boost::shared_ptr<ARDOUR::Processor>);
void automation_track_hidden (ARDOUR::ParamID param);
RouteAutomationNode* automation_track(ARDOUR::ParamID param);
RouteAutomationNode* automation_track(ARDOUR::AutomationType type);
- InsertAutomationNode*
+ ProcessorAutomationNode*
find_processor_automation_node (boost::shared_ptr<ARDOUR::Processor> i, ARDOUR::ParamID);
- ProcessorAutomationLine*
+ boost::shared_ptr<AutomationLine>
find_processor_automation_curve (boost::shared_ptr<ARDOUR::Processor> i, ARDOUR::ParamID);
void add_processor_automation_curve (boost::shared_ptr<ARDOUR::Processor> r, ARDOUR::ParamID);
void add_existing_processor_automation_curves (boost::shared_ptr<ARDOUR::Processor>);
- void add_automation_child(ARDOUR::ParamID param, AutomationTimeAxisView* track);
+ void add_automation_child(ARDOUR::ParamID param, boost::shared_ptr<AutomationTimeAxisView> track);
void reset_processor_automation_curves ();
void color_handler ();
void region_view_added (RegionView*);
- void add_ghost_to_processor (RegionView*, AutomationTimeAxisView*);
+ void add_ghost_to_processor (RegionView*, boost::shared_ptr<AutomationTimeAxisView>);
StreamView* _view;
ArdourCanvas::Canvas& parent_canvas;
void _set_track_mode (ARDOUR::Track* track, ARDOUR::TrackMode mode, Gtk::RadioMenuItem* reset_item);
void track_mode_changed ();
- list<InsertAutomationInfo*> processor_automation;
- vector<ProcessorAutomationLine*> processor_automation_curves;
+ list<ProcessorAutomationInfo*> processor_automation;
+
+ typedef vector<boost::shared_ptr<AutomationLine> > ProcessorAutomationCurves;
+ ProcessorAutomationCurves processor_automation_curves;
// Set from XML so context menu automation buttons can be correctly initialized
set<ARDOUR::ParamID> _show_automation;
- map<ARDOUR::ParamID, RouteAutomationNode*> _automation_tracks;
+ typedef map<ARDOUR::ParamID, RouteAutomationNode*> AutomationTracks;
+ AutomationTracks _automation_tracks;
sigc::connection modified_connection;
TimeAxisView::~TimeAxisView()
{
- for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
- delete *i;
- }
-
for (list<SelectionRect*>::iterator i = free_selection_rects.begin(); i != free_selection_rects.end(); ++i) {
delete (*i)->rect;
delete (*i)->start_trim;
/* now show children */
- for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
+ for (Children::iterator i = children.begin(); i != children.end(); ++i) {
if ((*i)->marked_for_display()) {
(*i)->canvas_display->show();
/* now hide children */
- for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
+ for (Children::iterator i = children.begin(); i != children.end(); ++i) {
(*i)->hide ();
}
have to do this here.
*/
- for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
+ for (Children::iterator i = children.begin(); i != children.end(); ++i) {
(*i)->set_selected (false);
}
void
TimeAxisView::set_samples_per_unit (double spu)
{
- for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
+ for (Children::iterator i = children.begin(); i != children.end(); ++i) {
(*i)->set_samples_per_unit (spu);
}
}
void
TimeAxisView::show_timestretch (nframes_t start, nframes_t end)
{
- for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
+ for (Children::iterator i = children.begin(); i != children.end(); ++i) {
(*i)->show_timestretch (start, end);
}
}
void
TimeAxisView::hide_timestretch ()
{
- for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
+ for (Children::iterator i = children.begin(); i != children.end(); ++i) {
(*i)->hide_timestretch ();
}
}
double y2;
SelectionRect *rect;
- for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
+ for (Children::iterator i = children.begin(); i != children.end(); ++i) {
(*i)->show_selection (ts);
}
{
show_selection (ts);
- for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
+ for (Children::iterator i = children.begin(); i != children.end(); ++i) {
(*i)->show_selection (ts);
}
}
selection_group->hide();
}
- for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
+ for (Children::iterator i = children.begin(); i != children.end(); ++i) {
(*i)->hide_selection ();
}
}
return rect;
}
+struct null_deleter { void operator()(void const *) const {} };
+
bool
TimeAxisView::is_child (TimeAxisView* tav)
{
- return find (children.begin(), children.end(), tav) != children.end();
+ return find (children.begin(), children.end(), boost::shared_ptr<TimeAxisView>(tav, null_deleter())) != children.end();
}
void
-TimeAxisView::add_child (TimeAxisView* child)
+TimeAxisView::add_child (boost::shared_ptr<TimeAxisView> child)
{
children.push_back (child);
}
void
-TimeAxisView::remove_child (TimeAxisView* child)
+TimeAxisView::remove_child (boost::shared_ptr<TimeAxisView> child)
{
- vector<TimeAxisView*>::iterator i;
+ Children::iterator i;
if ((i = find (children.begin(), children.end(), child)) != children.end()) {
children.erase (i);
{
set_height_pixels (height);
- for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
+ for (Children::iterator i = children.begin(); i != children.end(); ++i) {
(*i)->set_height_pixels ((TrackHeight)(*i)->height);
}
}
return this;
}
- for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
+ for (Children::iterator i = children.begin(); i != children.end(); ++i) {
TimeAxisView* tv;
if ((tv = (*i)->covers_y_position (y)) != 0) {
/* call this on the parent */
virtual XMLNode* get_child_xml_node (const string & childname) { return 0; }
+
+ typedef std::vector<boost::shared_ptr<TimeAxisView> > Children;
protected:
/** Find the parent with state */
TimeAxisView* get_parent_with_state();
- std::vector<TimeAxisView*> children;
+ Children children;
bool is_child (TimeAxisView*);
- void remove_child (TimeAxisView*);
- void add_child (TimeAxisView*);
+ void remove_child (boost::shared_ptr<TimeAxisView>);
+ void add_child (boost::shared_ptr<TimeAxisView>);
/* selection display */
virtual boost::shared_ptr<AutomationControl> control(ParamID id, bool create_if_missing=false);
virtual boost::shared_ptr<const AutomationControl> control(ParamID id) const;
+
+ typedef std::map<ParamID,boost::shared_ptr<AutomationControl> > Controls;
+ Controls controls() { return _controls; }
virtual void add_control(boost::shared_ptr<AutomationControl>);
virtual void automation_snapshot(nframes_t now);
+ virtual void transport_stopped(nframes_t now);
virtual bool find_next_event(nframes_t start, nframes_t end, ControlEvent& ev) const;
virtual void clear_automation();
- AutoState get_parameter_automation_state (ParamID param);
+ AutoState get_parameter_automation_state (ParamID param, bool lock = true);
virtual void set_parameter_automation_state (ParamID param, AutoState);
AutoStyle get_parameter_automation_style (ParamID param);
mutable Glib::Mutex _automation_lock;
- typedef std::map<ParamID,boost::shared_ptr<AutomationControl> > Controls;
-
Controls _controls;
std::set<ParamID> _visible_controls;
std::set<ParamID> _can_automate_list;
#include <ardour/types.h>
#include <ardour/curve.h>
+#include <ardour/automation_control.h>
using std::istream;
using std::ostream;
virtual void distribute_automated (AudioBuffer& src, BufferSet& obufs,
nframes_t start, nframes_t end, nframes_t nframes, pan_t** buffers) = 0;
- /* automation */
-
- virtual void snapshot (nframes_t now) = 0;
- virtual void transport_stopped (nframes_t frame) = 0;
- virtual void set_automation_state (AutoState) = 0;
- virtual void set_automation_style (AutoStyle) = 0;
-
- boost::shared_ptr<PBD::Controllable> control() { return _control; }
+ boost::shared_ptr<AutomationControl> pan_control() { return _control; }
- /* XXX this is wrong. for multi-dimensional panners, there
- must surely be more than 1 automation curve.
- */
- /* TODO: Panner is-a Automation solves this */
-
- virtual boost::shared_ptr<AutomationList> automation() = 0;
-
sigc::signal<void> Changed; /* for position */
sigc::signal<void> StateChanged; /* for mute */
bool _muted;
- struct PanControllable : public PBD::Controllable {
- PanControllable (std::string name, StreamPanner& p) : Controllable (name), panner (p) {}
+ struct PanControllable : public AutomationControl {
+ PanControllable (Session& s, std::string name, StreamPanner& p)
+ : AutomationControl (s, boost::shared_ptr<AutomationList>(new AutomationList(
+ ParamID(PanAutomation), 0.0, 1.0, 0.5)), name)
+ , panner (p) {}
StreamPanner& panner;
void distribute (AudioBuffer& src, BufferSet& obufs, gain_t gain_coeff, nframes_t nframes);
- void snapshot (nframes_t now);
- void transport_stopped (nframes_t frame);
- void set_automation_state (AutoState);
- void set_automation_style (AutoStyle);
-
- /* TODO: StreamPanner is-a Automatable? */
- boost::shared_ptr<AutomationList> automation() { return _automation; }
-
/* old school automation loading */
int load (istream&, string path, uint32_t&);
float desired_right;
float left_interp;
float right_interp;
-
- boost::shared_ptr<AutomationList> _automation;
};
class EqualPowerStereoPanner : public BaseStereoPanner
Multi2dPanner (Panner& parent);
~Multi2dPanner ();
- void snapshot (nframes_t now);
- void transport_stopped (nframes_t frame);
- void set_automation_state (AutoState);
- void set_automation_style (AutoStyle);
-
- /* XXX this is wrong. for multi-dimensional panners, there
- must surely be more than 1 automation curve.
- */
-
- /* TODO: StreamPanner is-a Automatable? */
-
- boost::shared_ptr<AutomationList> automation() { return _automation; }
-
void distribute (AudioBuffer& src, BufferSet& obufs, gain_t gain_coeff, nframes_t nframes);
void distribute_automated (AudioBuffer& src, BufferSet& obufs,
nframes_t start, nframes_t end, nframes_t nframes, pan_t** buffers);
int load (istream&, string path, uint32_t&);
private:
- boost::shared_ptr<AutomationList> _automation;
void update ();
};
virtual const char * maker() const = 0;
virtual uint32_t parameter_count () const = 0;
virtual float default_value (uint32_t port) = 0;
- virtual void set_parameter (uint32_t which, float val) = 0;
virtual float get_parameter(uint32_t which) const = 0;
virtual int get_parameter_descriptor (uint32_t which, ParameterDescriptor&) const = 0;
virtual bool has_editor() const = 0;
- sigc::signal<void,ParamID,float> ParameterChanged;
-
- PBD::Controllable *get_nth_control (uint32_t);
-
PluginInfoPtr get_info() { return _info; }
void set_info (const PluginInfoPtr inf) { _info = inf; }
cycles_t cycles() const { return _cycles; }
protected:
+ friend class PluginInsert;
+ virtual void set_parameter (uint32_t which, float val) = 0;
+
ARDOUR::AudioEngine& _engine;
ARDOUR::Session& _session;
PluginInfoPtr _info;
uint32_t _cycles;
map<string,string> presets;
bool save_preset(string name, string domain /* vst, ladspa etc. */);
-
- void setup_controls ();
-
- struct PortControllable : public PBD::Controllable {
- PortControllable (std::string name, Plugin&, uint32_t abs_port_id,
- float lower, float upper, bool toggled, bool logarithmic);
-
- void set_value (float);
- float get_value () const;
-
- Plugin& plugin;
- uint32_t absolute_port;
- float upper;
- float lower;
- float range;
- bool toggled;
- bool logarithmic;
- };
-
- vector<PortControllable*> controls;
};
PluginPtr find_plugin(ARDOUR::Session&, string name, long unique_id, ARDOUR::PluginType);
bool is_generator() const;
void set_parameter (ParamID param, float val);
+ float get_parameter (ParamID param);
float default_parameter_value (ParamID param);
+
+ struct PluginControl : public AutomationControl {
+ PluginControl (PluginInsert& p, boost::shared_ptr<AutomationList> list);
+
+ void set_value (float val);
+ float get_value (void) const;
+
+ private:
+ PluginInsert& _plugin;
+ boost::shared_ptr<AutomationList> _list;
+ bool _logarithmic;
+ bool _toggled;
+ };
boost::shared_ptr<Plugin> plugin(uint32_t num=0) const {
if (num < _plugins.size()) {
nframes_t signal_latency() const;
- void transport_stopped (nframes_t now);
- void automation_snapshot (nframes_t now);
-
private:
void parameter_changed (ParamID, float);
cerr << _name << ": added parameter " << param.to_string() << endl;
- // FIXME: sane default behaviour?
- _visible_controls.insert(param);
_can_automate_list.insert(param);
// Sync everything (derived classes) up to initial values
}
AutoState
-Automatable::get_parameter_automation_state (ParamID param)
+Automatable::get_parameter_automation_state (ParamID param, bool lock)
{
- Glib::Mutex::Lock lm (_automation_lock);
+ AutoState result = Off;
+
+ if (lock)
+ _automation_lock.lock();
boost::shared_ptr<AutomationControl> c = control(param);
- if (c) {
- return c->list()->automation_state();
- } else {
- return Off;
- }
+ if (c)
+ result = c->list()->automation_state();
+
+ if (lock)
+ _automation_lock.unlock();
+
+ return result;
}
void
}
}
+void
+Automatable::transport_stopped (nframes_t now)
+{
+ for (Controls::iterator li = _controls.begin(); li != _controls.end(); ++li) {
+
+ boost::shared_ptr<AutomationControl> c = li->second;
+
+ c->list()->reposition_for_rt_add (now);
+
+ if (c->list()->automation_state() != Off) {
+ c->set_value(c->list()->eval(now));
+ }
+ }
+}
+
{
assert(type != DataType::NIL);
assert(type < _buffers.size());
+ assert(buffer_capacity > 0);
if (num_buffers == 0)
return;
IO::start_pan_touch (uint32_t which)
{
if (which < _panner->size()) {
- (*_panner)[which]->automation()->start_touch();
+ (*_panner)[which]->pan_control()->list()->start_touch();
}
}
IO::end_pan_touch (uint32_t which)
{
if (which < _panner->size()) {
- (*_panner)[which]->automation()->stop_touch();
+ (*_panner)[which]->pan_control()->list()->stop_touch();
}
}
}
}
- Plugin::setup_controls ();
-
latency_compute_run ();
}
{
if (which < descriptor->PortCount) {
shadow_data[which] = (LADSPA_Data) val;
+#if 0
ParameterChanged (ParamID(PluginAutomation, which), val); /* EMIT SIGNAL */
if (which < parameter_count() && controls[which]) {
controls[which]->Changed ();
}
+#endif
} else {
warning << string_compose (_("illegal parameter number used with plugin \"%1\". This may"
StreamPanner::StreamPanner (Panner& p)
: parent (p),
- _control (new PanControllable(X_("panner"), *this))
+ _control (new PanControllable(p.session(), X_("panner"), *this))
{
_muted = false;
/*---------------------------------------------------------------------- */
BaseStereoPanner::BaseStereoPanner (Panner& p)
- : StreamPanner (p), _automation (new AutomationList(ParamID(PanAutomation), 0.0, 1.0, 0.5))
+ : StreamPanner (p)
{
}
{
}
-void
-BaseStereoPanner::snapshot (nframes_t now)
-{
- if (_automation->automation_state() == Write || _automation->automation_state() == Touch) {
- _automation->rt_add (now, x);
- }
-}
-
-void
-BaseStereoPanner::transport_stopped (nframes_t frame)
-{
- _automation->reposition_for_rt_add (frame);
-
- if (_automation->automation_state() != Off) {
- set_position (_automation->eval (frame));
- }
-}
-
-void
-BaseStereoPanner::set_automation_style (AutoStyle style)
-{
- _automation->set_automation_style (style);
-}
-
-void
-BaseStereoPanner::set_automation_state (AutoState state)
-{
- if (state != _automation->automation_state()) {
-
- _automation->set_automation_state (state);
-
- if (state != Off) {
- set_position (_automation->eval (parent.session().transport_frame()));
- }
- }
-}
-
int
BaseStereoPanner::load (istream& in, string path, uint32_t& linecnt)
{
char line[128];
LocaleGuard lg (X_("POSIX"));
- _automation->clear ();
+ _control->list()->clear ();
while (in.getline (line, sizeof (line), '\n')) {
nframes_t when;
continue;
}
- _automation->fast_simple_add (when, value);
+ _control->list()->fast_simple_add (when, value);
}
/* now that we are done loading */
- _automation->StateChanged ();
+ _control->list()->StateChanged ();
return 0;
}
/* fetch positional data */
- if (!_automation->curve().rt_safe_get_vector (start, end, buffers[0], nframes)) {
+ if (!_control->list()->curve().rt_safe_get_vector (start, end, buffers[0], nframes)) {
/* fallback */
if (!_muted) {
distribute (srcbuf, obufs, 1.0, nframes);
root->add_property (X_("type"), EqualPowerStereoPanner::name);
XMLNode* autonode = new XMLNode (X_("Automation"));
- autonode->add_child_nocopy (_automation->state (full_state));
+ autonode->add_child_nocopy (_control->list()->state (full_state));
root->add_child_nocopy (*autonode);
StreamPanner::add_state (*root);
} else if ((*iter)->name() == X_("Automation")) {
- _automation->set_state (*((*iter)->children().front()));
+ _control->list()->set_state (*((*iter)->children().front()));
- if (_automation->automation_state() != Off) {
- set_position (_automation->eval (parent.session().transport_frame()));
+ if (_control->list()->automation_state() != Off) {
+ set_position (_control->list()->eval (parent.session().transport_frame()));
}
}
}
/*----------------------------------------------------------------------*/
Multi2dPanner::Multi2dPanner (Panner& p)
- : StreamPanner (p), _automation (new AutomationList(ParamID(PanAutomation), 0.0, 1.0, 0.5)) // XXX useless
+ : StreamPanner (p)
{
update ();
}
{
}
-void
-Multi2dPanner::snapshot (nframes_t now)
-{
- // how?
-}
-
-void
-Multi2dPanner::transport_stopped (nframes_t frame)
-{
- //what?
-}
-
-void
-Multi2dPanner::set_automation_style (AutoStyle style)
-{
- //what?
-}
-
-void
-Multi2dPanner::set_automation_state (AutoState state)
-{
- // what?
-}
-
void
Multi2dPanner::update ()
{
if (changed || ((left == 0.5) && (right == 0.5))) {
front()->set_position (0.0);
- front()->automation()->reset_default (0.0);
+ front()->pan_control()->list()->reset_default (0.0);
back()->set_position (1.0);
- back()->automation()->reset_default (1.0);
+ back()->pan_control()->list()->reset_default (1.0);
changed = true;
}
Panner::set_automation_style (AutoStyle style)
{
for (vector<StreamPanner*>::iterator i = begin(); i != end(); ++i) {
- (*i)->set_automation_style (style);
+ (*i)->pan_control()->list()->set_automation_style (style);
}
_session.set_dirty ();
}
Panner::set_automation_state (AutoState state)
{
for (vector<StreamPanner*>::iterator i = begin(); i != end(); ++i) {
- (*i)->set_automation_state (state);
+ (*i)->pan_control()->list()->set_automation_state (state);
}
_session.set_dirty ();
}
Panner::automation_state () const
{
if (!empty()) {
- return front()->automation()->automation_state ();
+ return front()->pan_control()->list()->automation_state ();
} else {
return Off;
}
Panner::automation_style () const
{
if (!empty()) {
- return front()->automation()->automation_style ();
+ return front()->pan_control()->list()->automation_style ();
} else {
return Absolute;
}
Panner::transport_stopped (nframes_t frame)
{
for (vector<StreamPanner*>::iterator i = begin(); i != end(); ++i) {
- (*i)->transport_stopped (frame);
+ (*i)->pan_control()->list()->reposition_for_rt_add (frame);
}
}
Panner::snapshot (nframes_t now)
{
for (vector<StreamPanner*>::iterator i = begin(); i != end(); ++i) {
- (*i)->snapshot (now);
+ boost::shared_ptr<AutomationList> list = (*i)->pan_control()->list();
+ if (list->automation_write())
+ list->rt_add(now, (*i)->pan_control()->get_value());
}
}
Panner::clear_automation ()
{
for (vector<StreamPanner*>::iterator i = begin(); i != end(); ++i) {
- (*i)->automation()->clear ();
+ (*i)->pan_control()->list()->clear ();
}
_session.set_dirty ();
}
Panner::touching () const
{
for (vector<StreamPanner*>::const_iterator i = begin(); i != end(); ++i) {
- if ((*i)->automation()->touching ()) {
+ if ((*i)->pan_control()->list()->touching ()) {
return true;
}
}
{
}
-void
-Plugin::setup_controls ()
-{
- uint32_t port_cnt = parameter_count();
-
- /* set up a vector of null pointers for the controls.
- we'll fill this in on an as-needed basis.
- */
-
- for (uint32_t i = 0; i < port_cnt; ++i) {
- controls.push_back (0);
- }
-}
-
Plugin::~Plugin ()
{
- for (vector<PortControllable*>::iterator i = controls.begin(); i != controls.end(); ++i) {
- if (*i) {
- delete *i;
- }
- }
-}
-
-Controllable *
-Plugin::get_nth_control (uint32_t n)
-{
- if (n >= parameter_count()) {
- return 0;
- }
-
- if (controls[n] == 0) {
-
- Plugin::ParameterDescriptor desc;
-
- get_parameter_descriptor (n, desc);
-
- controls[n] = new PortControllable (describe_parameter (ParamID(PluginAutomation, n)), *this, n,
- desc.lower, desc.upper, desc.toggled, desc.logarithmic);
- }
-
- return controls[n];
}
-Plugin::PortControllable::PortControllable (string name, Plugin& p, uint32_t port_id,
- float low, float up, bool t, bool loga)
- : Controllable (name), plugin (p), absolute_port (port_id)
-{
- toggled = t;
- logarithmic = loga;
- lower = low;
- upper = up;
- range = upper - lower;
-}
-
-void
-Plugin::PortControllable::set_value (float value)
-{
- if (toggled) {
- if (value > 0.5) {
- value = 1.0;
- } else {
- value = 0.0;
- }
- } else {
-
- if (!logarithmic) {
- value = lower + (range * value);
- } else {
- float _lower = 0.0f;
- if (lower > 0.0f) {
- _lower = log(lower);
- }
-
- value = exp(_lower + log(range) * value);
- }
- }
-
- plugin.set_parameter (absolute_port, value);
-}
-
-float
-Plugin::PortControllable::get_value (void) const
-{
- float val = plugin.get_parameter (absolute_port);
-
- if (toggled) {
-
- return val;
-
- } else {
-
- if (logarithmic) {
- val = log(val);
- }
-
- return ((val - lower) / range);
- }
-}
-
vector<string>
Plugin::get_presets()
{
_plugins.push_back (plug);
- _plugins[0]->ParameterChanged.connect (mem_fun (*this, &PluginInsert::parameter_changed));
-
init ();
{
set_automatable ();
- _plugins[0]->ParameterChanged.connect (mem_fun (*this, &PluginInsert::parameter_changed));
-
{
Glib::Mutex::Lock em (_session.engine().process_lock());
IO::MoreChannels (max(input_streams(), output_streams()));
_plugins.push_back (plugin_factory (other.plugin (n)));
}
-
- _plugins[0]->ParameterChanged.connect (mem_fun (*this, &PluginInsert::parameter_changed));
-
init ();
ProcessorCreated (this); /* EMIT SIGNAL */
_plugins.front()->get_parameter_descriptor(i->id(), desc);
boost::shared_ptr<AutomationList> list(new AutomationList(
*i,
- (desc.min_unbound ? FLT_MIN : desc.lower),
- (desc.max_unbound ? FLT_MAX : desc.upper),
+ //(desc.min_unbound ? FLT_MIN : desc.lower),
+ //(desc.max_unbound ? FLT_MAX : desc.upper),
+ desc.lower, desc.upper,
_plugins.front()->default_value(i->id())));
add_control(boost::shared_ptr<AutomationControl>(
- new AutomationControl(_session, list)));
+ new PluginControl(*this, list)));
}
}
}
if (c->list()->param_id().type() == PluginAutomation && c->list()->automation_playback()) {
bool valid;
- float val = c->list()->rt_safe_eval (now, valid);
+ const float val = c->list()->rt_safe_eval (now, valid);
if (valid) {
- /* set the first plugin, the others will be set via signals */
- _plugins[0]->set_parameter (c->list()->param_id(), val);
+ c->set_value(val);
}
}
/* leave remaining channel buffers alone */
}
-void
-PluginInsert::automation_snapshot (nframes_t now)
-{
- for (Controls::iterator li = _controls.begin(); li != _controls.end(); ++li) {
-
- boost::shared_ptr<AutomationControl> c = li->second;
-
- if (c->list() != 0 && c->list()->param_id().type() == PluginAutomation
- && c->list()->automation_write ()) {
-
- float val = _plugins[0]->get_parameter (c->list()->param_id());
- c->list()->rt_add (now, val);
- _last_automation_snapshot = now;
- }
- }
-}
-
-void
-PluginInsert::transport_stopped (nframes_t now)
-{
- for (Controls::iterator li = _controls.begin(); li != _controls.end(); ++li) {
-
- boost::shared_ptr<AutomationControl> c = li->second;
-
- c->list()->reposition_for_rt_add (now);
-
- if (c->list()->param_id().type() == PluginAutomation && c->list()->automation_state() != Off) {
- _plugins[0]->set_parameter (li->first, c->list()->eval (now));
- }
- }
-}
-
void
PluginInsert::silence (nframes_t nframes, nframes_t offset)
{
boost::shared_ptr<AutomationControl> c = control (param);
- if (c && c->list()->automation_write()) {
- c->list()->add (_session.audible_frame(), val);
- }
+ if (c)
+ c->set_value(val);
_session.set_dirty();
}
+float
+PluginInsert::get_parameter (ParamID param)
+{
+ if (param.type() != PluginAutomation)
+ return 0.0;
+ else
+ return
+ _plugins[0]->get_parameter (param.id());
+}
+
void
PluginInsert::automation_run (BufferSet& bufs, nframes_t nframes, nframes_t offset)
{
}
}
+PluginInsert::PluginControl::PluginControl (PluginInsert& p, boost::shared_ptr<AutomationList> list)
+ : AutomationControl (p.session(), list, p.describe_parameter(list->param_id()))
+ , _plugin (p)
+ , _list (list)
+{
+ Plugin::ParameterDescriptor desc;
+ p.plugin(0)->get_parameter_descriptor (list->param_id().id(), desc);
+ _logarithmic = desc.logarithmic;
+ _toggled = desc.toggled;
+}
+
+void
+PluginInsert::PluginControl::set_value (float val)
+{
+ /* FIXME: probably should be taking out some lock here.. */
+
+ if (_toggled) {
+ if (val > 0.5) {
+ val = 1.0;
+ } else {
+ val = 0.0;
+ }
+ } else {
+
+ /*const float range = _list->get_max_y() - _list->get_min_y();
+ const float lower = _list->get_min_y();
+
+ if (!_logarithmic) {
+ val = lower + (range * val);
+ } else {
+ float log_lower = 0.0f;
+ if (lower > 0.0f) {
+ log_lower = log(lower);
+ }
+
+ val = exp(log_lower + log(range) * val);
+ }*/
+
+ }
+
+ for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugin._plugins.begin();
+ i != _plugin._plugins.end(); ++i) {
+ (*i)->set_parameter (_list->param_id().id(), val);
+ }
+
+ AutomationControl::set_value(val);
+}
+
+float
+PluginInsert::PluginControl::get_value (void) const
+{
+ /* FIXME: probably should be taking out some lock here.. */
+
+ float val = _plugin.get_parameter (_list->param_id());
+
+ return val;
+
+ /*if (_toggled) {
+
+ return val;
+
+ } else {
+
+ if (_logarithmic) {
+ val = log(val);
+ }
+
+ return ((val - lower) / range);
+ }*/
+}
+
void
Session::ensure_buffers (ChanCount howmany)
{
+ if (current_block_size == 0)
+ return; // too early? (is this ok?)
+
// We need at least 1 MIDI scratch buffer to mix/merge
if (howmany.n_midi() < 1)
howmany.set_midi(1);
VSTPlugin::set_parameter (uint32_t which, float val)
{
_plugin->setParameter (_plugin, which, val);
- ParameterChanged (which, val); /* EMIT SIGNAL */
+ //ParameterChanged (which, val); /* EMIT SIGNAL */
}
float
projects / ardour.git / commitdiff