13
0
livetrax/libs/canvas/rectangle.cc

292 lines
6.5 KiB
C++
Raw Normal View History

/*
Copyright (C) 2011-2013 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 <iostream>
#include <cairomm/context.h>
#include "pbd/stacktrace.h"
#include "pbd/compose.h"
#include "canvas/canvas.h"
#include "canvas/rectangle.h"
#include "canvas/debug.h"
#include "canvas/utils.h"
using namespace std;
using namespace ArdourCanvas;
Rectangle::Rectangle (Canvas* c)
: Item (c)
, _outline_what ((What) (LEFT | RIGHT | TOP | BOTTOM))
{
}
Rectangle::Rectangle (Canvas* c, Rect const & rect)
: Item (c)
, _rect (rect)
, _outline_what ((What) (LEFT | RIGHT | TOP | BOTTOM))
{
}
Rectangle::Rectangle (Item* parent)
: Item (parent)
, _outline_what ((What) (LEFT | RIGHT | TOP | BOTTOM))
{
}
Rectangle::Rectangle (Item* parent, Rect const & rect)
: Item (parent)
, _rect (rect)
, _outline_what ((What) (LEFT | RIGHT | TOP | BOTTOM))
{
}
2014-11-03 21:33:54 -05:00
Rect
Rectangle::get_self_for_render () const
{
/* In general, a Rectangle will have a _position of (0,0) within its
parent, and its extent is actually defined by _rect. But in the
unusual case that _position is set to something other than (0,0),
we should take that into account when rendering.
*/
2014-11-03 21:33:54 -05:00
return item_to_window (_rect.translate (_position), false);
2014-11-03 21:33:54 -05:00
}
void
Rectangle::render_self (Rect const & area, Cairo::RefPtr<Cairo::Context> context, Rect self) const
{
boost::optional<Rect> r = self.intersection (area);
2015-10-05 10:17:49 -04:00
if (!r) {
return;
}
Rect draw = r.get ();
if (_fill && !_transparent) {
if (_stops.empty()) {
setup_fill_context (context);
} else {
setup_gradient_context (context, self, Duple (draw.x0, draw.y0));
}
context->rectangle (draw.x0, draw.y0, draw.width(), draw.height());
context->fill ();
}
2015-10-05 10:17:49 -04:00
if (_outline) {
setup_outline_context (context);
2015-10-05 10:17:49 -04:00
2014-10-31 10:56:03 -04:00
/* the goal here is that if the border is 1 pixel
* thick, it will precisely align with the corner
* coordinates of the rectangle. So if the rectangle
* has a left edge at 0 and a right edge at 10, then
* the left edge must span 0..1, the right edge
* must span 10..11 because the first and final pixels
* to be colored are actually "at" 0.5 and 10.5 (midway
* between the integer coordinates).
*
* See the Cairo FAQ on single pixel lines for more
* detail.
2014-10-31 10:56:03 -04:00
*/
if (fmod (_outline_width, 2.0) != 0.0) {
const double shift = _outline_width * 0.5;
self = self.translate (Duple (shift, shift));
}
2015-10-05 10:17:49 -04:00
if (_outline_what == What (LEFT|RIGHT|BOTTOM|TOP)) {
2015-10-05 10:17:49 -04:00
2014-10-31 10:56:03 -04:00
context->rectangle (self.x0, self.y0, self.width(), self.height());
} else {
if (_outline_what & LEFT) {
context->move_to (self.x0, self.y0);
context->line_to (self.x0, self.y1);
}
2015-10-05 10:17:49 -04:00
if (_outline_what & TOP) {
context->move_to (self.x0, self.y0);
context->line_to (self.x1, self.y0);
}
if (_outline_what & BOTTOM) {
context->move_to (self.x0, self.y1);
context->line_to (self.x1, self.y1);
}
2015-10-05 10:17:49 -04:00
if (_outline_what & RIGHT) {
context->move_to (self.x1, self.y0);
context->line_to (self.x1, self.y1);
}
}
2015-10-05 10:17:49 -04:00
context->stroke ();
}
}
2014-11-03 21:33:54 -05:00
void
Rectangle::render (Rect const & area, Cairo::RefPtr<Cairo::Context> context) const
{
render_self (area, context, get_self_for_render ());
}
void
Rectangle::compute_bounding_box () const
{
if (!_rect.empty()) {
Rect r = _rect.fix ();
/* if the outline is 1 pixel, then the actual
bounding box is 0.5 pixels outside the stated
corners of the rectangle.
if the outline is 2 pixels, then the actual
bounding box is 1.0 pixels outside the stated
corners of the rectangle (so that the middle
of the 2 pixel wide border passes through
the corners, alternatively described as 1 row
of pixels outside of the corners, and 1 row
inside).
if the outline is 3 pixels, then the actual
bounding box is 1.5 outside the stated corners
of the rectangle (so that the middle row of
pixels of the border passes through the corners).
if the outline is 4 pixels, then the actual bounding
box is 2.0 pixels outside the stated corners
of the rectangle, so that the border consists
of 2 pixels outside the corners and 2 pixels inside.
hence ... the bounding box is width * 0.5 larger
than the rectangle itself.
*/
2015-03-20 18:31:21 -04:00
_bounding_box = r.expand (1.0 + _outline_width * 0.5);
}
_bounding_box_dirty = false;
}
void
Rectangle::set (Rect const & r)
{
/* We don't update the bounding box here; it's just
as cheap to do it when asked.
*/
if (r != _rect) {
2015-10-05 10:17:49 -04:00
begin_change ();
2015-10-05 10:17:49 -04:00
_rect = r;
2015-10-05 10:17:49 -04:00
_bounding_box_dirty = true;
end_change ();
}
}
void
Rectangle::set_x0 (Coord x0)
{
if (x0 != _rect.x0) {
begin_change ();
2015-10-05 10:17:49 -04:00
_rect.x0 = x0;
2015-10-05 10:17:49 -04:00
_bounding_box_dirty = true;
end_change ();
}
}
void
Rectangle::set_y0 (Coord y0)
{
if (y0 != _rect.y0) {
begin_change ();
2015-10-05 10:17:49 -04:00
_rect.y0 = y0;
2015-10-05 10:17:49 -04:00
_bounding_box_dirty = true;
end_change();
}
}
void
Rectangle::set_x1 (Coord x1)
{
if (x1 != _rect.x1) {
begin_change ();
2015-10-05 10:17:49 -04:00
_rect.x1 = x1;
2015-10-05 10:17:49 -04:00
_bounding_box_dirty = true;
end_change ();
}
}
void
Rectangle::set_y1 (Coord y1)
{
if (y1 != _rect.y1) {
begin_change ();
2015-10-05 10:17:49 -04:00
_rect.y1 = y1;
2015-10-05 10:17:49 -04:00
_bounding_box_dirty = true;
end_change ();
}
}
void
Rectangle::set_outline_what (What what)
{
if (what != _outline_what) {
begin_visual_change ();
_outline_what = what;
end_visual_change ();
}
}
double
Rectangle::vertical_fraction (double y) const
{
/* y is in canvas coordinates */
Duple i (canvas_to_item (Duple (0, y)));
boost::optional<Rect> r = bounding_box();
if (!r) {
return 0; /* not really correct, but what else can we do? */
}
Rect bbox (r.get());
if (i.y < bbox.y0 || i.y >= bbox.y1) {
return 0;
}
/* convert to fit Cairo origin model (origin at upper left)
*/
return 1.0 - ((i.y - bbox.y0) / bbox.height());
}