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)
, _max_tempo (temp.beats_per_minute())
, _tempo (temp)
-
{
-
- points = new ArdourCanvas::Points ();
- points->push_back (ArdourCanvas::Duple (0.0, 0.0));
- points->push_back (ArdourCanvas::Duple (1.0, 0.0));
- 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));
+ 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
- _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);
+ _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::Curve::Inside);
- _curve->set_points_per_segment (32);
+ _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));
+ points->push_back (ArdourCanvas::Duple (1.0, 0.0));
+ points->push_back (ArdourCanvas::Duple (1.0, curve_height));
+ points->push_back (ArdourCanvas::Duple (0.0, curve_height));
+
_curve->set (*points);
set_color_rgba (rgba);
*/
_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));
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));
}
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;
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);
- max_y = y2_pos;
- points->push_back (ArdourCanvas::Duple (0.0, y2_pos));
- points->push_back (ArdourCanvas::Duple (ArdourCanvas::COORD_MAX - 5.0, y2_pos));
+ const double y_pos = (curve_height) - (((tempo_at - _min_tempo) / (tempo_delta)) * curve_height);
+
+ max_y = y_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) / 32;
+ const framepos_t frame_step = (end_frame - frame) / 31;
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));
- max_y = max (y2_pos, max_y);
+ points->push_back (ArdourCanvas::Duple (editor.sample_to_pixel (current_frame - frame), y_pos));
+
+ 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 */
- _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();
+ points->push_back (ArdourCanvas::Duple (editor.sample_to_pixel (end_frame - frame), y_pos));
+ }
}
_curve->set (*points);
_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"));
}
#include "pbd/signals.h"
#include "canvas/types.h"
+#include "canvas/framed_curve.h"
namespace ARDOUR {
class TempoSection;
ArdourCanvas::Container* _parent;
ArdourCanvas::Container *group;
ArdourCanvas::Points *points;
- ArdourCanvas::Rectangle* _background;
- ArdourCanvas::Curve* _curve;
+ ArdourCanvas::FramedCurve* _curve;
double unit_position;
framepos_t frame_position;
--- /dev/null
+/*
+ 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
--- /dev/null
+/*
+ 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;
+}
'item.cc',
'fill.cc',
'flag.cc',
+ 'framed_curve.cc',
'image.cc',
'line.cc',
'line_set.cc',
projects / ardour.git / commitdiff