Tempo ramps - add Canvas::FramedCurve and use it in the tempo marker bar.

gtk2_ardour/tempo_curve.cc

@@ -24,7 +24,7 @@ static double curve_height = 13.0;
 
 void TempoCurve::setup_sizes(const double timebar_height)
 {
-	curve_height = floor (timebar_height) - 2;
+	curve_height = floor (timebar_height) - 2.5;
 }
 
 TempoCurve::TempoCurve (PublicEditor& ed, ArdourCanvas::Container& parent, guint32 rgba, ARDOUR::TempoSection& temp, framepos_t frame, bool handle_events)
@@ -38,8 +38,21 @@ TempoCurve::TempoCurve (PublicEditor& ed, ArdourCanvas::Container& parent, guint
 	, _max_tempo (temp.beats_per_minute())
 	, _tempo (temp)
 
-
 {
+	frame_position = frame;
+	unit_position = editor.sample_to_pixel (frame);
+
+	group = new ArdourCanvas::Container (&parent, ArdourCanvas::Duple (unit_position, 1));
+#ifdef CANVAS_DEBUG
+	group->name = string_compose ("Marker::group for %1", _tempo.beats_per_minute());
+#endif
+
+	_curve = new ArdourCanvas::FramedCurve (group);
+#ifdef CANVAS_DEBUG
+	_curve->name = string_compose ("TempoCurve::_curve for %1", _tempo.beats_per_minute());
+#endif
+	_curve->set_fill_mode (ArdourCanvas::FramedCurve::Inside);
+	_curve->set_points_per_segment (31);
 
 	points = new ArdourCanvas::Points ();
 	points->push_back (ArdourCanvas::Duple (0.0, 0.0));
@@ -47,27 +60,6 @@ TempoCurve::TempoCurve (PublicEditor& ed, ArdourCanvas::Container& parent, guint
 	points->push_back (ArdourCanvas::Duple (1.0, curve_height));
 	points->push_back (ArdourCanvas::Duple (0.0, curve_height));
 
-	frame_position = frame;
-	unit_position = editor.sample_to_pixel (frame);
-
-	group = new ArdourCanvas::Container (&parent, ArdourCanvas::Duple (unit_position, 0));
-#ifdef CANVAS_DEBUG
-	group->name = string_compose ("Marker::group for %1", _tempo.beats_per_minute());
-#endif
-
-	_background = new ArdourCanvas::Rectangle (group);
-#ifdef CANVAS_DEBUG
-	_background->name = string_compose ("TempoCurve::_background for %1", _tempo.beats_per_minute());
-#endif
-	_background->set_x0 (0.0);
-	_background->set_x1 (ArdourCanvas::COORD_MAX);
-	_background->set_outline_what (ArdourCanvas::Rectangle::What(0));
-	_curve = new ArdourCanvas::Curve (group);
-#ifdef CANVAS_DEBUG
-	_curve->name = string_compose ("TempoCurve::_curve for %1", _tempo.beats_per_minute());
-#endif
-	_curve->set_fill_mode (ArdourCanvas::Curve::Inside);
-	_curve->set_points_per_segment (32);
 	_curve->set (*points);
 
 	set_color_rgba (rgba);
@@ -79,7 +71,6 @@ TempoCurve::TempoCurve (PublicEditor& ed, ArdourCanvas::Container& parent, guint
 	 */
 
 	_curve->set_data ("tempo curve", this);
-	_background->set_data ("tempo curve", this);
 
 	if (handle_events) {
 		//group->Event.connect (sigc::bind (sigc::mem_fun (editor, &PublicEditor::canvas_marker_event), group, this));
@@ -87,7 +78,6 @@ TempoCurve::TempoCurve (PublicEditor& ed, ArdourCanvas::Container& parent, guint
 
 	set_position (_tempo.frame(), UINT32_MAX);
 	_curve->Event.connect (sigc::bind (sigc::mem_fun (editor, &PublicEditor::canvas_tempo_curve_event), _curve, this));
-	_background->Event.connect (sigc::bind (sigc::mem_fun (editor, &PublicEditor::canvas_tempo_curve_event), _background, this));
 
 }
 
@@ -120,7 +110,6 @@ TempoCurve::the_item() const
 void
 TempoCurve::set_position (framepos_t frame, framepos_t end_frame)
 {
-	points->clear();
 	unit_position = editor.sample_to_pixel (frame);
 	group->set_x_position (unit_position);
 	frame_position = frame;
@@ -128,40 +117,40 @@ TempoCurve::set_position (framepos_t frame, framepos_t end_frame)
 
 	const double tempo_delta = max (10.0, _max_tempo - _min_tempo);
 	double max_y = 0.0;
+
+	points->clear();
+
 	points = new ArdourCanvas::Points ();
+	points->push_back (ArdourCanvas::Duple (0.0, curve_height));
 
 	if (end_frame == UINT32_MAX) {
-		_curve->set_fill_mode (ArdourCanvas::Curve::None);
 		const double tempo_at = _tempo.tempo_at_frame (frame, editor.session()->frame_rate()) * _tempo.note_type();
-		const double y2_pos =  (curve_height + 2.0) - (((tempo_at - _min_tempo) / (tempo_delta)) * curve_height);
+		const double y_pos =  (curve_height) - (((tempo_at - _min_tempo) / (tempo_delta)) * curve_height);
-		max_y = y2_pos;
+
-		points->push_back (ArdourCanvas::Duple (0.0, y2_pos));
+		max_y = y_pos;
-		points->push_back (ArdourCanvas::Duple (ArdourCanvas::COORD_MAX - 5.0, y2_pos));
+
+		points->push_back (ArdourCanvas::Duple (0.0, y_pos));
+		points->push_back (ArdourCanvas::Duple (ArdourCanvas::COORD_MAX - 5.0, y_pos));
 
 	} else {
-		_curve->set_fill_mode (ArdourCanvas::Curve::Inside);
+		const framepos_t frame_step = (end_frame - frame) / 31;
-		const framepos_t frame_step = (end_frame - frame) / 32;
 		framepos_t current_frame = frame;
+
 		while (current_frame < end_frame) {
 			const double tempo_at = _tempo.tempo_at_frame (current_frame, editor.session()->frame_rate()) * _tempo.note_type();
-			const double y2_pos = (curve_height + 2.0) - (((tempo_at - _min_tempo) / (tempo_delta)) * curve_height);
+			const double y_pos = (curve_height) - (((tempo_at - _min_tempo) / (tempo_delta)) * curve_height);
 
-			points->push_back (ArdourCanvas::Duple (editor.sample_to_pixel (current_frame - frame), y2_pos));
+			points->push_back (ArdourCanvas::Duple (editor.sample_to_pixel (current_frame - frame), y_pos));
-			max_y = max (y2_pos, max_y);
+
+			max_y = max (y_pos, max_y);
 			current_frame += frame_step;
 		}
-	}
+		if (current_frame != end_frame) {
+			const double tempo_at = _tempo.tempo_at_frame (end_frame, editor.session()->frame_rate()) * _tempo.note_type();
+			const double y_pos = (curve_height) - (((tempo_at - _min_tempo) / (tempo_delta)) * curve_height);
 
-	/* the background fills the gap between the bottom of the curve and the time bar */
+			points->push_back (ArdourCanvas::Duple (editor.sample_to_pixel (end_frame - frame), y_pos));
-	_background->set_x0 (0.0);
+		}
-	_background->set_x1 (editor.sample_to_pixel (end_frame - frame));
-	_background->set_y0 (max_y + 1.0);
-	_background->set_y1 (curve_height + 2.0);
-
-	if (max_y == curve_height + 2.0) {
-		_background->hide();
-	} else {
-		_background->show();
 	}
 
 	_curve->set (*points);
@@ -196,6 +185,4 @@ TempoCurve::set_color_rgba (uint32_t c)
 	_curve->set_fill_color (UIConfiguration::instance().color_mod ("selection rect", "selection rect"));
 	_curve->set_outline_color (_color);
 
-	_background->set_fill (true);
-	_background->set_fill_color (UIConfiguration::instance().color_mod ("selection rect", "selection rect"));
 }

gtk2_ardour/tempo_curve.h

@@ -10,6 +10,7 @@
 #include "pbd/signals.h"
 
 #include "canvas/types.h"
+#include "canvas/framed_curve.h"
 
 namespace ARDOUR {
 	class TempoSection;
@@ -50,8 +51,7 @@ protected:
 	ArdourCanvas::Container* _parent;
 	ArdourCanvas::Container *group;
 	ArdourCanvas::Points *points;
-	ArdourCanvas::Rectangle* _background;
+	ArdourCanvas::FramedCurve* _curve;
-	ArdourCanvas::Curve* _curve;
 
 	double        unit_position;
 	framepos_t    frame_position;

libs/canvas/canvas/framed_curve.h

@@ -0,0 +1,66 @@
+/*
+    Copyright (C) 2013 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 __CANVAS_FRAMED_CURVE_H__
+#define __CANVAS_FRAMED_CURVE_H__
+
+#include "canvas/visibility.h"
+
+#include "canvas/interpolated_curve.h"
+#include "canvas/poly_item.h"
+#include "canvas/fill.h"
+
+/* similar to a Curve, with the first point being a height definition rather than a point to
+   interpolate.
+*/
+
+namespace ArdourCanvas {
+
+class LIBCANVAS_API FramedCurve : public PolyItem, public InterpolatedCurve
+{
+  public:
+    FramedCurve (Canvas*);
+    FramedCurve (Item*);
+
+    enum CurveFill {
+	    None,
+	    Inside,
+	    Outside,
+    };
+
+    void compute_bounding_box () const;
+    void render (Rect const & area, Cairo::RefPtr<Cairo::Context>) const;
+    void set (Points const &);
+
+    void set_points_per_segment (uint32_t n);
+
+    bool covers (Duple const &) const;
+    void set_fill_mode (CurveFill cf) { curve_fill = cf; }
+
+  private:
+    Points samples;
+    Points::size_type n_samples;
+    uint32_t points_per_segment;
+    CurveFill curve_fill;
+
+    void interpolate ();
+};
+
+}
+
+#endif

libs/canvas/framed_curve.cc

@@ -0,0 +1,268 @@
+/*
+    Copyright (C) 2013 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 <cmath>
+#include <exception>
+#include <algorithm>
+
+#include "canvas/framed_curve.h"
+
+using namespace ArdourCanvas;
+using std::min;
+using std::max;
+
+FramedCurve::FramedCurve (Canvas* c)
+	: PolyItem (c)
+	, n_samples (0)
+	, points_per_segment (16)
+	, curve_fill (None)
+{
+}
+
+FramedCurve::FramedCurve (Item* parent)
+	: PolyItem (parent)
+	, n_samples (0)
+	, points_per_segment (16)
+	, curve_fill (None)
+{
+}
+
+/** When rendering the curve, we will always draw a fixed number of straight
+ * line segments to span the x-axis extent of the curve. More segments:
+ * smoother visual rendering. Less rendering: closer to a visibily poly-line
+ * render.
+ */
+void
+FramedCurve::set_points_per_segment (uint32_t n)
+{
+	/* this only changes our appearance rather than the bounding box, so we
+	   just need to schedule a redraw rather than notify the parent of any
+	   changes
+	*/
+	points_per_segment = n;
+	interpolate ();
+	redraw ();
+}
+
+void
+FramedCurve::compute_bounding_box () const
+{
+	PolyItem::compute_bounding_box ();
+
+	/* possibly add extents of any point indicators here if we ever do that */
+}
+
+void
+FramedCurve::set (Points const& p)
+{
+	PolyItem::set (p);
+	interpolate ();
+}
+
+void
+FramedCurve::interpolate ()
+{
+	Points curve_points = _points;
+
+	if (curve_points.size()) {
+		curve_points.erase (curve_points.begin());
+	}
+	samples.clear ();
+
+	InterpolatedCurve::interpolate (curve_points, points_per_segment, CatmullRomCentripetal, false, samples);
+	n_samples = samples.size();
+}
+
+void
+FramedCurve::render (Rect const & area, Cairo::RefPtr<Cairo::Context> context) const
+{
+	if (!_outline || _points.size() < 3 || !_bounding_box) {
+		return;
+	}
+
+	Rect self = item_to_window (_bounding_box.get());
+	boost::optional<Rect> d = self.intersection (area);
+	assert (d);
+	Rect draw = d.get ();
+
+	/* Our approach is to always draw n_segments across our total size.
+	 *
+	 * This is very inefficient if we are asked to only draw a small
+	 * section of the curve. For now we rely on cairo clipping to help
+	 * with this.
+	 */
+
+
+	setup_outline_context (context);
+
+	if (_points.size() == 3) {
+
+		/* straight line */
+
+		Duple window_space;
+		Points::const_iterator it = _points.begin();
+		window_space = item_to_window (*it);
+		context->move_to (window_space.x, window_space.y);
+		++it;
+		window_space = item_to_window (*it);
+		context->line_to (window_space.x, window_space.y);
+		window_space = item_to_window (_points.back());
+		context->line_to (window_space.x, window_space.y);
+
+		switch (curve_fill) {
+			case None:
+				context->stroke();
+				break;
+			case Inside:
+				context->stroke_preserve ();
+				window_space = item_to_window (Duple(_points.back().x, draw.height()));
+				context->line_to (window_space.x, window_space.y);
+				window_space = item_to_window (Duple(_points.back().x, draw.height()));
+				context->line_to (window_space.x, window_space.y);
+				context->close_path();
+				setup_fill_context(context);
+				context->fill ();
+				break;
+			case Outside:
+				context->stroke_preserve ();
+				window_space = item_to_window (Duple(_points.back().x, 0.0));
+				context->line_to (window_space.x, window_space.y);
+				window_space = item_to_window (Duple(_points.front().x, 0.0));
+				context->line_to (window_space.x, window_space.y);
+				context->close_path();
+				setup_fill_context(context);
+				context->fill ();
+				break;
+		}
+
+	} else {
+
+		/* curve of at least 3 points */
+
+		/* x-axis limits of the curve, in window space coordinates */
+
+		Duple w1 = item_to_window (Duple (_points.front().x, 0.0));
+		Duple w2 = item_to_window (Duple (_points.back().x, 0.0));
+
+		/* clamp actual draw to area bound by points, rather than our bounding box which is slightly different */
+
+		context->save ();
+		context->rectangle (draw.x0, draw.y0, draw.width(), draw.height());
+		context->clip ();
+
+		/* expand drawing area by several pixels on each side to avoid cairo stroking effects at the boundary.
+		   they will still occur, but cairo's clipping will hide them.
+		 */
+
+		draw = draw.expand (4.0);
+
+		/* now clip it to the actual points in the curve */
+
+		if (draw.x0 < w1.x) {
+			draw.x0 = w1.x;
+		}
+
+		if (draw.x1 >= w2.x) {
+			draw.x1 = w2.x;
+		}
+
+		/* find left and right-most sample */
+		Duple window_space;
+		Points::size_type left = 0;
+		Points::size_type right = n_samples;
+
+		for (Points::size_type idx = 0; idx < n_samples - 1; ++idx) {
+			left = idx;
+			window_space = item_to_window (Duple (samples[idx].x, 0.0));
+			if (window_space.x >= draw.x0) break;
+		}
+		for (Points::size_type idx = n_samples; idx > left + 1; --idx) {
+			window_space = item_to_window (Duple (samples[idx].x, 0.0));
+			if (window_space.x <= draw.x1) break;
+			right = idx;
+		}
+
+		/* draw line between samples */
+		window_space = item_to_window (Duple (samples[left].x, samples[left].y));
+		context->move_to (window_space.x, window_space.y);
+		for (uint32_t idx = left + 1; idx < right; ++idx) {
+			window_space = item_to_window (Duple (samples[idx].x, samples[idx].y), false);
+			context->line_to (window_space.x, window_space.y);
+		}
+
+		switch (curve_fill) {
+			case None:
+				context->stroke();
+				break;
+			case Inside:
+				context->stroke_preserve ();
+				window_space = item_to_window (Duple (samples[right-1].x, draw.height()));
+				context->line_to (window_space.x, window_space.y);
+				window_space = item_to_window (Duple (samples[left].x, draw.height()));
+				context->line_to (window_space.x, window_space.y);
+				context->close_path();
+				setup_fill_context(context);
+				context->fill ();
+				break;
+			case Outside:
+				context->stroke_preserve ();
+				window_space = item_to_window (Duple (samples[right-1].x, 0.0));
+				context->line_to (window_space.x, window_space.y);
+				window_space = item_to_window (Duple (samples[left].x, 0.0));
+				context->line_to (window_space.x, window_space.y);
+				context->close_path();
+				setup_fill_context(context);
+				context->fill ();
+				break;
+		}
+		context->restore ();
+	}
+
+#if 0
+	/* add points */
+	setup_outline_context (context);
+	for (Points::const_iterator p = _points.begin(); p != _points.end(); ++p) {
+		Duple window_space (item_to_window (*p));
+		context->arc (window_space.x, window_space.y, 5.0, 0.0, 2 * M_PI);
+		context->stroke ();
+	}
+#endif
+}
+
+bool
+FramedCurve::covers (Duple const & pc) const
+{
+	Duple point = window_to_item (pc);
+
+	/* O(N) N = number of points, and not accurate */
+
+	for (Points::const_iterator p = _points.begin(); p != _points.end(); ++p) {
+
+		const Coord dx = point.x - (*p).x;
+		const Coord dy = point.y - (*p).y;
+		const Coord dx2 = dx * dx;
+		const Coord dy2 = dy * dy;
+
+		if ((dx2 < 2.0 && dy2 < 2.0) || (dx2 + dy2 < 4.0)) {
+			return true;
+		}
+	}
+
+	return false;
+}

libs/canvas/wscript

@@ -40,6 +40,7 @@ canvas_sources = [
         'item.cc',
         'fill.cc',
         'flag.cc',
+        'framed_curve.cc',
         'image.cc',
         'line.cc',
         'line_set.cc',