13
0
livetrax/libs/canvas/ruler.cc
nick_m 7fc3b0c34c Initial stab at tempo ramps.
Replaces the list of points in TempoMap with TempoSection functions, which
compute tempo-at or tick-at time relative to tempo section start.
TempoMap consults them additively to determine things like bbt_time(),
frame_time() get_grid() etc.
This has a marked effect on scrolling speed along with the code simplification
in the places it has been attempted.

Several things are broken here.
Currently every ramp except the last one is an exponential ramp. this may
be simple to fix :).
Mouse-over midi grid doesn't match mouse click grid. should also be simple.

Many things seem to work, but their accuracy should be in question until
each area has been addressed.
2016-05-27 23:38:09 +10:00

233 lines
5.3 KiB
C++

/*
Copyright (C) 2014 Paul Davis
Author: Carl Hetherington <cth@carlh.net>
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 <algorithm>
#include <cairomm/context.h>
#include <pangomm/layout.h>
#include "canvas/ruler.h"
#include "canvas/types.h"
#include "canvas/debug.h"
#include "canvas/utils.h"
#include "canvas/canvas.h"
using namespace std;
using namespace ArdourCanvas;
Ruler::Ruler (Canvas* c, const Metric& m)
: Rectangle (c)
, _metric (&m)
, _lower (0)
, _upper (0)
, _divide_height (-1.0)
, _need_marks (true)
{
}
Ruler::Ruler (Canvas* c, const Metric& m, Rect const& r)
: Rectangle (c, r)
, _metric (&m)
, _lower (0)
, _upper (0)
, _divide_height (-1.0)
, _need_marks (true)
{
}
Ruler::Ruler (Item* parent, const Metric& m)
: Rectangle (parent)
, _metric (&m)
, _lower (0)
, _upper (0)
, _divide_height (-1.0)
, _need_marks (true)
{
}
Ruler::Ruler (Item* parent, const Metric& m, Rect const& r)
: Rectangle (parent, r)
, _metric (&m)
, _lower (0)
, _upper (0)
, _divide_height (-1.0)
, _need_marks (true)
{
}
void
Ruler::set_range (double l, double u)
{
begin_visual_change ();
_lower = l;
_upper = u;
_need_marks = true;
end_visual_change ();
}
void
Ruler::set_font_description (Pango::FontDescription fd)
{
begin_visual_change ();
_font_description = new Pango::FontDescription (fd);
end_visual_change ();
}
void
Ruler::render (Rect const & area, Cairo::RefPtr<Cairo::Context> cr) const
{
if (_lower == _upper) {
/* nothing to draw */
return;
}
Rect self (item_to_window (get()));
boost::optional<Rect> i = self.intersection (area);
if (!i) {
return;
}
Rect intersection (i.get());
Distance height = self.height();
if (_need_marks) {
marks.clear ();
_metric->get_marks (marks, _lower, _upper, 50);
_need_marks = false;
}
/* draw background */
setup_fill_context (cr);
cr->rectangle (intersection.x0, intersection.y0, intersection.width(), intersection.height());
cr->fill ();
/* switch to outline context */
setup_outline_context (cr);
/* draw line on lower edge as a separator */
if (_outline_width == 1.0) {
/* Cairo single pixel line correction */
cr->move_to (self.x0, self.y1-0.5);
cr->line_to (self.x1, self.y1-0.5);
} else {
cr->move_to (self.x0, self.y1);
cr->line_to (self.x1, self.y1);
}
cr->stroke ();
/* draw ticks + text */
Glib::RefPtr<Pango::Layout> layout = Pango::Layout::create (cr);
if (_font_description) {
layout->set_font_description (*_font_description);
}
for (vector<Mark>::const_iterator m = marks.begin(); m != marks.end(); ++m) {
Duple pos;
pos.x = floor ((m->position - _lower) / _metric->units_per_pixel);
pos.y = self.y1; /* bottom edge */
if (_outline_width == 1.0) {
/* Cairo single pixel line correction */
cr->move_to (pos.x + 0.5, pos.y);
} else {
cr->move_to (pos.x, pos.y);
}
switch (m->style) {
case Mark::Major:
if (_divide_height >= 0) {
cr->rel_line_to (0, -_divide_height);
} else {
cr->rel_line_to (0, -height);
}
break;
case Mark::Minor:
cr->rel_line_to (0, -height/3.0);
break;
case Mark::Micro:
cr->rel_line_to (0, -height/5.0);
break;
}
cr->stroke ();
/* and the text */
if (!m->label.empty()) {
Pango::Rectangle logical;
layout->set_text (m->label);
logical = layout->get_pixel_logical_extents ();
if (_divide_height >= 0) {
cr->move_to (pos.x + 2.0, self.y0 + _divide_height + logical.get_y() + 2.0); /* 2 pixel padding below divider */
} else {
cr->move_to (pos.x + 2.0, self.y0 + logical.get_y());
}
layout->show_in_cairo_context (cr);
}
}
if (_divide_height >= 0.0) {
cr->set_line_width (1.0);
set_source_rgba (cr, _divider_color_top);
cr->move_to (self.x0, self.y0 + _divide_height-1.0+0.5);
cr->line_to (self.x1, self.y0 + _divide_height-1.0+0.5);
cr->stroke ();
set_source_rgba (cr, _divider_color_bottom);
cr->move_to (self.x0, self.y0 + _divide_height+0.5);
cr->line_to (self.x1, self.y0 + _divide_height+0.5);
cr->stroke ();
}
/* done! */
}
void
Ruler::set_divide_height (double h)
{
_divide_height = h;
}
void
Ruler::set_divide_colors (Color t, Color b)
{
_divider_color_bottom = b;
_divider_color_top = t;
}
void
Ruler::set_metric (const Metric& m)
{
_metric = &m;
_need_marks = true;
redraw ();
}