#include <climits>
#include <vector>
-#include <fstream>
#include "boost/shared_ptr.hpp"
#include "control_point.h"
#include "gui_thread.h"
#include "rgb_macros.h"
-#include "ardour_ui.h"
#include "public_editor.h"
#include "selection.h"
#include "time_axis_view.h"
#include "point_selection.h"
#include "automation_time_axis.h"
+#include "ui_config.h"
#include "ardour/event_type_map.h"
#include "ardour/session.h"
#include "ardour/value_as_string.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
using namespace std;
using namespace ARDOUR;
using namespace PBD;
using namespace Editing;
-/** @param converter A TimeConverter whose origin_b is the start time of the AutomationList in session frames.
+/** @param converter A TimeConverter whose origin_b is the start time of the AutomationList in session samples.
* This will not be deleted by AutomationLine.
*/
AutomationLine::AutomationLine (const string& name,
ArdourCanvas::Item& parent,
boost::shared_ptr<AutomationList> al,
const ParameterDescriptor& desc,
- Evoral::TimeConverter<double, framepos_t>* converter)
+ Evoral::TimeConverter<double, samplepos_t>* converter)
: trackview (tv)
, _name (name)
, alist (al)
- , _time_converter (converter ? converter : new Evoral::IdentityConverter<double, framepos_t>)
+ , _time_converter (converter ? converter : new Evoral::IdentityConverter<double, samplepos_t>)
, _parent_group (parent)
, _offset (0)
- , _maximum_time (max_framepos)
+ , _maximum_time (max_samplepos)
+ , _fill (false)
, _desc (desc)
{
if (converter) {
} else {
_our_time_converter = true;
}
-
+
_visible = Line;
update_pending = false;
have_timeout = false;
- _uses_gain_mapping = false;
no_draw = false;
_is_boolean = false;
terminal_points_can_slide = true;
trackview.session()->register_with_memento_command_factory(alist->id(), this);
- if (alist->parameter().type() == GainAutomation ||
- alist->parameter().type() == EnvelopeAutomation ||
- desc.unit == ParameterDescriptor::DB) {
- set_uses_gain_mapping (true);
- }
-
interpolation_changed (alist->interpolation ());
connect_to_list ();
}
} else if (_visible & SelectedControlPoints) {
for (vector<ControlPoint*>::iterator i = control_points.begin(); i != control_points.end(); ++i) {
- if ((*i)->get_selected()) {
+ if ((*i)->selected()) {
(*i)->show ();
} else {
(*i)->hide ();
}
}
}
+}
+bool
+AutomationLine::get_uses_gain_mapping () const
+{
+ switch (_desc.type) {
+ case GainAutomation:
+ case EnvelopeAutomation:
+ case TrimAutomation:
+ return true;
+ default:
+ return false;
+ }
}
void
AutomationLine::hide ()
{
/* leave control points setting unchanged, we are just hiding the
- overall line
+ overall line
*/
-
+
set_visibility (AutomationLine::VisibleAspects (_visible & ~Line));
}
(*i)->set_size (bsz);
}
+ if (_fill) {
+ line->set_fill_y1 (_height);
+ } else {
+ line->set_fill_y1 (0);
+ }
reset ();
}
}
{
_line_color = color;
line->set_outline_color (color);
-}
-void
-AutomationLine::set_uses_gain_mapping (bool yn)
-{
- if (yn != _uses_gain_mapping) {
- _uses_gain_mapping = yn;
- reset ();
- }
+ Gtkmm2ext::SVAModifier mod = UIConfiguration::instance().modifier ("automation line fill");
+
+ line->set_fill_color ((color & 0xffffff00) + mod.a()*255);
}
ControlPoint*
string
AutomationLine::get_verbose_cursor_string (double fraction) const
{
- std::string s = fraction_to_string (fraction);
- if (_uses_gain_mapping) {
- s += " dB";
- }
-
- return s;
+ return fraction_to_string (fraction);
}
string
-AutomationLine::get_verbose_cursor_relative_string (double original, double fraction) const
+AutomationLine::get_verbose_cursor_relative_string (double fraction, double delta) const
{
std::string s = fraction_to_string (fraction);
- if (_uses_gain_mapping) {
- s += " dB";
- }
-
- std::string d = fraction_to_relative_string (original, fraction);
-
- if (!d.empty()) {
-
- s += " (\u0394";
- s += d;
-
- if (_uses_gain_mapping) {
- s += " dB";
- }
-
- s += ')';
- }
-
- return s;
+ std::string d = delta_to_string (delta);
+ return s + " (" + d + ")";
}
/**
string
AutomationLine::fraction_to_string (double fraction) const
{
- if (_uses_gain_mapping) {
- char buf[32];
- if (fraction == 0.0) {
- snprintf (buf, sizeof (buf), "-inf");
- } else {
- snprintf (buf, sizeof (buf), "%.1f", accurate_coefficient_to_dB (slider_position_to_gain_with_max (fraction, Config->get_max_gain())));
- }
- return buf;
- } else {
- view_to_model_coord_y (fraction);
- return ARDOUR::value_as_string (_desc, fraction);
- }
-
- return ""; /*NOTREACHED*/
+ view_to_model_coord_y (fraction);
+ return ARDOUR::value_as_string (_desc, fraction);
}
-/**
- * @param original an old y-axis fraction
- * @param fraction the new y fraction
- * @return string representation of the difference between original and fraction, using dB if appropriate.
- */
string
-AutomationLine::fraction_to_relative_string (double original, double fraction) const
+AutomationLine::delta_to_string (double delta) const
{
- char buf[32];
-
- if (original == fraction) {
- return "0";
- }
-
- if (_uses_gain_mapping) {
- if (original == 0.0) {
- /* there is no sensible representation of a relative
- change from -inf dB, so return an empty string.
- */
- return "";
- } else if (fraction == 0.0) {
- snprintf (buf, sizeof (buf), "-inf");
- } else {
- double old_db = accurate_coefficient_to_dB (slider_position_to_gain_with_max (original, Config->get_max_gain()));
- double new_db = accurate_coefficient_to_dB (slider_position_to_gain_with_max (fraction, Config->get_max_gain()));
- snprintf (buf, sizeof (buf), "%.1f", new_db - old_db);
- }
+ if (!get_uses_gain_mapping () && _desc.logarithmic) {
+ return "x " + ARDOUR::value_as_string (_desc, delta);
} else {
- view_to_model_coord_y (original);
- view_to_model_coord_y (fraction);
- return ARDOUR::value_as_string (_desc, fraction - original);
+ return "\u0394 " + ARDOUR::value_as_string (_desc, delta);
}
-
- return buf;
}
/**
double
AutomationLine::string_to_fraction (string const & s) const
{
- if (s == "-inf") {
- return 0;
- }
-
double v;
sscanf (s.c_str(), "%lf", &v);
- if (_uses_gain_mapping) {
- v = gain_to_slider_position_with_max (dB_to_coefficient (v), Config->get_max_gain());
- } else {
- double dummy = 0.0;
- model_to_view_coord (dummy, v);
+ switch (_desc.type) {
+ case GainAutomation:
+ case EnvelopeAutomation:
+ case TrimAutomation:
+ if (s == "-inf") { /* translation */
+ v = 0;
+ } else {
+ v = dB_to_coefficient (v);
+ }
+ break;
+ default:
+ break;
}
-
+ model_to_view_coord_y (v);
return v;
}
void
AutomationLine::start_drag_single (ControlPoint* cp, double x, float fraction)
{
- trackview.editor().begin_reversible_command (_("automation event move"));
trackview.editor().session()->add_command (
new MementoCommand<AutomationList> (memento_command_binder(), &get_state(), 0));
_drag_points.clear ();
_drag_points.push_back (cp);
- if (cp->get_selected ()) {
+ if (cp->selected ()) {
for (vector<ControlPoint*>::iterator i = control_points.begin(); i != control_points.end(); ++i) {
- if (*i != cp && (*i)->get_selected()) {
+ if (*i != cp && (*i)->selected()) {
_drag_points.push_back (*i);
}
}
void
AutomationLine::start_drag_line (uint32_t i1, uint32_t i2, float fraction)
{
- trackview.editor().begin_reversible_command (_("automation range move"));
trackview.editor().session()->add_command (
new MementoCommand<AutomationList> (memento_command_binder (), &get_state(), 0));
void
AutomationLine::start_drag_multiple (list<ControlPoint*> cp, float fraction, XMLNode* state)
{
- trackview.editor().begin_reversible_command (_("automation range move"));
trackview.editor().session()->add_command (
new MementoCommand<AutomationList> (memento_command_binder(), state, 0));
bool operator() (ControlPoint const * a, ControlPoint const * b) const {
if (floateq (a->get_x(), b->get_x(), 1)) {
return a->view_index() < b->view_index();
- }
+ }
return a->get_x() < b->get_x();
}
};
AutomationLine::ContiguousControlPoints::ContiguousControlPoints (AutomationLine& al)
- : line (al), before_x (0), after_x (DBL_MAX)
+ : line (al), before_x (0), after_x (DBL_MAX)
{
}
if (sz > 0 && sz < line.npoints()) {
const TempoMap& map (e.session()->tempo_map());
- /* determine the limits on x-axis motion for this
+ /* determine the limits on x-axis motion for this
contiguous range of control points
*/
if (front()->view_index() > 0) {
before_x = line.nth (front()->view_index() - 1)->get_x();
- const framepos_t pos = e.pixel_to_sample(before_x);
- const Meter& meter = map.meter_at (pos);
- const framecnt_t len = ceil (meter.frames_per_bar (map.tempo_at (pos), e.session()->frame_rate())
+ const samplepos_t pos = e.pixel_to_sample(before_x);
+ const Meter& meter = map.meter_at_sample (pos);
+ const samplecnt_t len = ceil (meter.samples_per_bar (map.tempo_at_sample (pos), e.session()->sample_rate())
/ (Timecode::BBT_Time::ticks_per_beat * meter.divisions_per_bar()) );
const double one_tick_in_pixels = e.sample_to_pixel_unrounded (len);
if (back()->view_index() < (line.npoints() - 1)) {
after_x = line.nth (back()->view_index() + 1)->get_x();
- const framepos_t pos = e.pixel_to_sample(after_x);
- const Meter& meter = map.meter_at (pos);
- const framecnt_t len = ceil (meter.frames_per_bar (map.tempo_at (pos), e.session()->frame_rate())
+ const samplepos_t pos = e.pixel_to_sample(after_x);
+ const Meter& meter = map.meter_at_sample (pos);
+ const samplecnt_t len = ceil (meter.samples_per_bar (map.tempo_at_sample (pos), e.session()->sample_rate())
/ (Timecode::BBT_Time::ticks_per_beat * meter.divisions_per_bar()));
const double one_tick_in_pixels = e.sample_to_pixel_unrounded (len);
}
}
-double
-AutomationLine::ContiguousControlPoints::clamp_dx (double dx)
+double
+AutomationLine::ContiguousControlPoints::clamp_dx (double dx)
{
if (empty()) {
return dx;
/* get the maximum distance we can move any of these points along the x-axis
*/
-
+
double tx; /* possible position a point would move to, given dx */
ControlPoint* cp;
-
+
if (dx > 0) {
/* check the last point, since we're moving later in time */
cp = back();
cp = front();
}
- tx = cp->get_x() + dx; // new possible position if we just add the motion
+ tx = cp->get_x() + dx; // new possible position if we just add the motion
tx = max (tx, before_x); // can't move later than following point
tx = min (tx, after_x); // can't move earlier than preceeding point
- return tx - cp->get_x ();
+ return tx - cp->get_x ();
}
-void
-AutomationLine::ContiguousControlPoints::move (double dx, double dy)
+void
+AutomationLine::ContiguousControlPoints::move (double dx, double dvalue)
{
for (std::list<ControlPoint*>::iterator i = begin(); i != end(); ++i) {
- (*i)->move_to ((*i)->get_x() + dx, (*i)->get_y() - line.height() * dy, ControlPoint::Full);
+ // compute y-axis delta
+ double view_y = 1.0 - (*i)->get_y() / line.height();
+ line.view_to_model_coord_y (view_y);
+ line.apply_delta (view_y, dvalue);
+ line.model_to_view_coord_y (view_y);
+ view_y = (1.0 - view_y) * line.height();
+
+ (*i)->move_to ((*i)->get_x() + dx, view_y, ControlPoint::Full);
line.reset_line_coords (**i);
}
}
* @param fraction New y fraction.
* @return x position and y fraction that were actually used (once clamped).
*/
-pair<double, float>
+pair<float, float>
AutomationLine::drag_motion (double const x, float fraction, bool ignore_x, bool with_push, uint32_t& final_index)
{
if (_drag_points.empty()) {
- return pair<double,float> (x,fraction);
+ return pair<double,float> (fraction, _desc.is_linear () ? 0 : 1);
}
double dx = ignore_x ? 0 : (x - _drag_x);
if (!_drag_had_movement) {
- /* "first move" ... do some stuff that we don't want to do if
+ /* "first move" ... do some stuff that we don't want to do if
no motion ever took place, but need to do before we handle
motion.
*/
-
+
/* partition the points we are dragging into (potentially several)
* set(s) of contiguous points. this will not happen with a normal
* drag, but if the user does a discontiguous selection, it can.
*/
-
+
uint32_t expected_view_index = 0;
CCP contig;
-
+
for (list<ControlPoint*>::iterator i = _drag_points.begin(); i != _drag_points.end(); ++i) {
if (i == _drag_points.begin() || (*i)->view_index() != expected_view_index) {
contig.reset (new ContiguousControlPoints (*this));
for (vector<CCP>::iterator ccp = contiguous_points.begin(); ccp != contiguous_points.end(); ++ccp) {
(*ccp)->compute_x_bounds (trackview.editor());
}
- }
+ _drag_had_movement = true;
+ }
/* OK, now on to the stuff related to *this* motion event. First, for
* each contiguous range, figure out the maximum x-axis motion we are
* allowed (because of neighbouring points that are not moving.
- *
- * if we are moving forwards with push, we don't need to do this,
+ *
+ * if we are moving forwards with push, we don't need to do this,
* since all later points will move too.
*/
}
}
+ /* compute deflection */
+ double delta_value;
+ {
+ double value0 = _last_drag_fraction;
+ double value1 = _last_drag_fraction + dy;
+ view_to_model_coord_y (value0);
+ view_to_model_coord_y (value1);
+ delta_value = compute_delta (value0, value1);
+ }
+
+ /* special case -inf */
+ if (delta_value == 0 && dy > 0 && !_desc.is_linear ()) {
+ assert (_desc.lower == 0);
+ delta_value = 1.0;
+ }
+
/* clamp y */
-
for (list<ControlPoint*>::iterator i = _drag_points.begin(); i != _drag_points.end(); ++i) {
- double const y = ((_height - (*i)->get_y()) / _height) + dy;
- if (y < 0) {
- dy -= y;
+ double vy = 1.0 - (*i)->get_y() / _height;
+ view_to_model_coord_y (vy);
+ const double orig = vy;
+ apply_delta (vy, delta_value);
+ if (vy < _desc.lower) {
+ delta_value = compute_delta (orig, _desc.lower);
}
- if (y > 1) {
- dy -= (y - 1);
+ if (vy > _desc.upper) {
+ delta_value = compute_delta (orig, _desc.upper);
}
}
if (dx || dy) {
-
/* and now move each section */
-
for (vector<CCP>::iterator ccp = contiguous_points.begin(); ccp != contiguous_points.end(); ++ccp) {
- (*ccp)->move (dx, dy);
+ (*ccp)->move (dx, delta_value);
}
+
if (with_push) {
final_index = contiguous_points.back()->back()->view_index () + 1;
ControlPoint* p;
}
}
- /* update actual line coordinates (will queue a redraw)
- */
+ /* update actual line coordinates (will queue a redraw) */
if (line_points.size() > 1) {
line->set_steps (line_points, is_stepped());
}
}
-
+
+ /* calculate effective delta */
+ ControlPoint* cp = _drag_points.front();
+ double vy = 1.0 - cp->get_y() / (double)_height;
+ view_to_model_coord_y (vy);
+ float val = (*(cp->model ()))->value;
+ float effective_delta = _desc.compute_delta (val, vy);
+ /* special case recovery from -inf */
+ if (val == 0 && effective_delta == 0 && vy > 0) {
+ assert (!_desc.is_linear ());
+ effective_delta = HUGE_VAL; // +Infinity
+ }
+
+ double const result_frac = _last_drag_fraction + dy;
_drag_distance += dx;
_drag_x += dx;
- _last_drag_fraction = fraction;
- _drag_had_movement = true;
+ _last_drag_fraction = result_frac;
did_push = with_push;
- return pair<double, float> (_drag_x + dx, _last_drag_fraction + dy);
+ return pair<float, float> (result_frac, effective_delta);
}
/** Should be called to indicate the end of a drag */
*/
double view_x = cp.get_x();
- double view_y = 1.0 - (cp.get_y() / _height);
+ double view_y = 1.0 - cp.get_y() / (double)_height;
/* if xval has not changed, set it directly from the model to avoid rounding errors */
trackview.editor().begin_reversible_command (_("remove control point"));
XMLNode &before = alist->get_state();
+ trackview.editor ().get_selection ().clear_points ();
alist->erase (cp.model());
-
+
trackview.editor().session()->add_command(
new MementoCommand<AutomationList> (memento_command_binder (), &before, &alist->get_state()));
}
/** Get selectable points within an area.
- * @param start Start position in session frames.
- * @param end End position in session frames.
+ * @param start Start position in session samples.
+ * @param end End position in session samples.
* @param bot Bottom y range, as a fraction of line height, where 0 is the bottom of the line.
* @param top Top y range, as a fraction of line height, where 0 is the bottom of the line.
* @param result Filled in with selectable things; in this case, ControlPoints.
*/
void
-AutomationLine::get_selectables (framepos_t start, framepos_t end, double botfrac, double topfrac, list<Selectable*>& results)
+AutomationLine::get_selectables (samplepos_t start, samplepos_t end, double botfrac, double topfrac, list<Selectable*>& results)
{
/* convert fractions to display coordinates with 0 at the top of the track */
double const bot_track = (1 - topfrac) * trackview.current_height ();
double const model_when = (*(*i)->model())->when;
/* model_when is relative to the start of the source, so we just need to add on the origin_b here
- (as it is the session frame position of the start of the source)
+ (as it is the session sample position of the start of the source)
*/
-
- framepos_t const session_frames_when = _time_converter->to (model_when) + _time_converter->origin_b ();
- if (session_frames_when >= start && session_frames_when <= end && (*i)->get_y() >= bot_track && (*i)->get_y() <= top_track) {
+ samplepos_t const session_samples_when = _time_converter->to (model_when) + _time_converter->origin_b ();
+
+ if (session_samples_when >= start && session_samples_when <= end && (*i)->get_y() >= bot_track && (*i)->get_y() <= top_track) {
results.push_back (*i);
}
}
set_colors ();
}
-void AutomationLine::set_colors ()
+void
+AutomationLine::set_colors ()
{
- set_line_color (ARDOUR_UI::config()->color ("automation line"));
+ set_line_color (UIConfiguration::instance().color ("automation line"));
for (vector<ControlPoint*>::iterator i = control_points.begin(); i != control_points.end(); ++i) {
(*i)->set_color ();
}
np = events.size();
Evoral::ControlList& e = const_cast<Evoral::ControlList&> (events);
-
+
for (AutomationList::iterator ai = e.begin(); ai != e.end(); ++ai, ++pi) {
double tx = (*ai)->when;
_name) << endmsg;
continue;
}
-
- if (tx >= max_framepos || tx < 0 || tx >= _maximum_time) {
+
+ if (tx >= max_samplepos || tx < 0 || tx >= _maximum_time) {
continue;
}
-
+
/* convert x-coordinate to a canvas unit coordinate (this takes
* zoom and scroll into account).
*/
-
+
tx = trackview.editor().sample_to_pixel_unrounded (tx);
-
+
/* convert from canonical view height (0..1.0) to actual
* height coordinates (using X11's top-left rooted system)
*/
return;
}
+ /* TODO: abort any drags in progress, e.g. draging points while writing automation
+ * (the control-point model, used by AutomationLine::drag_motion, will be invalid).
+ *
+ * Note: reset() may also be called from an aborted drag (LineDrag::aborted)
+ * maybe abort in list_changed(), interpolation_changed() and ... ?
+ * XXX
+ */
+
alist->apply_to_points (*this, &AutomationLine::reset_callback);
}
void
AutomationLine::queue_reset ()
{
- /* this must be called from the GUI thread
- */
+ /* this must be called from the GUI thread */
if (trackview.editor().session()->transport_rolling() && alist->automation_write()) {
/* automation write pass ... defer to a timeout */
void
AutomationLine::view_to_model_coord_y (double& y) const
{
- /* TODO: This should be more generic (use ParameterDescriptor) */
- if (alist->parameter().type() == GainAutomation ||
- alist->parameter().type() == EnvelopeAutomation) {
- y = slider_position_to_gain_with_max (y, Config->get_max_gain());
- y = max (0.0, y);
- y = min (2.0, y);
- } else if (alist->parameter().type() == PanAzimuthAutomation ||
- alist->parameter().type() == PanElevationAutomation) {
- y = 1.0 - y;
- } else if (alist->parameter().type() == PanWidthAutomation) {
- y = 2.0 * y - 1.0;
- } else {
- y = y * (double)(alist->get_max_y() - alist->get_min_y()) + alist->get_min_y();
- if (_desc.integer_step) {
- y = round(y);
- } else if (_desc.toggled) {
- y = (y > 0.5) ? 1.0 : 0.0;
+ if (alist->default_interpolation () != alist->interpolation()) {
+ switch (alist->interpolation()) {
+ case AutomationList::Discrete:
+ /* toggles and MIDI only -- see is_stepped() */
+ assert (alist->default_interpolation () == AutomationList::Linear);
+ break;
+ case AutomationList::Linear:
+ y = y * (_desc.upper - _desc.lower) + _desc.lower;
+ return;
+ default:
+ /* types that default to linear, can't be use
+ * Logarithmic or Exponential interpolation.
+ * "Curved" is invalid for automation (only x-fads)
+ */
+ assert (0);
+ break;
}
}
+ y = _desc.from_interface (y);
+}
+
+double
+AutomationLine::compute_delta (double from, double to) const
+{
+ return _desc.compute_delta (from, to);
+}
+
+void
+AutomationLine::apply_delta (double& val, double delta) const
+{
+ if (val == 0 && !_desc.is_linear () && delta >= 1.0) {
+ /* recover from -inf */
+ val = 1.0 / _height;
+ view_to_model_coord_y (val);
+ return;
+ }
+ val = _desc.apply_delta (val, delta);
}
void
AutomationLine::model_to_view_coord_y (double& y) const
{
- /* TODO: This should be more generic (use ParameterDescriptor) */
- if (alist->parameter().type() == GainAutomation ||
- alist->parameter().type() == EnvelopeAutomation) {
- y = gain_to_slider_position_with_max (y, Config->get_max_gain());
- } else if (alist->parameter().type() == PanAzimuthAutomation ||
- alist->parameter().type() == PanElevationAutomation) {
- y = 1.0 - y;
- } else if (alist->parameter().type() == PanWidthAutomation) {
- y = .5 + y * .5;
- } else {
- y = (y - alist->get_min_y()) / (double)(alist->get_max_y() - alist->get_min_y());
+ if (alist->default_interpolation () != alist->interpolation()) {
+ switch (alist->interpolation()) {
+ case AutomationList::Discrete:
+ /* toggles and MIDI only -- see is_stepped */
+ assert (alist->default_interpolation () == AutomationList::Linear);
+ break;
+ case AutomationList::Linear:
+ y = (y - _desc.lower) / (_desc.upper - _desc.lower);
+ return;
+ default:
+ /* types that default to linear, can't be use
+ * Logarithmic or Exponential interpolation.
+ * "Curved" is invalid for automation (only x-fads)
+ */
+ assert (0);
+ break;
+ }
}
+ y = _desc.to_interface (y);
}
void
AutomationLine::interpolation_changed (AutomationList::InterpolationStyle style)
{
if (line_points.size() > 1) {
+ reset ();
line->set_steps(line_points, is_stepped());
}
}
void
-AutomationLine::add_visible_control_point (uint32_t view_index, uint32_t pi, double tx, double ty,
+AutomationLine::add_visible_control_point (uint32_t view_index, uint32_t pi, double tx, double ty,
AutomationList::iterator model, uint32_t npoints)
{
ControlPoint::ShapeType shape;
* to the start of the track or region that it is on.
*/
void
-AutomationLine::set_maximum_time (framecnt_t t)
+AutomationLine::set_maximum_time (samplecnt_t t)
{
if (_maximum_time == t) {
return;
}
-/** @return min and max x positions of points that are in the list, in session frames */
-pair<framepos_t, framepos_t>
+/** @return min and max x positions of points that are in the list, in session samples */
+pair<samplepos_t, samplepos_t>
AutomationLine::get_point_x_range () const
{
- pair<framepos_t, framepos_t> r (max_framepos, 0);
+ pair<samplepos_t, samplepos_t> r (max_samplepos, 0);
for (AutomationList::const_iterator i = the_list()->begin(); i != the_list()->end(); ++i) {
r.first = min (r.first, session_position (i));
return r;
}
-framepos_t
+samplepos_t
AutomationLine::session_position (AutomationList::const_iterator p) const
{
return _time_converter->to ((*p)->when) + _offset + _time_converter->origin_b ();
}
void
-AutomationLine::set_offset (framepos_t off)
+AutomationLine::set_offset (samplepos_t off)
{
if (_offset == off) {
return;
projects / ardour.git / blobdiff