2 Copyright (C) 2011 Paul Davis
3 Author: Carl Hetherington <cth@carlh.net>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 /** @file canvas/arrow.cc
22 * @brief Implementation of the Arrow canvas object.
25 #include "pbd/compose.h"
27 #include "canvas/arrow.h"
28 #include "canvas/debug.h"
29 #include "canvas/polygon.h"
30 #include "canvas/line.h"
32 using namespace ArdourCanvas;
34 /** Construct an Arrow.
35 * @param parent Parent canvas group.
37 Arrow::Arrow (Canvas* c)
43 Arrow::Arrow (Item* parent)
52 /* set up default arrow heads at each end */
53 for (int i = 0; i < 2; ++i) {
54 _heads[i].polygon = new Polygon (this);
55 _heads[i].outward = true;
59 CANVAS_DEBUG_NAME (_heads[i].polygon, string_compose ("arrow head %1", i));
62 _line = new Line (this);
63 CANVAS_DEBUG_NAME (_line, "arrow line");
67 Arrow::compute_bounding_box () const
69 /* Compute our bounding box manually rather than using the default
70 container algorithm, since having the bounding box with origin other
71 than zero causes strange problems for mysterious reasons. */
73 const double outline_pad = 0.5 + (_line->outline_width() / 2.0);
74 const double head_width = std::max(_heads[0].width, _heads[1].width);
76 _bounding_box = Rect(0,
78 _line->x1() + (head_width / 2.0) + outline_pad,
81 _bounding_box_dirty = false;
84 /** Set whether to show an arrow head at one end or other
86 * @param which 0 or 1 to specify the arrow head to set up.
87 * @param true if this arrow head should be shown.
90 Arrow::set_show_head (int which, bool show)
92 assert (which == 0 || which == 1);
97 delete _heads[which].polygon;
98 _heads[which].polygon = 0;
100 setup_polygon (which);
103 _bounding_box_dirty = true;
107 /** Set whether a given arrow head points into the line or
109 * @param which 0 or 1 to specify the arrow head to set up.
110 * @param true if this arrow head should point out from the line,
111 * otherwise false to point in.
114 Arrow::set_head_outward (int which, bool outward)
116 assert (which == 0 || which == 1);
120 _heads[which].outward = outward;
122 setup_polygon (which);
123 _bounding_box_dirty = true;
127 /** Set the height of a given arrow head.
128 * @param which 0 or 1 to specify the arrow head to set up.
129 * @param height Height of the arrow head in pixels.
132 Arrow::set_head_height (int which, Distance height)
134 assert (which == 0 || which == 1);
138 _heads[which].height = height;
140 setup_polygon (which);
141 _bounding_box_dirty = true;
145 /** Set the width of a given arrow head.
146 * @param which 0 or 1 to specify the arrow head to set up.
147 * @param width Width of the arrow head in pixels.
150 Arrow::set_head_width (int which, Distance width)
152 assert (which == 0 || which == 1);
156 _heads[which].width = width;
158 setup_polygon (which);
159 _bounding_box_dirty = true;
163 /** Set the width of our line, and the outline of our arrow(s).
164 * @param width New width in pixels.
167 Arrow::set_outline_width (Distance width)
169 _line->set_outline_width (width);
170 if (_heads[0].polygon) {
171 _heads[0].polygon->set_outline_width (width);
173 if (_heads[1].polygon) {
174 _heads[1].polygon->set_outline_width (width);
176 _bounding_box_dirty = true;
179 /** Set the x position of our line.
180 * @param x New x position in pixels (in our coordinate system).
183 Arrow::set_x (Coord x)
187 for (int i = 0; i < 2; ++i) {
188 if (_heads[i].polygon) {
189 _heads[i].polygon->set_x_position (x - _heads[i].width / 2);
192 _bounding_box_dirty = true;
195 /** Set the y position of end 0 of our line.
196 * @param y0 New y0 position in pixels (in our coordinate system).
199 Arrow::set_y0 (Coord y0)
202 if (_heads[0].polygon) {
203 _heads[0].polygon->set_y_position (y0);
205 _bounding_box_dirty = true;
208 /** Set the y position of end 1 of our line.
209 * @param y1 New y1 position in pixels (in our coordinate system).
212 Arrow::set_y1 (Coord y1)
215 if (_heads[1].polygon) {
216 _heads[1].polygon->set_y_position (y1 - _heads[1].height);
218 _bounding_box_dirty = true;
221 /** @return x position of our line in pixels (in our coordinate system) */
228 /** @return y position of end 1 of our line in pixels (in our coordinate system) */
235 /** Set up the polygon used to represent a particular arrow head.
236 * @param which 0 or 1 to specify the arrow head to set up.
239 Arrow::setup_polygon (int which)
241 assert (which == 0 || which == 1);
245 if ((which == 0 && _heads[which].outward) || (which == 1 && !_heads[which].outward)) {
246 /* this is an arrow head pointing towards -ve y */
247 points.push_back (Duple (_heads[which].width / 2, 0));
248 points.push_back (Duple (_heads[which].width, _heads[which].height));
249 points.push_back (Duple (0, _heads[which].height));
251 /* this is an arrow head pointing towards +ve y */
252 points.push_back (Duple (0, 0));
253 points.push_back (Duple (_heads[which].width, 0));
254 points.push_back (Duple (_heads[which].width / 2, _heads[which].height));
255 points.push_back (Duple (0, 0));
258 _heads[which].polygon->set (points);
261 /** Set the color of our line and arrow heads.
262 * @param color New color.
265 Arrow::set_color (Color color)
267 _line->set_outline_color (color);
268 for (int i = 0; i < 2; ++i) {
269 if (_heads[i].polygon) {
270 _heads[i].polygon->set_outline_color (color);
271 _heads[i].polygon->set_fill_color (color);
277 Arrow::covers (Duple const & point) const
279 if (_heads[0].polygon && _heads[0].polygon->covers (point)) {
282 if (_line && _line->covers (point)) {
286 if (_heads[1].polygon && _heads[1].polygon->covers (point)) {