X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fautomation_line.cc;h=9c1aa13198bc52c76dfbb2b9595d5c7491cad4ed;hb=f413b83cb9fa50954969a3d849999e1890ce6690;hp=d5ed529ad882adca59efd0bfd8fb0746b0ea46e9;hpb=44203ce955f33135065456f55f1f685131174ba6;p=ardour.git

diff --git a/gtk2_ardour/automation_line.cc b/gtk2_ardour/automation_line.cc
index d5ed529ad8..9c1aa13198 100644
--- a/gtk2_ardour/automation_line.cc
+++ b/gtk2_ardour/automation_line.cc
@@ -30,7 +30,6 @@
 
 #include <climits>
 #include <vector>
-#include <fstream>
 
 #include "boost/shared_ptr.hpp"
 
@@ -53,18 +52,18 @@
 #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;
@@ -87,6 +86,7 @@ AutomationLine::AutomationLine (const string&                              name,
 	, _parent_group (parent)
 	, _offset (0)
 	, _maximum_time (max_framepos)
+	, _fill (false)
 	, _desc (desc)
 {
 	if (converter) {
@@ -94,18 +94,17 @@ AutomationLine::AutomationLine (const string&                              name,
 	} 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;
 	_height = 0;
 
-	group = new ArdourCanvas::Container (&parent);
+	group = new ArdourCanvas::Container (&parent, ArdourCanvas::Duple(0, 1.5));
 	CANVAS_DEBUG_NAME (group, "region gain envelope group");
 
 	line = new ArdourCanvas::PolyLine (group);
@@ -118,12 +117,6 @@ AutomationLine::AutomationLine (const string&                              name,
 
 	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 ();
@@ -172,7 +165,7 @@ AutomationLine::update_visibility ()
 			}
 		} 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 ();
@@ -194,16 +187,28 @@ AutomationLine::update_visibility ()
 			}
 		}
 	}
+}
 
+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));
 }
 
@@ -230,6 +235,11 @@ AutomationLine::set_height (guint32 h)
 			(*i)->set_size (bsz);
 		}
 
+		if (_fill) {
+			line->set_fill_y1 (_height);
+		} else {
+			line->set_fill_y1 (0);
+		}
 		reset ();
 	}
 }
@@ -239,15 +249,10 @@ AutomationLine::set_line_color (uint32_t color)
 {
 	_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 ();
-	}
+	ArdourCanvas::SVAModifier mod = UIConfiguration::instance().modifier ("automation line fill");
+
+	line->set_fill_color ((color & 0xffffff00) + mod.a()*255);
 }
 
 ControlPoint*
@@ -289,16 +294,16 @@ AutomationLine::modify_point_y (ControlPoint& cp, double y)
 
 	cp.move_to (x, y, ControlPoint::Full);
 
+	alist->freeze ();
+	sync_model_with_view_point (cp);
+	alist->thaw ();
+
 	reset_line_coords (cp);
 
 	if (line_points.size() > 1) {
 		line->set_steps (line_points, is_stepped());
 	}
 
-	alist->freeze ();
-	sync_model_with_view_point (cp);
-	alist->thaw ();
-
 	update_pending = false;
 
 	trackview.editor().session()->add_command (
@@ -317,50 +322,31 @@ AutomationLine::reset_line_coords (ControlPoint& cp)
 	}
 }
 
-void
+bool
 AutomationLine::sync_model_with_view_points (list<ControlPoint*> cp)
 {
 	update_pending = true;
 
+	bool moved = false;
 	for (list<ControlPoint*>::iterator i = cp.begin(); i != cp.end(); ++i) {
-		sync_model_with_view_point (**i);
+		moved = sync_model_with_view_point (**i) || moved;
 	}
+
+	return moved;
 }
 
 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 + ")";
 }
 
 /**
@@ -370,56 +356,18 @@ AutomationLine::get_verbose_cursor_relative_string (double original, double frac
 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;
 }
 
 /**
@@ -429,20 +377,23 @@ AutomationLine::fraction_to_relative_string (double original, double fraction) c
 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;
 }
 
@@ -456,16 +407,15 @@ AutomationLine::string_to_fraction (string const & s) const
 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);
 			}
 		}
@@ -482,7 +432,6 @@ AutomationLine::start_drag_single (ControlPoint* cp, double x, float fraction)
 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));
 
@@ -502,7 +451,6 @@ AutomationLine::start_drag_line (uint32_t i1, uint32_t i2, float fraction)
 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));
 
@@ -515,13 +463,13 @@ struct ControlPointSorter
 	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)
 {
 }
 
@@ -533,7 +481,7 @@ AutomationLine::ContiguousControlPoints::compute_x_bounds (PublicEditor& e)
 	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
 		*/
 
@@ -541,8 +489,8 @@ AutomationLine::ContiguousControlPoints::compute_x_bounds (PublicEditor& e)
 			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 Meter& meter = map.meter_at_frame (pos);
+			const framecnt_t len = ceil (meter.frames_per_bar (map.tempo_at_frame (pos), e.session()->frame_rate())
 					/ (Timecode::BBT_Time::ticks_per_beat * meter.divisions_per_bar()) );
 			const double one_tick_in_pixels = e.sample_to_pixel_unrounded (len);
 
@@ -557,8 +505,8 @@ AutomationLine::ContiguousControlPoints::compute_x_bounds (PublicEditor& e)
 			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 Meter& meter = map.meter_at_frame (pos);
+			const framecnt_t len = ceil (meter.frames_per_bar (map.tempo_at_frame (pos), e.session()->frame_rate())
 					/ (Timecode::BBT_Time::ticks_per_beat * meter.divisions_per_bar()));
 			const double one_tick_in_pixels = e.sample_to_pixel_unrounded (len);
 
@@ -567,8 +515,8 @@ AutomationLine::ContiguousControlPoints::compute_x_bounds (PublicEditor& e)
 	}
 }
 
-double 
-AutomationLine::ContiguousControlPoints::clamp_dx (double dx) 
+double
+AutomationLine::ContiguousControlPoints::clamp_dx (double dx)
 {
 	if (empty()) {
 		return dx;
@@ -576,10 +524,10 @@ AutomationLine::ContiguousControlPoints::clamp_dx (double 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();
@@ -588,17 +536,24 @@ AutomationLine::ContiguousControlPoints::clamp_dx (double dx)
 		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);
 	}
 }
@@ -627,11 +582,11 @@ AutomationLine::start_drag_common (double x, float fraction)
  *  @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);
@@ -639,19 +594,19 @@ AutomationLine::drag_motion (double const x, float fraction, bool ignore_x, bool
 
 	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));
@@ -668,13 +623,14 @@ AutomationLine::drag_motion (double const x, float fraction, bool ignore_x, bool
 		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.
 	 */
 
@@ -687,25 +643,42 @@ AutomationLine::drag_motion (double const x, float fraction, bool ignore_x, bool
 		}
 	}
 
+	/* 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;
@@ -717,21 +690,32 @@ AutomationLine::drag_motion (double const x, float fraction, bool ignore_x, bool
 			}
 		}
 
-		/* 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 */
@@ -743,13 +727,13 @@ AutomationLine::end_drag (bool with_push, uint32_t final_index)
 	}
 
 	alist->freeze ();
-	sync_model_with_view_points (_drag_points);
+	bool moved = sync_model_with_view_points (_drag_points);
 
 	if (with_push) {
 		ControlPoint* p;
 		uint32_t i = final_index;
 		while ((p = nth (i)) != 0 && p->can_slide()) {
-			sync_model_with_view_point (*p);
+			moved = sync_model_with_view_point (*p) || moved;
 			++i;
 		}
 	}
@@ -758,6 +742,12 @@ AutomationLine::end_drag (bool with_push, uint32_t final_index)
 
 	update_pending = false;
 
+	if (moved) {
+		/* A point has moved as a result of sync (clamped to integer or boolean
+		   value), update line accordingly. */
+		line->set_steps (line_points, is_stepped());
+	}
+
 	trackview.editor().session()->add_command (
 		new MementoCommand<AutomationList>(memento_command_binder (), 0, &alist->get_state()));
 
@@ -767,7 +757,7 @@ AutomationLine::end_drag (bool with_push, uint32_t final_index)
 	contiguous_points.clear ();
 }
 
-void
+bool
 AutomationLine::sync_model_with_view_point (ControlPoint& cp)
 {
 	/* find out where the visual control point is.
@@ -776,7 +766,7 @@ AutomationLine::sync_model_with_view_point (ControlPoint& cp)
 	*/
 
 	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 */
 
@@ -792,6 +782,17 @@ AutomationLine::sync_model_with_view_point (ControlPoint& cp)
 	view_to_model_coord_y (view_y);
 
 	alist->modify (cp.model(), view_x, view_y);
+
+	/* convert back from model to view y for clamping position (for integer/boolean/etc) */
+	model_to_view_coord_y (view_y);
+	const double point_y = _height - (view_y * _height);
+	if (point_y != cp.get_y()) {
+		cp.move_to (cp.get_x(), point_y, ControlPoint::Full);
+		reset_line_coords (cp);
+		return true;
+	}
+
+	return false;
 }
 
 bool
@@ -860,8 +861,9 @@ AutomationLine::remove_point (ControlPoint& cp)
 	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()));
 
@@ -889,7 +891,7 @@ AutomationLine::get_selectables (framepos_t start, framepos_t end, double botfra
 		/* 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)
 		*/
-		
+
 		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) {
@@ -924,9 +926,10 @@ AutomationLine::set_selected_points (PointSelection const & points)
 	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 ();
 	}
@@ -969,7 +972,7 @@ AutomationLine::reset_callback (const Evoral::ControlList& events)
 	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;
@@ -984,17 +987,17 @@ AutomationLine::reset_callback (const Evoral::ControlList& events)
 			                           _name) << endmsg;
 			continue;
 		}
-		
+
 		if (tx >= max_framepos || 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)
 		 */
@@ -1165,40 +1168,55 @@ AutomationLine::view_to_model_coord (double& x, double& y) const
 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.toggled || _desc.integer_step) {
-			y = round(y);
+#ifdef XXX_NEW_INTERPOLATON__BREAK_SESSION_FORMAT_XXX
+	if (alist->default_interpolation () != alist->interpolation()) {
+		switch (alist->interpolation()) {
+			case AutomationList::Linear:
+				y = y * (_desc.upper - _desc.lower) + _desc.lower;
+				return;
+			default:
+				assert (0);
+				break;
 		}
 	}
+#endif
+	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());
+#ifdef XXX_NEW_INTERPOLATON__BREAK_SESSION_FORMAT_XXX
+	if (alist->default_interpolation () != alist->interpolation()) {
+		switch (alist->interpolation()) {
+			case AutomationList::Linear:
+				y = (y - _desc.lower) / (_desc.upper - _desc.lower);
+				return;
+			default:
+				assert (0);
+				break;
+		}
 	}
+#endif
+	y = _desc.to_interface (y);
 }
 
 void
@@ -1213,12 +1231,13 @@ 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;