ardour/ardour
ardour
/
ardour
13
1
Fork 0
Code Pull Requests Releases Activity

canvas lollipops: object redesign and reimplementation

This commit is contained in:
Paul Davis 2023-01-12 17:06:43 -07:00
parent 0f611b4efa
commit f7e97be115
5 changed files with 61 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
gtk2_ardour/ghostregion.cc
View File

@ -62,7 +62,7 @@ GhostRegion::GhostRegion (RegionView& rv,
, base_rect (0)
{
group = new ArdourCanvas::Container (parent);
CANVAS_DEBUG_NAME (group, "ghost region");
CANVAS_DEBUG_NAME (group, "ghost region group");
group->set_position (ArdourCanvas::Duple (initial_pos, 0));
if (is_automation_ghost()) {
@ -200,6 +200,8 @@ MidiGhostRegion::MidiGhostRegion(MidiRegionView& rv,
if (base_rect) {
base_rect->lower_to_bottom();
}
CANVAS_DEBUG_NAME (_note_group, "midi ghost note group");
}
MidiGhostRegion::~MidiGhostRegion()

35
gtk2_ardour/velocity_ghost_region.cc
View File

@ -59,18 +59,26 @@ VelocityGhostRegion::~VelocityGhostRegion ()
void
VelocityGhostRegion::update_contents_height ()
{
for (auto const & ev : events) {
ArdourCanvas::Lollipop* l = dynamic_cast<ArdourCanvas::Lollipop*> (ev.second->item);
l->set (ArdourCanvas::Duple (l->x(), base_rect->y1()), ev.second->event->note()->velocity() / 127.0 * base_rect->y1 (), lollipop_radius);
for (auto const & i : events) {
set_size_and_position (*i.second);
}
}
bool
VelocityGhostRegion::lollevent (GdkEvent* ev, MidiGhostRegion::GhostEvent* gev)
{
return trackview.editor().canvas_velocity_event (ev, gev->item);
}
void
VelocityGhostRegion::add_note (NoteBase* n)
{
ArdourCanvas::Lollipop* l = new ArdourCanvas::Lollipop (_note_group);
GhostEvent* event = new GhostEvent (n, _note_group, l);
events.insert (std::make_pair (n->note(), event));
l->Event.connect (sigc::bind (sigc::mem_fun (*this, &VelocityGhostRegion::lollevent), event));
l->raise_to_top ();
event->item->set_fill_color (UIConfiguration::instance().color_mod(n->base_color(), "ghost track midi fill"));
event->item->set_outline_color (_outline);
@ -81,21 +89,30 @@ VelocityGhostRegion::add_note (NoteBase* n)
if (!n->item()->visible()) {
l->hide();
} else {
l->set (ArdourCanvas::Duple (n->x0() - 1.0, base_rect->y1()), n->note()->velocity() / 127.0 * base_rect->y1(), lollipop_radius);
set_size_and_position (*event);
}
}
}
void
VelocityGhostRegion::update_note (GhostEvent* n)
VelocityGhostRegion::set_size_and_position (GhostEvent& ev)
{
ArdourCanvas::Lollipop* l = dynamic_cast<ArdourCanvas::Lollipop*> (n->item);
l->set (ArdourCanvas::Duple (n->event->x0() - 1.0, base_rect->y1()), n->event->note()->velocity() / 127.0 * base_rect->y1(), lollipop_radius);
ArdourCanvas::Lollipop* l = dynamic_cast<ArdourCanvas::Lollipop*> (ev.item);
const double available_height = base_rect->y1() - (2.0 * lollipop_radius);
const double actual_height = (ev.event->note()->velocity() / 127.0) * available_height;
l->set (ArdourCanvas::Duple (ev.event->x0() - 1.0, base_rect->y1() - actual_height), actual_height, lollipop_radius);
}
void
VelocityGhostRegion::update_hit (GhostEvent* n)
VelocityGhostRegion::update_note (GhostEvent* ev)
{
set_size_and_position (*ev);
}
void
VelocityGhostRegion::update_hit (GhostEvent* ev)
{
set_size_and_position (*ev);
}
void
@ -106,5 +123,5 @@ VelocityGhostRegion::remove_note (NoteBase*)
void
VelocityGhostRegion::set_colors ()
{
base_rect->set_fill_color (Gtkmm2ext::Color (0xff0000ff));
base_rect->set_fill_color (Gtkmm2ext::Color (0xff000085));
}

2
gtk2_ardour/velocity_ghost_region.h
View File

@ -38,6 +38,8 @@ public:
void set_colors ();
private:
bool lollevent (GdkEvent*, MidiGhostRegion::GhostEvent*);
void set_size_and_position (MidiGhostRegion::GhostEvent&);
};
#endif /* __gtk_ardour_velocity_region_view_h__ */

10
libs/canvas/canvas/lollipop.h
View File

@ -44,19 +44,19 @@ public:
Coord radius() const { return _radius; }
void set_length (Coord);
Coord length() const { return _points[1].y - _points[0].y; }
Coord length() const { return _length; }
/* Set origin, length, radius in one pass */
void set (Duple const &, Coord, Coord);
void set_x (Coord);
Coord x () const { return _points[0].x; }
Coord y0 () const { return _points[0].y; }
Coord y1 () const { return _points[1].y; }
Coord x () const { return _position.x; }
Coord y0 () const { return _position.y; }
Coord y1 () const { return _position.y + _length; }
private:
Duple _points[2];
Coord _radius;
Coord _length;
};
}

97
libs/canvas/lollipop.cc
View File

@ -31,27 +31,22 @@ using namespace ArdourCanvas;
Lollipop::Lollipop (Canvas* c)
: Item (c)
, _radius (8)
, _length (0)
{
}
Lollipop::Lollipop (Item* parent)
: Item (parent)
, _radius (8)
, _length (0)
{
}
void
Lollipop::compute_bounding_box () const
{
Rect bbox;
bbox.x0 = min (_points[0].x, _points[1].x);
bbox.y0 = min (_points[0].y, _points[1].y);
bbox.x1 = max (_points[0].x, _points[1].x) + _radius;
bbox.y1 = max (_points[0].y, _points[1].y) + _radius;
bbox = bbox.expand (0.5 + (_outline_width / 2));
_bounding_box = bbox;
_bounding_box = Rect (-_radius, -_radius, _radius, _length + _radius).expand (0.5 + (_outline_width / 2));
set_bbox_clean ();
}
@ -60,26 +55,25 @@ Lollipop::render (Rect const & /*area*/, Cairo::RefPtr<Cairo::Context> context)
{
setup_outline_context (context);
Duple p0 = item_to_window (Duple (_points[0].x, _points[0].y));
Duple p1 = item_to_window (Duple (_points[1].x, _points[1].y));
Duple p = _parent->item_to_window (Duple (_position.x, _position.y));
if (_outline_width <= 1.0) {
/* See Cairo FAQ on single pixel lines to understand why we add 0.5
*/
const Duple half_a_pixel (0.5, 0.5);
p0 = p0.translate (half_a_pixel);
p1 = p1.translate (half_a_pixel);
p = p.translate (half_a_pixel);
}
context->move_to (p0.x, p0.y);
/* Do not enter the circle */
context->line_to (p1.x, p1.y + _radius);
/* the line */
context->move_to (p.x, p.y + _radius);
context->line_to (p.x, p.y + _length - _radius);
context->stroke ();
/* the circle */
context->arc (p1.x, p1.y, _radius, 0.0 * (M_PI/180.0), 360.0 * (M_PI/180.0));
context->arc (p.x, p.y, _radius, 0.0 * (M_PI/180.0), 360.0 * (M_PI/180.0));
if (fill()) {
setup_fill_context (context);
@ -110,12 +104,9 @@ Lollipop::set_radius (Coord r)
void
Lollipop::set_x (Coord x)
{
if (x != _points[0].x) {
if (x != _position.x) {
begin_change ();
_points[0].x = x;
_points[1].x = x;
_position.x = x;
set_bbox_dirty ();
end_change ();
}
@ -124,10 +115,10 @@ Lollipop::set_x (Coord x)
void
Lollipop::set_length (Coord len)
{
if (_points[1].y != _points[0].y - len) {
if (_length != len) {
begin_change ();
/* draw upwards */
_points[1].y = _points[0].y - len;
_length = len;
set_bbox_dirty ();
end_change ();
}
}
@ -138,63 +129,25 @@ Lollipop::set (Duple const & d, Coord l, Coord r)
begin_change ();
_radius = r;
_length = l;
_points[0].x = d.x;
_points[1].x = d.x;
_points[0].y = d.y;
/* Draw upwards */
_points[1].y = _points[0].y - l;
set_position (d);
set_bbox_dirty ();
end_change ();
}
bool
Lollipop::covers (Duple const & point) const
{
const Duple p = window_to_item (point);
const Duple p = _parent->window_to_item (point);
static const Distance threshold = 2.0;
/* this quick check works for vertical and horizontal lines, which are
* common.
*/
/* only the circle is considered as "covering" */
if (_points[0].x == _points[1].x) {
/* line is vertical, just check x coordinate */
if (fabs (_points[0].x - p.x) <= threshold) {
return true;
}
} else if (_points[0].y == _points[1].y) {
/* line is horizontal, just check y coordinate */
if (fabs (_points[0].y - p.y) <= threshold) {
return true;
}
}
Duple at;
double t;
Duple a (_points[0]);
Duple b (_points[1]);
const Rect visible (window_to_item (_canvas->visible_area()));
/*
Clamp the line endpoints to the visible area of the canvas. If we do
not do this, we have a line segment extending to COORD_MAX and our
math goes wrong.
*/
a.x = min (a.x, visible.x1);
a.y = min (a.y, visible.y1);
b.x = min (b.x, visible.x1);
b.y = min (b.y, visible.y1);
double d = distance_to_segment_squared (p, a, b, t, at);
if (t < 0.0 || t > 1.0) {
return false;
}
if (d < threshold) {
if (((fabs (_position.x - p.x)) <= (_radius + threshold)) &&
((fabs (_position.y - p.y)) <= (_radius + threshold))) {
/* inside circle */
return true;
}