X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;ds=sidebyside;f=src%2Fdisplay%2Fguideline.cpp;h=f1b85b556b7f5188ffc3f0891ab25ac054202357;hb=c35e882b037453a735cc6fbbd6b4475cf5afe602;hp=b029be7a0ee91f02ea162ff3151b314d7c87af26;hpb=627d5932965a686f0c1aa9083cab4429f3ba7abb;p=inkscape.git diff --git a/src/display/guideline.cpp b/src/display/guideline.cpp index b029be7a0..f1b85b556 100644 --- a/src/display/guideline.cpp +++ b/src/display/guideline.cpp @@ -1,30 +1,38 @@ #define __SP_GUIDELINE_C__ /* - * Infinite horizontal/vertical line + * Horizontal/vertical but can also be angled line * - * Author: + * Authors: * Lauris Kaplinski + * Johan Engelen + * Maximilian Albert * * Copyright (C) 2000-2002 Lauris Kaplinski + * Copyright (C) 2007 Johan Engelen + * Copyright (C) 2009 Maximilian Albert * * Released under GNU GPL, read the file 'COPYING' for more information */ #include +#include <2geom/transforms.h> #include "display-forward.h" #include "sp-canvas-util.h" +#include "sp-ctrlpoint.h" #include "guideline.h" static void sp_guideline_class_init(SPGuideLineClass *c); static void sp_guideline_init(SPGuideLine *guideline); static void sp_guideline_destroy(GtkObject *object); -static void sp_guideline_update(SPCanvasItem *item, NR::Matrix const &affine, unsigned int flags); +static void sp_guideline_update(SPCanvasItem *item, Geom::Matrix const &affine, unsigned int flags); static void sp_guideline_render(SPCanvasItem *item, SPCanvasBuf *buf); -static double sp_guideline_point(SPCanvasItem *item, NR::Point p, SPCanvasItem **actual_item); +static double sp_guideline_point(SPCanvasItem *item, Geom::Point p, SPCanvasItem **actual_item); + +static void sp_guideline_drawline (SPCanvasBuf *buf, gint x0, gint y0, gint x1, gint y1, guint32 rgba); static SPCanvasItemClass *parent_class; @@ -67,12 +75,28 @@ static void sp_guideline_init(SPGuideLine *gl) { gl->rgba = 0x0000ff7f; - gl->normal = Geom::Point(0,1); + gl->normal_to_line = Geom::Point(0,1); + gl->angle = 3.14159265358979323846/2; + gl->point_on_line = Geom::Point(0,0); gl->sensitive = 0; + + gl->origin = NULL; } static void sp_guideline_destroy(GtkObject *object) { + g_return_if_fail (object != NULL); + g_return_if_fail (SP_IS_GUIDELINE (object)); + //g_return_if_fail (SP_GUIDELINE(object)->origin != NULL); + //g_return_if_fail (SP_IS_CTRLPOINT(SP_GUIDELINE(object)->origin)); + + if (SP_GUIDELINE(object)->origin != NULL && SP_IS_CTRLPOINT(SP_GUIDELINE(object)->origin)) { + gtk_object_destroy(GTK_OBJECT(SP_GUIDELINE(object)->origin)); + } else { + // FIXME: This branch shouldn't be reached (although it seems to be harmless). + //g_error("Why can it be that gl->origin is not a valid SPCtrlPoint?\n"); + } + GTK_OBJECT_CLASS(parent_class)->destroy(object); } @@ -87,41 +111,82 @@ static void sp_guideline_render(SPCanvasItem *item, SPCanvasBuf *buf) unsigned int const b = NR_RGBA32_B (gl->rgba); unsigned int const a = NR_RGBA32_A (gl->rgba); - int p0, p1, step; - unsigned char *d; + if (gl->is_vertical()) { + int position = (int) Inkscape::round(gl->point_on_line[Geom::X]); + if (position < buf->rect.x0 || position >= buf->rect.x1) { + return; + } - if (gl->normal[Geom::Y] == 0.) { + int p0 = buf->rect.y0; + int p1 = buf->rect.y1; + int step = buf->buf_rowstride; + unsigned char *d = buf->buf + 4 * (position - buf->rect.x0); - if (gl->position < buf->rect.x0 || gl->position >= buf->rect.x1) { + for (int p = p0; p < p1; p++) { + d[0] = NR_COMPOSEN11_1111(r, a, d[0]); + d[1] = NR_COMPOSEN11_1111(g, a, d[1]); + d[2] = NR_COMPOSEN11_1111(b, a, d[2]); + d += step; + } + } else if (gl->is_horizontal()) { + int position = (int) Inkscape::round(gl->point_on_line[Geom::Y]); + if (position < buf->rect.y0 || position >= buf->rect.y1) { return; } - p0 = buf->rect.y0; - p1 = buf->rect.y1; - step = buf->buf_rowstride; - d = buf->buf + 3 * (gl->position - buf->rect.x0); + int p0 = buf->rect.x0; + int p1 = buf->rect.x1; + int step = 4; + unsigned char *d = buf->buf + (position - buf->rect.y0) * buf->buf_rowstride; + for (int p = p0; p < p1; p++) { + d[0] = NR_COMPOSEN11_1111(r, a, d[0]); + d[1] = NR_COMPOSEN11_1111(g, a, d[1]); + d[2] = NR_COMPOSEN11_1111(b, a, d[2]); + d += step; + } } else { + // render angled line, once intersection has been detected, draw from there. + Geom::Point parallel_to_line( gl->normal_to_line[Geom::Y], + /*should be minus, but inverted y axis*/ gl->normal_to_line[Geom::X]); + + //try to intersect with left vertical of rect + double y_intersect_left = (buf->rect.x0 - gl->point_on_line[Geom::X]) * parallel_to_line[Geom::Y] / parallel_to_line[Geom::X] + gl->point_on_line[Geom::Y]; + if ( (y_intersect_left >= buf->rect.y0) && (y_intersect_left <= buf->rect.y1) ) { + // intersects with left vertical! + double y_intersect_right = (buf->rect.x1 - gl->point_on_line[Geom::X]) * parallel_to_line[Geom::Y] / parallel_to_line[Geom::X] + gl->point_on_line[Geom::Y]; + sp_guideline_drawline (buf, buf->rect.x0, static_cast(round(y_intersect_left)), buf->rect.x1, static_cast(round(y_intersect_right)), gl->rgba); + return; + } - if (gl->position < buf->rect.y0 || gl->position >= buf->rect.y1) { + //try to intersect with right vertical of rect + double y_intersect_right = (buf->rect.x1 - gl->point_on_line[Geom::X]) * parallel_to_line[Geom::Y] / parallel_to_line[Geom::X] + gl->point_on_line[Geom::Y]; + if ( (y_intersect_right >= buf->rect.y0) && (y_intersect_right <= buf->rect.y1) ) { + // intersects with right vertical! + sp_guideline_drawline (buf, buf->rect.x1, static_cast(round(y_intersect_right)), buf->rect.x0, static_cast(round(y_intersect_left)), gl->rgba); return; } - p0 = buf->rect.x0; - p1 = buf->rect.x1; - step = 3; - d = buf->buf + (gl->position - buf->rect.y0) * buf->buf_rowstride; - } + //try to intersect with top horizontal of rect + double x_intersect_top = (buf->rect.y0 - gl->point_on_line[Geom::Y]) * parallel_to_line[Geom::X] / parallel_to_line[Geom::Y] + gl->point_on_line[Geom::X]; + if ( (x_intersect_top >= buf->rect.x0) && (x_intersect_top <= buf->rect.x1) ) { + // intersects with top horizontal! + double x_intersect_bottom = (buf->rect.y1 - gl->point_on_line[Geom::Y]) * parallel_to_line[Geom::X] / parallel_to_line[Geom::Y] + gl->point_on_line[Geom::X]; + sp_guideline_drawline (buf, static_cast(round(x_intersect_top)), buf->rect.y0, static_cast(round(x_intersect_bottom)), buf->rect.y1, gl->rgba); + return; + } - for (int p = p0; p < p1; p++) { - d[0] = NR_COMPOSEN11_1111(r, a, d[0]); - d[1] = NR_COMPOSEN11_1111(g, a, d[1]); - d[2] = NR_COMPOSEN11_1111(b, a, d[2]); - d += step; + //try to intersect with bottom horizontal of rect + double x_intersect_bottom = (buf->rect.y1 - gl->point_on_line[Geom::Y]) * parallel_to_line[Geom::X] / parallel_to_line[Geom::Y] + gl->point_on_line[Geom::X]; + if ( (x_intersect_top >= buf->rect.x0) && (x_intersect_top <= buf->rect.x1) ) { + // intersects with bottom horizontal! + sp_guideline_drawline (buf, static_cast(round(x_intersect_bottom)), buf->rect.y1, static_cast(round(x_intersect_top)), buf->rect.y0, gl->rgba); + return; + } } } -static void sp_guideline_update(SPCanvasItem *item, NR::Matrix const &affine, unsigned int flags) +static void sp_guideline_update(SPCanvasItem *item, Geom::Matrix const &affine, unsigned int flags) { SPGuideLine *gl = SP_GUIDELINE(item); @@ -129,16 +194,23 @@ static void sp_guideline_update(SPCanvasItem *item, NR::Matrix const &affine, un ((SPCanvasItemClass *) parent_class)->update(item, affine, flags); } - if (gl->normal[Geom::Y] == 0.) { - gl->position = (int) (affine[4] + 0.5); - sp_canvas_update_bbox (item, gl->position, -1000000, gl->position + 1, 1000000); + gl->point_on_line[Geom::X] = affine[4]; + gl->point_on_line[Geom::Y] = affine[5]; + + sp_ctrlpoint_set_coords(gl->origin, gl->point_on_line * affine.inverse()); + sp_canvas_item_request_update(SP_CANVAS_ITEM (gl->origin)); + + if (gl->is_horizontal()) { + sp_canvas_update_bbox (item, -1000000, (int) Inkscape::round(gl->point_on_line[Geom::Y]), 1000000, (int) Inkscape::round(gl->point_on_line[Geom::Y] + 1)); + } else if (gl->is_vertical()) { + sp_canvas_update_bbox (item, (int) Inkscape::round(gl->point_on_line[Geom::X]), -1000000, (int) Inkscape::round(gl->point_on_line[Geom::X] + 1), 1000000); } else { - gl->position = (int) (affine[5] - 0.5); - sp_canvas_update_bbox (item, -1000000, gl->position, 1000000, gl->position + 1); + sp_canvas_update_bbox (item, -1000000, -1000000, 1000000, 1000000); } } -static double sp_guideline_point(SPCanvasItem *item, NR::Point p, SPCanvasItem **actual_item) +// Returns 0.0 if point is on the guideline +static double sp_guideline_point(SPCanvasItem *item, Geom::Point p, SPCanvasItem **actual_item) { SPGuideLine *gl = SP_GUIDELINE (item); @@ -148,35 +220,48 @@ static double sp_guideline_point(SPCanvasItem *item, NR::Point p, SPCanvasItem * *actual_item = item; - if (gl->normal[Geom::Y] == 0.) { - return MAX(fabs(gl->position - p[NR::X])-1, 0); - } else { - return MAX(fabs(gl->position - p[NR::Y])-1, 0); - } + Geom::Point vec(gl->normal_to_line[Geom::X], - gl->normal_to_line[Geom::Y]); + double distance = Geom::dot((p - gl->point_on_line), vec); + return MAX(fabs(distance)-1, 0); } -SPCanvasItem *sp_guideline_new(SPCanvasGroup *parent, double position, Geom::Point normal) +SPCanvasItem *sp_guideline_new(SPCanvasGroup *parent, Geom::Point point_on_line, Geom::Point normal) { SPCanvasItem *item = sp_canvas_item_new(parent, SP_TYPE_GUIDELINE, NULL); + SPCanvasItem *origin = sp_canvas_item_new(parent, SP_TYPE_CTRLPOINT, NULL); SPGuideLine *gl = SP_GUIDELINE(item); + SPCtrlPoint *cp = SP_CTRLPOINT(origin); + gl->origin = cp; normal.normalize(); - gl->normal = normal; - sp_guideline_set_position(gl, position); + gl->normal_to_line = normal; + gl->angle = tan( -gl->normal_to_line[Geom::X] / gl->normal_to_line[Geom::Y]); + sp_guideline_set_position(gl, point_on_line); + + sp_ctrlpoint_set_coords(cp, point_on_line); return item; } -void sp_guideline_set_position(SPGuideLine *gl, double position) +void sp_guideline_set_position(SPGuideLine *gl, Geom::Point point_on_line) { - sp_canvas_item_affine_absolute(SP_CANVAS_ITEM (gl), - NR::Matrix(NR::translate(position, position))); + sp_canvas_item_affine_absolute(SP_CANVAS_ITEM (gl), Geom::Matrix(Geom::Translate(point_on_line))); + sp_canvas_item_affine_absolute(SP_CANVAS_ITEM (gl->origin), Geom::Matrix(Geom::Translate(point_on_line))); +} + +void sp_guideline_set_normal(SPGuideLine *gl, Geom::Point normal_to_line) +{ + gl->normal_to_line = normal_to_line; + gl->angle = tan( -normal_to_line[Geom::X] / normal_to_line[Geom::Y]); + + sp_canvas_item_request_update(SP_CANVAS_ITEM (gl)); } void sp_guideline_set_color(SPGuideLine *gl, unsigned int rgba) { gl->rgba = rgba; + sp_ctrlpoint_set_color(gl->origin, rgba); sp_canvas_item_request_update(SP_CANVAS_ITEM(gl)); } @@ -186,6 +271,89 @@ void sp_guideline_set_sensitive(SPGuideLine *gl, int sensitive) gl->sensitive = sensitive; } +void sp_guideline_delete(SPGuideLine *gl) +{ + //gtk_object_destroy(GTK_OBJECT(gl->origin)); + gtk_object_destroy(GTK_OBJECT(gl)); +} + +//########################################################## +// Line rendering +#define SAFE_SETPIXEL //undefine this when it is certain that setpixel is never called with invalid params + +/** + \brief This function renders a pixel on a particular buffer. + + The topleft of the buffer equals + ( rect.x0 , rect.y0 ) in screen coordinates + ( 0 , 0 ) in setpixel coordinates + The bottomright of the buffer equals + ( rect.x1 , rect,y1 ) in screen coordinates + ( rect.x1 - rect.x0 , rect.y1 - rect.y0 ) in setpixel coordinates +*/ +static void +sp_guideline_setpixel (SPCanvasBuf *buf, gint x, gint y, guint32 rgba) +{ +#ifdef SAFE_SETPIXEL + if ( (x >= buf->rect.x0) && (x < buf->rect.x1) && (y >= buf->rect.y0) && (y < buf->rect.y1) ) { +#endif + guint r, g, b, a; + r = NR_RGBA32_R (rgba); + g = NR_RGBA32_G (rgba); + b = NR_RGBA32_B (rgba); + a = NR_RGBA32_A (rgba); + guchar * p = buf->buf + (y - buf->rect.y0) * buf->buf_rowstride + (x - buf->rect.x0) * 4; + p[0] = NR_COMPOSEN11_1111 (r, a, p[0]); + p[1] = NR_COMPOSEN11_1111 (g, a, p[1]); + p[2] = NR_COMPOSEN11_1111 (b, a, p[2]); +#ifdef SAFE_SETPIXEL + } +#endif +} + +/** + \brief This function renders a line on a particular canvas buffer, + using Bresenham's line drawing function. + http://www.cs.unc.edu/~mcmillan/comp136/Lecture6/Lines.html + Coordinates are interpreted as SCREENcoordinates +*/ +static void +sp_guideline_drawline (SPCanvasBuf *buf, gint x0, gint y0, gint x1, gint y1, guint32 rgba) +{ + int dy = y1 - y0; + int dx = x1 - x0; + int stepx, stepy; + + if (dy < 0) { dy = -dy; stepy = -1; } else { stepy = 1; } + if (dx < 0) { dx = -dx; stepx = -1; } else { stepx = 1; } + dy <<= 1; // dy is now 2*dy + dx <<= 1; // dx is now 2*dx + + sp_guideline_setpixel(buf, x0, y0, rgba); + if (dx > dy) { + int fraction = dy - (dx >> 1); // same as 2*dy - dx + while (x0 != x1) { + if (fraction >= 0) { + y0 += stepy; + fraction -= dx; // same as fraction -= 2*dx + } + x0 += stepx; + fraction += dy; // same as fraction -= 2*dy + sp_guideline_setpixel(buf, x0, y0, rgba); + } + } else { + int fraction = dx - (dy >> 1); + while (y0 != y1) { + if (fraction >= 0) { + x0 += stepx; + fraction -= dy; + } + y0 += stepy; + fraction += dx; + sp_guideline_setpixel(buf, x0, y0, rgba); + } + } +} /* Local Variables: