- more conversion to use of floats

- add gvrender_box wrapper around gvrender_poygon for common cases
- implement GVRENDER_DOES_TRANSFORM and use in gvrender_ps.c

diff --git a/lib/common/arrows.c b/lib/common/arrows.c
index 12486d0d00a573fba8c0d6c61401cc4a625f38cb..4694231a93e2f944bc7bb11a4ba074c5508b8ab3 100644 (file)
--- a/lib/common/arrows.c
+++ b/lib/common/arrows.c
@@ -313,11 +313,11 @@ static void arrow_type_normal(GVJ_t * job, pointf p, pointf u, int flag)
        a[3].y = q.y + v.y;
     }
     if (flag & ARR_MOD_LEFT)
-       gvrender_polygonf(job, a, 3, !(flag & ARR_MOD_OPEN));
+       gvrender_polygon(job, a, 3, !(flag & ARR_MOD_OPEN));
     else if (flag & ARR_MOD_RIGHT)
-       gvrender_polygonf(job, &a[2], 3, !(flag & ARR_MOD_OPEN));
+       gvrender_polygon(job, &a[2], 3, !(flag & ARR_MOD_OPEN));
     else
-       gvrender_polygonf(job, &a[1], 3, !(flag & ARR_MOD_OPEN));
+       gvrender_polygon(job, &a[1], 3, !(flag & ARR_MOD_OPEN));
 }
 
 static void arrow_type_crow(GVJ_t * job, pointf p, pointf u, int flag)
@@ -350,11 +350,11 @@ static void arrow_type_crow(GVJ_t * job, pointf p, pointf u, int flag)
        a[5].y = p.y + v.y;
     }
     if (flag & ARR_MOD_LEFT)
-       gvrender_polygonf(job, a, 5, 1);
+       gvrender_polygon(job, a, 5, 1);
     else if (flag & ARR_MOD_RIGHT)
-       gvrender_polygonf(job, &a[2], 5, 1);
+       gvrender_polygon(job, &a[2], 5, 1);
     else
-       gvrender_polygonf(job, a, 7, 1);
+       gvrender_polygon(job, a, 7, 1);
 }
 
 static void arrow_type_tee(GVJ_t * job, pointf p, pointf u, int flag)
@@ -384,7 +384,7 @@ static void arrow_type_tee(GVJ_t * job, pointf p, pointf u, int flag)
        a[1] = m;
        a[2] = n;
     }
-    gvrender_polygonf(job, a, 4, 1);
+    gvrender_polygon(job, a, 4, 1);
     a[0] = p;
     a[1] = q;
     gvrender_polylinef(job, a, 2);
@@ -415,7 +415,7 @@ static void arrow_type_box(GVJ_t * job, pointf p, pointf u, int flag)
        a[1] = p;
        a[2] = m;
     }
-    gvrender_polygonf(job, a, 4, !(flag & ARR_MOD_OPEN));
+    gvrender_polygon(job, a, 4, !(flag & ARR_MOD_OPEN));
     a[0] = m;
     a[1] = q;
     gvrender_polylinef(job, a, 2);
@@ -438,11 +438,11 @@ static void arrow_type_diamond(GVJ_t * job, pointf p, pointf u, int flag)
     a[3].x = r.x - v.x;
     a[3].y = r.y - v.y;
     if (flag & ARR_MOD_LEFT)
-       gvrender_polygonf(job, &a[2], 3, !(flag & ARR_MOD_OPEN));
+       gvrender_polygon(job, &a[2], 3, !(flag & ARR_MOD_OPEN));
     else if (flag & ARR_MOD_RIGHT)
-       gvrender_polygonf(job, a, 3, !(flag & ARR_MOD_OPEN));
+       gvrender_polygon(job, a, 3, !(flag & ARR_MOD_OPEN));
     else
-       gvrender_polygonf(job, a, 4, !(flag & ARR_MOD_OPEN));
+       gvrender_polygon(job, a, 4, !(flag & ARR_MOD_OPEN));
 }
 
 static void arrow_type_dot(GVJ_t * job, pointf p, pointf u, int flag)
@@ -452,7 +452,7 @@ static void arrow_type_dot(GVJ_t * job, pointf p, pointf u, int flag)
     r = sqrt(u.x * u.x + u.y * u.y) / 2.;
     p.x += u.x / 2.;
     p.y += u.y / 2.;
-    gvrender_ellipsef(job, p, r, r, !(flag & ARR_MOD_OPEN));
+    gvrender_ellipse(job, p, r, r, !(flag & ARR_MOD_OPEN));
 }
 
 static pointf arrow_gen_type(GVJ_t * job, pointf p, pointf u, int flag)

diff --git a/lib/common/emit.c b/lib/common/emit.c
index 301641407193d47b3c50d32a90f2759882970d52..5110f7a86a61087de4edd1ab06448ff2a65555e6 100644 (file)
--- a/lib/common/emit.c
+++ b/lib/common/emit.c
@@ -371,27 +371,12 @@ static bool write_node_test(Agraph_t * g, Agnode_t * n)
 void emit_background(GVJ_t * job, graph_t *g)
 {
     char *str;
-    pointf AF[4];
-    point A[4];
-    int i;
-    /* fudge to compensate for rounding errors */
-    pointf fudge;
-
-    fudge.x = 2 * POINTS_PER_INCH / (job->zoom * job->dpi.x);
-    fudge.y = 2 * POINTS_PER_INCH / (job->zoom * job->dpi.y);
 
     if (! ((str = agget(g, "bgcolor")) && str[0]))
        str = "white";
-    AF[0].x = AF[1].x = job->pageBox.LL.x - fudge.x;
-    AF[2].x = AF[3].x = job->pageBox.UR.x + fudge.x;
-    AF[3].y = AF[0].y = job->pageBox.LL.y - fudge.y;
-    AF[1].y = AF[2].y = job->pageBox.UR.y + fudge.y;
-    for (i = 0; i < 4; i++) {
-       PF2P(AF[i],A[i]);
-    }
     gvrender_set_fillcolor(job, str);
     gvrender_set_pencolor(job, str);
-    gvrender_polygon(job, A, 4, TRUE); /* filled */
+    gvrender_box(job, job->pageBox, TRUE);     /* filled */
 }
 
 static void setup_page(GVJ_t * job, graph_t * g)
@@ -1473,7 +1458,8 @@ void emit_clusters(GVJ_t * job, Agraph_t * g, int flags)
 {
     int c, istyle, filled;
     graph_t *sg;
-    point A[4];
+    boxf BF;
+    pointf AF[4];
     char *color, *fillcolor, *pencolor, **style;
     node_t *n;
     edge_t *e;
@@ -1551,30 +1537,31 @@ void emit_clusters(GVJ_t * job, Agraph_t * g, int flags)
            if (((color = agget(sg, "fillcolor")) != 0) && color[0])
                fillcolor = color;
        }
-       A[0] = GD_bb(sg).LL;
-       A[2] = GD_bb(sg).UR;
-       A[1].x = A[2].x;
-       A[1].y = A[0].y;
-       A[3].x = A[0].x;
-       A[3].y = A[2].y;
+        B2BF(GD_bb(sg), BF);
        if (istyle & ROUNDED) {
            if (!pencolor) pencolor = DEFAULT_COLOR;
            if (!fillcolor) fillcolor = DEFAULT_FILL;
-           if (late_int(sg, G_peripheries, 1, 0) || filled)
-               round_corners(job, fillcolor, pencolor, A, 4, istyle);
+           if (late_int(sg, G_peripheries, 1, 0) || filled) {
+               AF[0] = BF.LL;
+               AF[1] = BF.UR;
+               AF[1].x = AF[2].x;
+               AF[1].y = AF[0].y;
+               AF[3].x = AF[0].x;
+               AF[3].y = AF[2].y;
+               round_corners(job, fillcolor, pencolor, AF, 4, istyle);
+           }
        }
        else {
            if (pencolor)
                gvrender_set_pencolor(job, pencolor);
            if (fillcolor)
                gvrender_set_fillcolor(job, fillcolor);
-           if (late_int(sg, G_peripheries, 1, 0)) {
-               gvrender_polygon(job, A, 4, filled);
-           }
+           if (late_int(sg, G_peripheries, 1, 0))
+               gvrender_box(job, BF, filled);
            else if (filled) { 
                if (fillcolor && fillcolor != pencolor)
                    gvrender_set_pencolor(job, fillcolor);
-               gvrender_polygon(job, A, 4, filled);
+               gvrender_box(job, BF, filled);
            }
        }
        if (GD_label(sg))

diff --git a/lib/common/htmltable.c b/lib/common/htmltable.c
index e5fc3f112d431a58d16e7eb796d52b02de828c95..de4e61218ee7418676f6a098548aad7b5879a1e6 100644 (file)
--- a/lib/common/htmltable.c
+++ b/lib/common/htmltable.c
@@ -247,18 +247,14 @@ emit_html_txt(GVJ_t* job, htmltxt_t* tp, htmlenv_t* env, void* obj)
                    fsize, fcolor, tp->box);
 }
 
-static void doSide(GVJ_t * job, point p, int wd, int ht)
+static void doSide(GVJ_t * job, pointf p, double wd, double ht)
 {
-    point A[4];
+    boxf BF;
 
-    A[0] = p;
-    A[1].x = p.x;
-    A[1].y = p.y + ht;
-    A[2].y = A[1].y;
-    A[2].x = p.x + wd;
-    A[3].x = A[2].x;
-    A[3].y = p.y;
-    gvrender_polygon(job, A, 4, 1);
+    BF.LL = p;
+    BF.UR.x = p.x + wd;
+    BF.UR.y = p.y + ht;
+    gvrender_box(job, BF, 1);
 }
 
 /* doBorder:
@@ -271,10 +267,11 @@ static void doSide(GVJ_t * job, point p, int wd, int ht)
  * from x to x+border will all pixels from x to x+border, and thus have
  * width border+1.
  */
-static void doBorder(GVJ_t * job, char *color, int border, box pts)
+static void doBorder(GVJ_t * job, char *color, int border, box B)
 {
-    point pt;
-    int wd, ht;
+    pointf pt;
+    boxf BF;
+    double wd, ht;
 
     gvrender_begin_context(job);
 
@@ -283,46 +280,34 @@ static void doBorder(GVJ_t * job, char *color, int border, box pts)
     gvrender_set_fillcolor(job, color);
     gvrender_set_pencolor(job, color);
 
+    B2BF(B, BF);
     if (border == 1) {
-       point A[4];
-
-       A[0] = pts.LL;
-       A[2] = pts.UR;
-       A[1].x = A[0].x;
-       A[1].y = A[2].y;
-       A[3].x = A[2].x;
-       A[3].y = A[0].y;
-       gvrender_polygon(job, A, 4, 0);
+       gvrender_box(job, BF, 0);
     } else {
        border--;
-       ht = pts.UR.y - pts.LL.y;
-       wd = pts.UR.x - pts.LL.x;
-       doSide(job, pts.LL, border, ht);
-       pt.x = pts.LL.x;
-       pt.y = pts.UR.y;
+       ht = BF.UR.y - BF.LL.y;
+       wd = BF.UR.x - BF.LL.x;
+       doSide(job, BF.LL, border, ht);
+       pt.x = BF.LL.x;
+       pt.y = BF.UR.y;
        doSide(job, pt, wd, -border);
-       doSide(job, pts.UR, -border, -ht);
-       pt.x = pts.UR.x;
-       pt.y = pts.LL.y;
+       doSide(job, BF.UR, -border, -ht);
+       pt.x = BF.UR.x;
+       pt.y = BF.LL.y;
        doSide(job, pt, -wd, border);
     }
 
     gvrender_end_context(job);
 }
 
-static void doFill(GVJ_t * job, char *color, box pts)
+static void doFill(GVJ_t * job, char *color, box B)
 {
-    point A[4];
+    boxf BF;
 
     gvrender_set_fillcolor(job, color);
     gvrender_set_pencolor(job, color);
-    A[0] = pts.LL;
-    A[1].x = pts.LL.x;
-    A[1].y = pts.UR.y;
-    A[2] = pts.UR;
-    A[3].x = pts.UR.x;
-    A[3].y = pts.LL.y;
-    gvrender_polygon(job, A, 4, 1);
+    B2BF(B, BF);
+    gvrender_box(job, BF, 1);
 }
 
 static void doAnchorStart(GVJ_t * job, htmldata_t * data, void *obj)

diff --git a/lib/common/render.h b/lib/common/render.h
index 0f1e0e7cbbd6124c20cf8b6a9a57d75a9d602f80..487f703f9c285cf9a73c67e9f9bbc932d57aa80e 100644 (file)
--- a/lib/common/render.h
+++ b/lib/common/render.h
@@ -146,7 +146,7 @@ extern "C" {
     extern void place_portlabel(edge_t * e, bool head_p);
     extern char *ps_string(char *s, int);
     extern int rank(graph_t * g, int balance, int maxiter);
-    extern void round_corners(GVJ_t*, char*, char*, point*, int, int);
+    extern void round_corners(GVJ_t*, char*, char*, pointf*, int, int);
     extern void routesplinesinit(void);
     extern point *routesplines(path *, int *);
     extern void routesplinesterm(void);

diff --git a/lib/common/shapes.c b/lib/common/shapes.c
index 9331ee129b5504306840d8d3ebb1d304c4355f1c..d0e11c2929fca50bd7786baf17e2703d93539a0d 100644 (file)
--- a/lib/common/shapes.c
+++ b/lib/common/shapes.c
@@ -336,19 +336,18 @@ static void Mcircle_hack(GVJ_t * job, node_t * n)
     gvrender_polyline(job, A, 2);
 }
 
-static point interpolate(double t, point p0, point p1)
+static pointf interpolate(double t, pointf p0, pointf p1)
 {
-    point rv;
+    pointf rv;
     rv.x = p0.x + t * (p1.x - p0.x);
     rv.y = p0.y + t * (p1.y - p0.y);
     return rv;
 }
 
-void round_corners(GVJ_t * job, char* fillc, char* penc, point * A, 
+void round_corners(GVJ_t * job, char* fillc, char* penc, pointf * AF, 
                        int sides, int style)
 {
-    point *B, C[2], p0, p1;
-    pointf BF[4];
+    pointf *B, C[2], p0, p1;
     double d, dx, dy, t;
     int i, seg, mode;
 
@@ -356,14 +355,14 @@ void round_corners(GVJ_t * job, char* fillc, char* penc, point * A,
        mode = DIAGONALS;
     else
        mode = ROUNDED;
-    B = N_NEW(4 * sides + 4, point);
+    B = N_NEW(4 * sides + 4, pointf);
     i = 0;
     for (seg = 0; seg < sides; seg++) {
-       p0 = A[seg];
+       p0 = AF[seg];
        if (seg < sides - 1)
-           p1 = A[seg + 1];
+           p1 = AF[seg + 1];
        else
-           p1 = A[0];
+           p1 = AF[0];
        dx = p1.x - p0.x;
        dy = p1.y - p0.y;
        d = sqrt(dx * dx + dy * dy);
@@ -385,7 +384,7 @@ void round_corners(GVJ_t * job, char* fillc, char* penc, point * A,
     if (mode == ROUNDED) {
        if (style & FILLED) {
            int j = 0;
-           point* pts = N_GNEW(2*sides,point);
+           pointf* pts = N_GNEW(2*sides,pointf);
            gvrender_begin_context(job);
            gvrender_set_pencolor (job, fillc);
            gvrender_set_fillcolor (job, fillc);
@@ -396,44 +395,38 @@ void round_corners(GVJ_t * job, char* fillc, char* penc, point * A,
            gvrender_polygon(job, pts, 2*sides, TRUE);
            free (pts);
            for (seg = 0; seg < sides; seg++) {
-               for (i = 0; i < 4; i++)
-                   P2PF(B[4 * seg + 2 + i], BF[i]);
-               gvrender_beziercurve(job, BF, 4, FALSE, FALSE, TRUE);
+               gvrender_beziercurve(job, B + 4 * seg + 2, 4, FALSE, FALSE, TRUE);
            }
            gvrender_end_context(job);
        }
        gvrender_set_pencolor(job, penc);
        for (seg = 0; seg < sides; seg++) {
-           gvrender_polyline(job, B + 4 * seg + 1, 2);
-
-           /* convert to floats for gvrender api */
-           for (i = 0; i < 4; i++)
-               P2PF(B[4 * seg + 2 + i], BF[i]);
-           gvrender_beziercurve(job, BF, 4, FALSE, FALSE, FALSE);
+           gvrender_polylinef(job, B + 4 * seg + 1, 2);
+           gvrender_beziercurve(job, B + 4 * seg + 2, 4, FALSE, FALSE, FALSE);
        }
     } else {                   /* diagonals are weird.  rewrite someday. */
        gvrender_set_pencolor(job, penc);
        if (style & FILLED)
            gvrender_set_fillcolor(job, fillc); /* emit fill color */
-       gvrender_polygon(job, A, sides, style & FILLED);
+       gvrender_polygon(job, AF, sides, style & FILLED);
        for (seg = 0; seg < sides; seg++) {
 #ifdef NOTDEF
            C[0] = B[3 * seg];
            C[1] = B[3 * seg + 3];
-           gvrender_polyline(job, C, 2);
+           gvrender_polylinef(job, C, 2);
 #endif
            C[0] = B[3 * seg + 2];
            C[1] = B[3 * seg + 4];
-           gvrender_polyline(job, C, 2);
+           gvrender_polylinef(job, C, 2);
        }
     }
     free(B);
 }
 
 static void 
-node_round_corners(GVJ_t * job, node_t* n, point * A, int sides, int style)
+node_round_corners(GVJ_t * job, node_t* n, pointf * AF, int sides, int style)
 {
-    round_corners(job, findFill(n), findPen(n), A, sides, style);
+    round_corners(job, findFill(n), findPen(n), AF, sides, style);
 }
 
 /*=============================poly start=========================*/
@@ -1213,9 +1206,8 @@ static void poly_gencode(GVJ_t * job, node_t * n)
     }
 
     ND_label(n)->p = ND_coord_i(n);
-/* prescale by 16.0 to help rounding trick below */
-    xsize = (16.0 * (ND_lw_i(n) + ND_rw_i(n)) / POINTS(ND_width(n)));
-    ysize = (16.0 * ND_ht_i(n) / POINTS(ND_height(n)));
+    xsize = (double)(ND_lw_i(n) + ND_rw_i(n)) / POINTS(ND_width(n));
+    ysize = (double)ND_ht_i(n) / POINTS(ND_height(n));
 
 #if defined(WITH_CODEGENS) && defined(HAVE_GD_PNG)
     /* this is bad, but it's because of how the VRML driver works */
@@ -1275,20 +1267,17 @@ static void poly_gencode(GVJ_t * job, node_t * n)
     if (ND_shape(n)->usershape) {
        for (i = 0; i < sides; i++) {
            P = vertices[i];
-/* simple rounding produces random results around .5 
- * this trick should clip off the random part. 
- * (note xsize/ysize prescaled by 16.0 above) */
-           A[i].x = ROUND(P.x * xsize) / 16;
-           A[i].y = ROUND(P.y * ysize) / 16;
+           AF[i].x = P.x * xsize;
+           AF[i].y = P.y * ysize;
            if (sides > 2) {
-               A[i].x += ND_coord_i(n).x;
-               A[i].y += ND_coord_i(n).y;
+               AF[i].x += (double)ND_coord_i(n).x;
+               AF[i].y += (double)ND_coord_i(n).y;
            }
        }
        name = ND_shape(n)->name;
        if (streq(name, "custom"))
            name = agget(n, "shapefile");
-       gvrender_usershape(job, name, A, sides, filled);
+       gvrender_usershape(job, name, AF, sides, filled);
        filled = FALSE;
     }
     /* if no boundary but filled, set boundary color to fill color */
@@ -1302,34 +1291,25 @@ static void poly_gencode(GVJ_t * job, node_t * n)
     for (j = 0; j < peripheries; j++) {
        for (i = 0; i < sides; i++) {
            P = vertices[i + j * sides];
-           AF[i].x = P.x * xsize / 16.;
-           AF[i].y = P.y * ysize / 16.;
-           if (sides > 2) {
-               AF[i].x += ND_coord_i(n).x;
-               AF[i].y += ND_coord_i(n).y;
-           }
-/* simple rounding produces random results around .5 
- * this trick should clip off the random part. 
- * (note xsize/ysize prescaled by 16.0 above) */
-           A[i].x = ROUND(P.x * xsize) / 16;
-           A[i].y = ROUND(P.y * ysize) / 16;
+           AF[i].x = P.x * xsize;
+           AF[i].y = P.y * ysize;
            if (sides > 2) {
-               A[i].x += ND_coord_i(n).x;
-               A[i].y += ND_coord_i(n).y;
+               AF[i].x += (double)ND_coord_i(n).x;
+               AF[i].y += (double)ND_coord_i(n).y;
            }
        }
        if (sides <= 2) {
            pointf PF;
 
            P2PF(ND_coord_i(n), PF);
-           gvrender_ellipsef(job, PF, AF[0].x, AF[0].y, filled);
+           gvrender_ellipse(job, PF, AF[0].x, AF[0].y, filled);
            if (style & DIAGONALS) {
                Mcircle_hack(job, n);
            }
        } else if (style & (ROUNDED | DIAGONALS)) {
-           node_round_corners(job, n, A, sides, style);
+           node_round_corners(job, n, AF, sides, style);
        } else {
-           gvrender_polygonf(job, AF, sides, filled);
+           gvrender_polygon(job, AF, sides, filled);
        }
        /* fill innermost periphery only */
        filled = FALSE;
@@ -1875,29 +1855,35 @@ static void gen_fields(GVJ_t * job, node_t * n, field_t * f)
 
 static void record_gencode(GVJ_t * job, node_t * n)
 {
-    point A[4];
-    int i, style;
+    boxf BF;
+    pointf AF[4];
+    int style;
     field_t *f;
 
     f = (field_t *) ND_shape_info(n);
-    A[0] = f->b.LL;
-    A[2] = f->b.UR;
-    A[1].x = A[2].x;
-    A[1].y = A[0].y;
-    A[3].x = A[0].x;
-    A[3].y = A[2].y;
-    for (i = 0; i < 4; i++)
-       A[i] = add_points(A[i], ND_coord_i(n));
+    B2BF(f->b, BF);
+    BF.LL.x += (double)(ND_coord_i(n).x);
+    BF.LL.y += (double)(ND_coord_i(n).y);
+    BF.UR.x += (double)(ND_coord_i(n).x);
+    BF.UR.y += (double)(ND_coord_i(n).y);
+    
     style = stylenode(job, n);
     pencolor(job, n);
     if (style & FILLED)
        gvrender_set_fillcolor(job, findFill(n)); /* emit fill color */
     if (streq(ND_shape(n)->name, "Mrecord"))
        style |= ROUNDED;
-    if (style & (ROUNDED | DIAGONALS))
-       node_round_corners(job, n, A, 4, style);
+    if (style & (ROUNDED | DIAGONALS)) {
+        AF[0] = BF.LL;
+        AF[2] = BF.UR;
+        AF[1].x = AF[2].x;
+        AF[1].y = AF[0].y;
+        AF[3].x = AF[0].x;
+        AF[3].y = AF[2].y;
+       node_round_corners(job, n, AF, 4, style);
+    }
     else
-       gvrender_polygon(job, A, 4, style & FILLED);
+       gvrender_box(job, BF, style & FILLED);
     gen_fields(job, n, f);
 }
 

diff --git a/lib/gvc/gvcjob.h b/lib/gvc/gvcjob.h
index b7ccda083c6c014fff02353c1d5219cb8f5925a2..a2c04422af82a804559046d153cded9a3203cacf 100644 (file)
--- a/lib/gvc/gvcjob.h
+++ b/lib/gvc/gvcjob.h
@@ -44,7 +44,6 @@ extern "C" {
     typedef enum { GVATTR_STRING, GVATTR_BOOL, GVATTR_COLOR } gvattr_t;
 
     typedef struct {
-       char **rawstyle;
        char *fontfam, fontopt;
        gvcolor_t pencolor, fillcolor;
        pen_type pen;
@@ -158,6 +157,7 @@ extern "C" {
        bool external_surface; /* surface belongs to caller */
 
        gvstyle_t *style;       /* active style from gvc->styles[] */
+       char **rawstyle;
        char *objname;          /* "graph", "node", or "edge" */
 
         int flags;             /* emit_graph flags */

diff --git a/lib/gvc/gvcproc.h b/lib/gvc/gvcproc.h
index 610c104affad2474325f194bf845256cc4847660..99342fb7a24bd6917bd1501eb31d9a3e22809a95 100644 (file)
--- a/lib/gvc/gvcproc.h
+++ b/lib/gvc/gvcproc.h
@@ -103,18 +103,16 @@ extern "C" {
     extern void gvrender_set_pencolor(GVJ_t * job, char *name);
     extern void gvrender_set_fillcolor(GVJ_t * job, char *name);
     extern void gvrender_set_style(GVJ_t * job, char **s);
-    extern void gvrender_ellipse(GVJ_t * job, point p,
-                       int rx, int ry, bool filled);
-    extern void gvrender_ellipsef(GVJ_t * job, pointf p,
+    extern void gvrender_ellipse(GVJ_t * job, pointf p,
                        double rx, double ry, bool filled);
-    extern void gvrender_polygon(GVJ_t * job, point * A, int n, bool filled);
-    extern void gvrender_polygonf(GVJ_t * job, pointf * AF, int n, bool filled);
+    extern void gvrender_polygon(GVJ_t * job, pointf * AF, int n, bool filled);
+    extern void gvrender_box(GVJ_t * job, boxf BF, bool filled);
     extern void gvrender_beziercurve(GVJ_t * job, pointf * AF, int n,
                        int arrow_at_start, int arrow_at_end, bool filled);
     extern void gvrender_polyline(GVJ_t * job, point * A, int n);
     extern void gvrender_polylinef(GVJ_t * job, pointf * AF, int n);
     extern void gvrender_comment(GVJ_t * job, char *str);
-    extern void gvrender_usershape(GVJ_t * job, char *name, point * A, int n, bool filled);
+    extern void gvrender_usershape(GVJ_t * job, char *name, pointf * AF, int n, bool filled);
 
 /* layout */
 

diff --git a/lib/gvc/gvrender.c b/lib/gvc/gvrender.c
index 29901031e7b73c2439bf700b9474f3b410fb11f7..831f64443deb0d691977b61cdd19df2569aae671 100644 (file)
--- a/lib/gvc/gvrender.c
+++ b/lib/gvc/gvrender.c
@@ -754,7 +754,7 @@ void gvrender_set_style(GVJ_t * job, char **s)
     char *line, *p;
     gvstyle_t *style = job->style;
 
-    style->rawstyle = s;
+    job->rawstyle = s;
     if (gvre) {
        while ((p = line = *s++)) {
            if (streq(line, "solid"))
@@ -793,7 +793,7 @@ void gvrender_set_style(GVJ_t * job, char **s)
 #endif
 }
 
-void gvrender_ellipsef(GVJ_t * job, pointf pf, double rx, double ry, bool filled)
+void gvrender_ellipse(GVJ_t * job, pointf pf, double rx, double ry, bool filled)
 {
     gvrender_engine_t *gvre = job->render.engine;
 
@@ -806,9 +806,11 @@ void gvrender_ellipsef(GVJ_t * job, pointf pf, double rx, double ry, bool filled
            /* corner */
            af[1].x = pf.x + rx;
            af[1].y = pf.y + ry;
-           /* scale */
-           af[0] = gvrender_ptf(job, af[0]);
-           af[1] = gvrender_ptf(job, af[1]);
+
+           if (! (job->render.features && (job->render.features->flags & GVRENDER_DOES_TRANSFORM))) {
+               af[0] = gvrender_ptf(job, af[0]);
+               af[1] = gvrender_ptf(job, af[1]);
+            }
            gvre->ellipse(job, af, filled);
        }
     }
@@ -826,52 +828,24 @@ void gvrender_ellipsef(GVJ_t * job, pointf pf, double rx, double ry, bool filled
 #endif
 }
 
-void gvrender_ellipse(GVJ_t * job, point p, int rx, int ry, bool filled)
-{
-    gvrender_engine_t *gvre = job->render.engine;
-
-    if (gvre && gvre->ellipse) {
-       if (job->style->pen != PEN_NONE) {
-           int i;
-           if (sizeAF < 2) {
-               sizeAF = 10;
-               AF = grealloc(AF, sizeAF * sizeof(pointf));
-           }
-           /* center */
-           AF[0].x = (double) p.x;
-           AF[0].y = (double) p.y;
-           /* corner */
-           AF[1].x = (double) (p.x + rx);
-           AF[1].y = (double) (p.y + ry);
-           for (i = 0; i < 2; i++)
-               AF[i] = gvrender_ptf(job, AF[i]);
-           gvre->ellipse(job, AF, filled);
-       }
-    }
-#ifdef WITH_CODEGENS
-    else {
-       codegen_t *cg = job->codegen;
-
-       if (cg && cg->ellipse)
-           cg->ellipse(p, rx, ry, filled);
-    }
-#endif
-}
-
-void gvrender_polygonf(GVJ_t * job, pointf * af, int n, bool filled)
+void gvrender_polygon(GVJ_t * job, pointf * af, int n, bool filled)
 {
     int i;
     gvrender_engine_t *gvre = job->render.engine;
 
     if (gvre && gvre->polygon) {
        if (job->style->pen != PEN_NONE) {
-           if (sizeAF < n) {
-               sizeAF = n+10;
-               AF = grealloc(AF, sizeAF * sizeof(pointf));
+           if (job->render.features && (job->render.features->flags & GVRENDER_DOES_TRANSFORM))
+               gvre->polygon(job, af, n, filled);
+           else {
+               if (sizeAF < n) {
+                   sizeAF = n+10;
+                   AF = grealloc(AF, sizeAF * sizeof(pointf));
+               }
+               for (i = 0; i < n; i++)
+                   AF[i] = gvrender_ptf(job, af[i]);
+               gvre->polygon(job, AF, n, filled);
            }
-           for (i = 0; i < n; i++)
-               AF[i] = gvrender_ptf(job, af[i]);
-           gvre->polygon(job, AF, n, filled);
        }
     }
 #ifdef WITH_CODEGENS
@@ -890,30 +864,18 @@ void gvrender_polygonf(GVJ_t * job, pointf * af, int n, bool filled)
 #endif
 }
 
-void gvrender_polygon(GVJ_t * job, point * A, int n, bool filled)
+void gvrender_box(GVJ_t * job, boxf B, bool filled)
 {
-    gvrender_engine_t *gvre = job->render.engine;
-
-    if (gvre && gvre->polygon) {
-       if (job->style->pen != PEN_NONE) {
-           int i;
-           if (sizeAF < n) {
-               sizeAF = n+10;
-               AF = grealloc(AF, sizeAF * sizeof(pointf));
-           }
-           for (i = 0; i < n; i++)
-               AF[i] = gvrender_pt(job, A[i]);
-           gvre->polygon(job, AF, n, filled);
-       }
-    }
-#ifdef WITH_CODEGENS
-    else {
-       codegen_t *cg = job->codegen;
-
-       if (cg && cg->polygon)
-           cg->polygon(A, n, filled);
-    }
-#endif
+    pointf A[4];
+
+    A[0] = B.LL;
+    A[2] = B.UR;
+    A[1].x = A[0].x;
+    A[1].y = A[2].y;
+    A[3].x = A[2].x;
+    A[3].y = A[0].y;
+    
+    gvrender_polygon(job, A, 4, filled);
 }
 
 void gvrender_beziercurve(GVJ_t * job, pointf * af, int n,
@@ -923,14 +885,18 @@ void gvrender_beziercurve(GVJ_t * job, pointf * af, int n,
 
     if (gvre && gvre->beziercurve) {
        if (job->style->pen != PEN_NONE) {
-           int i;
-           if (sizeAF < n) {
-               sizeAF = n+10;
-               AF = grealloc(AF, sizeAF * sizeof(pointf));
+           if (job->render.features && (job->render.features->flags & GVRENDER_DOES_TRANSFORM))
+               gvre->beziercurve(job, af, n, arrow_at_start, arrow_at_end,filled);
+           else {
+               int i;
+               if (sizeAF < n) {
+                   sizeAF = n+10;
+                   AF = grealloc(AF, sizeAF * sizeof(pointf));
+               }
+               for (i = 0; i < n; i++)
+                   AF[i] = gvrender_ptf(job, af[i]);
+               gvre->beziercurve(job, AF, n, arrow_at_start, arrow_at_end,filled);
            }
-           for (i = 0; i < n; i++)
-               AF[i] = gvrender_ptf(job, af[i]);
-           gvre->beziercurve(job, AF, n, arrow_at_start, arrow_at_end,filled);
        }
     }
 #ifdef WITH_CODEGENS
@@ -941,8 +907,9 @@ void gvrender_beziercurve(GVJ_t * job, pointf * af, int n,
            sizeA = n+10;
            A = grealloc(A, sizeA * sizeof(point));
        }
-       for (i = 0; i < n; i++)
+       for (i = 0; i < n; i++) {
            PF2P(af[i], A[i]);
+       }
        if (cg && cg->beziercurve)
            cg->beziercurve(A, n, arrow_at_start, arrow_at_end, filled);
     }
@@ -956,13 +923,17 @@ void gvrender_polylinef(GVJ_t * job, pointf * af, int n)
 
     if (gvre && gvre->polyline) {
        if (job->style->pen != PEN_NONE) {
-           if (sizeAF < n) {
-               sizeAF = n+10;
-               AF = grealloc(AF, sizeAF * sizeof(pointf));
+           if (job->render.features && (job->render.features->flags & GVRENDER_DOES_TRANSFORM))
+               gvre->polyline(job, af, n);
+            else {
+               if (sizeAF < n) {
+                   sizeAF = n+10;
+                   AF = grealloc(AF, sizeAF * sizeof(pointf));
+               }
+               for (i = 0; i < n; i++)
+                   AF[i] = gvrender_ptf(job, af[i]);
+               gvre->polyline(job, AF, n);
            }
-           for (i = 0; i < n; i++)
-               AF[i] = gvrender_ptf(job, af[i]);
-           gvre->polyline(job, AF, n);
        }
     }
 #ifdef WITH_CODEGENS
@@ -992,8 +963,15 @@ void gvrender_polyline(GVJ_t * job, point * a, int n)
                sizeAF = n+10;
                AF = grealloc(AF, sizeAF * sizeof(pointf));
            }
-           for (i = 0; i < n; i++)
-               AF[i] = gvrender_pt(job, a[i]);
+           if (job->render.features && (job->render.features->flags & GVRENDER_DOES_TRANSFORM)) {
+               for (i = 0; i < n; i++) {
+                   P2PF(a[i],AF[i]);
+               }
+           }
+           else {
+               for (i = 0; i < n; i++)
+                   AF[i] = gvrender_pt(job, a[i]);
+           }
            gvre->polyline(job, AF, n);
        }
     }
@@ -1027,7 +1005,7 @@ void gvrender_comment(GVJ_t * job, char *str)
 #endif
 }
 
-void gvrender_usershape(GVJ_t * job, char *name, point * a, int n, bool filled)
+void gvrender_usershape(GVJ_t * job, char *name, pointf * a, int n, bool filled)
 {
     gvrender_engine_t *gvre = job->render.engine;
     usershape_t *us;
@@ -1044,7 +1022,7 @@ void gvrender_usershape(GVJ_t * job, char *name, point * a, int n, bool filled)
        AF = grealloc(AF, sizeAF * sizeof(pointf));
     }
     for (i = 0; i < n; i++)
-       AF[i] = gvrender_pt(job, a[i]);
+       AF[i] = gvrender_ptf(job, a[i]);
 
     /* compute bb of polygon */
     b.LL = b.UR = AF[0];
@@ -1074,10 +1052,17 @@ void gvrender_usershape(GVJ_t * job, char *name, point * a, int n, bool filled)
         gvre->usershape(job, us, b, filled);
 #ifdef WITH_CODEGENS
     else {
+        point *A;
         codegen_t *cg = job->codegen;
 
+       if (sizeA < n) {
+           sizeA = n+10;
+           A = grealloc(A, sizeA * sizeof(point));
+       }
+       for (i = 0; i < n; i++)
+           PF2P(a[i], A[i]);
         if (cg && cg->usershape)
-            cg->usershape(us, b, a, n, filled);
+            cg->usershape(us, b, A, n, filled);
     }
 #endif
 }