namespace Gnome {
namespace Canvas {
-LinesetClass Lineset::lineset_class;
+LineSetClass LineSet::lineset_class;
-//static const char* overlap_error_str = "Lineset error: Line overlap";
+//static const char* overlap_error_str = "LineSet error: Line overlap";
-Lineset::Line::Line(double c, double w, uint32_t color)
+LineSet::Line::Line(double c, double w, uint32_t color)
: coord(c)
, width(w)
{
}
/* Constructor for dummy lines that are used only with the coordinate */
-Lineset::Line::Line(double c)
+LineSet::Line::Line(double c)
: coord(c)
{
}
void
-Lineset::Line::set_color(uint32_t color)
+LineSet::Line::set_color(uint32_t color)
{
UINT_TO_RGBA (color, &r, &g, &b, &a);
}
const Glib::Class&
-LinesetClass::init()
+LineSetClass::init()
{
if (!gtype_) {
- class_init_func_ = &LinesetClass::class_init_function;
+ class_init_func_ = &LineSetClass::class_init_function;
register_derived_type(Item::get_type());
}
}
void
-LinesetClass::class_init_function(void* g_class, void* class_data)
+LineSetClass::class_init_function(void* g_class, void* class_data)
{
}
-Lineset::Lineset(Group& parent, Orientation o)
- : Glib::ObjectBase("GnomeCanvasLineset")
+LineSet::LineSet(Group& parent, Orientation o)
+ : Glib::ObjectBase("GnomeCanvasLineSet")
, Item(Glib::ConstructParams(lineset_class.init()))
, cached_pos(lines.end())
, orientation(o)
item_construct(parent);
- property_x1().signal_changed().connect(mem_fun(*this, &Lineset::bounds_need_update));
- property_y1().signal_changed().connect(mem_fun(*this, &Lineset::bounds_need_update));
- property_x2().signal_changed().connect(mem_fun(*this, &Lineset::bounds_need_update));
- property_y2().signal_changed().connect(mem_fun(*this, &Lineset::bounds_need_update));
+ property_x1().signal_changed().connect(mem_fun(*this, &LineSet::bounds_need_update));
+ property_y1().signal_changed().connect(mem_fun(*this, &LineSet::bounds_need_update));
+ property_x2().signal_changed().connect(mem_fun(*this, &LineSet::bounds_need_update));
+ property_y2().signal_changed().connect(mem_fun(*this, &LineSet::bounds_need_update));
}
-Lineset::~Lineset()
+LineSet::~LineSet()
{
}
bool
-Lineset::line_compare(const Line& a, const Line& b)
+LineSet::line_compare(const Line& a, const Line& b)
{
return a.coord < b.coord;
}
void
-Lineset::print_lines()
+LineSet::print_lines()
{
for (Lines::iterator it = lines.begin(); it != lines.end(); ++it)
{
}
void
-Lineset::move_line(double coord, double dest)
+LineSet::move_line(double coord, double dest)
{
if (coord == dest) {
return;
}
void
-Lineset::change_line_width(double coord, double width)
+LineSet::change_line_width(double coord, double width)
{
Lines::iterator it = line_at(coord);
}
void
-Lineset::change_line_color(double coord, uint32_t color)
+LineSet::change_line_color(double coord, uint32_t color)
{
Lines::iterator it = line_at(coord);
}
void
-Lineset::add_line(double coord, double width, uint32_t color)
+LineSet::add_line(double coord, double width, uint32_t color)
{
Line l(coord, width, color);
}
void
-Lineset::remove_line(double coord)
+LineSet::remove_line(double coord)
{
Lines::iterator it = line_at(coord);
}
void
-Lineset::remove_lines(double c1, double c2)
+LineSet::remove_lines(double c1, double c2)
{
if (!lines.empty()) {
region_needs_update(c1, c2);
}
void
-Lineset::remove_until(double coord)
+LineSet::remove_until(double coord)
{
if (!lines.empty()) {
double first = lines.front().coord;
}
void
-Lineset::remove_from(double coord)
+LineSet::remove_from(double coord)
{
if (!lines.empty()) {
double last = lines.back().coord + lines.back().width;
}
void
-Lineset::clear()
+LineSet::clear()
{
if (!lines.empty()) {
double coord1 = lines.front().coord;
* this function is optimized to work faster if we access elements that are adjacent to each other.
* so if a large number of lines are modified, it is wise to modify them in sorted order.
*/
-Lineset::Lines::iterator
-Lineset::line_at(double coord)
+LineSet::Lines::iterator
+LineSet::line_at(double coord)
{
if (cached_pos != lines.end()) {
if (coord < cached_pos->coord) {
}
void
-Lineset::redraw_request(ArtIRect& r)
+LineSet::redraw_request(ArtIRect& r)
{
get_canvas()->request_redraw(r.x0, r.y0, r.x1, r.y1);
}
void
-Lineset::redraw_request(ArtDRect& r)
+LineSet::redraw_request(ArtDRect& r)
{
int x0, y0, x1, y1;
Canvas& cv = *get_canvas();
}
void
-Lineset::update_lines(bool need_redraw)
+LineSet::update_lines(bool need_redraw)
{
//cerr << "update_lines need_redraw=" << need_redraw << endl;
if (!need_redraw) {
if (update_region2 > update_region1) {
ArtDRect redraw;
- Lineset::bounds_vfunc(&redraw.x0, &redraw.y0, &redraw.x1, &redraw.y1);
+ LineSet::bounds_vfunc(&redraw.x0, &redraw.y0, &redraw.x1, &redraw.y1);
i2w(redraw.x0, redraw.y0);
i2w(redraw.x1, redraw.y1);
* return true if nothing or only parts of the rect area has been requested for redraw
*/
bool
-Lineset::update_bounds()
+LineSet::update_bounds()
{
GnomeCanvasItem* item = GNOME_CANVAS_ITEM(gobj());
ArtDRect old_b;
old_b.y0 = item->y1;
old_b.x1 = item->x2;
old_b.y1 = item->y2;
- Lineset::bounds_vfunc(&new_b.x0, &new_b.y0, &new_b.x1, &new_b.y1);
+ LineSet::bounds_vfunc(&new_b.x0, &new_b.y0, &new_b.x1, &new_b.y1);
i2w(new_b.x0, new_b.y0);
i2w(new_b.x1, new_b.y1);
* N. find out if the item moved. if it moved, the old bbox and the new bbox need to be updated.
*/
void
-Lineset::update_vfunc(double* affine, ArtSVP* clip_path, int flags)
+LineSet::update_vfunc(double* affine, ArtSVP* clip_path, int flags)
{
GnomeCanvasItem* item = GNOME_CANVAS_ITEM(gobj());
bool lines_need_redraw = true;
}
void
-Lineset::draw_vfunc(const Glib::RefPtr<Gdk::Drawable>& drawable, int x, int y, int width, int height)
+LineSet::draw_vfunc(const Glib::RefPtr<Gdk::Drawable>& drawable, int x, int y, int width, int height)
{
- cerr << "please don't use the GnomeCanvasLineset item in a non-aa Canvas" << endl;
+ cerr << "please don't use the GnomeCanvasLineSet item in a non-aa Canvas" << endl;
abort();
}
inline void
-Lineset::paint_vert(GnomeCanvasBuf* buf, Lineset::Line& line, int x1, int y1, int x2, int y2)
+LineSet::paint_vert(GnomeCanvasBuf* buf, LineSet::Line& line, int x1, int y1, int x2, int y2)
{
if (line.width == 1.0) {
PAINT_VERTA(buf, line.r, line.g, line.b, line.a, x1, y1, y2);
}
inline void
-Lineset::paint_horiz(GnomeCanvasBuf* buf, Lineset::Line& line, int x1, int y1, int x2, int y2)
+LineSet::paint_horiz(GnomeCanvasBuf* buf, LineSet::Line& line, int x1, int y1, int x2, int y2)
{
if (line.width == 1.0) {
PAINT_HORIZA(buf, line.r, line.g, line.b, line.a, x1, x2, y1);
}
void
-Lineset::render_vfunc(GnomeCanvasBuf* buf)
+LineSet::render_vfunc(GnomeCanvasBuf* buf)
{
ArtIRect rect;
int pos0, pos1, offset;
}
void
-Lineset::bounds_vfunc(double* _x1, double* _y1, double* _x2, double* _y2)
+LineSet::bounds_vfunc(double* _x1, double* _y1, double* _x2, double* _y2)
{
*_x1 = x1;
*_y1 = y1;
double
-Lineset::point_vfunc(double x, double y, int cx, int cy, GnomeCanvasItem** actual_item)
+LineSet::point_vfunc(double x, double y, int cx, int cy, GnomeCanvasItem** actual_item)
{
double x1, y1, x2, y2;
double dx, dy;
- Lineset::bounds_vfunc(&x1, &y1, &x2, &y2);
+ LineSet::bounds_vfunc(&x1, &y1, &x2, &y2);
*actual_item = gobj();
/* If not overrided emit the signal */
void
-Lineset::request_lines(double c1, double c2)
+LineSet::request_lines(double c1, double c2)
{
signal_request_lines(*this, c1, c2);
}
void
-Lineset::bounds_need_update()
+LineSet::bounds_need_update()
{
bounds_changed = true;
}
void
-Lineset::region_needs_update(double coord1, double coord2)
+LineSet::region_needs_update(double coord1, double coord2)
{
if (update_region1 > update_region2) {
update_region1 = coord1;
* These have been defined to avoid endless recursion with gnomecanvasmm.
* Don't know why this happens
*/
-bool Lineset::on_event(GdkEvent* p1)
+bool LineSet::on_event(GdkEvent* p1)
{
return false;
}
-void Lineset::realize_vfunc() { }
-void Lineset::unrealize_vfunc() { }
-void Lineset::map_vfunc() { }
-void Lineset::unmap_vfunc() { }
+void LineSet::realize_vfunc() { }
+void LineSet::unrealize_vfunc() { }
+void LineSet::map_vfunc() { }
+void LineSet::unmap_vfunc() { }
} /* namespace Canvas */
} /* namespace Gnome */
namespace Gnome {
namespace Canvas {
-class LinesetClass : public Glib::Class {
+class LineSetClass : public Glib::Class {
public:
const Glib::Class& init();
static void class_init_function(void* g_class, void* class_data);
};
-/**
- * A canvas item that displays a list of lines vertically or horizontally,
+/** A canvas item that displays a set of vertical or horizontal lines,
* spanning the entire size of the item.
*/
-class Lineset : public Item {
+class LineSet : public Item {
public:
enum Orientation {
Vertical,
Horizontal
};
- Lineset(Group& parent, Orientation);
- virtual ~Lineset();
+ LineSet(Group& parent, Orientation);
+ virtual ~LineSet();
Glib::PropertyProxy<double> property_x1() { return x1.get_proxy(); }
Glib::PropertyProxy<double> property_y1() { return y1.get_proxy(); }
Glib::PropertyProxy<double> property_x2() { return x2.get_proxy(); }
Glib::PropertyProxy<double> property_y2() { return y2.get_proxy(); }
- /*
- * Note: every line operation takes a coord parameter, as an index to
+ /* Note: every line operation takes a coord parameter, as an index to
* the line it modifies. The index will identify a line if it is between
* line.coord and line.coord + line.width.
*/
- /**
- * Move a line to a new position
- * for this to work (to move the desired line) it is important that
+ /** Move a line to a new position.
+ * For this to work (to move the desired line) it is important that
* lines have unique coordinates. This also applies to every line
* accessing functions below
*/
void move_line(double coord, double dest);
- /**
- * Change the width of a line. Only allow it if the new width doesn't
- * overlap the next line (see below)
+ /** Change the width of a line.
+ * Only allow if the new width doesn't overlap the next line (see below)
*/
void change_line_width(double coord, double width);
- /**
- * Change the color of a line
+ /** Change the color of a line.
*/
void change_line_color(double coord, uint32_t color);
- /**
- * this function adds a line to draw.
+ /** Add a line to draw.
* width is an offset, so that coord + width specifies the end of the line.
* lines should not overlap, as no layering information is provided.
* however, line_coord[i] + line_width[i] == line_coord[i+1] is
*/
void add_line(double coord, double width, uint32_t color);
- /**
- * remove the line at coord
+ /** Remove the line at coord
*/
void remove_line(double coord);
- /**
- * remove all lines in a coordinate range
+ /** Remove all lines in a coordinate range
*/
void remove_lines(double c1, double c2);
- /**
- * remove all lines with a coordinate lower than coord
+ /** Remove all lines with a coordinate lower than coord
*/
void remove_until(double coord);
- /**
- * remove all lines with a coordinate equal to or higher than coord
+ /** Remove all lines with a coordinate equal to or higher than coord.
*/
void remove_from(double coord);
- /**
- * remove all lines
+ /** Remove all lines.
*/
void clear();
- /**
- * this is a request of information on lines in a coordinate range.
- * for every line visible in the provided coordinate range,
- * call add_line() on it.
+ /** Add a set of lines in the given range.
+ * For every line visible in the provided coordinate range, call add_line().
* This is called when the area between c1 and c2 becomes visible, when
- * previously outside any possible view. So the number of calls to this
- * function will be kept at a minimum.
+ * previously outside any possible view.
+ * The number of calls to this function should be kept at a minimum.
*/
virtual void request_lines(double c1, double c2);
- /**
- * instead of overriding the update_lines function one can connect to this
- * and add lines externally instead. If add_lines() is overrided, this
- * signal will not be emitted.
+ /** Instead of overriding the update_lines function one can connect to this
+ * and add lines externally instead.
+ * If add_lines() is overrided, this signal will not be emitted.
*/
- sigc::signal<void, Lineset&, double, double> signal_request_lines;
+ sigc::signal<void, LineSet&, double, double> signal_request_lines;
- /* overrided from Gnome::Canvas::Item */
+ /* overridden from Gnome::Canvas::Item */
void update_vfunc(double* affine, ArtSVP* clip_path, int flags);
void realize_vfunc();
void unrealize_vfunc();
unsigned char a;
};
- static inline void paint_vert(GnomeCanvasBuf* buf, Lineset::Line& line, int x1, int y1, int x2, int y2);
- static inline void paint_horiz(GnomeCanvasBuf* buf, Lineset::Line& line, int x1, int y1, int x2, int y2);
+ static inline void paint_vert(GnomeCanvasBuf* buf, LineSet::Line& line, int x1, int y1, int x2, int y2);
+ static inline void paint_horiz(GnomeCanvasBuf* buf, LineSet::Line& line, int x1, int y1, int x2, int y2);
static bool line_compare(const Line& a, const Line& b);
Lines::iterator line_at(double coord);
- /* store that last accessed line so adjacent lines are found faster */
+ /** Stores last accessed line so adjacent lines are found faster */
Lines::iterator cached_pos;
- static LinesetClass lineset_class;
+ static LineSetClass lineset_class;
Orientation orientation;
Lines lines;
Glib::Property<double> x2;
Glib::Property<double> y2;
- /* cached bounding box in canvas coordinates*/
+ /** Cached bounding box in canvas coordinates */
ArtIRect bbox;
private:
- Lineset();
- Lineset(const Lineset&);
+ LineSet();
+ LineSet(const LineSet&);
bool in_update;
projects / ardour.git / commitdiff