From b2f771a144d2b6f9ac6563dd72dff99425b215bc Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Thu, 19 Mar 2015 00:52:46 +0100 Subject: Changed two SP_IS_LPE_ITEM calls (bzr r14013) --- src/ui/tool/path-manipulator.cpp | 38 ++++++++++++++++++++++---------------- 1 file changed, 22 insertions(+), 16 deletions(-) diff --git a/src/ui/tool/path-manipulator.cpp b/src/ui/tool/path-manipulator.cpp index c8b986824..dbcde240a 100644 --- a/src/ui/tool/path-manipulator.cpp +++ b/src/ui/tool/path-manipulator.cpp @@ -1221,10 +1221,13 @@ int PathManipulator::BSplineGetSteps() const { LivePathEffect::LPEBSpline const *lpe_bsp = NULL; - if (SP_IS_LPE_ITEM(_path) && _path->hasPathEffect()){ - Inkscape::LivePathEffect::Effect const *thisEffect = SP_LPE_ITEM(_path)->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE); - if(thisEffect){ - lpe_bsp = dynamic_cast(thisEffect->getLPEObj()->get_lpe()); + SPLPEItem * path = dynamic_cast(_path); + if (path){ + if(path->hasPathEffect()){ + Inkscape::LivePathEffect::Effect const *thisEffect = path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE); + if(thisEffect){ + lpe_bsp = dynamic_cast(thisEffect->getLPEObj()->get_lpe()); + } } } int steps = 0; @@ -1338,19 +1341,22 @@ void PathManipulator::_createGeometryFromControlPoints(bool alert_LPE) _spcurve->set_pathvector(pathv); if (alert_LPE) { /// \todo note that _path can be an Inkscape::LivePathEffect::Effect* too, kind of confusing, rework member naming? - if (SP_IS_LPE_ITEM(_path) && _path->hasPathEffect()){ - Inkscape::LivePathEffect::Effect* thisEffect = SP_LPE_ITEM(_path)->getPathEffectOfType(Inkscape::LivePathEffect::POWERSTROKE); - if(thisEffect){ - LivePathEffect::LPEPowerStroke *lpe_pwr = dynamic_cast(thisEffect->getLPEObj()->get_lpe()); - if (lpe_pwr) { - lpe_pwr->adjustForNewPath(pathv); + SPLPEItem * path = dynamic_cast(_path); + if (path){ + if(path->hasPathEffect()){ + Inkscape::LivePathEffect::Effect* thisEffect = path->getPathEffectOfType(Inkscape::LivePathEffect::POWERSTROKE); + if(thisEffect){ + LivePathEffect::LPEPowerStroke *lpe_pwr = dynamic_cast(thisEffect->getLPEObj()->get_lpe()); + if (lpe_pwr) { + lpe_pwr->adjustForNewPath(pathv); + } } - } - thisEffect = SP_LPE_ITEM(_path)->getPathEffectOfType(Inkscape::LivePathEffect::FILLET_CHAMFER); - if(thisEffect){ - LivePathEffect::LPEFilletChamfer *lpe_fll = dynamic_cast(thisEffect->getLPEObj()->get_lpe()); - if (lpe_fll) { - lpe_fll->adjustForNewPath(pathv); + thisEffect = path->getPathEffectOfType(Inkscape::LivePathEffect::FILLET_CHAMFER); + if(thisEffect){ + LivePathEffect::LPEFilletChamfer *lpe_fll = dynamic_cast(thisEffect->getLPEObj()->get_lpe()); + if (lpe_fll) { + lpe_fll->adjustForNewPath(pathv); + } } } } -- cgit v1.2.3 From 6177de61cec9a47677b076ffee4dd56d445f6c13 Mon Sep 17 00:00:00 2001 From: "Liam P. White" Date: Wed, 18 Mar 2015 21:41:26 -0400 Subject: Let's hope the world doesn't end Native 2geom path outliner, still buggy (bzr r14014) --- src/helper/CMakeLists.txt | 2 + src/helper/Makefile_insert | 2 + src/helper/geom-pathstroke.cpp | 505 ++++++++++++++++++++++++++++++++++++++ src/helper/geom-pathstroke.h | 57 +++++ src/live_effects/lpe-jointype.cpp | 56 +++-- src/live_effects/lpe-jointype.h | 4 +- 6 files changed, 597 insertions(+), 29 deletions(-) create mode 100644 src/helper/geom-pathstroke.cpp create mode 100644 src/helper/geom-pathstroke.h diff --git a/src/helper/CMakeLists.txt b/src/helper/CMakeLists.txt index 74ce2c85d..ff4760c24 100644 --- a/src/helper/CMakeLists.txt +++ b/src/helper/CMakeLists.txt @@ -13,6 +13,7 @@ set(helper_SRC action-context.cpp geom.cpp geom-nodetype.cpp + geom-pathstroke.cpp gnome-utils.cpp pixbuf-ops.cpp png-write.cpp @@ -30,6 +31,7 @@ set(helper_SRC action-context.h geom-curves.h geom-nodetype.h + geom-pathstroke.h geom.h gnome-utils.h mathfns.h diff --git a/src/helper/Makefile_insert b/src/helper/Makefile_insert index 5cb4cea8d..e59fcfb70 100644 --- a/src/helper/Makefile_insert +++ b/src/helper/Makefile_insert @@ -12,6 +12,8 @@ ink_common_sources += \ helper/geom-curves.h \ helper/geom-nodetype.cpp \ helper/geom-nodetype.h \ + helper/geom-pathstroke.cpp \ + helper/geom-pathstroke.h \ helper/gnome-utils.cpp \ helper/gnome-utils.h \ helper/mathfns.h \ diff --git a/src/helper/geom-pathstroke.cpp b/src/helper/geom-pathstroke.cpp new file mode 100644 index 000000000..f41732a51 --- /dev/null +++ b/src/helper/geom-pathstroke.cpp @@ -0,0 +1,505 @@ +/* Author: + * Liam P. White + * + * Copyright (C) 2014-2015 Author + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#include <2geom/path-sink.h> +#include <2geom/point.h> +#include <2geom/bezier-curve.h> +#include <2geom/svg-elliptical-arc.h> +#include <2geom/sbasis-to-bezier.h> // cubicbezierpath_from_sbasis + +#include "helper/geom-pathstroke.h" + +namespace Geom { +// 2geom/circle-circle.cpp, no header +int circle_circle_intersection(Point X0, double r0, Point X1, double r1, Point &p0, Point &p1); + +static Point intersection_point(Point origin_a, Point vector_a, Point origin_b, Point vector_b) +{ + Coord denom = cross(vector_b, vector_a); + if (!are_near(denom,0.)) { + Coord t = (cross(origin_a,vector_b) + cross(vector_b,origin_b)) / denom; + return origin_a + vector_a*t; + } + return Point(infinity(), infinity()); +} + +/** +* Find circle that touches inside of the curve, with radius matching the curvature, at time value \c t. +* Because this method internally uses unitTangentAt, t should be smaller than 1.0 (see unitTangentAt). +*/ +static Circle touching_circle( D2 const &curve, double t, double tol=0.01 ) +{ + D2 dM=derivative(curve); + if ( are_near(L2sq(dM(t)),0.) ) { + dM=derivative(dM); + } + if ( are_near(L2sq(dM(t)),0.) ) { // try second time + dM=derivative(dM); + } + Piecewise > unitv = unitVector(dM,tol); + Piecewise dMlength = dot(Piecewise >(dM),unitv); + Piecewise k = cross(derivative(unitv),unitv); + k = divide(k,dMlength,tol,3); + double curv = k(t); // note that this value is signed + + Geom::Point normal = unitTangentAt(curve, t).cw(); + double radius = 1/curv; + Geom::Point center = curve(t) + radius*normal; + return Geom::Circle(center, fabs(radius)); +} + +} + +namespace { + +typedef void join_func(Geom::Path& res, Geom::Curve const& outgoing, double miter, double width); + +void bevel_join(Geom::Path& res, Geom::Curve const& outgoing, double /*miter*/, double /*width*/) +{ + res.appendNew(outgoing.initialPoint()); +} + +void round_join(Geom::Path& res, Geom::Curve const& outgoing, double /*miter*/, double width) +{ + res.appendNew(width, width, 0, false, width > 0, outgoing.initialPoint()); +} + +void miter_join(Geom::Path& res, Geom::Curve const& outgoing, double miter, double width) +{ + Geom::Curve const& incoming = res.back(); + Geom::Point tang1 = Geom::unitTangentAt(reverse(incoming.toSBasis()), 0.); + Geom::Point tang2 = outgoing.unitTangentAt(0); + Geom::Point p = Geom::intersection_point(incoming.finalPoint(), tang1, outgoing.initialPoint(), tang2); + if (p.isFinite()) { + // check size of miter + Geom::Point point_on_path = incoming.finalPoint() - Geom::rot90(tang1)*width; + double len = Geom::distance(p, point_on_path); + if (len <= miter) { + // miter OK, check to see if we can do a relocation + // TODO FIXME + /*if (auto line = cast(const(LineSegment))res.back_open) { + Curve copy = line.duplicate; + copy.setFinal(p); + res.erase_last(); + res.append(copy); + } else {*/ + res.appendNew(p); + //} + } + } + res.appendNew(outgoing.initialPoint()); +} + +// might need a little reworking +void extrapolate_join(Geom::Path& path_builder, Geom::Curve const& outgoing, double miter_limit, double line_width) +{ + using namespace Geom; + Geom::Curve const& incoming = path_builder.back(); + Geom::Point endPt = outgoing.initialPoint(); + + // The method used when extrapolating curves fails to work when either side of the join to be extrapolated + // is a line segment. When this situation is encountered, fall back to a regular miter join. + bool lineProblem = (dynamic_cast(&incoming)) || (dynamic_cast(&outgoing)); + if (lineProblem == false) { + // Geom::Point tang1 = Geom::unitTangentAt(Geom::reverse(incoming.toSBasis()), 0.); + Geom::Point tang2 = Geom::unitTangentAt(outgoing.toSBasis(), 0); + + Geom::Circle circle1 = Geom::touching_circle(Geom::reverse(incoming.toSBasis()), 0.); + Geom::Circle circle2 = Geom::touching_circle(outgoing.toSBasis(), 0); + + Geom::Point points[2]; + int solutions = Geom::circle_circle_intersection(circle1.center(), circle1.ray(), + circle2.center(), circle2.ray(), + points[0], points[1]); + if (solutions == 2) { + Geom::Point sol(0,0); + if ( dot(tang2,points[0]-endPt) > 0 ) { + // points[0] is bad, choose points[1] + sol = points[1]; + } else if ( dot(tang2,points[1]-endPt) > 0 ) { // points[0] could be good, now check points[1] + // points[1] is bad, choose points[0] + sol = points[0]; + } else { + // both points are good, choose nearest + sol = ( distanceSq(endPt, points[0]) < distanceSq(endPt, points[1]) ) ? points[0] : points[1]; + } + + Geom::EllipticalArc *arc0 = circle1.arc(incoming.finalPoint(), 0.5*(incoming.finalPoint()+sol), sol, true); + Geom::EllipticalArc *arc1 = circle2.arc(sol, 0.5*(sol+endPt), endPt, true); + try { + if (arc0) { + path_builder.append(*arc0); + delete arc0; + arc0 = NULL; + } else { + throw std::exception(); + } + + if (arc1) { + path_builder.append(*arc1); + delete arc1; + arc1 = NULL; + } else { + throw std::exception(); + } + + } catch (std::exception const & ex) { + printf("WARNING: Error extrapolating line join: %s\n", ex.what()); + path_builder.appendNew(endPt); + } + } else { + // 1 or no solutions found, default to miter + miter_join(path_builder, outgoing, miter_limit, line_width); + } + } else { + // Line segments exist + miter_join(path_builder, outgoing, miter_limit, line_width); + } +} + +void join_inside(Geom::Path& res, Geom::Curve const& outgoing) +{ + res.appendNew(outgoing.initialPoint()); +} + +void outline_helper(Geom::Path& res, Geom::Path const& to_add, double width, double miter, Inkscape::LineJoinType join) +{ + Geom::Point tang1 = -Geom::unitTangentAt(reverse(res.back().toSBasis()), 0.); + //Geom::Point tang2 = to_add[0].unitTangentAt(0); + Geom::Point discontinuity_vec = to_add.initialPoint() - res.finalPoint(); + bool on_outside = (Geom::dot(tang1, discontinuity_vec) >= 0); + + if (on_outside) { + join_func *jf; + switch (join) { + case Inkscape::JOIN_BEVEL: + jf = &bevel_join; + break; + case Inkscape::JOIN_ROUND: + jf = &round_join; + break; + case Inkscape::JOIN_EXTRAPOLATE: + jf = &extrapolate_join; + break; + default: + jf = &miter_join; + } + jf(res, to_add[0], miter, width); + } else { + join_inside(res, to_add[0]); + } + + res.append(to_add); +} + +// Offsetting a line segment is mathematically stable and quick to do +Geom::LineSegment offset_line(Geom::LineSegment const& l, double width) +{ + Geom::Point tang1 = Geom::rot90(l.unitTangentAt(0)); + Geom::Point tang2 = Geom::rot90(unitTangentAt(reverse(l.toSBasis()), 0.)); + + Geom::Point start = l.initialPoint() + tang1 * width; + Geom::Point end = l.finalPoint() - tang2 * width; + + return Geom::LineSegment(start, end); +} + +void get_cubic_data(Geom::CubicBezier const& bez, double time, double& len, double& rad) +{ + // get derivatives + std::vector derivs = bez.pointAndDerivatives(time, 3); + + Geom::Point der1 = derivs[1]; // first deriv (tangent vector) + Geom::Point der2 = derivs[2]; // second deriv (tangent's tangent) + double l = Geom::L2(der1); // length + + len = rad = 0; + + // TODO: we might want to consider using Geom::touching_circle to determine the + // curvature radius here. Less code duplication, but slower + + if (Geom::are_near(l, 0, 1e-4)) { + l = Geom::L2(der2); + Geom::Point der3 = derivs.at(3); // try second time + if (Geom::are_near(l, 0, 1e-4)) { + l = Geom::L2(der3); + if (Geom::are_near(l, 0)) { + return; // this isn't a segment... + } + rad = 1e8; + } else { + rad = -l * (Geom::dot(der2, der2) / Geom::cross(der3, der2)); + } + } else { + rad = -l * (Geom::dot(der1, der1) / Geom::cross(der2, der1)); + } + len = l; +} + +void offset_cubic(Geom::Path& p, Geom::CubicBezier const& bez, double width, double tol, size_t levels) +{ + using Geom::X; + using Geom::Y; + + Geom::Point start_pos = bez.initialPoint(); + Geom::Point end_pos = bez.finalPoint(); + + Geom::Point start_normal = Geom::rot90(bez.unitTangentAt(0)); + Geom::Point end_normal = -Geom::rot90(Geom::unitTangentAt(Geom::reverse(bez.toSBasis()), 0.)); + + // offset the start and end control points out by the width + Geom::Point start_new = start_pos + start_normal*width; + Geom::Point end_new = end_pos + end_normal*width; + + // -------- + double start_rad, end_rad; + double start_len, end_len; // tangent lengths + get_cubic_data(bez, 0, start_len, start_rad); + get_cubic_data(bez, 1, end_len, end_rad); + + double start_off = 1, end_off = 1; + // correction of the lengths of the tangent to the offset + if (!Geom::are_near(start_rad, 0)) + start_off += width / start_rad; + if (!Geom::are_near(end_rad, 0)) + end_off += width / end_rad; + start_off *= start_len; + end_off *= end_len; + // -------- + + Geom::Point mid1_new = start_normal.ccw()*start_off; + mid1_new = Geom::Point(start_new[X] + mid1_new[X]/3., start_new[Y] + mid1_new[Y]/3.); + Geom::Point mid2_new = end_normal.ccw()*end_off; + mid2_new = Geom::Point(end_new[X] - mid2_new[X]/3., end_new[Y] - mid2_new[Y]/3.); + + // create the estimate curve + Geom::CubicBezier c = Geom::CubicBezier(start_new, mid1_new, mid2_new, end_new); + + // reached maximum recursive depth + // don't bother with any more correction + if (levels == 0) { + p.append(c, Geom::Path::STITCH_DISCONTINUOUS); + return; + } + + // check the tolerance for our estimate to be a parallel curve + Geom::Point chk = c.pointAt(.5); + Geom::Point req = bez.pointAt(.5) + Geom::rot90(bez.unitTangentAt(.5))*width; // required accuracy + + Geom::Point const diff = req - chk; + double const err = Geom::dot(diff, diff); + + if (err < tol) { + if (Geom::are_near(start_new, p.finalPoint())) { + p.setFinal(start_new); // if it isn't near, we throw + } + + // we're good, curve is accurate enough + p.append(c); + return; + } else { + // split the curve in two + std::pair s = bez.subdivide(.5); + offset_cubic(p, s.first, width, tol, levels - 1); + offset_cubic(p, s.second, width, tol, levels - 1); + } +} + +void offset_quadratic(Geom::Path& p, Geom::QuadraticBezier const& bez, double width, double tol, size_t levels) +{ + // cheat + // it's faster + // seriously + std::vector points = bez.points(); + Geom::Point b1 = points[0] + (2./3) * (points[1] - points[0]); + Geom::Point b2 = b1 + (1./3) * (points[2] - points[0]); + Geom::CubicBezier cub = Geom::CubicBezier(points[0], b1, b2, points[3]); + offset_cubic(p, cub, width, tol, levels); +} + +void offset_curve(Geom::Path& res, Geom::Curve const* current, double width) +{ + double const tolerance = 0.0025; + size_t levels = 8; + + // TODO: we can handle SVGEllipticalArc here as well, do that! + + if (Geom::BezierCurve const *b = dynamic_cast(current)) { + size_t order = b->order(); + switch (order) { + case 1: + res.append(offset_line(static_cast(*current), width)); + break; + case 2: { + Geom::QuadraticBezier const& q = static_cast(*current); + offset_quadratic(res, q, width, tolerance, levels); + break; + } + case 3: { + Geom::CubicBezier const& cb = static_cast(*current); + offset_cubic(res, cb, width, tolerance, levels); + break; + } + default: { + Geom::Path sbasis_path = Geom::cubicbezierpath_from_sbasis(current->toSBasis(), 0.1); + for (size_t i = 0; i < sbasis_path.size(); ++i) + offset_curve(res, &sbasis_path[i], width); + break; + } + } + } else { + Geom::Path sbasis_path = Geom::cubicbezierpath_from_sbasis(current->toSBasis(), 0.1); + for (size_t i = 0; i < sbasis_path.size(); ++i) + offset_curve(res, &sbasis_path[i], width); + } +} + +} + +namespace Inkscape { + +Geom::PathVector outline(Geom::Path const& input, double width, double miter, LineJoinType join, LineCapType butt) +{ + if (input.size() == 0) return Geom::PathVector(); // nope, don't even try + + Geom::PathBuilder res; + Geom::Path with_dir = half_outline(input, width/2., miter, join); + Geom::Path against_dir = half_outline(input.reverse(), width/2., miter, join); + + res.moveTo(with_dir[0].initialPoint()); + res.append(with_dir); + + // glue caps + if (!input.closed()) { + switch (butt) { + case BUTT_ROUND: + res.arcTo((-width) / 2., (-width) / 2., 0., true, true, against_dir.initialPoint()); + break; + case BUTT_SQUARE: { + Geom::Point end_deriv = -Geom::unitTangentAt(Geom::reverse(input[input.size()-1].toSBasis()), 0.); + double radius = 0.5 * Geom::distance(with_dir.finalPoint(), against_dir.initialPoint()); + res.lineTo(with_dir.finalPoint() + end_deriv*radius); + res.lineTo(against_dir.initialPoint() + end_deriv*radius); + res.lineTo(against_dir.initialPoint()); + break; + } + case BUTT_PEAK: { + Geom::Point end_deriv = -Geom::unitTangentAt(Geom::reverse(input[input.size()-1].toSBasis()), 0.); + double radius = 0.5 * Geom::distance(with_dir.finalPoint(), against_dir.initialPoint()); + Geom::Point midpoint = ((with_dir.finalPoint() + against_dir.initialPoint()) * 0.5) + end_deriv*radius; + res.lineTo(midpoint); + res.lineTo(against_dir.initialPoint()); + break; + } + case BUTT_FLAT: + default: + res.lineTo(against_dir.initialPoint()); + break; + } + } else { + res.moveTo(against_dir.initialPoint()); + } + + res.append(against_dir); + + if (!input.closed()) { + switch(butt) { + case BUTT_ROUND: + res.arcTo((-width) / 2., (-width) / 2., 0., true, true, with_dir.initialPoint()); + break; + case BUTT_SQUARE: { + Geom::Point end_deriv = -input[0].unitTangentAt(0.); + double radius = 0.5 * Geom::distance(against_dir.finalPoint(), with_dir.initialPoint()); + res.lineTo(against_dir.finalPoint() + end_deriv*radius); + res.lineTo(with_dir.initialPoint() + end_deriv*radius); + res.lineTo(with_dir.initialPoint()); + break; + } + case BUTT_PEAK: { + Geom::Point end_deriv = -input[0].unitTangentAt(0.); + double radius = 0.5 * Geom::distance(against_dir.finalPoint(), with_dir.initialPoint()); + Geom::Point midpoint = ((against_dir.finalPoint() + with_dir.initialPoint()) * 0.5) + end_deriv*radius; + res.lineTo(midpoint); + res.lineTo(with_dir.initialPoint()); + break; + } + case BUTT_FLAT: + default: + res.lineTo(with_dir.initialPoint()); + } + res.closePath(); + } + + res.flush(); + return res.peek(); +} + +Geom::Path half_outline(Geom::Path const& input, double width, double miter, LineJoinType join) +{ + Geom::Path res; + if (input.size() == 0) return res; + + Geom::Point tang1 = input[0].unitTangentAt(0); + Geom::Point start = input.initialPoint() + tang1 * width; + Geom::Path temp; + + res.start(start); + + // Do two curves at a time for efficiency, since the join function needs to know the outgoing curve as well + const size_t k = input.size(); + for (size_t u = 0; u < k; u += 2) { + temp = Geom::Path(); + + offset_curve(temp, &input[u], width); + + // on the first run through, there isn't a join + if (u == 0) { + res.append(temp); + } else { + outline_helper(res, temp, width, miter, join); + } + + // odd number of paths + if (u < k - 1) { + temp = Geom::Path(); + offset_curve(temp, &input[u+1], width); + outline_helper(res, temp, width, miter, join); + } + } + + if (input.closed()) { + Geom::Curve const &c1 = res[res.size()-1]; + Geom::Curve const &c2 = res[0]; + temp = Geom::Path(); + temp.append(c1); + Geom::Path temp2; + temp2.append(c2); + outline_helper(temp, temp2, width, miter, join); + temp.erase_last(); // we already outlined c2 + temp.erase(temp.begin()); // we already outlined c1 + + // + res.append(temp); + } + + res.close(); + return res; +} + +} // namespace Inkscape + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8 : diff --git a/src/helper/geom-pathstroke.h b/src/helper/geom-pathstroke.h new file mode 100644 index 000000000..fe79e2777 --- /dev/null +++ b/src/helper/geom-pathstroke.h @@ -0,0 +1,57 @@ +#ifndef INKSCAPE_HELPER_PATH_STROKE_H +#define INKSCAPE_HELPER_PATH_STROKE_H + +/* Author: + * Liam P. White + * + * Copyright (C) 2014-2015 Author + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#include <2geom/path.h> +#include <2geom/pathvector.h> + +namespace Inkscape { + +enum LineJoinType { + JOIN_BEVEL, + JOIN_ROUND, + JOIN_MITER, + JOIN_EXTRAPOLATE, +}; + +enum LineCapType { + BUTT_FLAT, + BUTT_ROUND, + BUTT_SQUARE, + BUTT_PEAK, // ? +}; + +/** + * Offset the input path by @a width. + * Joins may behave oddly if the width is negative. + * + * @param input + * @param width Amount to offset. + * @param miter Miter limit. Only used with JOIN_EXTRAPOLATE and JOIN_MITER. + * @param join + */ +Geom::Path half_outline(Geom::Path const& input, double width, double miter, LineJoinType join = JOIN_BEVEL); + +Geom::PathVector outline(Geom::Path const& input, double width, double miter, LineJoinType join = JOIN_BEVEL, LineCapType cap = BUTT_FLAT); + +} // namespace Inkscape + +#endif // INKSCAPE_HELPER_PATH_STROKE_H + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8 : diff --git a/src/live_effects/lpe-jointype.cpp b/src/live_effects/lpe-jointype.cpp index bf2526986..291337da0 100644 --- a/src/live_effects/lpe-jointype.cpp +++ b/src/live_effects/lpe-jointype.cpp @@ -8,7 +8,7 @@ */ #include "live_effects/parameter/enum.h" -#include "live_effects/pathoutlineprovider.h" +#include "helper/geom-pathstroke.h" #include "sp-shape.h" #include "style.h" @@ -28,19 +28,18 @@ namespace Inkscape { namespace LivePathEffect { static const Util::EnumData JoinTypeData[] = { - {LINEJOIN_STRAIGHT, N_("Beveled"), "bevel"}, - {LINEJOIN_ROUND, N_("Rounded"), "round"}, - {LINEJOIN_POINTY, N_("Miter"), "miter"}, - {LINEJOIN_REFLECTED, N_("Reflected"), "extrapolated"}, - {LINEJOIN_EXTRAPOLATED, N_("Extrapolated arc"), "extrp_arc"} + {JOIN_BEVEL, N_("Beveled"), "bevel"}, + {JOIN_ROUND, N_("Rounded"), "round"}, + {JOIN_MITER, N_("Miter"), "miter"}, + {JOIN_EXTRAPOLATE, N_("Extrapolated arc"), "extrp_arc"}, }; static const Util::EnumData CapTypeData[] = { - {BUTT_STRAIGHT, N_("Butt"), "butt"}, + {BUTT_FLAT, N_("Butt"), "butt"}, {BUTT_ROUND, N_("Rounded"), "round"}, {BUTT_SQUARE, N_("Square"), "square"}, - {BUTT_POINTY, N_("Peak"), "peak"}, - {BUTT_LEANED, N_("Leaned"), "leaned"} + {BUTT_PEAK, N_("Peak"), "peak"}, + //{BUTT_LEANED, N_("Leaned"), "leaned"} }; static const Util::EnumDataConverter CapTypeConverter(CapTypeData, sizeof(CapTypeData)/sizeof(*CapTypeData)); @@ -50,9 +49,9 @@ LPEJoinType::LPEJoinType(LivePathEffectObject *lpeobject) : Effect(lpeobject), line_width(_("Line width"), _("Thickness of the stroke"), "line_width", &wr, this, 1.), linecap_type(_("Line cap"), _("The end shape of the stroke"), "linecap_type", CapTypeConverter, &wr, this, butt_straight), - linejoin_type(_("Join:"), _("Determines the shape of the path's corners"), "linejoin_type", JoinTypeConverter, &wr, this, LINEJOIN_EXTRAPOLATED), - start_lean(_("Start path lean"), _("Start path lean"), "start_lean", &wr, this, 0.), - end_lean(_("End path lean"), _("End path lean"), "end_lean", &wr, this, 0.), + linejoin_type(_("Join:"), _("Determines the shape of the path's corners"), "linejoin_type", JoinTypeConverter, &wr, this, JOIN_EXTRAPOLATE), + //start_lean(_("Start path lean"), _("Start path lean"), "start_lean", &wr, this, 0.), + //end_lean(_("End path lean"), _("End path lean"), "end_lean", &wr, this, 0.), miter_limit(_("Miter limit:"), _("Maximum length of the miter join (in units of stroke width)"), "miter_limit", &wr, this, 100.), attempt_force_join(_("Force miter"), _("Overrides the miter limit and forces a join."), "attempt_force_join", &wr, this, true) { @@ -60,17 +59,17 @@ LPEJoinType::LPEJoinType(LivePathEffectObject *lpeobject) : registerParameter(&linecap_type); registerParameter(&line_width); registerParameter(&linejoin_type); - registerParameter(&start_lean); - registerParameter(&end_lean); + //registerParameter(&start_lean); + //registerParameter(&end_lean); registerParameter(&miter_limit); registerParameter(&attempt_force_join); was_initialized = false; - start_lean.param_set_range(-1,1); - start_lean.param_set_increments(0.1, 0.1); - start_lean.param_set_digits(4); - end_lean.param_set_range(-1,1); - end_lean.param_set_increments(0.1, 0.1); - end_lean.param_set_digits(4); + //start_lean.param_set_range(-1,1); + //start_lean.param_set_increments(0.1, 0.1); + //start_lean.param_set_digits(4); + //end_lean.param_set_range(-1,1); + //end_lean.param_set_increments(0.1, 0.1); + //end_lean.param_set_digits(4); } LPEJoinType::~LPEJoinType() @@ -164,15 +163,18 @@ void LPEJoinType::doOnRemove(SPLPEItem const* lpeitem) } } -// NOTE: I originally had all the outliner functions defined in here, but they were actually useful -// enough for other LPEs so I moved them all into pathoutlineprovider.cpp. The code here is just a -// wrapper around it. std::vector LPEJoinType::doEffect_path(std::vector const & path_in) { - return Outline::PathVectorOutline(path_in, line_width, static_cast(linecap_type.get_value()), - static_cast(linejoin_type.get_value()), - (attempt_force_join ? std::numeric_limits::max() : miter_limit), - start_lean/2 ,end_lean/2); + Geom::PathVector ret; + for (size_t i = 0; i < path_in.size(); ++i) { + Geom::PathVector tmp = Inkscape::outline(path_in[i], line_width, + (attempt_force_join ? std::numeric_limits::max() : miter_limit), + static_cast(linejoin_type.get_value()), + static_cast(linecap_type.get_value())); + ret.insert(ret.begin(), tmp.begin(), tmp.end()); + } + + return ret; } } // namespace LivePathEffect diff --git a/src/live_effects/lpe-jointype.h b/src/live_effects/lpe-jointype.h index 73705666d..799901eb6 100644 --- a/src/live_effects/lpe-jointype.h +++ b/src/live_effects/lpe-jointype.h @@ -33,8 +33,8 @@ private: ScalarParam line_width; EnumParam linecap_type; EnumParam linejoin_type; - ScalarParam start_lean; - ScalarParam end_lean; + //ScalarParam start_lean; + //ScalarParam end_lean; ScalarParam miter_limit; BoolParam attempt_force_join; bool was_initialized; -- cgit v1.2.3 From 79d7d2355d907094557d814602cb043a77a32dfe Mon Sep 17 00:00:00 2001 From: Bryce Harrington Date: Wed, 18 Mar 2015 18:52:34 -0700 Subject: packaging: Show details about failures in bug updating (bzr r14015) --- packaging/scripts/lp-mark-bugs-released | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/packaging/scripts/lp-mark-bugs-released b/packaging/scripts/lp-mark-bugs-released index f18f1468a..7e936213d 100755 --- a/packaging/scripts/lp-mark-bugs-released +++ b/packaging/scripts/lp-mark-bugs-released @@ -21,7 +21,7 @@ import tempfile from launchpadlib.launchpad import Launchpad from launchpadlib.errors import HTTPError -opt_dry_run = True +opt_dry_run = False def mark_released (bug): if bug.status == 'Fix Committed': @@ -68,7 +68,9 @@ def main(): mark_released(task) except HTTPError, error: - print 'An error happened in the upload:', error.content + print 'An error happened in the upload: %s\n%s' %( + error.content, + error.__dict__) sys.exit(1) if __name__ == '__main__': -- cgit v1.2.3 From 8fe962f4de79592f7df62c3ec08f98cf90757208 Mon Sep 17 00:00:00 2001 From: Bryce Harrington Date: Wed, 18 Mar 2015 18:53:00 -0700 Subject: ui/tools: sp. fixes (cosmetic) (bzr r14016) --- src/ui/tools/box3d-tool.h | 2 +- src/ui/tools/connector-tool.cpp | 2 +- src/ui/tools/dynamic-base.h | 2 +- src/ui/tools/gradient-tool.cpp | 2 +- src/ui/tools/node-tool.cpp | 2 +- src/ui/tools/pen-tool.cpp | 4 ++-- src/ui/tools/spray-tool.cpp | 2 +- 7 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/ui/tools/box3d-tool.h b/src/ui/tools/box3d-tool.h index 1dd6bb5f8..33ae6d8e7 100644 --- a/src/ui/tools/box3d-tool.h +++ b/src/ui/tools/box3d-tool.h @@ -80,7 +80,7 @@ private: Proj::Pt3 drag_ptC_proj; bool ctrl_dragged; /* whether we are ctrl-dragging */ - bool extruded; /* whether shift-dragging already occured (i.e. the box is already extruded) */ + bool extruded; /* whether shift-dragging already occurred (i.e. the box is already extruded) */ sigc::connection sel_changed_connection; diff --git a/src/ui/tools/connector-tool.cpp b/src/ui/tools/connector-tool.cpp index d76b0d142..c3ef19507 100644 --- a/src/ui/tools/connector-tool.cpp +++ b/src/ui/tools/connector-tool.cpp @@ -49,7 +49,7 @@ * Much of the way connectors work for user-defined points has been * changed so that it no longer defines special attributes to record * the points. Instead it uses single node paths to define points - * who are then seperate objects that can be fixed on the canvas, + * who are then separate objects that can be fixed on the canvas, * grouped into objects and take full advantage of all transform, snap * and align functionality of all other objects. * diff --git a/src/ui/tools/dynamic-base.h b/src/ui/tools/dynamic-base.h index c948fa286..095af8f88 100644 --- a/src/ui/tools/dynamic-base.h +++ b/src/ui/tools/dynamic-base.h @@ -47,7 +47,7 @@ protected: /** accumulated shape which ultimately goes in svg:path */ SPCurve *accumulated; - /** canvas items for "comitted" segments */ + /** canvas items for "committed" segments */ GSList *segments; /** canvas item for red "leading" segment */ diff --git a/src/ui/tools/gradient-tool.cpp b/src/ui/tools/gradient-tool.cpp index 5be84eb76..b27859ebb 100644 --- a/src/ui/tools/gradient-tool.cpp +++ b/src/ui/tools/gradient-tool.cpp @@ -321,7 +321,7 @@ sp_gradient_context_add_stops_between_selected_stops (GradientTool *rc) if (d->point_type == POINT_RG_FOCUS) { /* * There are 2 draggables at the center (start) of a radial gradient - * To avoid creating 2 seperate stops, ignore this draggable point type + * To avoid creating 2 separate stops, ignore this draggable point type */ continue; } diff --git a/src/ui/tools/node-tool.cpp b/src/ui/tools/node-tool.cpp index f8045a029..a4b903960 100644 --- a/src/ui/tools/node-tool.cpp +++ b/src/ui/tools/node-tool.cpp @@ -75,7 +75,7 @@ * - ControlPointSelection: keeps track of node selection and a set of nodes that can potentially * be selected. There can be more than one selection. Performs actions that require no * knowledge about the path, only about the nodes, like dragging and transforms. It is not - * specific to nodes and can accomodate any control point derived from SelectableControlPoint. + * specific to nodes and can accommodate any control point derived from SelectableControlPoint. * Transforms nodes in response to transform handle events. * - TransformHandleSet: displays nodeset transform handles and emits transform events. The aim * is to eventually use a common class for object and control point transforms. diff --git a/src/ui/tools/pen-tool.cpp b/src/ui/tools/pen-tool.cpp index d28b7c27a..d5f501163 100644 --- a/src/ui/tools/pen-tool.cpp +++ b/src/ui/tools/pen-tool.cpp @@ -2143,7 +2143,7 @@ bool PenTool::_undoLastPoint() { this->p[1] = this->p[0]; } - // asign the value in a third of the distance of the last segment. + // assign the value in a third of the distance of the last segment. if (this->bspline){ this->p[1] = this->p[0] + (1./3)*(this->p[3] - this->p[0]); } @@ -2165,7 +2165,7 @@ bool PenTool::_undoLastPoint() { this->green_curve->backspace(); } - // assign the value of this->p[1] to the oposite of the green line last segment + // assign the value of this->p[1] to the opposite of the green line last segment if (this->spiro){ Geom::CubicBezier const *cubic = dynamic_cast(this->green_curve->last_segment()); if ( cubic ) { diff --git a/src/ui/tools/spray-tool.cpp b/src/ui/tools/spray-tool.cpp index ec7d10e13..0399b1e55 100644 --- a/src/ui/tools/spray-tool.cpp +++ b/src/ui/tools/spray-tool.cpp @@ -406,7 +406,7 @@ static bool sp_spray_recursive(SPDesktop *desktop, parent->appendChild(copy); SPObject *new_obj = doc->getObjectByRepr(copy); - item_copied = dynamic_cast(new_obj); // Convertion object->item + item_copied = dynamic_cast(new_obj); // Conversion object->item Geom::Point center=item->getCenter(); sp_spray_scale_rel(center,desktop, item_copied, Geom::Scale(_scale,_scale)); sp_spray_scale_rel(center,desktop, item_copied, Geom::Scale(scale,scale)); -- cgit v1.2.3 From 2c6f909f381a31d7de1245debcdde92f36e94d30 Mon Sep 17 00:00:00 2001 From: "Liam P. White" Date: Thu, 19 Mar 2015 20:58:14 -0400 Subject: Fix remaining bugs in path outliner (bzr r14017) --- src/helper/geom-pathstroke.cpp | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/src/helper/geom-pathstroke.cpp b/src/helper/geom-pathstroke.cpp index f41732a51..1b8f90104 100644 --- a/src/helper/geom-pathstroke.cpp +++ b/src/helper/geom-pathstroke.cpp @@ -66,7 +66,7 @@ void bevel_join(Geom::Path& res, Geom::Curve const& outgoing, double /*miter*/, void round_join(Geom::Path& res, Geom::Curve const& outgoing, double /*miter*/, double width) { - res.appendNew(width, width, 0, false, width > 0, outgoing.initialPoint()); + res.appendNew(width, width, 0, false, width <= 0, outgoing.initialPoint()); } void miter_join(Geom::Path& res, Geom::Curve const& outgoing, double miter, double width) @@ -318,7 +318,7 @@ void offset_quadratic(Geom::Path& p, Geom::QuadraticBezier const& bez, double wi std::vector points = bez.points(); Geom::Point b1 = points[0] + (2./3) * (points[1] - points[0]); Geom::Point b2 = b1 + (1./3) * (points[2] - points[0]); - Geom::CubicBezier cub = Geom::CubicBezier(points[0], b1, b2, points[3]); + Geom::CubicBezier cub = Geom::CubicBezier(points[0], b1, b2, points[2]); offset_cubic(p, cub, width, tol, levels); } @@ -378,7 +378,7 @@ Geom::PathVector outline(Geom::Path const& input, double width, double miter, Li if (!input.closed()) { switch (butt) { case BUTT_ROUND: - res.arcTo((-width) / 2., (-width) / 2., 0., true, true, against_dir.initialPoint()); + res.arcTo(width / 2., width / 2., 0., true, false, against_dir.initialPoint()); break; case BUTT_SQUARE: { Geom::Point end_deriv = -Geom::unitTangentAt(Geom::reverse(input[input.size()-1].toSBasis()), 0.); @@ -410,7 +410,7 @@ Geom::PathVector outline(Geom::Path const& input, double width, double miter, Li if (!input.closed()) { switch(butt) { case BUTT_ROUND: - res.arcTo((-width) / 2., (-width) / 2., 0., true, true, with_dir.initialPoint()); + res.arcTo(width / 2., width / 2., 0., true, false, with_dir.initialPoint()); break; case BUTT_SQUARE: { Geom::Point end_deriv = -input[0].unitTangentAt(0.); @@ -451,7 +451,7 @@ Geom::Path half_outline(Geom::Path const& input, double width, double miter, Lin res.start(start); // Do two curves at a time for efficiency, since the join function needs to know the outgoing curve as well - const size_t k = input.size(); + const size_t k = input.size_default(); for (size_t u = 0; u < k; u += 2) { temp = Geom::Path(); @@ -473,8 +473,13 @@ Geom::Path half_outline(Geom::Path const& input, double width, double miter, Lin } if (input.closed()) { - Geom::Curve const &c1 = res[res.size()-1]; - Geom::Curve const &c2 = res[0]; + if (input.back_closed().isDegenerate()) { + res.erase_last(); + res.erase_last(); // ? + } + + Geom::Curve const &c1 = res.back(); + Geom::Curve const &c2 = res.front(); temp = Geom::Path(); temp.append(c1); Geom::Path temp2; @@ -485,9 +490,9 @@ Geom::Path half_outline(Geom::Path const& input, double width, double miter, Lin // res.append(temp); + res.close(); } - res.close(); return res; } -- cgit v1.2.3 From 5f452e2604d96a028325493da3b704e7dfe08250 Mon Sep 17 00:00:00 2001 From: "Liam P. White" Date: Thu, 19 Mar 2015 21:25:41 -0400 Subject: (audible sound of head banging off wall) Fix that one thing (bzr r14018) --- src/live_effects/lpe-jointype.cpp | 10 ++---- src/live_effects/lpe-powerstroke.cpp | 33 +++++++++---------- src/live_effects/lpe-taperstroke.cpp | 61 ++++++++++++++++-------------------- 3 files changed, 45 insertions(+), 59 deletions(-) diff --git a/src/live_effects/lpe-jointype.cpp b/src/live_effects/lpe-jointype.cpp index 291337da0..033128d98 100644 --- a/src/live_effects/lpe-jointype.cpp +++ b/src/live_effects/lpe-jointype.cpp @@ -81,7 +81,6 @@ LPEJoinType::~LPEJoinType() void LPEJoinType::doOnApply(SPLPEItem const* lpeitem) { - if (SP_IS_SHAPE(lpeitem)) { SPLPEItem* item = const_cast(lpeitem); double width = (lpeitem && lpeitem->style) ? lpeitem->style->stroke_width.computed : 1.; @@ -107,6 +106,7 @@ void LPEJoinType::doOnApply(SPLPEItem const* lpeitem) sp_repr_css_unset_property (css, "fill"); } + sp_repr_css_set_property(css, "fill-rule", "nonzero"); sp_repr_css_set_property(css, "stroke", "none"); sp_desktop_apply_css_recursive(item, css, true); @@ -116,17 +116,13 @@ void LPEJoinType::doOnApply(SPLPEItem const* lpeitem) was_initialized = true; line_width.param_set_value(width); } - } else { - g_warning("LPE Join Type can only be applied to paths (not groups)."); - } } //from LPEPowerStroke -- sets stroke color from existing fill color void LPEJoinType::doOnRemove(SPLPEItem const* lpeitem) { - - if (SP_IS_SHAPE(lpeitem)) { + if (SP_IS_SHAPE(lpeitem)) { // does this check even make sense? SPLPEItem *item = const_cast(lpeitem); SPCSSAttr *css = sp_repr_css_attr_new (); @@ -142,7 +138,7 @@ void LPEJoinType::doOnRemove(SPLPEItem const* lpeitem) } } else if (lpeitem->style->fill.isColor()) { gchar c[64]; - sp_svg_write_color (c, sizeof(c), lpeitem->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->stroke_opacity.value))); + sp_svg_write_color (c, sizeof(c), lpeitem->style->fill.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->fill_opacity.value))); sp_repr_css_set_property (css, "stroke", c); } else { sp_repr_css_set_property (css, "stroke", "none"); diff --git a/src/live_effects/lpe-powerstroke.cpp b/src/live_effects/lpe-powerstroke.cpp index f7fe9592d..5d9d224e8 100644 --- a/src/live_effects/lpe-powerstroke.cpp +++ b/src/live_effects/lpe-powerstroke.cpp @@ -297,7 +297,8 @@ LPEPowerStroke::doOnApply(SPLPEItem const* lpeitem) } else { sp_repr_css_unset_property (css, "fill"); } - + + sp_repr_css_set_property(css, "fill-rule", "nonzero"); sp_repr_css_set_property(css, "stroke", "none"); sp_desktop_apply_css_recursive(item, css, true); @@ -330,25 +331,21 @@ void LPEPowerStroke::doOnRemove(SPLPEItem const* lpeitem) if (SP_IS_SHAPE(lpeitem)) { SPLPEItem *item = const_cast(lpeitem); SPCSSAttr *css = sp_repr_css_attr_new (); - if (true) { - if (lpeitem->style->fill.isPaintserver()) { - SPPaintServer * server = lpeitem->style->getFillPaintServer(); - if (server) { - Glib::ustring str; - str += "url(#"; - str += server->getId(); - str += ")"; - sp_repr_css_set_property (css, "stroke", str.c_str()); - } - } else if (lpeitem->style->fill.isColor()) { - gchar c[64]; - sp_svg_write_color (c, sizeof(c), lpeitem->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->stroke_opacity.value))); - sp_repr_css_set_property (css, "stroke", c); - } else { - sp_repr_css_set_property (css, "stroke", "none"); + if (lpeitem->style->fill.isPaintserver()) { + SPPaintServer * server = lpeitem->style->getFillPaintServer(); + if (server) { + Glib::ustring str; + str += "url(#"; + str += server->getId(); + str += ")"; + sp_repr_css_set_property (css, "stroke", str.c_str()); } + } else if (lpeitem->style->fill.isColor()) { + char c[64] = {0}; + sp_svg_write_color (c, sizeof(c), lpeitem->style->fill.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->fill_opacity.value))); + sp_repr_css_set_property (css, "stroke", c); } else { - sp_repr_css_unset_property (css, "stroke"); + sp_repr_css_set_property (css, "stroke", "none"); } Inkscape::CSSOStringStream os; diff --git a/src/live_effects/lpe-taperstroke.cpp b/src/live_effects/lpe-taperstroke.cpp index 7a024147c..9feb650af 100644 --- a/src/live_effects/lpe-taperstroke.cpp +++ b/src/live_effects/lpe-taperstroke.cpp @@ -102,27 +102,24 @@ void LPETaperStroke::doOnApply(SPLPEItem const* lpeitem) double width = (lpeitem && lpeitem->style) ? lpeitem->style->stroke_width.computed : 1.; SPCSSAttr *css = sp_repr_css_attr_new (); - if (true) { - if (lpeitem->style->stroke.isPaintserver()) { - SPPaintServer * server = lpeitem->style->getStrokePaintServer(); - if (server) { - Glib::ustring str; - str += "url(#"; - str += server->getId(); - str += ")"; - sp_repr_css_set_property (css, "fill", str.c_str()); - } - } else if (lpeitem->style->stroke.isColor()) { - gchar c[64]; - sp_svg_write_color (c, sizeof(c), lpeitem->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->stroke_opacity.value))); - sp_repr_css_set_property (css, "fill", c); - } else { - sp_repr_css_set_property (css, "fill", "none"); + if (lpeitem->style->stroke.isPaintserver()) { + SPPaintServer * server = lpeitem->style->getStrokePaintServer(); + if (server) { + Glib::ustring str; + str += "url(#"; + str += server->getId(); + str += ")"; + sp_repr_css_set_property (css, "fill", str.c_str()); } + } else if (lpeitem->style->stroke.isColor()) { + gchar c[64]; + sp_svg_write_color (c, sizeof(c), lpeitem->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->stroke_opacity.value))); + sp_repr_css_set_property (css, "fill", c); } else { - sp_repr_css_unset_property (css, "fill"); + sp_repr_css_set_property (css, "fill", "none"); } + sp_repr_css_set_property(css, "fill-rule", "nonzero"); sp_repr_css_set_property(css, "stroke", "none"); sp_desktop_apply_css_recursive(item, css, true); @@ -142,25 +139,21 @@ void LPETaperStroke::doOnRemove(SPLPEItem const* lpeitem) SPLPEItem *item = const_cast(lpeitem); SPCSSAttr *css = sp_repr_css_attr_new (); - if (true) { - if (lpeitem->style->fill.isPaintserver()) { - SPPaintServer * server = lpeitem->style->getFillPaintServer(); - if (server) { - Glib::ustring str; - str += "url(#"; - str += server->getId(); - str += ")"; - sp_repr_css_set_property (css, "stroke", str.c_str()); - } - } else if (lpeitem->style->fill.isColor()) { - gchar c[64]; - sp_svg_write_color (c, sizeof(c), lpeitem->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->stroke_opacity.value))); - sp_repr_css_set_property (css, "stroke", c); - } else { - sp_repr_css_set_property (css, "stroke", "none"); + if (lpeitem->style->fill.isPaintserver()) { + SPPaintServer * server = lpeitem->style->getFillPaintServer(); + if (server) { + Glib::ustring str; + str += "url(#"; + str += server->getId(); + str += ")"; + sp_repr_css_set_property (css, "stroke", str.c_str()); } + } else if (lpeitem->style->fill.isColor()) { + gchar c[64]; + sp_svg_write_color (c, sizeof(c), lpeitem->style->fill.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->fill_opacity.value))); + sp_repr_css_set_property (css, "stroke", c); } else { - sp_repr_css_unset_property (css, "stroke"); + sp_repr_css_set_property (css, "stroke", "none"); } Inkscape::CSSOStringStream os; -- cgit v1.2.3 From f711db46d6e23da2b808f555bb446f18662840d9 Mon Sep 17 00:00:00 2001 From: "Liam P. White" Date: Thu, 19 Mar 2015 21:30:33 -0400 Subject: nop (if true etc) (bzr r14019) --- src/live_effects/lpe-jointype.cpp | 68 ++++++++++++++++++--------------------- 1 file changed, 31 insertions(+), 37 deletions(-) diff --git a/src/live_effects/lpe-jointype.cpp b/src/live_effects/lpe-jointype.cpp index 033128d98..09869822c 100644 --- a/src/live_effects/lpe-jointype.cpp +++ b/src/live_effects/lpe-jointype.cpp @@ -81,29 +81,26 @@ LPEJoinType::~LPEJoinType() void LPEJoinType::doOnApply(SPLPEItem const* lpeitem) { + if (SP_IS_SHAPE(lpeitem)) { SPLPEItem* item = const_cast(lpeitem); double width = (lpeitem && lpeitem->style) ? lpeitem->style->stroke_width.computed : 1.; SPCSSAttr *css = sp_repr_css_attr_new (); - if (true) { - if (lpeitem->style->stroke.isPaintserver()) { - SPPaintServer * server = lpeitem->style->getStrokePaintServer(); - if (server) { - Glib::ustring str; - str += "url(#"; - str += server->getId(); - str += ")"; - sp_repr_css_set_property (css, "fill", str.c_str()); - } - } else if (lpeitem->style->stroke.isColor()) { - gchar c[64]; - sp_svg_write_color (c, sizeof(c), lpeitem->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->stroke_opacity.value))); - sp_repr_css_set_property (css, "fill", c); - } else { - sp_repr_css_set_property (css, "fill", "none"); + if (lpeitem->style->stroke.isPaintserver()) { + SPPaintServer * server = lpeitem->style->getStrokePaintServer(); + if (server) { + Glib::ustring str; + str += "url(#"; + str += server->getId(); + str += ")"; + sp_repr_css_set_property (css, "fill", str.c_str()); } + } else if (lpeitem->style->stroke.isColor()) { + gchar c[64]; + sp_svg_write_color (c, sizeof(c), lpeitem->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->stroke_opacity.value))); + sp_repr_css_set_property (css, "fill", c); } else { - sp_repr_css_unset_property (css, "fill"); + sp_repr_css_set_property (css, "fill", "none"); } sp_repr_css_set_property(css, "fill-rule", "nonzero"); @@ -111,40 +108,37 @@ void LPEJoinType::doOnApply(SPLPEItem const* lpeitem) sp_desktop_apply_css_recursive(item, css, true); sp_repr_css_attr_unref (css); - if (!was_initialized) - { + + if (!was_initialized) { was_initialized = true; line_width.param_set_value(width); } + } } //from LPEPowerStroke -- sets stroke color from existing fill color void LPEJoinType::doOnRemove(SPLPEItem const* lpeitem) { - if (SP_IS_SHAPE(lpeitem)) { // does this check even make sense? + if (SP_IS_SHAPE(lpeitem)) { SPLPEItem *item = const_cast(lpeitem); SPCSSAttr *css = sp_repr_css_attr_new (); - if (true) { - if (lpeitem->style->fill.isPaintserver()) { - SPPaintServer * server = lpeitem->style->getFillPaintServer(); - if (server) { - Glib::ustring str; - str += "url(#"; - str += server->getId(); - str += ")"; - sp_repr_css_set_property (css, "stroke", str.c_str()); - } - } else if (lpeitem->style->fill.isColor()) { - gchar c[64]; - sp_svg_write_color (c, sizeof(c), lpeitem->style->fill.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->fill_opacity.value))); - sp_repr_css_set_property (css, "stroke", c); - } else { - sp_repr_css_set_property (css, "stroke", "none"); + if (lpeitem->style->fill.isPaintserver()) { + SPPaintServer * server = lpeitem->style->getFillPaintServer(); + if (server) { + Glib::ustring str; + str += "url(#"; + str += server->getId(); + str += ")"; + sp_repr_css_set_property (css, "stroke", str.c_str()); } + } else if (lpeitem->style->fill.isColor()) { + gchar c[64]; + sp_svg_write_color (c, sizeof(c), lpeitem->style->fill.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->fill_opacity.value))); + sp_repr_css_set_property (css, "stroke", c); } else { - sp_repr_css_unset_property (css, "stroke"); + sp_repr_css_set_property (css, "stroke", "none"); } Inkscape::CSSOStringStream os; -- cgit v1.2.3 From 9585f670efe431bb89ccda9a45c322089826fe3d Mon Sep 17 00:00:00 2001 From: "Liam P. White" Date: Thu, 19 Mar 2015 21:56:01 -0400 Subject: take out the trash (bzr r14020) --- src/live_effects/Makefile_insert | 2 - src/live_effects/lpe-taperstroke.cpp | 43 +- src/live_effects/pathoutlineprovider.cpp | 803 ------------------------------- src/live_effects/pathoutlineprovider.h | 55 --- 4 files changed, 30 insertions(+), 873 deletions(-) delete mode 100644 src/live_effects/pathoutlineprovider.cpp delete mode 100644 src/live_effects/pathoutlineprovider.h diff --git a/src/live_effects/Makefile_insert b/src/live_effects/Makefile_insert index 8f0a3ac57..dace45739 100644 --- a/src/live_effects/Makefile_insert +++ b/src/live_effects/Makefile_insert @@ -109,8 +109,6 @@ ink_common_sources += \ live_effects/lpe-fill-between-many.h \ live_effects/lpe-ellipse_5pts.cpp \ live_effects/lpe-ellipse_5pts.h \ - live_effects/pathoutlineprovider.cpp \ - live_effects/pathoutlineprovider.h \ live_effects/lpe-jointype.cpp \ live_effects/lpe-jointype.h \ live_effects/lpe-taperstroke.cpp \ diff --git a/src/live_effects/lpe-taperstroke.cpp b/src/live_effects/lpe-taperstroke.cpp index 9feb650af..d54b2acc0 100644 --- a/src/live_effects/lpe-taperstroke.cpp +++ b/src/live_effects/lpe-taperstroke.cpp @@ -19,7 +19,8 @@ #include <2geom/circle.h> #include <2geom/sbasis-to-bezier.h> -#include "pathoutlineprovider.h" +#include "helper/geom-nodetype.h" +#include "helper/geom-pathstroke.h" #include "display/curve.h" #include "sp-shape.h" #include "style.h" @@ -60,11 +61,10 @@ namespace TpS { } // TpS static const Util::EnumData JoinType[] = { - {LINEJOIN_STRAIGHT, N_("Beveled"), "bevel"}, - {LINEJOIN_ROUND, N_("Rounded"), "round"}, - {LINEJOIN_REFLECTED, N_("Reflected"), "reflected"}, - {LINEJOIN_POINTY, N_("Miter"), "miter"}, - {LINEJOIN_EXTRAPOLATED, N_("Extrapolated"), "extrapolated"} + {JOIN_BEVEL, N_("Beveled"), "bevel"}, + {JOIN_ROUND, N_("Rounded"), "round"}, + {JOIN_MITER, N_("Miter"), "miter"}, + {JOIN_EXTRAPOLATE, N_("Extrapolated"), "extrapolated"}, }; static const Util::EnumDataConverter JoinTypeConverter(JoinType, sizeof (JoinType)/sizeof(*JoinType)); @@ -75,7 +75,7 @@ LPETaperStroke::LPETaperStroke(LivePathEffectObject *lpeobject) : attach_start(_("Start offset:"), _("Taper distance from path start"), "attach_start", &wr, this, 0.2), attach_end(_("End offset:"), _("The ending position of the taper"), "end_offset", &wr, this, 0.2), smoothing(_("Taper smoothing:"), _("Amount of smoothing to apply to the tapers"), "smoothing", &wr, this, 0.5), - join_type(_("Join type:"), _("Join type for non-smooth nodes"), "jointype", JoinTypeConverter, &wr, this, LINEJOIN_EXTRAPOLATED), + join_type(_("Join type:"), _("Join type for non-smooth nodes"), "jointype", JoinTypeConverter, &wr, this, JOIN_EXTRAPOLATE), miter_limit(_("Miter limit:"), _("Limit for miter joins"), "miter_limit", &wr, this, 100.) { show_orig_path = true; @@ -127,7 +127,7 @@ void LPETaperStroke::doOnApply(SPLPEItem const* lpeitem) line_width.param_set_value(width); } else { - printf("WARNING: It only makes sense to apply Join Type to paths (not groups).\n"); + printf("WARNING: It only makes sense to apply Taper stroke to paths (not groups).\n"); } } @@ -172,8 +172,25 @@ using Geom::D2; using Geom::SBasis; // leave Geom::Path -Geom::Path return_at_first_cusp(Geom::Path const & path_in, double /*smooth_tolerance*/ = 0.05) { - return Geom::split_at_cusps(path_in)[0]; +static Geom::Path return_at_first_cusp(Geom::Path const & path_in, double /*smooth_tolerance*/ = 0.05) +{ + Geom::Path temp; + + for (unsigned i = 0; i < path_in.size(); i++) { + temp.append(path_in[i]); + if (Geom::get_nodetype(path_in[i], path_in[i + 1]) != Geom::NODE_SMOOTH ) { + break; + } + } + + return temp; +} + +static Geom::CubicBezier sbasis_to_cubicbezier(Geom::D2 const & sbasis_in) +{ + std::vector temp; + Geom::sbasis_to_bezier(temp, sbasis_in, 4); + return Geom::CubicBezier( temp ); } Piecewise > stretch_along(Piecewise > pwd2_in, Geom::Path pattern, double width); @@ -278,7 +295,7 @@ Geom::PathVector LPETaperStroke::doEffect_path(Geom::PathVector const& path_in) // although this seems obvious, it can probably lead to bugs. if (!metInMiddle) { // append the outside outline of the path (goes with the direction of the path) - throwaway_path = Outline::PathOutsideOutline(pathv_out[1], -fabs(line_width), static_cast(join_type.get_value()), miter_limit); + throwaway_path = half_outline(pathv_out[1], -fabs(line_width)/2., miter_limit, static_cast(join_type.get_value())); if (!zeroStart && real_path.size() >= 1 && throwaway_path.size() >= 1) { if (!Geom::are_near(real_path.finalPoint(), throwaway_path.initialPoint())) { real_path.appendNew(throwaway_path.initialPoint()); @@ -310,7 +327,7 @@ Geom::PathVector LPETaperStroke::doEffect_path(Geom::PathVector const& path_in) if (!metInMiddle) { // append the inside outline of the path (against direction) - throwaway_path = Outline::PathOutsideOutline(pathv_out[1].reverse(), -fabs(line_width), static_cast(join_type.get_value()), miter_limit); + throwaway_path = half_outline(pathv_out[1].reverse(), -fabs(line_width)/2., miter_limit, static_cast(join_type.get_value())); if (!Geom::are_near(real_path.finalPoint(), throwaway_path.initialPoint()) && real_path.size() >= 1) { real_path.appendNew(throwaway_path.initialPoint()); @@ -515,7 +532,7 @@ void subdivideCurve(Geom::Curve * curve_in, Geom::Coord t, Geom::Curve *& val_fi val_second = seg_pair.second.duplicate(); } else { // all other cases: - Geom::CubicBezier cubic = Geom::sbasis_to_cubicbezier(curve_in->toSBasis()); + Geom::CubicBezier cubic = sbasis_to_cubicbezier(curve_in->toSBasis()); std::pair cubic_pair = cubic.subdivide(t); val_first = cubic_pair.first.duplicate(); val_second = cubic_pair.second.duplicate(); diff --git a/src/live_effects/pathoutlineprovider.cpp b/src/live_effects/pathoutlineprovider.cpp deleted file mode 100644 index 21a0fb809..000000000 --- a/src/live_effects/pathoutlineprovider.cpp +++ /dev/null @@ -1,803 +0,0 @@ -/* Author: - * Liam P. White - * - * Copyright (C) 2014 Author - * - * Released under GNU GPL, read the file 'COPYING' for more information - */ - -#include <2geom/angle.h> -#include <2geom/path.h> -#include <2geom/circle.h> -#include <2geom/sbasis-to-bezier.h> -#include <2geom/shape.h> -#include <2geom/transforms.h> -#include <2geom/path-sink.h> -#include - -#include "pathoutlineprovider.h" -#include "livarot/path-description.h" -#include "helper/geom-nodetype.h" -#include "svg/svg.h" - -namespace Geom { -/** -* Refer to: Weisstein, Eric W. "Circle-Circle Intersection." - From MathWorld--A Wolfram Web Resource. - http://mathworld.wolfram.com/Circle-CircleIntersection.html -* -* @return 0 if no intersection -* @return 1 if one circle is contained in the other -* @return 2 if intersections are found (they are written to p0 and p1) -*/ -static int circle_circle_intersection(Circle const &circle0, Circle const &circle1, Point & p0, Point & p1) -{ - Point X0 = circle0.center(); - double r0 = circle0.ray(); - Point X1 = circle1.center(); - double r1 = circle1.ray(); - - /* dx and dy are the vertical and horizontal distances between - * the circle centers. - */ - Point D = X1 - X0; - - /* Determine the straight-line distance between the centers. */ - double d = L2(D); - - /* Check for solvability. */ - if (d > (r0 + r1)) { - /* no solution. circles do not intersect. */ - return 0; - } - if (d <= fabs(r0 - r1)) { - /* no solution. one circle is contained in the other */ - return 1; - } - - /* 'point 2' is the point where the line through the circle - * intersection points crosses the line between the circle - * centers. - */ - - /* Determine the distance from point 0 to point 2. */ - double a = ((r0*r0) - (r1*r1) + (d*d)) / (2.0 * d) ; - - /* Determine the coordinates of point 2. */ - Point p2 = X0 + D * (a/d); - - /* Determine the distance from point 2 to either of the - * intersection points. - */ - double h = std::sqrt((r0*r0) - (a*a)); - - /* Now determine the offsets of the intersection points from - * point 2. - */ - Point r = (h/d)*rot90(D); - - /* Determine the absolute intersection points. */ - p0 = p2 + r; - p1 = p2 - r; - - return 2; -} -/** -* Find circle that touches inside of the curve, with radius matching the curvature, at time value \c t. -* Because this method internally uses unitTangentAt, t should be smaller than 1.0 (see unitTangentAt). -*/ -static Circle touching_circle( D2 const &curve, double t, double tol=0.01 ) -{ - D2 dM=derivative(curve); - if ( are_near(L2sq(dM(t)),0.) ) { - dM=derivative(dM); - } - if ( are_near(L2sq(dM(t)),0.) ) { // try second time - dM=derivative(dM); - } - Piecewise > unitv = unitVector(dM,tol); - Piecewise dMlength = dot(Piecewise >(dM),unitv); - Piecewise k = cross(derivative(unitv),unitv); - k = divide(k,dMlength,tol,3); - double curv = k(t); // note that this value is signed - - Geom::Point normal = unitTangentAt(curve, t).cw(); - double radius = 1/curv; - Geom::Point center = curve(t) + radius*normal; - return Geom::Circle(center, fabs(radius)); -} - -std::vector split_at_cusps(const Geom::Path& in) -{ - PathVector out = PathVector(); - Path temp = Path(); - - for (unsigned i = 0; i < in.size(); i++) { - temp.append(in[i]); - if ( get_nodetype(in[i], in[i + 1]) != Geom::NODE_SMOOTH ) { - out.push_back(temp); - temp = Path(); - } - } - if (temp.size() > 0) { - out.push_back(temp); - } - return out; -} - -Geom::CubicBezier sbasis_to_cubicbezier(Geom::D2 const & sbasis_in) -{ - std::vector temp; - sbasis_to_bezier(temp, sbasis_in, 4); - return Geom::CubicBezier( temp ); -} - -static boost::optional intersection_point(Geom::Point const & origin_a, Geom::Point const & vector_a, Geom::Point const & origin_b, Geom::Point const & vector_b) -{ - Geom::Coord denom = cross(vector_b, vector_a); - if (!Geom::are_near(denom,0.)) { - Geom::Coord t = (cross(origin_a,vector_b) + cross(vector_b,origin_b)) / denom; - return origin_a + t * vector_a; - } - return boost::none; -} - -} // namespace Geom - -namespace Outline { - -typedef Geom::D2 D2SB; -typedef Geom::Piecewise PWD2; - -// UTILITY - -unsigned bezierOrder (const Geom::Curve* curve_in) -{ - using namespace Geom; - if ( const BezierCurve* bz = dynamic_cast(curve_in) ) { - return bz->order(); - } - return 0; -} - -/** - * @return true if the angle formed by the curves and their handles is greater than 180 degrees clockwise, otherwise false. - */ -bool outside_angle (const Geom::Curve& cbc1, const Geom::Curve& cbc2) -{ - Geom::Point start_point; - Geom::Point cross_point = cbc1.finalPoint(); - Geom::Point end_point; - - if (cross_point != cbc2.initialPoint()) { - printf("WARNING: Non-contiguous path in Outline::outside_angle()"); - return false; - } - - Geom::CubicBezier cubicBezier = Geom::sbasis_to_cubicbezier(cbc1.toSBasis()); - start_point = cubicBezier [2]; - - /* - * Because the node editor does not yet support true quadratics, paths are converted to - * cubic beziers in the node tool with degenerate handles on one side. - */ - - if (are_near(start_point, cross_point, 0.0000001)) { - start_point = cubicBezier [1]; - } - cubicBezier = Geom::sbasis_to_cubicbezier(cbc2.toSBasis()); - end_point = cubicBezier [1]; - if (are_near(end_point, cross_point, 0.0000001)) { - end_point = cubicBezier [2]; - } - - // got our three points, now let's see what their clockwise angle is - - // Definition of a Graham scan - - /******************************************************************** - # Three points are a counter-clockwise turn if ccw > 0, clockwise if - # ccw < 0, and collinear if ccw = 0 because ccw is a determinant that - # gives the signed area of the triangle formed by p1, p2 and p3. - function ccw(p1, p2, p3): - return (p2.x - p1.x)*(p3.y - p1.y) - (p2.y - p1.y)*(p3.x - p1.x) - *********************************************************************/ - - double ccw = ( (cross_point.x() - start_point.x()) * (end_point.y() - start_point.y()) ) - - ( (cross_point.y() - start_point.y()) * (end_point.x() - start_point.x()) ); - return ccw > 0; -} - -// LINE JOINS - -typedef Geom::BezierCurveN<1u> BezierLine; - -/** - * Removes the crossings on an interior join. - * @param path_builder Contains the incoming segment; result is appended to this - * @param outgoing The outgoing segment - */ -void joinInside(Geom::Path& path_builder, Geom::Curve const& outgoing) -{ - Geom::Curve const& incoming = path_builder.back(); - - // Using Geom::crossings to find intersections between two curves - Geom::Crossings cross = Geom::crossings(incoming, outgoing); - if (!cross.empty()) { - // Crossings found, create the join - Geom::CubicBezier cubic = Geom::sbasis_to_cubicbezier(incoming.toSBasis()); - cubic = cubic.subdivide(cross[0].ta).first; - // erase the last segment, as we're going to overwrite it now - path_builder.erase_last(); - path_builder.append(cubic, Geom::Path::STITCH_DISCONTINUOUS); - - cubic = Geom::sbasis_to_cubicbezier(outgoing.toSBasis()); - cubic = cubic.subdivide(cross[0].tb).second; - path_builder.append(cubic, Geom::Path::STITCH_DISCONTINUOUS); - } else { - // No crossings occurred, or Geom::crossings() failed; default to bevel - if (Geom::are_near(incoming.finalPoint(), outgoing.initialPoint())) { - path_builder.appendNew(outgoing.initialPoint()); - } else { - path_builder.setFinal(outgoing.initialPoint()); - } - } -} - -/** - * Try to create a miter join. Falls back to bevel if no miter can be created. - * @param path_builder Path to append curves to; back() is the incoming curve - * @param outgoing Outgoing curve. - * @param miter_limit When mitering, don't exceed this length - * @param line_width The thickness of the line. - */ -void miter_curves(Geom::Path& path_builder, Geom::Curve const& outgoing, double miter_limit, double line_width) -{ - using namespace Geom; - Curve const& incoming = path_builder.back(); - Point tang1 = unitTangentAt(Geom::reverse(incoming.toSBasis()), 0.); - Point tang2 = unitTangentAt(outgoing.toSBasis(), 0); - - boost::optional p = intersection_point (incoming.finalPoint(), tang1, outgoing.initialPoint(), tang2); - if (p) { - // check size of miter - Point point_on_path = incoming.finalPoint() - rot90(tang1) * line_width; - Coord len = distance(*p, point_on_path); - if (len <= miter_limit) { - // miter OK - path_builder.appendNew(*p); - } - } - path_builder.appendNew(outgoing.initialPoint()); -} - -/** - * Smoothly extrapolate curves along a circular route. Falls back to miter if necessary. - * @param path_builder Path to append curves to; back() is the incoming curve - * @param outgoing Outgoing curve. - * @param miter_limit When mitering, don't exceed this length - * @param line_width The thickness of the line. Used for miter fallback. - */ -void extrapolate_curves(Geom::Path& path_builder, Geom::Curve const& outgoing, double miter_limit, double line_width) -{ - Geom::Curve const& incoming = path_builder.back(); - Geom::Point endPt = outgoing.initialPoint(); - - // The method used when extrapolating curves fails to work when either side of the join to be extrapolated - // is a line segment. When this situation is encountered, fall back to a regular miter join. - bool lineProblem = (dynamic_cast(&incoming)) || (dynamic_cast(&outgoing)); - if (lineProblem == false) { - // Geom::Point tang1 = Geom::unitTangentAt(Geom::reverse(incoming.toSBasis()), 0.); - Geom::Point tang2 = Geom::unitTangentAt(outgoing.toSBasis(), 0); - - Geom::Circle circle1 = Geom::touching_circle(Geom::reverse(incoming.toSBasis()), 0.); - Geom::Circle circle2 = Geom::touching_circle(outgoing.toSBasis(), 0); - - Geom::Point points[2]; - int solutions = Geom::circle_circle_intersection(circle1, circle2, points[0], points[1]); - if (solutions == 2) { - Geom::Point sol(0,0); - if ( dot(tang2,points[0]-endPt) > 0 ) { - // points[0] is bad, choose points[1] - sol = points[1]; - } else if ( dot(tang2,points[1]-endPt) > 0 ) { // points[0] could be good, now check points[1] - // points[1] is bad, choose points[0] - sol = points[0]; - } else { - // both points are good, choose nearest - sol = ( distanceSq(endPt, points[0]) < distanceSq(endPt, points[1]) ) ? points[0] : points[1]; - } - - Geom::EllipticalArc *arc0 = circle1.arc(incoming.finalPoint(), 0.5*(incoming.finalPoint()+sol), sol, true); - Geom::EllipticalArc *arc1 = circle2.arc(sol, 0.5*(sol+endPt), endPt, true); - try { - if (arc0) { - path_builder.append (arc0->toSBasis()); - delete arc0; - arc0 = NULL; - } else { - throw std::exception(); - } - - if (arc1) { - path_builder.append (arc1->toSBasis()); - delete arc1; - arc1 = NULL; - } else { - throw std::exception(); - } - - } catch (std::exception const & ex) { - printf("WARNING: Error extrapolating line join: %s\n", ex.what()); - path_builder.appendNew(endPt); - } - } else { - // 1 or no solutions found, default to miter - miter_curves(path_builder, outgoing, miter_limit, line_width); - } - } else { - // Line segments exist - miter_curves(path_builder, outgoing, miter_limit, line_width); - } -} - -/** - * Extrapolate curves by reflecting them along the line that would be given by beveling the join. - * @param path_builder Path to append curves to; back() is the incoming curve - * @param outgoing Outgoing curve. - * @param miter_limit When mitering, don't exceed this length - * @param line_width The thickness of the line. Used for miter fallback. - */ -void reflect_curves(Geom::Path& path_builder, Geom::Curve const& outgoing, double miter_limit, double line_width) -{ - using namespace Geom; - Curve const& incoming = path_builder.back(); - // On the outside, we'll take the incoming curve, the outgoing curve, and - // reflect them over the line formed by taking the unit tangent vector at times - // 0 and 1, respectively, rotated by 90 degrees. - Crossings cross; - - // reflect curves along the line that would be given by beveling the join - Point tang1 = unitTangentAt(reverse(incoming.toSBasis()), 0.); - D2SB newcurve1 = incoming.toSBasis() * reflection(-rot90(tang1), incoming.finalPoint()); - CubicBezier bzr1 = sbasis_to_cubicbezier(reverse(newcurve1)); - - Point tang2 = Geom::unitTangentAt(outgoing.toSBasis(), 0.); - D2SB newcurve2 = outgoing.toSBasis() * reflection(-rot90(tang2), outgoing.initialPoint()); - CubicBezier bzr2 = sbasis_to_cubicbezier(reverse(newcurve2)); - - cross = crossings(bzr1, bzr2); - if (cross.empty()) { - // paths don't cross, fall back to miter - miter_curves(path_builder, outgoing, miter_limit, line_width); - } else { - // reflected join - std::pair sub1 = bzr1.subdivide(cross[0].ta); - std::pair sub2 = bzr2.subdivide(cross[0].tb); - - // TODO it seems as if a bug in 2geom sometimes doesn't catch the first - // crossing of paths, but the second instead; but only sometimes. - path_builder.appendNew (sub1.first[1], sub1.first[2], sub2.second[0]); - path_builder.appendNew (sub2.second[1], sub2.second[2], outgoing.initialPoint()); - } -} - -// Ideal function pointer we want to pass -typedef void JoinFunc(Geom::Path& /*path_builder*/, Geom::Curve const& /*outgoing*/, double /*miter_limit*/, double /*line_width*/); - -/** - * Helper function for repeated logic in outlineHalf. - */ -static void outlineHelper(Geom::Path& path_builder, Geom::PathVector* path_vec, bool outside, double width, double miter, JoinFunc func) -{ - Geom::Curve * cbc2 = path_vec->front()[0].duplicate(); - - if (outside) { - func(path_builder, *cbc2, miter, width); - } else { - joinInside(path_builder, *cbc2); - } - - // store it - Geom::Path temp_path = path_vec->front(); - if (!outside) { - // erase the first segment since the inside join code already appended it - temp_path.erase(temp_path.begin()); - } - - if (temp_path.initialPoint() != path_builder.finalPoint()) { - temp_path.setInitial(path_builder.finalPoint()); - } - - path_builder.append(temp_path); - - delete cbc2; -} - -/** - * Offsets exactly one half of a bezier spline (path). - * @param path_in The input path to use. (To create the other side use path_in.reverse() ) - * @param line_width the line width to use (usually you want to divide this by 2) - * @param miter_limit the miter parameter - * @param func Join function to apply at each join. - */ - -Geom::Path outlineHalf(const Geom::Path& path_in, double line_width, double miter_limit, JoinFunc func) -{ - // NOTE: it is important to notice the distinction between a Geom::Path and a livarot ::Path here! - // if you do not see "Geom::" there is a different function set! - - Geom::PathVector pv = split_at_cusps(path_in); - - ::Path to_outline; - ::Path outlined_result; - - Geom::Path path_builder = Geom::Path(); // the path to store the result in - Geom::PathVector* path_vec; // needed because livarot returns a pointer (TODO make this not a pointer) - - // Do two curves at a time for efficiency, since the join function needs to know the outgoing curve as well - const size_t k = pv.size(); - for (size_t u = 0; u < k; u += 2) { - to_outline = Path(); - outlined_result = Path(); - - to_outline.LoadPath(pv[u], Geom::identity(), false, false); - to_outline.OutsideOutline(&outlined_result, line_width / 2, join_straight, butt_straight, 10); - // now a curve has been outside outlined and loaded into outlined_result - - // get the Geom::Path - path_vec = outlined_result.MakePathVector(); - - // on the first run through, there is no join - if (u == 0) { - path_builder.start(path_vec->front().initialPoint()); - path_builder.append(path_vec->front()); - } else { - outlineHelper(path_builder, path_vec, outside_angle(pv[u-1][pv[u-1].size()-1], pv[u][0]), line_width, miter_limit, func); - } - - // outline the next segment, but don't store it yet - if (path_vec) - delete path_vec; - path_vec = NULL; - - // odd number of paths - if (u < k - 1) { - outlined_result = Path(); - to_outline = Path(); - - to_outline.LoadPath(pv[u+1], Geom::Affine(), false, false); - to_outline.OutsideOutline(&outlined_result, line_width / 2, join_straight, butt_straight, 10); - - path_vec = outlined_result.MakePathVector(); - outlineHelper(path_builder, path_vec, outside_angle(pv[u][pv[u].size()-1], pv[u+1][0]), line_width, miter_limit, func); - - if (path_vec) - delete path_vec; - path_vec = NULL; - } - } - - if (path_in.closed()) { - Geom::Curve * cbc1; - Geom::Curve * cbc2; - - if ( path_in[path_in.size()].isDegenerate() ) { - // handle case for last segment curved - outlined_result = Path(); - to_outline = Path(); - - Geom::Path oneCurve; oneCurve.append(path_in[0]); - - to_outline.LoadPath(oneCurve, Geom::Affine(), false, false); - to_outline.OutsideOutline(&outlined_result, line_width / 2, join_straight, butt_straight, 10); - - path_vec = outlined_result.MakePathVector(); - - cbc1 = path_builder[path_builder.size() - 1].duplicate(); - cbc2 = path_vec->front()[0].duplicate(); - - delete path_vec; - } else { - // handle case for last segment straight - // since the path doesn't actually give us access to it, we'll do it ourselves - outlined_result = Path(); - to_outline = Path(); - - Geom::Path oneCurve; oneCurve.append(Geom::LineSegment(path_in.finalPoint(), path_in.initialPoint())); - - to_outline.LoadPath(oneCurve, Geom::Affine(), false, false); - to_outline.OutsideOutline(&outlined_result, line_width / 2, join_straight, butt_straight, 10); - - path_vec = outlined_result.MakePathVector(); - - cbc1 = path_builder[path_builder.size() - 1].duplicate(); - cbc2 = (*path_vec)[0] [0].duplicate(); - - outlineHelper(path_builder, path_vec, outside_angle(path_in[path_in.size()-1], oneCurve[0]), line_width, miter_limit, func); - - delete cbc1; - cbc1 = cbc2->duplicate(); - delete path_vec; - - oneCurve = Geom::Path(); oneCurve.append(path_in[0]); - - to_outline.LoadPath(oneCurve, Geom::Affine(), false, false); - to_outline.OutsideOutline(&outlined_result, line_width / 2, join_straight, butt_straight, 10); - - path_vec = outlined_result.MakePathVector(); - delete cbc2; cbc2 = (*path_vec)[0] [0].duplicate(); - delete path_vec; - } - - Geom::Path temporary; - temporary.append(*cbc1); - - Geom::Curve const & prev_curve = path_in[path_in.size()].isDegenerate() ? path_in[path_in.size() - 1] : path_in[path_in.size()]; - Geom::Path isStraight; - isStraight.append(prev_curve); - isStraight.append(path_in[0]); - // does closing path require a join? - if (Geom::split_at_cusps(isStraight).size() > 1) { - bool outside = outside_angle(prev_curve, path_in[0]); - if (outside) { - func(temporary, *cbc2, miter_limit, line_width); - } else { - joinInside(temporary, *cbc2); - path_builder.erase(path_builder.begin()); - } - - // extract the appended curves - path_builder.erase_last(); - if (Geom::are_near(path_builder.finalPoint(), temporary.initialPoint())) { - path_builder.setFinal(temporary.initialPoint()); - } else { - path_builder.appendNew(temporary.initialPoint()); - } - path_builder.append(temporary); - } else { - // closing path does not require a join - path_builder.setFinal(path_builder.initialPoint()); - } - path_builder.close(); - - if (cbc1) delete cbc1; - if (cbc2) delete cbc2; - } - - return path_builder; -} - -Geom::PathVector outlinePath(const Geom::PathVector& path_in, double line_width, LineJoinType join, ButtTypeMod butt, double miter_lim, bool extrapolate, double start_lean, double end_lean) -{ - Geom::PathVector path_out; - - unsigned pv_size = path_in.size(); - for (unsigned i = 0; i < pv_size; i++) { - - if (path_in[i].size() > 1) { - Geom::Path with_direction; - Geom::Path against_direction; - - with_direction = Outline::outlineHalf(path_in[i], -line_width, miter_lim, extrapolate ? extrapolate_curves : reflect_curves); - against_direction = Outline::outlineHalf(path_in[i].reverse(), -line_width, miter_lim, extrapolate ? extrapolate_curves : reflect_curves); - - Geom::PathBuilder pb; - - pb.moveTo(with_direction.initialPoint()); - pb.append(with_direction); - - //add in our line caps - if (!path_in[i].closed()) { - switch (butt) { - case BUTT_STRAIGHT: - pb.lineTo(against_direction.initialPoint()); - break; - case BUTT_ROUND: - pb.arcTo((-line_width) / 2, (-line_width) / 2, 0., true, true, against_direction.initialPoint() ); - break; - case BUTT_POINTY: { - Geom::Point end_deriv = -Geom::unitTangentAt(Geom::reverse(path_in[i].back().toSBasis()), 0.); - double radius = 0.5 * Geom::distance(with_direction.finalPoint(), against_direction.initialPoint()); - Geom::Point midpoint = 0.5 * (with_direction.finalPoint() + against_direction.initialPoint()) + radius*end_deriv; - pb.lineTo(midpoint); - pb.lineTo(against_direction.initialPoint()); - break; - } - case BUTT_SQUARE: { - Geom::Point end_deriv = -Geom::unitTangentAt(Geom::reverse(path_in[i].back().toSBasis()), 0.); - double radius = 0.5 * Geom::distance(with_direction.finalPoint(), against_direction.initialPoint()); - pb.lineTo(with_direction.finalPoint() + radius*end_deriv); - pb.lineTo(against_direction.initialPoint() + radius*end_deriv); - pb.lineTo(against_direction.initialPoint()); - break; - } - case BUTT_LEANED: { - Geom::Point end_deriv = -Geom::unitTangentAt(Geom::reverse(path_in[i].back().toSBasis()), 0.); - double maxRadius = (end_lean+0.5) * Geom::distance(with_direction.finalPoint(), against_direction.initialPoint()); - double minRadius = ((end_lean*-1)+0.5) * Geom::distance(with_direction.finalPoint(), against_direction.initialPoint()); - pb.lineTo(with_direction.finalPoint() + maxRadius*end_deriv); - pb.lineTo(against_direction.initialPoint() + minRadius*end_deriv); - pb.lineTo(against_direction.initialPoint()); - break; - } - } - } else { - pb.moveTo(against_direction.initialPoint()); - } - - pb.append(against_direction); - - //cap (if necessary) - if (!path_in[i].closed()) { - switch (butt) { - case BUTT_STRAIGHT: - pb.lineTo(with_direction.initialPoint()); - break; - case BUTT_ROUND: - pb.arcTo((-line_width) / 2, (-line_width) / 2, 0., true, true, with_direction.initialPoint() ); - break; - case BUTT_POINTY: { - Geom::Point end_deriv = -Geom::unitTangentAt(path_in[i].front().toSBasis(), 0.); - double radius = 0.5 * Geom::distance(against_direction.finalPoint(), with_direction.initialPoint()); - Geom::Point midpoint = 0.5 * (against_direction.finalPoint() + with_direction.initialPoint()) + radius*end_deriv; - pb.lineTo(midpoint); - pb.lineTo(with_direction.initialPoint()); - break; - } - case BUTT_SQUARE: { - Geom::Point end_deriv = -Geom::unitTangentAt(path_in[i].front().toSBasis(), 0.); - double radius = 0.5 * Geom::distance(against_direction.finalPoint(), with_direction.initialPoint()); - pb.lineTo(against_direction.finalPoint() + radius*end_deriv); - pb.lineTo(with_direction.initialPoint() + radius*end_deriv); - pb.lineTo(with_direction.initialPoint()); - break; - } - case BUTT_LEANED: { - Geom::Point end_deriv = -Geom::unitTangentAt(path_in[i].front().toSBasis(), 0.); - double maxRadius = (start_lean+0.5) * Geom::distance(against_direction.finalPoint(), with_direction.initialPoint()); - double minRadius = ((start_lean*-1)+0.5) * Geom::distance(against_direction.finalPoint(), with_direction.initialPoint()); - pb.lineTo(against_direction.finalPoint() + minRadius*end_deriv); - pb.lineTo(with_direction.initialPoint() + maxRadius*end_deriv); - pb.lineTo(with_direction.initialPoint()); - break; - } - } - } - pb.flush(); - path_out.push_back(pb.peek()[0]); - if (path_in[i].closed()) { - path_out.push_back(pb.peek()[1]); - } - } else { - Path p = Path(); - Path outlinepath = Path(); - ButtType original_butt; - switch (butt) { - case BUTT_STRAIGHT: - original_butt = butt_straight; - break; - case BUTT_ROUND: - original_butt = butt_round; - break; - case butt_pointy: { - original_butt = butt_pointy; - break; - } - case BUTT_SQUARE: { - original_butt = butt_square; - break; - } - case BUTT_LEANED: { - original_butt = butt_straight; - break; - } - } - p.LoadPath(path_in[i], Geom::Affine(), false, false); - p.Outline(&outlinepath, line_width / 2, static_cast(join), original_butt, miter_lim); - Geom::PathVector *pv_p = outlinepath.MakePathVector(); - //somewhat hack-ish - path_out.push_back( (*pv_p)[0].reverse() ); - if (pv_p) delete pv_p; - } - } - return path_out; -} - -#define miter_lim fabs(line_width * miter_limit) - -Geom::PathVector PathVectorOutline(Geom::PathVector const & path_in, double line_width, ButtTypeMod linecap_type, LineJoinType linejoin_type, double miter_limit, double start_lean, double end_lean) -{ - std::vector path_out = std::vector(); - if (path_in.empty()) { - return path_out; - } - Path p = Path(); - Path outlinepath = Path(); - for (unsigned i = 0; i < path_in.size(); i++) { - p.LoadPath(path_in[i], Geom::Affine(), false, ( (i==0) ? false : true)); - } - - // magic! - ButtType original_butt; - switch (linecap_type) { - case BUTT_STRAIGHT: - original_butt = butt_straight; - break; - case BUTT_ROUND: - original_butt = butt_round; - break; - case butt_pointy: { - original_butt = butt_pointy; - break; - } - case BUTT_SQUARE: { - original_butt = butt_square; - break; - } - case BUTT_LEANED: { - original_butt = butt_straight; - break; - } - } - if (linejoin_type <= LINEJOIN_POINTY) { - p.Outline(&outlinepath, line_width / 2, static_cast(linejoin_type), - original_butt, miter_lim); - // fix memory leak - std::vector *pv_p = outlinepath.MakePathVector(); - path_out = *pv_p; - delete pv_p; - - } else if (linejoin_type == LINEJOIN_REFLECTED) { - // reflected arc join - path_out = outlinePath(path_in, line_width, static_cast(linejoin_type), - linecap_type , miter_lim, false, start_lean, end_lean); - - } else if (linejoin_type == LINEJOIN_EXTRAPOLATED) { - // extrapolated arc join - path_out = outlinePath(path_in, line_width, LINEJOIN_STRAIGHT, linecap_type, miter_lim, true, start_lean, end_lean); - } - - return path_out; -} - -Geom::Path PathOutsideOutline(Geom::Path const & path_in, double line_width, LineJoinType linejoin_type, double miter_limit) -{ - - Geom::Path path_out; - - if (linejoin_type <= LINEJOIN_POINTY || path_in.size() <= 1) { - - Geom::PathVector * pathvec; - - Path path_tangent = Path(); - Path path_outline = Path(); - path_outline.LoadPath(path_in, Geom::Affine(), false, false); - path_outline.OutsideOutline(&path_tangent, line_width / 2, static_cast(linejoin_type), butt_straight, miter_lim); - - pathvec = path_tangent.MakePathVector(); - path_out = pathvec->front(); - delete pathvec; - return path_out; - } else if (linejoin_type == LINEJOIN_REFLECTED) { - path_out = outlineHalf(path_in, line_width, miter_lim, reflect_curves); - return path_out; - } else if (linejoin_type == LINEJOIN_EXTRAPOLATED) { - path_out = outlineHalf(path_in, line_width, miter_lim, extrapolate_curves); - return path_out; - } - return path_out; -} - -} // namespace Outline - -/* - Local Variables: - mode:c++ - c-file-style:"stroustrup" - c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) - indent-tabs-mode:nil - fill-column:99 - End: -*/ -// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8 : diff --git a/src/live_effects/pathoutlineprovider.h b/src/live_effects/pathoutlineprovider.h deleted file mode 100644 index c17584be2..000000000 --- a/src/live_effects/pathoutlineprovider.h +++ /dev/null @@ -1,55 +0,0 @@ -#ifndef SEEN_PATH_OUTLINE_H -#define SEEN_PATH_OUTLINE_H - -/* Author: - * Liam P. White - * - * Copyright (C) 2014 Author - * - * Released under GNU GPL, read the file 'COPYING' for more information - */ - -#include -#include - -enum LineJoinType { - LINEJOIN_STRAIGHT, - LINEJOIN_ROUND, - LINEJOIN_POINTY, - LINEJOIN_REFLECTED, - LINEJOIN_EXTRAPOLATED -}; -enum ButtTypeMod { - BUTT_STRAIGHT, - BUTT_ROUND, - BUTT_SQUARE, - BUTT_POINTY, - BUTT_LEANED -}; - -namespace Geom -{ - Geom::CubicBezier sbasis_to_cubicbezier(Geom::D2 const & sbasis_in); - std::vector split_at_cusps(const Geom::Path& in); -} - -namespace Outline -{ - unsigned bezierOrder (const Geom::Curve* curve_in); - std::vector PathVectorOutline(std::vector const & path_in, double line_width, ButtTypeMod linecap_type, - LineJoinType linejoin_type, double miter_limit, double start_lean = 0, double end_lean = 0); - Geom::Path PathOutsideOutline(Geom::Path const & path_in, double line_width, LineJoinType linejoin_type, double miter_limit); -} - -#endif // SEEN_PATH_OUTLINE_H - -/* - Local Variables: - mode:c++ - c-file-style:"stroustrup" - c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) - indent-tabs-mode:nil - fill-column:99 - End: -*/ -// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8 : -- cgit v1.2.3 From 7605490d79cf0244db020654aa23610b2a0d83ea Mon Sep 17 00:00:00 2001 From: Bryce Harrington Date: Sat, 21 Mar 2015 03:42:18 -0700 Subject: sp. fix seperate (bzr r14021) --- share/extensions/restack.py | 8 ++++---- share/extensions/text_extract.py | 24 ++++++++++++------------ share/extensions/text_merge.py | 4 ++-- share/keys/macromedia-freehand-mx.xml | 4 ++-- src/svg-profile.h | 2 +- src/ui/dialog/filter-effects-dialog.cpp | 2 +- src/uri-references.cpp | 2 +- 7 files changed, 23 insertions(+), 23 deletions(-) diff --git a/share/extensions/restack.py b/share/extensions/restack.py index 615b41527..507353025 100755 --- a/share/extensions/restack.py +++ b/share/extensions/restack.py @@ -54,9 +54,9 @@ class Restack(inkex.Effect): svg = self.document.getroot() parentnode = self.current_layer file = self.args[ -1 ] - + #get all bounding boxes in file by calling inkscape again with the --query-all command line option - #it returns a comma seperated list structured id,x,y,w,h + #it returns a comma separated list structured id,x,y,w,h if bsubprocess: p = Popen('inkscape --query-all "%s"' % (file), shell=True, stdout=PIPE, stderr=PIPE) err = p.stderr @@ -65,12 +65,12 @@ class Restack(inkex.Effect): reader=csv.CSVParser().parse_string(f) #there was a module cvs.py in earlier inkscape that behaved differently except: reader=csv.reader(f.split( os.linesep )) - err.close() + err.close() else: _,f,err = os.popen3('inkscape --query-all "%s"' % ( file ) ) reader=csv.reader( f ) err.close() - + #build a dictionary with id as the key dimen = dict() for line in reader: diff --git a/share/extensions/text_extract.py b/share/extensions/text_extract.py index bf263ef39..dfcddefdc 100755 --- a/share/extensions/text_extract.py +++ b/share/extensions/text_extract.py @@ -42,15 +42,15 @@ class Extract(inkex.Effect): def __init__(self): inkex.Effect.__init__(self) self.OptionParser.add_option("-d", "--direction", - action="store", type="string", + action="store", type="string", dest="direction", default="tb", help="direction to extract text") self.OptionParser.add_option("-x", "--xanchor", - action="store", type="string", + action="store", type="string", dest="xanchor", default="m", help="horizontal point to compare") self.OptionParser.add_option("-y", "--yanchor", - action="store", type="string", + action="store", type="string", dest="yanchor", default="m", help="vertical point to compare") @@ -58,15 +58,15 @@ class Extract(inkex.Effect): if len(self.selected)==0: for node in self.document.xpath('//svg:text | //svg:flowRoot', namespaces=inkex.NSS): self.selected[node.get('id')] = node - + if len( self.selected ) > 0: objlist = [] svg = self.document.getroot() parentnode = self.current_layer file = self.args[ -1 ] - - #get all bounding boxes in file by calling inkscape again with the --query-all command line option - #it returns a comma seperated list structured id,x,y,w,h + + # get all bounding boxes in file by calling inkscape again with the --query-all command line option + # it returns a comma separated list structured id,x,y,w,h if bsubprocess: p = Popen('inkscape --query-all "%s"' % (file), shell=True, stdout=PIPE, stderr=PIPE) err = p.stderr @@ -75,12 +75,12 @@ class Extract(inkex.Effect): reader=csv.CSVParser().parse_string(f) #there was a module cvs.py in earlier inkscape that behaved differently except: reader=csv.reader(f.split( os.linesep )) - err.close() + err.close() else: _,f,err = os.popen3('inkscape --query-all "%s"' % ( file ) ) reader=csv.reader( f ) err.close() - + #build a dictionary with id as the key dimen = dict() for line in reader: @@ -89,7 +89,7 @@ class Extract(inkex.Effect): if not bsubprocess: #close file if opened using os.popen3 f.close - + #find the center of all selected objects **Not the average! x,y,w,h = dimen[self.selected.keys()[0]] minx = x @@ -131,7 +131,7 @@ class Extract(inkex.Effect): cy = y + h else: # middle cy = y + h / 2 - + #direction chosen if self.options.direction == "tb": objlist.append([cy,id]) @@ -146,7 +146,7 @@ class Extract(inkex.Effect): #move them to the top of the object stack in this order. for item in objlist: self.recurse(deepcopy(self.selected[item[1]])) - + def recurse(self, node): istext = (node.tag == '{http://www.w3.org/2000/svg}flowPara' or node.tag == '{http://www.w3.org/2000/svg}flowDiv' or node.tag == '{http://www.w3.org/2000/svg}text') if node.text != None or node.tail != None: diff --git a/share/extensions/text_merge.py b/share/extensions/text_merge.py index dc6ee331c..625f14b75 100644 --- a/share/extensions/text_merge.py +++ b/share/extensions/text_merge.py @@ -73,8 +73,8 @@ class Merge(inkex.Effect): parentnode = self.current_layer file = self.args[ -1 ] - #get all bounding boxes in file by calling inkscape again with the --query-all command line option - #it returns a comma seperated list structured id,x,y,w,h + # get all bounding boxes in file by calling inkscape again with the --query-all command line option + # it returns a comma separated list structured id,x,y,w,h if bsubprocess: p = Popen('inkscape --query-all "%s"' % (file), shell=True, stdout=PIPE, stderr=PIPE) err = p.stderr diff --git a/share/keys/macromedia-freehand-mx.xml b/share/keys/macromedia-freehand-mx.xml index 3512806bf..89069a217 100644 --- a/share/keys/macromedia-freehand-mx.xml +++ b/share/keys/macromedia-freehand-mx.xml @@ -35,7 +35,7 @@ File, Edit, View, Modify, Text, Xtras, Window, Help. - + @@ -396,7 +396,7 @@ File, Edit, View, Modify, Text, Xtras, Window, Help. - + diff --git a/src/svg-profile.h b/src/svg-profile.h index 9d221fc76..8945ee313 100644 --- a/src/svg-profile.h +++ b/src/svg-profile.h @@ -74,7 +74,7 @@ public: SVG_PRINT_1_1, /**< */ - PROFILE_UNIQUE_CNT, /**< A marker to seperate between the entires + PROFILE_UNIQUE_CNT, /**< A marker to separate between the entires that are unique, and those which are aggregates of them. */ diff --git a/src/ui/dialog/filter-effects-dialog.cpp b/src/ui/dialog/filter-effects-dialog.cpp index 3da0e0043..077c6f5ca 100644 --- a/src/ui/dialog/filter-effects-dialog.cpp +++ b/src/ui/dialog/filter-effects-dialog.cpp @@ -211,7 +211,7 @@ private: ComboBoxEnum* combo; }; -// Contains an arbitrary number of spin buttons that use seperate attributes +// Contains an arbitrary number of spin buttons that use separate attributes class MultiSpinButton : public Gtk::HBox { public: diff --git a/src/uri-references.cpp b/src/uri-references.cpp index b23bed74a..2518c173e 100644 --- a/src/uri-references.cpp +++ b/src/uri-references.cpp @@ -65,7 +65,7 @@ void URIReference::attach(const URI &uri) throw(BadURIException) skip = true; } - // The path contains references to seperate document files to load. + // The path contains references to separate document files to load. if(document && uri.getPath() && !skip ) { std::string base = document->getBase() ? document->getBase() : ""; std::string path = uri.getFullPath(base); -- cgit v1.2.3 From 034b578ef602f2095374800a8c967b1b6e5c21dd Mon Sep 17 00:00:00 2001 From: Tavmjong Bah Date: Sat, 21 Mar 2015 12:41:01 +0100 Subject: Add GUI for 'viewBox'. (bzr r14022) --- src/document.cpp | 11 +++ src/document.h | 1 + src/ui/widget/page-sizer.cpp | 169 +++++++++++++++++++++++++++++++++++++------ src/ui/widget/page-sizer.h | 21 ++++++ 4 files changed, 180 insertions(+), 22 deletions(-) diff --git a/src/document.cpp b/src/document.cpp index 62e2f5b46..1c6bb76de 100644 --- a/src/document.cpp +++ b/src/document.cpp @@ -764,6 +764,17 @@ void SPDocument::setHeight(const Inkscape::Util::Quantity &height, bool changeSi root->updateRepr(); } +Geom::Rect SPDocument::getViewBox() const +{ + Geom::Rect viewBox; + if (root->viewBox_set) { + viewBox = root->viewBox; + } else { + viewBox = Geom::Rect::from_xywh( 0, 0, getWidth().value("px"), getHeight().value("px")); + } + return viewBox; +} + void SPDocument::setViewBox(const Geom::Rect &viewBox) { root->viewBox_set = true; diff --git a/src/document.h b/src/document.h index ed19d123b..74dcfa75e 100644 --- a/src/document.h +++ b/src/document.h @@ -247,6 +247,7 @@ public: Geom::Scale getDocumentScale() const; Inkscape::Util::Quantity getWidth() const; Inkscape::Util::Quantity getHeight() const; + Geom::Rect getViewBox() const; Geom::Point getDimensions() const; Geom::OptRect preferredBounds() const; void setWidthAndHeight(const Inkscape::Util::Quantity &width, const Inkscape::Util::Quantity &height, bool changeSize=true); diff --git a/src/ui/widget/page-sizer.cpp b/src/ui/widget/page-sizer.cpp index 8e647ebb4..8c86daea0 100644 --- a/src/ui/widget/page-sizer.cpp +++ b/src/ui/widget/page-sizer.cpp @@ -242,7 +242,13 @@ PageSizer::PageSizer(Registry & _wr) _marginBottom( _("Botto_m:"), _("Bottom margin"), "fit-margin-bottom", _wr), _lockMarginUpdate(false), _scaleX(_("Scale _x:"), _("Scale X"), "scale-x", _wr), + _scaleY(_("Scale _y:"), _("Scale Y"), "scale-y", _wr), _lockScaleUpdate(false), + _viewboxX(_("X:"), _("X"), "viewbox-x", _wr), + _viewboxY(_("Y:"), _("Y"), "viewbox-y", _wr), + _viewboxW(_("Width:"), _("Width"), "viewbox-width", _wr), + _viewboxH(_("Height:"), _("Height"), "viewbox-height", _wr), + _lockViewboxUpdate(false), _widgetRegistry(&_wr) { // set precision of scalar entry boxes @@ -254,7 +260,21 @@ PageSizer::PageSizer(Registry & _wr) _marginRight.setDigits(5); _marginBottom.setDigits(5); _scaleX.setDigits(5); + _scaleY.setDigits(5); + _viewboxX.setDigits(2); + _viewboxY.setDigits(2); + _viewboxW.setDigits(2); + _viewboxH.setDigits(2); + _scaleX.setRange( 0.00001, 100000 ); + _scaleY.setRange( 0.00001, 100000 ); + _viewboxX.setRange( -100000, 100000 ); + _viewboxY.setRange( -100000, 100000 ); + _viewboxW.setRange( 0, 200000 ); + _viewboxH.setRange( 0, 200000 ); + + _scaleY.set_sensitive (false); // We only want to display Y scale. + _wr.setUpdating (false); //# Set up the Paper Size combo box @@ -435,21 +455,62 @@ PageSizer::PageSizer(Registry & _wr) _scaleTable.set_row_spacing(4); _scaleTable.set_column_spacing(4); - _dimensionWidth.set_hexpand(); - _dimensionWidth.set_vexpand(); _scaleTable.attach(_scaleX, 0, 0, 1, 1); + _scaleTable.attach(_scaleY, 1, 0, 1, 1); - _dimensionUnits.set_hexpand(); - _dimensionUnits.set_vexpand(); - _scaleTable.attach(_scaleLabel, 1, 0, 1, 1); + _scaleTable.attach(_scaleLabel, 2, 0, 1, 1); + _scaleTable.attach(_scaleWarning, 0, 1, 2, 1); + _viewboxExpander.set_hexpand(); + _viewboxExpander.set_vexpand(); + _scaleTable.attach(_viewboxExpander, 0, 2, 2, 1); #else - _scaleTable.resize(2, 1); + _scaleTable.resize(3, 2); _scaleTable.set_row_spacings(4); _scaleTable.set_col_spacings(4); _scaleTable.attach(_scaleX, 0,1, 0,1); - _scaleTable.attach(_scaleLabel, 1,2, 0,1); + _scaleTable.attach(_scaleY, 1,2, 0,1); + _scaleTable.attach(_scaleLabel, 2,3, 0,1); + _scaleTable.attach(_scaleWarning, 0,3, 1,2, Gtk::FILL); + _scaleTable.attach(_viewboxExpander, 0,3, 2,3); #endif + _scaleWarning.set_label(_("While SVG allows non-uniform scaling it is recommended to use only uniform scaling in Inkscape. To set a non-uniform scaling, set the 'viewBox' directly.")); + _scaleWarning.set_line_wrap( true ); + + _viewboxExpander.set_use_underline(); + _viewboxExpander.set_label(_("_Viewbox...")); + _viewboxExpander.add(_viewboxTable); + +#if WITH_GTKMM_3_0 + _viewboxTable.set_row_spacing(2); + _viewboxTable.set_column_spacing(2); + + _viewboxX.set_hexpand(); + _viewboxX.set_vexpand(); + _viewboxTable.attach(_viewboxX, 0, 0, 1, 1); + + _viewboxY.set_hexpand(); + _viewboxY.set_vexpand(); + _viewboxTable.attach(_viewboxY, 1, 0, 1, 1); + + _viewboxW.set_hexpand(); + _viewboxW.set_vexpand(); + _viewboxTable.attach(_viewbox, 0, 1, 1, 1); + + _viewboxH.set_hexpand(); + _viewboxH.set_vexpand(); + _viewboxTable.attach(_viewboxH, 1, 1, 1, 1); + +#else + _viewboxTable.set_border_width(4); + _viewboxTable.set_row_spacings(2); + _viewboxTable.set_col_spacings(2); + _viewboxTable.attach(_viewboxX, 0,1, 0,1); + _viewboxTable.attach(_viewboxY, 1,2, 0,1); + _viewboxTable.attach(_viewboxW, 0,1, 1,2); + _viewboxTable.attach(_viewboxH, 1,2, 1,2); +#endif + _wr.setUpdating (true); updateScaleUI(); _wr.setUpdating (false); @@ -478,7 +539,11 @@ PageSizer::init () _changedh_connection = _dimensionHeight.signal_value_changed().connect (sigc::mem_fun (*this, &PageSizer::on_value_changed)); _changedu_connection = _dimensionUnits.getUnitMenu()->signal_changed().connect (sigc::mem_fun (*this, &PageSizer::on_units_changed)); _fitPageButton.signal_clicked().connect(sigc::mem_fun(*this, &PageSizer::fire_fit_canvas_to_selection_or_drawing)); - _changeds_connection = _scaleX.signal_value_changed().connect (sigc::mem_fun (*this, &PageSizer::on_scale_changed)); + _changeds_connection = _scaleX.signal_value_changed().connect (sigc::mem_fun (*this, &PageSizer::on_scale_changed)); + _changedvx_connection = _viewboxX.signal_value_changed().connect (sigc::mem_fun (*this, &PageSizer::on_viewbox_changed)); + _changedvy_connection = _viewboxY.signal_value_changed().connect (sigc::mem_fun (*this, &PageSizer::on_viewbox_changed)); + _changedvw_connection = _viewboxW.signal_value_changed().connect (sigc::mem_fun (*this, &PageSizer::on_viewbox_changed)); + _changedvh_connection = _viewboxH.signal_value_changed().connect (sigc::mem_fun (*this, &PageSizer::on_viewbox_changed)); show_all_children(); } @@ -744,10 +809,6 @@ void PageSizer::updateScaleUI() { - if (_lockScaleUpdate) { - return; - } - static bool _called = false; if (_called) { return; @@ -756,28 +817,56 @@ PageSizer::updateScaleUI() _called = true; _changeds_connection.block(); + _changedvx_connection.block(); + _changedvy_connection.block(); + _changedvw_connection.block(); + _changedvh_connection.block(); SPDesktop *dt = SP_ACTIVE_DESKTOP; if (dt) { SPDocument *doc = dt->getDocument(); + + // Update scale Geom::Scale scale = doc->getDocumentScale(); - SPNamedView *nv = dt->getNamedView(); std::stringstream ss; ss << _("User units per ") << nv->display_units->abbr << "." ; _scaleLabel.set_text( ss.str() ); - double scaleX_inv = - Inkscape::Util::Quantity::convert( scale[Geom::X], "px", nv->display_units ); - if( scaleX_inv > 0 ) { - _scaleX.setValue(1.0/scaleX_inv); - } else { - // Should never happen - std::cerr << "PageSizer::updateScaleUI(): Invalid scale value: " << scaleX_inv << std::endl; - _scaleX.setValue(1.0); + if( !_lockScaleUpdate ) { + + double scaleX_inv = + Inkscape::Util::Quantity::convert( scale[Geom::X], "px", nv->display_units ); + if( scaleX_inv > 0 ) { + _scaleX.setValue(1.0/scaleX_inv); + } else { + // Should never happen + std::cerr << "PageSizer::updateScaleUI(): Invalid scale value: " << scaleX_inv << std::endl; + _scaleX.setValue(1.0); + } + } + + { // Don't need to lock as scaleY widget not linked to callback. + double scaleY_inv = + Inkscape::Util::Quantity::convert( scale[Geom::Y], "px", nv->display_units ); + if( scaleY_inv > 0 ) { + _scaleY.setValue(1.0/scaleY_inv); + } else { + // Should never happen + std::cerr << "PageSizer::updateScaleUI(): Invalid scale value: " << scaleY_inv << std::endl; + _scaleY.setValue(1.0); + } } + if( !_lockViewboxUpdate ) { + Geom::Rect viewBox = doc->getViewBox(); + _viewboxX.setValue( viewBox.min()[Geom::X] ); + _viewboxY.setValue( viewBox.min()[Geom::Y] ); + _viewboxW.setValue( viewBox.width() ); + _viewboxH.setValue( viewBox.height() ); + } + } else { // Should never happen std::cerr << "PageSizer::updateScaleUI(): No active desktop." << std::endl; @@ -785,6 +874,10 @@ PageSizer::updateScaleUI() } _changeds_connection.unblock(); + _changedvx_connection.unblock(); + _changedvy_connection.unblock(); + _changedvw_connection.unblock(); + _changedvh_connection.unblock(); _called = false; } @@ -801,6 +894,7 @@ PageSizer::on_value_changed() setDim (Inkscape::Util::Quantity(_dimensionWidth.getValue(""), _dimensionUnits.getUnit()), Inkscape::Util::Quantity(_dimensionHeight.getValue(""), _dimensionUnits.getUnit())); } + void PageSizer::on_units_changed() { @@ -830,13 +924,44 @@ PageSizer::on_scale_changed() double scaleX_inv = Inkscape::Util::Quantity(1.0/value, nv->display_units ).value("px"); _lockScaleUpdate = true; - doc->setDocumentScale( 1.0/scaleX_inv ); + doc->setDocumentScale( 1.0/scaleX_inv ); + updateScaleUI(); _lockScaleUpdate = false; DocumentUndo::done(doc, SP_VERB_NONE, _("Set page scale")); } } } +/** + * Callback for viewbox widgets + */ +void +PageSizer::on_viewbox_changed() +{ + if (_widgetRegistry->isUpdating()) return; + + double viewboxX = _viewboxX.getValue(); + double viewboxY = _viewboxY.getValue(); + double viewboxW = _viewboxW.getValue(); + double viewboxH = _viewboxH.getValue(); + + if( viewboxW > 0 && viewboxH > 0) { + SPDesktop *dt = SP_ACTIVE_DESKTOP; + if (dt) { + SPDocument *doc = dt->getDocument(); + _lockViewboxUpdate = true; + doc->setViewBox( Geom::Rect::from_xywh( viewboxX, viewboxY, viewboxW, viewboxH ) ); + updateScaleUI(); + _lockViewboxUpdate = false; + DocumentUndo::done(doc, SP_VERB_NONE, _("Set 'viewBox'")); + } + } else { + std::cerr + << "PageSizer::on_viewbox_changed(): width and height must both be greater than zero." + << std::endl; + } +} + } // namespace Widget } // namespace UI } // namespace Inkscape diff --git a/src/ui/widget/page-sizer.h b/src/ui/widget/page-sizer.h index f9a72d9f3..0eea28e61 100644 --- a/src/ui/widget/page-sizer.h +++ b/src/ui/widget/page-sizer.h @@ -264,17 +264,38 @@ protected: #endif Gtk::Label _scaleLabel; + Gtk::Label _scaleWarning; RegisteredScalar _scaleX; + RegisteredScalar _scaleY; bool _lockScaleUpdate; + // Viewbox + Gtk::Expander _viewboxExpander; +#if WITH_GTKMM_3_0 + Gtk::Grid _viewboxTable; +#else + Gtk::Table _viewboxTable; +#endif + + RegisteredScalar _viewboxX; + RegisteredScalar _viewboxY; + RegisteredScalar _viewboxW; + RegisteredScalar _viewboxH; + bool _lockViewboxUpdate; + //callback void on_value_changed(); void on_units_changed(); void on_scale_changed(); + void on_viewbox_changed(); sigc::connection _changedw_connection; sigc::connection _changedh_connection; sigc::connection _changedu_connection; sigc::connection _changeds_connection; + sigc::connection _changedvx_connection; + sigc::connection _changedvy_connection; + sigc::connection _changedvw_connection; + sigc::connection _changedvh_connection; Registry *_widgetRegistry; -- cgit v1.2.3 From ae1bd880cb7f913509b1b0e2de1fa4aa7e430d15 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Sat, 21 Mar 2015 12:45:38 +0100 Subject: Improve the cache system of bspline, "Correctly" show bspline weight power on nodes and handles (bzr r14023) --- src/ui/tool/curve-drag-point.cpp | 4 ++-- src/ui/tool/node.cpp | 15 ++++++++------- src/ui/tool/path-manipulator.cpp | 21 +++++++++++++++++---- src/ui/tool/path-manipulator.h | 2 +- 4 files changed, 28 insertions(+), 14 deletions(-) diff --git a/src/ui/tool/curve-drag-point.cpp b/src/ui/tool/curve-drag-point.cpp index 49c949107..a90dfb155 100644 --- a/src/ui/tool/curve-drag-point.cpp +++ b/src/ui/tool/curve-drag-point.cpp @@ -54,7 +54,7 @@ bool CurveDragPoint::grabbed(GdkEventMotion */*event*/) // delta is a vector equal 1/3 of distance from first to second Geom::Point delta = (second->position() - first->position()) / 3.0; // only update the nodes if the mode is bspline - if(!_pm.isBSpline(false)){ + if(!_pm.isBSpline()){ first->front()->move(first->front()->position() + delta); second->back()->move(second->back()->position() - delta); } @@ -91,7 +91,7 @@ void CurveDragPoint::dragged(Geom::Point &new_pos, GdkEventMotion *event) Geom::Point offset1 = (weight/(3*t*t*(1-t))) * delta; //modified so that, if the trace is bspline, it only acts if the SHIFT key is pressed - if(!_pm.isBSpline(false)){ + if(!_pm.isBSpline()){ first->front()->move(first->front()->position() + offset0); second->back()->move(second->back()->position() + offset1); }else if(weight>=0.8){ diff --git a/src/ui/tool/node.cpp b/src/ui/tool/node.cpp index eeea47e4d..08cc6708d 100644 --- a/src/ui/tool/node.cpp +++ b/src/ui/tool/node.cpp @@ -192,7 +192,7 @@ void Handle::move(Geom::Point const &new_pos) setRelativePos(new_delta); //move the handler and its oposite the same proportion - if(_pm().isBSpline()){ + if(_pm().isBSpline()){ setPosition(_pm().BSplineHandleReposition(this,this)); this->other()->setPosition(_pm().BSplineHandleReposition(this->other(),this)); } @@ -222,7 +222,6 @@ void Handle::move(Geom::Point const &new_pos) setPosition(_pm().BSplineHandleReposition(this,this)); this->other()->setPosition(_pm().BSplineHandleReposition(this->other(),this)); } - } void Handle::setPosition(Geom::Point const &p) @@ -382,7 +381,7 @@ void Handle::dragged(Geom::Point &new_pos, GdkEventMotion *event) std::vector unselected; //if the snap adjustment is activated and it is not bspline - if (snap && !_pm().isBSpline(false)) { + if (snap && !_pm().isBSpline()) { ControlPointSelection::Set &nodes = _parent->_selection.allPoints(); for (ControlPointSelection::Set::iterator i = nodes.begin(); i != nodes.end(); ++i) { Node *n = static_cast(*i); @@ -486,7 +485,7 @@ Glib::ustring Handle::_getTip(unsigned state) const char const *more; // a trick to mark as bspline if the node has no strength, we are going to use it later // to show the appropiate messages. We cannot do it in any different way becasue the function is constant - + Handle *h = const_cast(this); bool isBSpline = _pm().isBSpline(); bool can_shift_rotate = _parent->type() == NODE_CUSP && !other()->isDegenerate(); if (can_shift_rotate && !isBSpline) { @@ -550,7 +549,7 @@ Glib::ustring Handle::_getTip(unsigned state) const "Auto node handle: drag to convert to smooth node (%s)"), more); }else{ return format_tip(C_("Path handle tip", - "BSpline node handle: Shift to drag, double click to reset (%s)"), more); + "BSpline node handle: Shift to drag, double click to reset (%s). %g power"),more,_pm().BSplineHandlePosition(h,NULL)); } } } @@ -1435,6 +1434,8 @@ Node *Node::nodeAwayFrom(Handle *h) Glib::ustring Node::_getTip(unsigned state) const { bool isBSpline = _pm().isBSpline(); + Handle *h = const_cast(&_front); + Handle *h2 = const_cast(&_back); if (state_held_shift(state)) { bool can_drag_out = (_next() && _front.isDegenerate()) || (_prev() && _back.isDegenerate()); if (can_drag_out) { @@ -1469,7 +1470,7 @@ Glib::ustring Node::_getTip(unsigned state) const "%s: drag to shape the path (more: Shift, Ctrl, Alt)"), nodetype); }else if(_selection.size() == 1){ return format_tip(C_("Path node tip", - "BSpline node: %g weight, drag to shape the path (more: Shift, Ctrl, Alt)"),noPower/*this->bsplineWeight*/); + "BSpline node: drag to shape the path (more: Shift, Ctrl, Alt). %g power"),_pm().BSplineHandlePosition(h,h2)); } return format_tip(C_("Path node tip", "%s: drag to shape the path, click to toggle scale/rotation handles (more: Shift, Ctrl, Alt)"), nodetype); @@ -1479,7 +1480,7 @@ Glib::ustring Node::_getTip(unsigned state) const "%s: drag to shape the path, click to select only this node (more: Shift, Ctrl, Alt)"), nodetype); }else{ return format_tip(C_("Path node tip", - "BSpline node: drag to shape the path, click to select only this node (more: Shift, Ctrl, Alt)")); + "BSpline node: drag to shape the path, click to select only this node (more: Shift, Ctrl, Alt). %g power"),_pm().BSplineHandlePosition(h,h2)); } } diff --git a/src/ui/tool/path-manipulator.cpp b/src/ui/tool/path-manipulator.cpp index dbcde240a..8b735f3e6 100644 --- a/src/ui/tool/path-manipulator.cpp +++ b/src/ui/tool/path-manipulator.cpp @@ -1240,17 +1240,29 @@ int PathManipulator::BSplineGetSteps() const { // determines if the trace has bspline effect bool PathManipulator::isBSpline(bool recalculate){ if(recalculate){ - _is_bspline = this->BSplineGetSteps() > 0; + SPLPEItem * path = dynamic_cast(_path); + if (path){ + if(path->hasPathEffect()){ + Inkscape::LivePathEffect::Effect const *thisEffect = path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE); + if(thisEffect){ + _is_bspline = true; + return _is_bspline; + } + } + } + } + _is_bspline = false; return _is_bspline; } bool PathManipulator::isBSpline() const { - return BSplineGetSteps() > 0; + return _is_bspline; } // returns the corresponding strength to the position of the handlers -double PathManipulator::BSplineHandlePosition(Handle *h, Handle *h2){ +double PathManipulator::BSplineHandlePosition(Handle *h, Handle *h2) +{ using Geom::X; using Geom::Y; if(h2){ @@ -1275,7 +1287,8 @@ double PathManipulator::BSplineHandlePosition(Handle *h, Handle *h2){ } // give the location for the handler in the corresponding position -Geom::Point PathManipulator::BSplineHandleReposition(Handle *h, Handle *h2){ +Geom::Point PathManipulator::BSplineHandleReposition(Handle *h, Handle *h2) +{ double pos = this->BSplineHandlePosition(h, h2); return BSplineHandleReposition(h,pos); } diff --git a/src/ui/tool/path-manipulator.h b/src/ui/tool/path-manipulator.h index 4d2bf4300..4badec569 100644 --- a/src/ui/tool/path-manipulator.h +++ b/src/ui/tool/path-manipulator.h @@ -107,7 +107,7 @@ private: void _createControlPointsFromGeometry(); - bool isBSpline(bool recalculate = false); + bool isBSpline(bool recalculate); bool isBSpline() const; double BSplineHandlePosition(Handle *h, Handle *h2 = NULL); Geom::Point BSplineHandleReposition(Handle *h, Handle *h2 = NULL); -- cgit v1.2.3 From 0ac42882cbf0cd6bfaab7ee8576ea73eb6e92936 Mon Sep 17 00:00:00 2001 From: Tavmjong Bah Date: Sat, 21 Mar 2015 16:26:27 +0100 Subject: Fix GTK3 build (typo). (bzr r14024) --- src/ui/widget/page-sizer.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ui/widget/page-sizer.cpp b/src/ui/widget/page-sizer.cpp index 8c86daea0..0a5697661 100644 --- a/src/ui/widget/page-sizer.cpp +++ b/src/ui/widget/page-sizer.cpp @@ -495,7 +495,7 @@ PageSizer::PageSizer(Registry & _wr) _viewboxW.set_hexpand(); _viewboxW.set_vexpand(); - _viewboxTable.attach(_viewbox, 0, 1, 1, 1); + _viewboxTable.attach(_viewboxW, 0, 1, 1, 1); _viewboxH.set_hexpand(); _viewboxH.set_vexpand(); -- cgit v1.2.3 From b13875d6c37d2a5a6857d7fd06ce0661f86a1c8e Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Sat, 21 Mar 2015 20:21:53 +0100 Subject: Cleanup headers in BSpline LPE (bzr r14025) --- src/live_effects/lpe-bspline.cpp | 44 ++++++---------------------------------- src/live_effects/lpe-bspline.h | 3 +-- 2 files changed, 7 insertions(+), 40 deletions(-) diff --git a/src/live_effects/lpe-bspline.cpp b/src/live_effects/lpe-bspline.cpp index b924d8a23..dba501f42 100644 --- a/src/live_effects/lpe-bspline.cpp +++ b/src/live_effects/lpe-bspline.cpp @@ -1,48 +1,16 @@ /* * Released under GNU GPL, read the file 'COPYING' for more information */ - -#ifdef HAVE_CONFIG_H -# include -#endif - #include - -#if WITH_GLIBMM_2_32 -# include -#endif - -#include -#include - - -#include "display/curve.h" -#include <2geom/bezier-curve.h> -#include <2geom/point.h> -#include "helper/geom-curves.h" #include "live_effects/lpe-bspline.h" -#include "live_effects/lpeobject.h" -#include "live_effects/parameter/parameter.h" #include "ui/widget/scalar.h" -#include "xml/repr.h" -#include "svg/svg.h" +#include "display/curve.h" +#include "helper/geom-curves.h" #include "sp-path.h" -#include "style.h" -#include "document-private.h" -#include "document.h" -#include "document-undo.h" -#include "verbs.h" -#include "sp-lpe-item.h" -#include "sp-namedview.h" -#include "display/sp-canvas.h" -#include -#include -#include "util/units.h" -// For handling un-continuous paths: -#include "message-stack.h" -#include "inkscape.h" - -using Inkscape::DocumentUndo; +#include "svg/svg.h" +#include "xml/repr.h" +// TODO due to internal breakage in glibmm headers, this must be last: +#include namespace Inkscape { namespace LivePathEffect { diff --git a/src/live_effects/lpe-bspline.h b/src/live_effects/lpe-bspline.h index 642562b24..8017e39ef 100644 --- a/src/live_effects/lpe-bspline.h +++ b/src/live_effects/lpe-bspline.h @@ -6,9 +6,8 @@ * * Released under GNU GPL, read the file 'COPYING' for more information */ - #include "live_effects/effect.h" -#include "live_effects/parameter/bool.h" + #include namespace Inkscape { -- cgit v1.2.3 From 06adc7b92c491fb3eaa6a6be2a8bb0e940c8ba81 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Sat, 21 Mar 2015 22:23:39 +0100 Subject: Fix a bug in multi-path-manipulator and finish bspline refactor (bzr r14026) --- src/ui/tool/multi-path-manipulator.h | 2 +- src/ui/tool/path-manipulator.cpp | 26 +++++++++++--------------- src/ui/tool/path-manipulator.h | 2 +- 3 files changed, 13 insertions(+), 17 deletions(-) diff --git a/src/ui/tool/multi-path-manipulator.h b/src/ui/tool/multi-path-manipulator.h index cdbf34e9d..1bbcdd7ec 100644 --- a/src/ui/tool/multi-path-manipulator.h +++ b/src/ui/tool/multi-path-manipulator.h @@ -39,7 +39,7 @@ public: virtual bool event(Inkscape::UI::Tools::ToolBase *, GdkEvent *event); bool empty() { return _mmap.empty(); } - unsigned size() { return _mmap.empty(); } + unsigned size() { return _mmap.size(); } void setItems(std::set const &); void clear() { _mmap.clear(); } void cleanup(); diff --git a/src/ui/tool/path-manipulator.cpp b/src/ui/tool/path-manipulator.cpp index 8b735f3e6..b1e4d641e 100644 --- a/src/ui/tool/path-manipulator.cpp +++ b/src/ui/tool/path-manipulator.cpp @@ -11,6 +11,7 @@ */ #include "live_effects/lpe-powerstroke.h" +#include "live_effects/lpe-bspline.h" #include "live_effects/lpe-fillet-chamfer.h" #include #include @@ -43,7 +44,6 @@ #include "ui/tool/multi-path-manipulator.h" #include "xml/node.h" #include "xml/node-observer.h" -#include "live_effects/lpe-bspline.h" namespace Inkscape { namespace UI { @@ -151,7 +151,7 @@ PathManipulator::PathManipulator(MultiPathManipulator &mpm, SPPath *path, _createControlPointsFromGeometry(); //Define if the path is BSpline on construction - isBSpline(true); + recalculateIsBSpline(); } PathManipulator::~PathManipulator() @@ -1238,22 +1238,18 @@ int PathManipulator::BSplineGetSteps() const { } // determines if the trace has bspline effect -bool PathManipulator::isBSpline(bool recalculate){ - if(recalculate){ - SPLPEItem * path = dynamic_cast(_path); - if (path){ - if(path->hasPathEffect()){ - Inkscape::LivePathEffect::Effect const *thisEffect = path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE); - if(thisEffect){ - _is_bspline = true; - return _is_bspline; - } +void PathManipulator::recalculateIsBSpline(){ + SPLPEItem * path = dynamic_cast(_path); + if (path){ + if(path->hasPathEffect()){ + Inkscape::LivePathEffect::Effect const *thisEffect = path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE); + if(thisEffect){ + _is_bspline = true; + return; } } - } _is_bspline = false; - return _is_bspline; } bool PathManipulator::isBSpline() const { @@ -1325,7 +1321,7 @@ void PathManipulator::_createGeometryFromControlPoints(bool alert_LPE) { Geom::PathBuilder builder; //Refresh if is bspline some times -think on path change selection, this value get lost - isBSpline(true); + recalculateIsBSpline(); for (std::list::iterator spi = _subpaths.begin(); spi != _subpaths.end(); ) { SubpathPtr subpath = *spi; if (subpath->empty()) { diff --git a/src/ui/tool/path-manipulator.h b/src/ui/tool/path-manipulator.h index 4badec569..6dc1c9d09 100644 --- a/src/ui/tool/path-manipulator.h +++ b/src/ui/tool/path-manipulator.h @@ -107,7 +107,7 @@ private: void _createControlPointsFromGeometry(); - bool isBSpline(bool recalculate); + void recalculateIsBSpline(); bool isBSpline() const; double BSplineHandlePosition(Handle *h, Handle *h2 = NULL); Geom::Point BSplineHandleReposition(Handle *h, Handle *h2 = NULL); -- cgit v1.2.3 From f2f410ca16f49a676413deac914c4a2bed14d041 Mon Sep 17 00:00:00 2001 From: "Liam P. White" Date: Sun, 22 Mar 2015 01:01:50 -0400 Subject: improve, optimize, fix path outliner (bzr r14027) --- src/helper/geom-pathstroke.cpp | 183 +++++++++++++++++++++++++---------------- 1 file changed, 112 insertions(+), 71 deletions(-) diff --git a/src/helper/geom-pathstroke.cpp b/src/helper/geom-pathstroke.cpp index 1b8f90104..6fcfb79d5 100644 --- a/src/helper/geom-pathstroke.cpp +++ b/src/helper/geom-pathstroke.cpp @@ -11,6 +11,7 @@ #include <2geom/bezier-curve.h> #include <2geom/svg-elliptical-arc.h> #include <2geom/sbasis-to-bezier.h> // cubicbezierpath_from_sbasis +#include <2geom/path-intersection.h> #include "helper/geom-pathstroke.h" @@ -57,16 +58,28 @@ static Circle touching_circle( D2 const &curve, double t, double tol=0.0 namespace { +// Join functions may: +// - inspect any curve of the current path +// - append any type of curve to the current path +// - inspect the outgoing path +// +// Join functions must: +// - append the outgoing curve +// OR +// - end at outgoing.finalPoint + typedef void join_func(Geom::Path& res, Geom::Curve const& outgoing, double miter, double width); void bevel_join(Geom::Path& res, Geom::Curve const& outgoing, double /*miter*/, double /*width*/) { res.appendNew(outgoing.initialPoint()); + res.append(outgoing); } void round_join(Geom::Path& res, Geom::Curve const& outgoing, double /*miter*/, double width) { res.appendNew(width, width, 0, false, width <= 0, outgoing.initialPoint()); + res.append(outgoing); } void miter_join(Geom::Path& res, Geom::Curve const& outgoing, double miter, double width) @@ -81,18 +94,25 @@ void miter_join(Geom::Path& res, Geom::Curve const& outgoing, double miter, doub double len = Geom::distance(p, point_on_path); if (len <= miter) { // miter OK, check to see if we can do a relocation - // TODO FIXME - /*if (auto line = cast(const(LineSegment))res.back_open) { - Curve copy = line.duplicate; - copy.setFinal(p); - res.erase_last(); - res.append(copy); - } else {*/ + bool ls = dynamic_cast(&res.back_open()); + if (ls) { + res.setFinal(p); + } else { res.appendNew(p); - //} + } } } + res.appendNew(outgoing.initialPoint()); + + // check if we can do another relocation + + bool ls = dynamic_cast(&outgoing); + if (ls) { + res.setFinal(outgoing.finalPoint()); + } else { + res.append(outgoing); + } } // might need a little reworking @@ -152,6 +172,7 @@ void extrapolate_join(Geom::Path& path_builder, Geom::Curve const& outgoing, dou printf("WARNING: Error extrapolating line join: %s\n", ex.what()); path_builder.appendNew(endPt); } + path_builder.append(outgoing); } else { // 1 or no solutions found, default to miter miter_join(path_builder, outgoing, miter_limit, line_width); @@ -164,11 +185,36 @@ void extrapolate_join(Geom::Path& path_builder, Geom::Curve const& outgoing, dou void join_inside(Geom::Path& res, Geom::Curve const& outgoing) { - res.appendNew(outgoing.initialPoint()); + Geom::Curve const& incoming = res.back_open(); + Geom::Crossings cross = Geom::crossings(incoming, outgoing); + + if (!cross.empty()) { + // yeah if we could avoid allocing that'd be great + Geom::Curve *d1 = incoming.portion(0., cross[0].ta); + res.erase_last(); + res.append(*d1); + delete d1; + + Geom::Curve *d2 = outgoing.portion(cross[0].tb, 1.); + res.setFinal(d2->initialPoint()); + res.append(*d2); + delete d2; + } else { + res.appendNew(outgoing.initialPoint()); + res.append(outgoing); + } } void outline_helper(Geom::Path& res, Geom::Path const& to_add, double width, double miter, Inkscape::LineJoinType join) { + Geom::Curve const& outgoing = to_add[0]; + if (Geom::are_near(res.finalPoint(), outgoing.initialPoint())) { + // if the points are /that/ close, just ignore this one + res.setFinal(outgoing.initialPoint()); + res.append(outgoing); + return; + } + Geom::Point tang1 = -Geom::unitTangentAt(reverse(res.back().toSBasis()), 0.); //Geom::Point tang2 = to_add[0].unitTangentAt(0); Geom::Point discontinuity_vec = to_add.initialPoint() - res.finalPoint(); @@ -189,12 +235,10 @@ void outline_helper(Geom::Path& res, Geom::Path const& to_add, double width, dou default: jf = &miter_join; } - jf(res, to_add[0], miter, width); + jf(res, outgoing, miter, width); } else { - join_inside(res, to_add[0]); + join_inside(res, outgoing); } - - res.append(to_add); } // Offsetting a line segment is mathematically stable and quick to do @@ -359,8 +403,40 @@ void offset_curve(Geom::Path& res, Geom::Curve const* current, double width) } } +typedef void cap_func(Geom::PathBuilder& res, Geom::Path const& with_dir, Geom::Path const& against_dir, double width); + +void flat_cap(Geom::PathBuilder& res, Geom::Path const&, Geom::Path const& against_dir, double) +{ + res.lineTo(against_dir.initialPoint()); +} + +void round_cap(Geom::PathBuilder& res, Geom::Path const&, Geom::Path const& against_dir, double width) +{ + res.arcTo(width / 2., width / 2., 0., true, false, against_dir.initialPoint()); +} + +void square_cap(Geom::PathBuilder& res, Geom::Path const& with_dir, Geom::Path const& against_dir, double width) +{ + width /= 2.; + Geom::Point normal_1 = -Geom::unitTangentAt(Geom::reverse(with_dir.back().toSBasis()), 0.); + Geom::Point normal_2 = -against_dir[0].unitTangentAt(0.); + res.lineTo(with_dir.finalPoint() + normal_1*width); + res.lineTo(against_dir.initialPoint() + normal_2*width); + res.lineTo(against_dir.initialPoint()); +} + +void peak_cap(Geom::PathBuilder& res, Geom::Path const& with_dir, Geom::Path const& against_dir, double width) +{ + width /= 2.; + Geom::Point normal_1 = -Geom::unitTangentAt(Geom::reverse(with_dir.back().toSBasis()), 0.); + Geom::Point normal_2 = -against_dir[0].unitTangentAt(0.); + Geom::Point midpoint = ((with_dir.finalPoint() + normal_1*width) + (against_dir.initialPoint() + normal_2*width)) * 0.5; + res.lineTo(midpoint); + res.lineTo(against_dir.initialPoint()); } +} // namespace + namespace Inkscape { Geom::PathVector outline(Geom::Path const& input, double width, double miter, LineJoinType join, LineCapType butt) @@ -374,33 +450,24 @@ Geom::PathVector outline(Geom::Path const& input, double width, double miter, Li res.moveTo(with_dir[0].initialPoint()); res.append(with_dir); + cap_func *cf; + switch (butt) { + case BUTT_ROUND: + cf = &round_cap; + break; + case BUTT_SQUARE: + cf = &square_cap; + break; + case BUTT_PEAK: + cf = &peak_cap; + break; + default: + cf = &flat_cap; + } + // glue caps if (!input.closed()) { - switch (butt) { - case BUTT_ROUND: - res.arcTo(width / 2., width / 2., 0., true, false, against_dir.initialPoint()); - break; - case BUTT_SQUARE: { - Geom::Point end_deriv = -Geom::unitTangentAt(Geom::reverse(input[input.size()-1].toSBasis()), 0.); - double radius = 0.5 * Geom::distance(with_dir.finalPoint(), against_dir.initialPoint()); - res.lineTo(with_dir.finalPoint() + end_deriv*radius); - res.lineTo(against_dir.initialPoint() + end_deriv*radius); - res.lineTo(against_dir.initialPoint()); - break; - } - case BUTT_PEAK: { - Geom::Point end_deriv = -Geom::unitTangentAt(Geom::reverse(input[input.size()-1].toSBasis()), 0.); - double radius = 0.5 * Geom::distance(with_dir.finalPoint(), against_dir.initialPoint()); - Geom::Point midpoint = ((with_dir.finalPoint() + against_dir.initialPoint()) * 0.5) + end_deriv*radius; - res.lineTo(midpoint); - res.lineTo(against_dir.initialPoint()); - break; - } - case BUTT_FLAT: - default: - res.lineTo(against_dir.initialPoint()); - break; - } + cf(res, with_dir, against_dir, width); } else { res.moveTo(against_dir.initialPoint()); } @@ -408,30 +475,7 @@ Geom::PathVector outline(Geom::Path const& input, double width, double miter, Li res.append(against_dir); if (!input.closed()) { - switch(butt) { - case BUTT_ROUND: - res.arcTo(width / 2., width / 2., 0., true, false, with_dir.initialPoint()); - break; - case BUTT_SQUARE: { - Geom::Point end_deriv = -input[0].unitTangentAt(0.); - double radius = 0.5 * Geom::distance(against_dir.finalPoint(), with_dir.initialPoint()); - res.lineTo(against_dir.finalPoint() + end_deriv*radius); - res.lineTo(with_dir.initialPoint() + end_deriv*radius); - res.lineTo(with_dir.initialPoint()); - break; - } - case BUTT_PEAK: { - Geom::Point end_deriv = -input[0].unitTangentAt(0.); - double radius = 0.5 * Geom::distance(against_dir.finalPoint(), with_dir.initialPoint()); - Geom::Point midpoint = ((against_dir.finalPoint() + with_dir.initialPoint()) * 0.5) + end_deriv*radius; - res.lineTo(midpoint); - res.lineTo(with_dir.initialPoint()); - break; - } - case BUTT_FLAT: - default: - res.lineTo(with_dir.initialPoint()); - } + cf(res, against_dir, with_dir, width); res.closePath(); } @@ -451,7 +495,8 @@ Geom::Path half_outline(Geom::Path const& input, double width, double miter, Lin res.start(start); // Do two curves at a time for efficiency, since the join function needs to know the outgoing curve as well - const size_t k = input.size_default(); + const size_t k = (input.back_closed().isDegenerate() && input.closed()) + ?input.size_default()-1:input.size_default(); for (size_t u = 0; u < k; u += 2) { temp = Geom::Path(); @@ -462,6 +507,7 @@ Geom::Path half_outline(Geom::Path const& input, double width, double miter, Lin res.append(temp); } else { outline_helper(res, temp, width, miter, join); + res.insert(res.end(), ++temp.begin(), temp.end()); } // odd number of paths @@ -469,15 +515,11 @@ Geom::Path half_outline(Geom::Path const& input, double width, double miter, Lin temp = Geom::Path(); offset_curve(temp, &input[u+1], width); outline_helper(res, temp, width, miter, join); + res.insert(res.end(), ++temp.begin(), temp.end()); } } if (input.closed()) { - if (input.back_closed().isDegenerate()) { - res.erase_last(); - res.erase_last(); // ? - } - Geom::Curve const &c1 = res.back(); Geom::Curve const &c2 = res.front(); temp = Geom::Path(); @@ -485,9 +527,8 @@ Geom::Path half_outline(Geom::Path const& input, double width, double miter, Lin Geom::Path temp2; temp2.append(c2); outline_helper(temp, temp2, width, miter, join); - temp.erase_last(); // we already outlined c2 - temp.erase(temp.begin()); // we already outlined c1 - + res.erase(res.begin()); + res.erase_last(); // res.append(temp); res.close(); -- cgit v1.2.3 From 67868b4bba3c015b07ee0f91d6a660288e77a203 Mon Sep 17 00:00:00 2001 From: Janis Eisaks Date: Sun, 22 Mar 2015 14:05:47 +0200 Subject: Latvian translation update (bzr r14028) --- po/lv.po | 762 +++++++++++++++++++++++++++++++++++++-------------------------- 1 file changed, 443 insertions(+), 319 deletions(-) diff --git a/po/lv.po b/po/lv.po index 1d15f8461..8d6e1e11c 100644 --- a/po/lv.po +++ b/po/lv.po @@ -7,8 +7,8 @@ msgid "" msgstr "" "Project-Id-Version: Inkscape\n" "Report-Msgid-Bugs-To: inkscape-devel@lists.sourceforge.net\n" -"POT-Creation-Date: 2015-02-27 20:13+0100\n" -"PO-Revision-Date: 2015-03-01 17:37+0200\n" +"POT-Creation-Date: 2015-03-10 09:10+0100\n" +"PO-Revision-Date: 2015-03-22 14:04+0200\n" "Last-Translator: Jānis Eisaks \n" "Language-Team: Latvian \n" "Language: lv\n" @@ -936,17 +936,17 @@ msgstr "Melna gaisma" #: ../share/filters/filters.svg.h:411 ../share/filters/filters.svg.h:575 ../share/filters/filters.svg.h:587 ../share/filters/filters.svg.h:627 ../share/filters/filters.svg.h:631 ../share/filters/filters.svg.h:819 #: ../share/filters/filters.svg.h:827 ../share/filters/filters.svg.h:831 ../src/extension/internal/bitmap/colorize.cpp:52 ../src/extension/internal/filter/bumps.h:101 ../src/extension/internal/filter/bumps.h:321 -#: ../src/extension/internal/filter/bumps.h:328 ../src/extension/internal/filter/color.h:82 ../src/extension/internal/filter/color.h:164 ../src/extension/internal/filter/color.h:171 ../src/extension/internal/filter/color.h:262 -#: ../src/extension/internal/filter/color.h:340 ../src/extension/internal/filter/color.h:347 ../src/extension/internal/filter/color.h:437 ../src/extension/internal/filter/color.h:532 ../src/extension/internal/filter/color.h:654 -#: ../src/extension/internal/filter/color.h:751 ../src/extension/internal/filter/color.h:830 ../src/extension/internal/filter/color.h:921 ../src/extension/internal/filter/color.h:1049 ../src/extension/internal/filter/color.h:1119 -#: ../src/extension/internal/filter/color.h:1212 ../src/extension/internal/filter/color.h:1324 ../src/extension/internal/filter/color.h:1429 ../src/extension/internal/filter/color.h:1505 ../src/extension/internal/filter/color.h:1609 -#: ../src/extension/internal/filter/color.h:1616 ../src/extension/internal/filter/morphology.h:194 ../src/extension/internal/filter/overlays.h:73 ../src/extension/internal/filter/paint.h:99 ../src/extension/internal/filter/paint.h:713 -#: ../src/extension/internal/filter/paint.h:717 ../src/extension/internal/filter/shadows.h:73 ../src/extension/internal/filter/transparency.h:345 ../src/filter-enums.cpp:67 ../src/ui/dialog/clonetiler.cpp:830 -#: ../src/ui/dialog/clonetiler.cpp:981 ../src/ui/dialog/document-properties.cpp:164 ../share/extensions/color_HSL_adjust.inx.h:20 ../share/extensions/color_blackandwhite.inx.h:3 ../share/extensions/color_brighter.inx.h:2 -#: ../share/extensions/color_custom.inx.h:15 ../share/extensions/color_darker.inx.h:2 ../share/extensions/color_desaturate.inx.h:2 ../share/extensions/color_grayscale.inx.h:2 ../share/extensions/color_lesshue.inx.h:2 -#: ../share/extensions/color_lesslight.inx.h:2 ../share/extensions/color_lesssaturation.inx.h:2 ../share/extensions/color_morehue.inx.h:2 ../share/extensions/color_morelight.inx.h:2 ../share/extensions/color_moresaturation.inx.h:2 -#: ../share/extensions/color_negative.inx.h:2 ../share/extensions/color_randomize.inx.h:8 ../share/extensions/color_removeblue.inx.h:2 ../share/extensions/color_removegreen.inx.h:2 ../share/extensions/color_removered.inx.h:2 -#: ../share/extensions/color_replace.inx.h:6 ../share/extensions/color_rgbbarrel.inx.h:2 ../share/extensions/interp_att_g.inx.h:19 +#: ../src/extension/internal/filter/bumps.h:328 ../src/extension/internal/filter/color.h:83 ../src/extension/internal/filter/color.h:165 ../src/extension/internal/filter/color.h:172 ../src/extension/internal/filter/color.h:283 +#: ../src/extension/internal/filter/color.h:337 ../src/extension/internal/filter/color.h:415 ../src/extension/internal/filter/color.h:422 ../src/extension/internal/filter/color.h:512 ../src/extension/internal/filter/color.h:607 +#: ../src/extension/internal/filter/color.h:729 ../src/extension/internal/filter/color.h:826 ../src/extension/internal/filter/color.h:905 ../src/extension/internal/filter/color.h:996 ../src/extension/internal/filter/color.h:1124 +#: ../src/extension/internal/filter/color.h:1194 ../src/extension/internal/filter/color.h:1287 ../src/extension/internal/filter/color.h:1399 ../src/extension/internal/filter/color.h:1504 ../src/extension/internal/filter/color.h:1580 +#: ../src/extension/internal/filter/color.h:1684 ../src/extension/internal/filter/color.h:1691 ../src/extension/internal/filter/morphology.h:194 ../src/extension/internal/filter/overlays.h:73 ../src/extension/internal/filter/paint.h:99 +#: ../src/extension/internal/filter/paint.h:713 ../src/extension/internal/filter/paint.h:717 ../src/extension/internal/filter/shadows.h:73 ../src/extension/internal/filter/transparency.h:345 ../src/filter-enums.cpp:67 +#: ../src/ui/dialog/clonetiler.cpp:830 ../src/ui/dialog/clonetiler.cpp:981 ../src/ui/dialog/document-properties.cpp:164 ../share/extensions/color_HSL_adjust.inx.h:20 ../share/extensions/color_blackandwhite.inx.h:3 +#: ../share/extensions/color_brighter.inx.h:2 ../share/extensions/color_custom.inx.h:15 ../share/extensions/color_darker.inx.h:2 ../share/extensions/color_desaturate.inx.h:2 ../share/extensions/color_grayscale.inx.h:2 +#: ../share/extensions/color_lesshue.inx.h:2 ../share/extensions/color_lesslight.inx.h:2 ../share/extensions/color_lesssaturation.inx.h:2 ../share/extensions/color_morehue.inx.h:2 ../share/extensions/color_morelight.inx.h:2 +#: ../share/extensions/color_moresaturation.inx.h:2 ../share/extensions/color_negative.inx.h:2 ../share/extensions/color_randomize.inx.h:8 ../share/extensions/color_removeblue.inx.h:2 ../share/extensions/color_removegreen.inx.h:2 +#: ../share/extensions/color_removered.inx.h:2 ../share/extensions/color_replace.inx.h:6 ../share/extensions/color_rgbbarrel.inx.h:2 ../share/extensions/interp_att_g.inx.h:19 msgid "Color" msgstr "Krāsa" @@ -4815,7 +4815,7 @@ msgid "Add Noise" msgstr "Pievienot troksni" #. _settings->add_checkbutton(false, SP_ATTR_STITCHTILES, _("Stitch Tiles"), "stitch", "noStitch"); -#: ../src/extension/internal/bitmap/addNoise.cpp:47 ../src/extension/internal/filter/color.h:426 ../src/extension/internal/filter/color.h:1497 ../src/extension/internal/filter/color.h:1585 ../src/extension/internal/filter/distort.h:69 +#: ../src/extension/internal/bitmap/addNoise.cpp:47 ../src/extension/internal/filter/color.h:501 ../src/extension/internal/filter/color.h:1572 ../src/extension/internal/filter/color.h:1660 ../src/extension/internal/filter/distort.h:69 #: ../src/extension/internal/filter/morphology.h:60 ../src/rdf.cpp:244 ../src/ui/dialog/filter-effects-dialog.cpp:2842 ../src/ui/dialog/filter-effects-dialog.cpp:2916 ../src/ui/dialog/object-attributes.cpp:49 #: ../share/extensions/jessyInk_effects.inx.h:5 ../share/extensions/jessyInk_export.inx.h:3 ../share/extensions/jessyInk_transitions.inx.h:5 ../share/extensions/webslicer_create_rect.inx.h:14 msgid "Type:" @@ -4923,7 +4923,7 @@ msgstr "Kokogle" msgid "Apply charcoal stylization to selected bitmap(s)" msgstr "Alfa -> iezīmētai" -#: ../src/extension/internal/bitmap/colorize.cpp:50 ../src/extension/internal/filter/color.h:317 +#: ../src/extension/internal/bitmap/colorize.cpp:50 ../src/extension/internal/filter/color.h:392 msgid "Colorize" msgstr "Tonēšana" @@ -4931,7 +4931,7 @@ msgstr "Tonēšana" msgid "Colorize selected bitmap(s) with specified color, using given opacity" msgstr "Krāsot atlasīto(-ās) bitkarti(-es) ar norādīto krāsu, izmantojot doto necauspīdīgumu" -#: ../src/extension/internal/bitmap/contrast.cpp:40 ../src/extension/internal/filter/color.h:1114 +#: ../src/extension/internal/bitmap/contrast.cpp:40 ../src/extension/internal/filter/color.h:1189 msgid "Contrast" msgstr "Kontrasts" @@ -5039,7 +5039,7 @@ msgstr "Implozija" msgid "Implode selected bitmap(s)" msgstr "Implodēt atlasīto(-ās) bitkarti(-es)" -#: ../src/extension/internal/bitmap/level.cpp:41 ../src/extension/internal/filter/color.h:742 ../src/extension/internal/filter/image.h:56 ../src/extension/internal/filter/morphology.h:66 ../src/extension/internal/filter/paint.h:345 +#: ../src/extension/internal/bitmap/level.cpp:41 ../src/extension/internal/filter/color.h:817 ../src/extension/internal/filter/image.h:56 ../src/extension/internal/filter/morphology.h:66 ../src/extension/internal/filter/paint.h:345 msgid "Level" msgstr "Līmenis" @@ -5063,7 +5063,7 @@ msgstr "Līmeņojiet atlasīto(-ās) bitkarti(-es) mainot vērtības starp norā msgid "Level (with Channel)" msgstr "Līmenis (ar kanālu)" -#: ../src/extension/internal/bitmap/levelChannel.cpp:54 ../src/extension/internal/filter/color.h:636 +#: ../src/extension/internal/bitmap/levelChannel.cpp:54 ../src/extension/internal/filter/color.h:711 msgid "Channel:" msgstr "Kanāls:" @@ -5192,7 +5192,7 @@ msgstr "Ēnot atlasīto(-ās) bitkarti(-es) ar šķietamu, attālinātu gaismas msgid "Sharpen selected bitmap(s)" msgstr "Palielināt atlasītās(-o) bitkartes(-šu) asumu" -#: ../src/extension/internal/bitmap/solarize.cpp:39 ../src/extension/internal/filter/color.h:1494 ../src/extension/internal/filter/color.h:1498 +#: ../src/extension/internal/bitmap/solarize.cpp:39 ../src/extension/internal/filter/color.h:1569 ../src/extension/internal/filter/color.h:1573 msgid "Solarize" msgstr "Solarizācija" @@ -5527,15 +5527,16 @@ msgstr "Gaismas krāsa" #: ../src/extension/internal/filter/bevels.h:62 ../src/extension/internal/filter/bevels.h:143 ../src/extension/internal/filter/bevels.h:227 ../src/extension/internal/filter/blurs.h:62 ../src/extension/internal/filter/blurs.h:131 #: ../src/extension/internal/filter/blurs.h:200 ../src/extension/internal/filter/blurs.h:266 ../src/extension/internal/filter/blurs.h:350 ../src/extension/internal/filter/bumps.h:141 ../src/extension/internal/filter/bumps.h:361 -#: ../src/extension/internal/filter/color.h:81 ../src/extension/internal/filter/color.h:170 ../src/extension/internal/filter/color.h:261 ../src/extension/internal/filter/color.h:346 ../src/extension/internal/filter/color.h:436 -#: ../src/extension/internal/filter/color.h:531 ../src/extension/internal/filter/color.h:653 ../src/extension/internal/filter/color.h:750 ../src/extension/internal/filter/color.h:829 ../src/extension/internal/filter/color.h:920 -#: ../src/extension/internal/filter/color.h:1048 ../src/extension/internal/filter/color.h:1118 ../src/extension/internal/filter/color.h:1211 ../src/extension/internal/filter/color.h:1323 ../src/extension/internal/filter/color.h:1428 -#: ../src/extension/internal/filter/color.h:1504 ../src/extension/internal/filter/color.h:1615 ../src/extension/internal/filter/distort.h:95 ../src/extension/internal/filter/distort.h:204 ../src/extension/internal/filter/filter-file.cpp:151 -#: ../src/extension/internal/filter/filter.cpp:214 ../src/extension/internal/filter/image.h:61 ../src/extension/internal/filter/morphology.h:75 ../src/extension/internal/filter/morphology.h:202 ../src/extension/internal/filter/overlays.h:79 -#: ../src/extension/internal/filter/paint.h:112 ../src/extension/internal/filter/paint.h:243 ../src/extension/internal/filter/paint.h:362 ../src/extension/internal/filter/paint.h:506 ../src/extension/internal/filter/paint.h:601 -#: ../src/extension/internal/filter/paint.h:724 ../src/extension/internal/filter/paint.h:876 ../src/extension/internal/filter/paint.h:980 ../src/extension/internal/filter/protrusions.h:54 ../src/extension/internal/filter/shadows.h:80 -#: ../src/extension/internal/filter/textures.h:90 ../src/extension/internal/filter/transparency.h:69 ../src/extension/internal/filter/transparency.h:140 ../src/extension/internal/filter/transparency.h:214 -#: ../src/extension/internal/filter/transparency.h:287 ../src/extension/internal/filter/transparency.h:349 ../src/ui/dialog/inkscape-preferences.cpp:1751 +#: ../src/extension/internal/filter/color.h:82 ../src/extension/internal/filter/color.h:171 ../src/extension/internal/filter/color.h:282 ../src/extension/internal/filter/color.h:336 ../src/extension/internal/filter/color.h:421 +#: ../src/extension/internal/filter/color.h:511 ../src/extension/internal/filter/color.h:606 ../src/extension/internal/filter/color.h:728 ../src/extension/internal/filter/color.h:825 ../src/extension/internal/filter/color.h:904 +#: ../src/extension/internal/filter/color.h:995 ../src/extension/internal/filter/color.h:1123 ../src/extension/internal/filter/color.h:1193 ../src/extension/internal/filter/color.h:1286 ../src/extension/internal/filter/color.h:1398 +#: ../src/extension/internal/filter/color.h:1503 ../src/extension/internal/filter/color.h:1579 ../src/extension/internal/filter/color.h:1690 ../src/extension/internal/filter/distort.h:95 ../src/extension/internal/filter/distort.h:204 +#: ../src/extension/internal/filter/filter-file.cpp:151 ../src/extension/internal/filter/filter.cpp:214 ../src/extension/internal/filter/image.h:61 ../src/extension/internal/filter/morphology.h:75 +#: ../src/extension/internal/filter/morphology.h:202 ../src/extension/internal/filter/overlays.h:79 ../src/extension/internal/filter/paint.h:112 ../src/extension/internal/filter/paint.h:243 ../src/extension/internal/filter/paint.h:362 +#: ../src/extension/internal/filter/paint.h:506 ../src/extension/internal/filter/paint.h:601 ../src/extension/internal/filter/paint.h:724 ../src/extension/internal/filter/paint.h:876 ../src/extension/internal/filter/paint.h:980 +#: ../src/extension/internal/filter/protrusions.h:54 ../src/extension/internal/filter/shadows.h:80 ../src/extension/internal/filter/textures.h:90 ../src/extension/internal/filter/transparency.h:69 +#: ../src/extension/internal/filter/transparency.h:140 ../src/extension/internal/filter/transparency.h:214 ../src/extension/internal/filter/transparency.h:287 ../src/extension/internal/filter/transparency.h:349 +#: ../src/ui/dialog/inkscape-preferences.cpp:1751 msgid "Filters" msgstr "Filtri" @@ -5547,7 +5548,7 @@ msgstr "Vienkāršs izkliedēts slīpums faktūru veidošanai" msgid "Matte Jelly" msgstr "Matēta želeja" -#: ../src/extension/internal/filter/bevels.h:136 ../src/extension/internal/filter/bevels.h:220 ../src/extension/internal/filter/blurs.h:187 ../src/extension/internal/filter/color.h:74 +#: ../src/extension/internal/filter/bevels.h:136 ../src/extension/internal/filter/bevels.h:220 ../src/extension/internal/filter/blurs.h:187 ../src/extension/internal/filter/color.h:75 msgid "Brightness" msgstr "Spilgtums" @@ -5600,25 +5601,25 @@ msgid "Blend:" msgstr "Sapludināt:" #: ../src/extension/internal/filter/blurs.h:192 ../src/extension/internal/filter/blurs.h:339 ../src/extension/internal/filter/bumps.h:131 ../src/extension/internal/filter/bumps.h:337 ../src/extension/internal/filter/bumps.h:344 -#: ../src/extension/internal/filter/color.h:329 ../src/extension/internal/filter/color.h:336 ../src/extension/internal/filter/color.h:1423 ../src/extension/internal/filter/color.h:1596 ../src/extension/internal/filter/color.h:1602 +#: ../src/extension/internal/filter/color.h:404 ../src/extension/internal/filter/color.h:411 ../src/extension/internal/filter/color.h:1498 ../src/extension/internal/filter/color.h:1671 ../src/extension/internal/filter/color.h:1677 #: ../src/extension/internal/filter/paint.h:705 ../src/extension/internal/filter/transparency.h:63 ../src/filter-enums.cpp:55 msgid "Darken" msgstr "Padarīt tumšāku" #: ../src/extension/internal/filter/blurs.h:193 ../src/extension/internal/filter/blurs.h:340 ../src/extension/internal/filter/bumps.h:132 ../src/extension/internal/filter/bumps.h:335 ../src/extension/internal/filter/bumps.h:342 -#: ../src/extension/internal/filter/color.h:327 ../src/extension/internal/filter/color.h:332 ../src/extension/internal/filter/color.h:647 ../src/extension/internal/filter/color.h:1415 ../src/extension/internal/filter/color.h:1420 -#: ../src/extension/internal/filter/color.h:1594 ../src/extension/internal/filter/paint.h:703 ../src/extension/internal/filter/transparency.h:62 ../src/filter-enums.cpp:54 ../src/ui/dialog/input.cpp:382 +#: ../src/extension/internal/filter/color.h:402 ../src/extension/internal/filter/color.h:407 ../src/extension/internal/filter/color.h:722 ../src/extension/internal/filter/color.h:1490 ../src/extension/internal/filter/color.h:1495 +#: ../src/extension/internal/filter/color.h:1669 ../src/extension/internal/filter/paint.h:703 ../src/extension/internal/filter/transparency.h:62 ../src/filter-enums.cpp:54 ../src/ui/dialog/input.cpp:382 msgid "Screen" msgstr "Ekrāns" #: ../src/extension/internal/filter/blurs.h:194 ../src/extension/internal/filter/blurs.h:341 ../src/extension/internal/filter/bumps.h:133 ../src/extension/internal/filter/bumps.h:338 ../src/extension/internal/filter/bumps.h:345 -#: ../src/extension/internal/filter/color.h:325 ../src/extension/internal/filter/color.h:333 ../src/extension/internal/filter/color.h:645 ../src/extension/internal/filter/color.h:1414 ../src/extension/internal/filter/color.h:1421 -#: ../src/extension/internal/filter/color.h:1595 ../src/extension/internal/filter/color.h:1601 ../src/extension/internal/filter/paint.h:701 ../src/extension/internal/filter/transparency.h:60 ../src/filter-enums.cpp:53 +#: ../src/extension/internal/filter/color.h:400 ../src/extension/internal/filter/color.h:408 ../src/extension/internal/filter/color.h:720 ../src/extension/internal/filter/color.h:1489 ../src/extension/internal/filter/color.h:1496 +#: ../src/extension/internal/filter/color.h:1670 ../src/extension/internal/filter/color.h:1676 ../src/extension/internal/filter/paint.h:701 ../src/extension/internal/filter/transparency.h:60 ../src/filter-enums.cpp:53 msgid "Multiply" msgstr "Pavairot" #: ../src/extension/internal/filter/blurs.h:195 ../src/extension/internal/filter/blurs.h:342 ../src/extension/internal/filter/bumps.h:134 ../src/extension/internal/filter/bumps.h:339 ../src/extension/internal/filter/bumps.h:346 -#: ../src/extension/internal/filter/color.h:328 ../src/extension/internal/filter/color.h:335 ../src/extension/internal/filter/color.h:1422 ../src/extension/internal/filter/color.h:1593 ../src/extension/internal/filter/paint.h:704 +#: ../src/extension/internal/filter/color.h:403 ../src/extension/internal/filter/color.h:410 ../src/extension/internal/filter/color.h:1497 ../src/extension/internal/filter/color.h:1668 ../src/extension/internal/filter/paint.h:704 #: ../src/extension/internal/filter/transparency.h:64 ../src/filter-enums.cpp:56 msgid "Lighten" msgstr "Padarīt gaišāku" @@ -5649,7 +5650,7 @@ msgstr "Paplašināšana" msgid "Erosion" msgstr "Erozija" -#: ../src/extension/internal/filter/blurs.h:336 ../src/extension/internal/filter/color.h:1205 ../src/extension/internal/filter/color.h:1317 ../src/ui/dialog/document-properties.cpp:122 +#: ../src/extension/internal/filter/blurs.h:336 ../src/extension/internal/filter/color.h:1280 ../src/extension/internal/filter/color.h:1392 ../src/ui/dialog/document-properties.cpp:122 msgid "Background color" msgstr "Fona krāsa" @@ -5657,9 +5658,9 @@ msgstr "Fona krāsa" msgid "Blend type:" msgstr "Sajaukšanas tips:" -#: ../src/extension/internal/filter/blurs.h:338 ../src/extension/internal/filter/bumps.h:130 ../src/extension/internal/filter/bumps.h:336 ../src/extension/internal/filter/bumps.h:343 ../src/extension/internal/filter/color.h:326 -#: ../src/extension/internal/filter/color.h:334 ../src/extension/internal/filter/color.h:646 ../src/extension/internal/filter/color.h:1413 ../src/extension/internal/filter/color.h:1419 ../src/extension/internal/filter/color.h:1586 -#: ../src/extension/internal/filter/color.h:1600 ../src/extension/internal/filter/distort.h:78 ../src/extension/internal/filter/paint.h:702 ../src/extension/internal/filter/textures.h:77 ../src/extension/internal/filter/transparency.h:61 +#: ../src/extension/internal/filter/blurs.h:338 ../src/extension/internal/filter/bumps.h:130 ../src/extension/internal/filter/bumps.h:336 ../src/extension/internal/filter/bumps.h:343 ../src/extension/internal/filter/color.h:401 +#: ../src/extension/internal/filter/color.h:409 ../src/extension/internal/filter/color.h:721 ../src/extension/internal/filter/color.h:1488 ../src/extension/internal/filter/color.h:1494 ../src/extension/internal/filter/color.h:1661 +#: ../src/extension/internal/filter/color.h:1675 ../src/extension/internal/filter/distort.h:78 ../src/extension/internal/filter/paint.h:702 ../src/extension/internal/filter/textures.h:77 ../src/extension/internal/filter/transparency.h:61 #: ../src/filter-enums.cpp:52 ../src/ui/dialog/inkscape-preferences.cpp:653 msgid "Normal" msgstr "Normāls" @@ -5688,17 +5689,17 @@ msgstr "Reljefa vienkāršošana" msgid "Bump source" msgstr "Reljefa avots" -#: ../src/extension/internal/filter/bumps.h:88 ../src/extension/internal/filter/bumps.h:317 ../src/extension/internal/filter/color.h:157 ../src/extension/internal/filter/color.h:637 ../src/extension/internal/filter/color.h:821 +#: ../src/extension/internal/filter/bumps.h:88 ../src/extension/internal/filter/bumps.h:317 ../src/extension/internal/filter/color.h:158 ../src/extension/internal/filter/color.h:712 ../src/extension/internal/filter/color.h:896 #: ../src/extension/internal/filter/transparency.h:132 ../src/filter-enums.cpp:128 ../src/ui/tools/flood-tool.cpp:183 ../src/widgets/sp-color-icc-selector.cpp:330 ../src/widgets/sp-color-scales.cpp:415 ../src/widgets/sp-color-scales.cpp:416 msgid "Red" msgstr "Sarkans" -#: ../src/extension/internal/filter/bumps.h:89 ../src/extension/internal/filter/bumps.h:318 ../src/extension/internal/filter/color.h:158 ../src/extension/internal/filter/color.h:638 ../src/extension/internal/filter/color.h:822 +#: ../src/extension/internal/filter/bumps.h:89 ../src/extension/internal/filter/bumps.h:318 ../src/extension/internal/filter/color.h:159 ../src/extension/internal/filter/color.h:713 ../src/extension/internal/filter/color.h:897 #: ../src/extension/internal/filter/transparency.h:133 ../src/filter-enums.cpp:129 ../src/ui/tools/flood-tool.cpp:184 ../src/widgets/sp-color-icc-selector.cpp:331 ../src/widgets/sp-color-scales.cpp:418 ../src/widgets/sp-color-scales.cpp:419 msgid "Green" msgstr "Zaļš" -#: ../src/extension/internal/filter/bumps.h:90 ../src/extension/internal/filter/bumps.h:319 ../src/extension/internal/filter/color.h:159 ../src/extension/internal/filter/color.h:639 ../src/extension/internal/filter/color.h:823 +#: ../src/extension/internal/filter/bumps.h:90 ../src/extension/internal/filter/bumps.h:319 ../src/extension/internal/filter/color.h:160 ../src/extension/internal/filter/color.h:714 ../src/extension/internal/filter/color.h:898 #: ../src/extension/internal/filter/transparency.h:134 ../src/filter-enums.cpp:130 ../src/ui/tools/flood-tool.cpp:185 ../src/widgets/sp-color-icc-selector.cpp:332 ../src/widgets/sp-color-scales.cpp:421 ../src/widgets/sp-color-scales.cpp:422 msgid "Blue" msgstr "Zils" @@ -5719,11 +5720,11 @@ msgstr "Atspīdums" msgid "Diffuse" msgstr "Izkliedēt" -#: ../src/extension/internal/filter/bumps.h:98 ../src/extension/internal/filter/bumps.h:329 ../src/libgdl/gdl-dock-placeholder.c:175 ../src/libgdl/gdl-dock.c:199 ../src/widgets/rect-toolbar.cpp:335 ../share/extensions/interp_att_g.inx.h:11 +#: ../src/extension/internal/filter/bumps.h:98 ../src/extension/internal/filter/bumps.h:329 ../src/libgdl/gdl-dock-placeholder.c:175 ../src/libgdl/gdl-dock.c:199 ../src/widgets/rect-toolbar.cpp:334 ../share/extensions/interp_att_g.inx.h:11 msgid "Height" msgstr "Augstums" -#: ../src/extension/internal/filter/bumps.h:99 ../src/extension/internal/filter/bumps.h:330 ../src/extension/internal/filter/color.h:76 ../src/extension/internal/filter/color.h:824 ../src/extension/internal/filter/color.h:1113 +#: ../src/extension/internal/filter/bumps.h:99 ../src/extension/internal/filter/bumps.h:330 ../src/extension/internal/filter/color.h:77 ../src/extension/internal/filter/color.h:899 ../src/extension/internal/filter/color.h:1188 #: ../src/extension/internal/filter/paint.h:86 ../src/extension/internal/filter/paint.h:592 ../src/extension/internal/filter/paint.h:707 ../src/ui/tools/flood-tool.cpp:188 ../src/widgets/sp-color-icc-selector.cpp:341 #: ../src/widgets/sp-color-scales.cpp:447 ../src/widgets/sp-color-scales.cpp:448 ../src/widgets/tweak-toolbar.cpp:318 ../share/extensions/color_randomize.inx.h:5 msgid "Lightness" @@ -5837,7 +5838,7 @@ msgstr "Aizmiglots attēls" msgid "Background opacity" msgstr "Fona necaurspīdība" -#: ../src/extension/internal/filter/bumps.h:327 ../src/extension/internal/filter/color.h:1040 +#: ../src/extension/internal/filter/bumps.h:327 ../src/extension/internal/filter/color.h:1115 msgid "Lighting" msgstr "Apgaismojums" @@ -5873,397 +5874,441 @@ msgstr "Pēc" msgid "Turns an image to jelly" msgstr "Pārvērš attēlu želejā" -#: ../src/extension/internal/filter/color.h:72 +#: ../src/extension/internal/filter/color.h:73 msgid "Brilliance" msgstr "Mirdzums" -#: ../src/extension/internal/filter/color.h:75 ../src/extension/internal/filter/color.h:1417 +#: ../src/extension/internal/filter/color.h:76 ../src/extension/internal/filter/color.h:1492 msgid "Over-saturation" msgstr "Pārsātināšana" -#: ../src/extension/internal/filter/color.h:77 ../src/extension/internal/filter/color.h:161 ../src/extension/internal/filter/overlays.h:70 ../src/extension/internal/filter/paint.h:85 ../src/extension/internal/filter/paint.h:502 +#: ../src/extension/internal/filter/color.h:78 ../src/extension/internal/filter/color.h:162 ../src/extension/internal/filter/overlays.h:70 ../src/extension/internal/filter/paint.h:85 ../src/extension/internal/filter/paint.h:502 #: ../src/extension/internal/filter/transparency.h:136 ../src/extension/internal/filter/transparency.h:210 msgid "Inverted" msgstr "Apgriezts" -#: ../src/extension/internal/filter/color.h:85 +#: ../src/extension/internal/filter/color.h:86 msgid "Brightness filter" msgstr "Spilgtuma filtrs" -#: ../src/extension/internal/filter/color.h:152 +#: ../src/extension/internal/filter/color.h:153 msgid "Channel Painting" msgstr "Kanālu krāsosana" -#: ../src/extension/internal/filter/color.h:156 ../src/extension/internal/filter/color.h:257 ../src/extension/internal/filter/paint.h:87 ../src/filter-enums.cpp:66 ../src/ui/dialog/inkscape-preferences.cpp:952 +#: ../src/extension/internal/filter/color.h:157 ../src/extension/internal/filter/color.h:332 ../src/extension/internal/filter/paint.h:87 ../src/filter-enums.cpp:66 ../src/ui/dialog/inkscape-preferences.cpp:952 #: ../src/ui/tools/flood-tool.cpp:187 ../src/widgets/sp-color-icc-selector.cpp:337 ../src/widgets/sp-color-icc-selector.cpp:342 ../src/widgets/sp-color-scales.cpp:444 ../src/widgets/sp-color-scales.cpp:445 ../src/widgets/tweak-toolbar.cpp:302 #: ../share/extensions/color_randomize.inx.h:4 msgid "Saturation" msgstr "Piesātinājums" -#: ../src/extension/internal/filter/color.h:160 ../src/extension/internal/filter/transparency.h:135 ../src/filter-enums.cpp:131 ../src/ui/tools/flood-tool.cpp:189 +#: ../src/extension/internal/filter/color.h:161 ../src/extension/internal/filter/transparency.h:135 ../src/filter-enums.cpp:131 ../src/ui/tools/flood-tool.cpp:189 msgid "Alpha" msgstr "Alfa" -#: ../src/extension/internal/filter/color.h:174 +#: ../src/extension/internal/filter/color.h:175 msgid "Replace RGB by any color" msgstr "Aizvietot RGB ar jebkuru krāsu" #: ../src/extension/internal/filter/color.h:254 +msgid "Color Blindness" +msgstr "" + +#: ../src/extension/internal/filter/color.h:258 +msgid "Blindness type:" +msgstr "" + +#: ../src/extension/internal/filter/color.h:259 +msgid "Rod monochromacy (atypical achromatopsia)" +msgstr "" + +#: ../src/extension/internal/filter/color.h:260 +msgid "Cone monochromacy (typical achromatopsia)" +msgstr "" + +#: ../src/extension/internal/filter/color.h:261 +msgid "Geen weak (deuteranomaly)" +msgstr "" + +#: ../src/extension/internal/filter/color.h:262 +msgid "Green blind (deuteranopia)" +msgstr "" + +#: ../src/extension/internal/filter/color.h:263 +msgid "Red weak (protanomaly)" +msgstr "" + +#: ../src/extension/internal/filter/color.h:264 +msgid "Red blind (protanopia)" +msgstr "" + +#: ../src/extension/internal/filter/color.h:265 +msgid "Blue weak (tritanomaly)" +msgstr "" + +#: ../src/extension/internal/filter/color.h:266 +msgid "Blue blind (tritanopia)" +msgstr "" + +#: ../src/extension/internal/filter/color.h:286 +msgid "Simulate color blindness" +msgstr "Simulēt krāsu aklumu" + +#: ../src/extension/internal/filter/color.h:329 msgid "Color Shift" msgstr "Krāsu pārbīde" -#: ../src/extension/internal/filter/color.h:256 +#: ../src/extension/internal/filter/color.h:331 msgid "Shift (°)" msgstr "Pārbīde (°)" -#: ../src/extension/internal/filter/color.h:265 +#: ../src/extension/internal/filter/color.h:340 msgid "Rotate and desaturate hue" msgstr "Pagriezt un atsātināt nokrāsu" -#: ../src/extension/internal/filter/color.h:321 +#: ../src/extension/internal/filter/color.h:396 msgid "Harsh light" msgstr "Asa gaisma" -#: ../src/extension/internal/filter/color.h:322 +#: ../src/extension/internal/filter/color.h:397 msgid "Normal light" msgstr "Parasta gaisma" -#: ../src/extension/internal/filter/color.h:323 +#: ../src/extension/internal/filter/color.h:398 msgid "Duotone" msgstr "Divtoņu" -#: ../src/extension/internal/filter/color.h:324 ../src/extension/internal/filter/color.h:1412 +#: ../src/extension/internal/filter/color.h:399 ../src/extension/internal/filter/color.h:1487 msgid "Blend 1:" msgstr "Sapludinājums 1:" -#: ../src/extension/internal/filter/color.h:331 ../src/extension/internal/filter/color.h:1418 +#: ../src/extension/internal/filter/color.h:406 ../src/extension/internal/filter/color.h:1493 msgid "Blend 2:" msgstr "Sapludinājums 2:" -#: ../src/extension/internal/filter/color.h:350 +#: ../src/extension/internal/filter/color.h:425 msgid "Blend image or object with a flood color" msgstr "Sapludināt attēlu vai objektu ar pludināšanas krāsu" -#: ../src/extension/internal/filter/color.h:424 ../src/filter-enums.cpp:23 +#: ../src/extension/internal/filter/color.h:499 ../src/filter-enums.cpp:23 msgid "Component Transfer" msgstr "Sastāvdaļu pārnese" -#: ../src/extension/internal/filter/color.h:427 ../src/filter-enums.cpp:110 +#: ../src/extension/internal/filter/color.h:502 ../src/filter-enums.cpp:110 msgid "Identity" msgstr "Identitāte" -#: ../src/extension/internal/filter/color.h:428 ../src/extension/internal/filter/paint.h:498 ../src/filter-enums.cpp:111 ../src/ui/dialog/filter-effects-dialog.cpp:1050 +#: ../src/extension/internal/filter/color.h:503 ../src/extension/internal/filter/paint.h:498 ../src/filter-enums.cpp:111 ../src/ui/dialog/filter-effects-dialog.cpp:1050 msgid "Table" msgstr "Tabula" -#: ../src/extension/internal/filter/color.h:429 ../src/extension/internal/filter/paint.h:499 ../src/filter-enums.cpp:112 ../src/ui/dialog/filter-effects-dialog.cpp:1053 +#: ../src/extension/internal/filter/color.h:504 ../src/extension/internal/filter/paint.h:499 ../src/filter-enums.cpp:112 ../src/ui/dialog/filter-effects-dialog.cpp:1053 msgid "Discrete" msgstr "Atsevišķs" -#: ../src/extension/internal/filter/color.h:430 ../src/filter-enums.cpp:113 ../src/live_effects/lpe-interpolate_points.cpp:25 ../src/live_effects/lpe-powerstroke.cpp:194 +#: ../src/extension/internal/filter/color.h:505 ../src/filter-enums.cpp:113 ../src/live_effects/lpe-interpolate_points.cpp:25 ../src/live_effects/lpe-powerstroke.cpp:194 msgid "Linear" msgstr "Lineārs" -#: ../src/extension/internal/filter/color.h:431 ../src/filter-enums.cpp:114 +#: ../src/extension/internal/filter/color.h:506 ../src/filter-enums.cpp:114 msgid "Gamma" msgstr "Gamma" -#: ../src/extension/internal/filter/color.h:440 +#: ../src/extension/internal/filter/color.h:515 msgid "Basic component transfer structure" msgstr "Pamata komponentu pārneses struktūra" -#: ../src/extension/internal/filter/color.h:509 +#: ../src/extension/internal/filter/color.h:584 msgid "Duochrome" msgstr "Divkrāsu" -#: ../src/extension/internal/filter/color.h:513 +#: ../src/extension/internal/filter/color.h:588 msgid "Fluorescence level" msgstr "Fluorescences līmenis" -#: ../src/extension/internal/filter/color.h:514 +#: ../src/extension/internal/filter/color.h:589 msgid "Swap:" msgstr "Apmainīt:" -#: ../src/extension/internal/filter/color.h:515 +#: ../src/extension/internal/filter/color.h:590 msgid "No swap" msgstr "Nav pieejama maiņvieta (swap)" -#: ../src/extension/internal/filter/color.h:516 +#: ../src/extension/internal/filter/color.h:591 msgid "Color and alpha" msgstr "Krāsu un alfa" -#: ../src/extension/internal/filter/color.h:517 +#: ../src/extension/internal/filter/color.h:592 msgid "Color only" msgstr "Tikai krāsu" -#: ../src/extension/internal/filter/color.h:518 +#: ../src/extension/internal/filter/color.h:593 msgid "Alpha only" msgstr "Tikai alfa" -#: ../src/extension/internal/filter/color.h:522 +#: ../src/extension/internal/filter/color.h:597 msgid "Color 1" msgstr "1. krāsa" -#: ../src/extension/internal/filter/color.h:525 +#: ../src/extension/internal/filter/color.h:600 msgid "Color 2" msgstr "2. krāsa" -#: ../src/extension/internal/filter/color.h:535 +#: ../src/extension/internal/filter/color.h:610 msgid "Convert luminance values to a duochrome palette" msgstr "Pārvērst spilgtuma vērtības par divkrāsu paleti" -#: ../src/extension/internal/filter/color.h:634 +#: ../src/extension/internal/filter/color.h:709 msgid "Extract Channel" msgstr "Ekstraģēt kanālu" -#: ../src/extension/internal/filter/color.h:640 ../src/widgets/sp-color-icc-selector.cpp:344 ../src/widgets/sp-color-icc-selector.cpp:349 ../src/widgets/sp-color-scales.cpp:469 ../src/widgets/sp-color-scales.cpp:470 +#: ../src/extension/internal/filter/color.h:715 ../src/widgets/sp-color-icc-selector.cpp:344 ../src/widgets/sp-color-icc-selector.cpp:349 ../src/widgets/sp-color-scales.cpp:469 ../src/widgets/sp-color-scales.cpp:470 msgid "Cyan" msgstr "Ciāns" -#: ../src/extension/internal/filter/color.h:641 ../src/widgets/sp-color-icc-selector.cpp:345 ../src/widgets/sp-color-icc-selector.cpp:350 ../src/widgets/sp-color-scales.cpp:472 ../src/widgets/sp-color-scales.cpp:473 +#: ../src/extension/internal/filter/color.h:716 ../src/widgets/sp-color-icc-selector.cpp:345 ../src/widgets/sp-color-icc-selector.cpp:350 ../src/widgets/sp-color-scales.cpp:472 ../src/widgets/sp-color-scales.cpp:473 msgid "Magenta" msgstr "Fuksīns (Magenta)" -#: ../src/extension/internal/filter/color.h:642 ../src/widgets/sp-color-icc-selector.cpp:346 ../src/widgets/sp-color-icc-selector.cpp:351 ../src/widgets/sp-color-scales.cpp:475 ../src/widgets/sp-color-scales.cpp:476 +#: ../src/extension/internal/filter/color.h:717 ../src/widgets/sp-color-icc-selector.cpp:346 ../src/widgets/sp-color-icc-selector.cpp:351 ../src/widgets/sp-color-scales.cpp:475 ../src/widgets/sp-color-scales.cpp:476 msgid "Yellow" msgstr "Dzeltens" -#: ../src/extension/internal/filter/color.h:644 +#: ../src/extension/internal/filter/color.h:719 msgid "Background blend mode:" msgstr "Fona sajaukšanas veids:" -#: ../src/extension/internal/filter/color.h:649 +#: ../src/extension/internal/filter/color.h:724 msgid "Channel to alpha" msgstr "Kanālu uz alfa" -#: ../src/extension/internal/filter/color.h:657 +#: ../src/extension/internal/filter/color.h:732 msgid "Extract color channel as a transparent image" msgstr "Ekstraģēt krāsa kanālu kā caurspīdīgu attēlu" -#: ../src/extension/internal/filter/color.h:740 +#: ../src/extension/internal/filter/color.h:815 msgid "Fade to Black or White" msgstr "Izgaisināt melnā vai baltā" -#: ../src/extension/internal/filter/color.h:743 +#: ../src/extension/internal/filter/color.h:818 msgid "Fade to:" msgstr "Izgaisināt:" -#: ../src/extension/internal/filter/color.h:744 ../src/ui/widget/selected-style.cpp:274 ../src/widgets/sp-color-icc-selector.cpp:347 ../src/widgets/sp-color-scales.cpp:478 ../src/widgets/sp-color-scales.cpp:479 +#: ../src/extension/internal/filter/color.h:819 ../src/ui/widget/selected-style.cpp:274 ../src/widgets/sp-color-icc-selector.cpp:347 ../src/widgets/sp-color-scales.cpp:478 ../src/widgets/sp-color-scales.cpp:479 msgid "Black" msgstr "Melns" -#: ../src/extension/internal/filter/color.h:745 ../src/ui/widget/selected-style.cpp:270 +#: ../src/extension/internal/filter/color.h:820 ../src/ui/widget/selected-style.cpp:270 msgid "White" msgstr "Balts" -#: ../src/extension/internal/filter/color.h:754 +#: ../src/extension/internal/filter/color.h:829 msgid "Fade to black or white" msgstr "Izgaisināt melnā vai baltā" -#: ../src/extension/internal/filter/color.h:819 +#: ../src/extension/internal/filter/color.h:894 msgid "Greyscale" msgstr "Pelēktoņu" -#: ../src/extension/internal/filter/color.h:825 ../src/extension/internal/filter/paint.h:83 ../src/extension/internal/filter/paint.h:239 +#: ../src/extension/internal/filter/color.h:900 ../src/extension/internal/filter/paint.h:83 ../src/extension/internal/filter/paint.h:239 msgid "Transparent" msgstr "Caurspīdīgs" -#: ../src/extension/internal/filter/color.h:833 +#: ../src/extension/internal/filter/color.h:908 msgid "Customize greyscale components" msgstr "Pieskaņojiet pelēktoņu sastāvdaļas" -#: ../src/extension/internal/filter/color.h:905 ../src/ui/widget/selected-style.cpp:266 +#: ../src/extension/internal/filter/color.h:980 ../src/ui/widget/selected-style.cpp:266 msgid "Invert" msgstr "Invertēt" -#: ../src/extension/internal/filter/color.h:907 +#: ../src/extension/internal/filter/color.h:982 msgid "Invert channels:" msgstr "Invertēt kanālus:" -#: ../src/extension/internal/filter/color.h:908 +#: ../src/extension/internal/filter/color.h:983 msgid "No inversion" msgstr "Nav inversijas" -#: ../src/extension/internal/filter/color.h:909 +#: ../src/extension/internal/filter/color.h:984 msgid "Red and blue" msgstr "Sarkans un zils" -#: ../src/extension/internal/filter/color.h:910 +#: ../src/extension/internal/filter/color.h:985 msgid "Red and green" msgstr "Sarkans un zaļs" -#: ../src/extension/internal/filter/color.h:911 +#: ../src/extension/internal/filter/color.h:986 msgid "Green and blue" msgstr "Zaļš un zils" -#: ../src/extension/internal/filter/color.h:913 +#: ../src/extension/internal/filter/color.h:988 msgid "Light transparency" msgstr "Viegls caurspīdīgums" -#: ../src/extension/internal/filter/color.h:914 +#: ../src/extension/internal/filter/color.h:989 msgid "Invert hue" msgstr "Invertēt nokrāsu" -#: ../src/extension/internal/filter/color.h:915 +#: ../src/extension/internal/filter/color.h:990 msgid "Invert lightness" msgstr "Invertēt gaišumu" -#: ../src/extension/internal/filter/color.h:916 +#: ../src/extension/internal/filter/color.h:991 msgid "Invert transparency" msgstr "Invertēt caurspīdīgumu" -#: ../src/extension/internal/filter/color.h:924 +#: ../src/extension/internal/filter/color.h:999 msgid "Manage hue, lightness and transparency inversions" msgstr "Vadiet nokrāsas, gaišuma un caurspīdīguma inversijas" -#: ../src/extension/internal/filter/color.h:1042 +#: ../src/extension/internal/filter/color.h:1117 msgid "Lights" msgstr "Gaismas" -#: ../src/extension/internal/filter/color.h:1043 +#: ../src/extension/internal/filter/color.h:1118 msgid "Shadows" msgstr "Ēnas" -#: ../src/extension/internal/filter/color.h:1044 ../src/extension/internal/filter/paint.h:356 ../src/filter-enums.cpp:33 ../src/live_effects/effect.cpp:110 ../src/ui/dialog/filter-effects-dialog.cpp:1047 +#: ../src/extension/internal/filter/color.h:1119 ../src/extension/internal/filter/paint.h:356 ../src/filter-enums.cpp:33 ../src/live_effects/effect.cpp:110 ../src/ui/dialog/filter-effects-dialog.cpp:1047 #: ../src/widgets/gradient-toolbar.cpp:1159 msgid "Offset" msgstr "Nobīde" -#: ../src/extension/internal/filter/color.h:1052 +#: ../src/extension/internal/filter/color.h:1127 msgid "Modify lights and shadows separately" msgstr "Mainīt gaismas un ēnas atsevišķi" -#: ../src/extension/internal/filter/color.h:1111 +#: ../src/extension/internal/filter/color.h:1186 msgid "Lightness-Contrast" msgstr "Spilgtums-kontrasts" -#: ../src/extension/internal/filter/color.h:1122 +#: ../src/extension/internal/filter/color.h:1197 msgid "Modify lightness and contrast separately" msgstr "Mainīt gaišumu un kontrastu atsevišķi" -#: ../src/extension/internal/filter/color.h:1190 +#: ../src/extension/internal/filter/color.h:1265 msgid "Nudge RGB" msgstr "Nobīdīt RGB" -#: ../src/extension/internal/filter/color.h:1194 +#: ../src/extension/internal/filter/color.h:1269 msgid "Red offset" msgstr "Sarkanā nobīde" -#: ../src/extension/internal/filter/color.h:1195 ../src/extension/internal/filter/color.h:1198 ../src/extension/internal/filter/color.h:1201 ../src/extension/internal/filter/color.h:1307 ../src/extension/internal/filter/color.h:1310 -#: ../src/extension/internal/filter/color.h:1313 ../src/ui/dialog/input.cpp:1616 ../src/ui/dialog/layers.cpp:917 +#: ../src/extension/internal/filter/color.h:1270 ../src/extension/internal/filter/color.h:1273 ../src/extension/internal/filter/color.h:1276 ../src/extension/internal/filter/color.h:1382 ../src/extension/internal/filter/color.h:1385 +#: ../src/extension/internal/filter/color.h:1388 ../src/ui/dialog/input.cpp:1616 ../src/ui/dialog/layers.cpp:917 msgid "X" msgstr "X" -#: ../src/extension/internal/filter/color.h:1196 ../src/extension/internal/filter/color.h:1199 ../src/extension/internal/filter/color.h:1202 ../src/extension/internal/filter/color.h:1308 ../src/extension/internal/filter/color.h:1311 -#: ../src/extension/internal/filter/color.h:1314 ../src/ui/dialog/input.cpp:1616 +#: ../src/extension/internal/filter/color.h:1271 ../src/extension/internal/filter/color.h:1274 ../src/extension/internal/filter/color.h:1277 ../src/extension/internal/filter/color.h:1383 ../src/extension/internal/filter/color.h:1386 +#: ../src/extension/internal/filter/color.h:1389 ../src/ui/dialog/input.cpp:1616 msgid "Y" msgstr "Y" -#: ../src/extension/internal/filter/color.h:1197 +#: ../src/extension/internal/filter/color.h:1272 msgid "Green offset" msgstr "Zaļa nobīde" -#: ../src/extension/internal/filter/color.h:1200 +#: ../src/extension/internal/filter/color.h:1275 msgid "Blue offset" msgstr "Zilā nobīde" -#: ../src/extension/internal/filter/color.h:1215 +#: ../src/extension/internal/filter/color.h:1290 msgid "Nudge RGB channels separately and blend them to different types of backgrounds" msgstr "Nobīdīt RGB kanālus atsevišķi vienu no otra un sajaukt tos dažādu fona krāsu iegūšanai" -#: ../src/extension/internal/filter/color.h:1302 +#: ../src/extension/internal/filter/color.h:1377 msgid "Nudge CMY" msgstr "Nobīdīt CMY" -#: ../src/extension/internal/filter/color.h:1306 +#: ../src/extension/internal/filter/color.h:1381 msgid "Cyan offset" msgstr "Ciāna nobīde" -#: ../src/extension/internal/filter/color.h:1309 +#: ../src/extension/internal/filter/color.h:1384 msgid "Magenta offset" msgstr "Fuksīna nobīde:" -#: ../src/extension/internal/filter/color.h:1312 +#: ../src/extension/internal/filter/color.h:1387 msgid "Yellow offset" msgstr "Dzeltenā nobīde" -#: ../src/extension/internal/filter/color.h:1327 +#: ../src/extension/internal/filter/color.h:1402 msgid "Nudge CMY channels separately and blend them to different types of backgrounds" msgstr "Nobīdīt CMY kanālus atsevišķi vienu no otra un sajaukt tos dažādu fona krāsu iegūšanai" -#: ../src/extension/internal/filter/color.h:1408 +#: ../src/extension/internal/filter/color.h:1483 msgid "Quadritone fantasy" msgstr "Četrtoņu fantāzija" -#: ../src/extension/internal/filter/color.h:1410 +#: ../src/extension/internal/filter/color.h:1485 msgid "Hue distribution (°)" msgstr "Nokrāsas sadale (°)" -#: ../src/extension/internal/filter/color.h:1411 ../share/extensions/svgcalendar.inx.h:19 +#: ../src/extension/internal/filter/color.h:1486 ../share/extensions/svgcalendar.inx.h:19 msgid "Colors" msgstr "Krāsas" -#: ../src/extension/internal/filter/color.h:1432 +#: ../src/extension/internal/filter/color.h:1507 msgid "Replace hue by two colors" msgstr "Aizvietot nokrāsu ar divām krāsām" -#: ../src/extension/internal/filter/color.h:1496 +#: ../src/extension/internal/filter/color.h:1571 msgid "Hue rotation (°)" msgstr "Nokrāsas griešana (°)" -#: ../src/extension/internal/filter/color.h:1499 +#: ../src/extension/internal/filter/color.h:1574 msgid "Moonarize" msgstr "Mēnessgaisma" -#: ../src/extension/internal/filter/color.h:1508 +#: ../src/extension/internal/filter/color.h:1583 msgid "Classic photographic solarization effect" msgstr "Klasiskais foto solarizācijas efekts" -#: ../src/extension/internal/filter/color.h:1581 +#: ../src/extension/internal/filter/color.h:1656 msgid "Tritone" msgstr "Trīstoņu" -#: ../src/extension/internal/filter/color.h:1587 +#: ../src/extension/internal/filter/color.h:1662 msgid "Enhance hue" msgstr "Pastiprināt nokrāsu" -#: ../src/extension/internal/filter/color.h:1588 +#: ../src/extension/internal/filter/color.h:1663 msgid "Phosphorescence" msgstr "Fosforescence" -#: ../src/extension/internal/filter/color.h:1589 +#: ../src/extension/internal/filter/color.h:1664 msgid "Colored nights" msgstr "Krāsainās naktis" -#: ../src/extension/internal/filter/color.h:1590 +#: ../src/extension/internal/filter/color.h:1665 msgid "Hue to background" msgstr "Nokrāsu par fonu" -#: ../src/extension/internal/filter/color.h:1592 +#: ../src/extension/internal/filter/color.h:1667 msgid "Global blend:" msgstr "Vispārējā sapludināšana" -#: ../src/extension/internal/filter/color.h:1598 +#: ../src/extension/internal/filter/color.h:1673 msgid "Glow" msgstr "Spīdums" -#: ../src/extension/internal/filter/color.h:1599 +#: ../src/extension/internal/filter/color.h:1674 msgid "Glow blend:" msgstr "Kvēlojošā sapludināšana:" -#: ../src/extension/internal/filter/color.h:1604 +#: ../src/extension/internal/filter/color.h:1679 msgid "Local light" msgstr "Vietējā gaisma" -#: ../src/extension/internal/filter/color.h:1605 +#: ../src/extension/internal/filter/color.h:1680 msgid "Global light" msgstr "Vispārējā gaisma" -#: ../src/extension/internal/filter/color.h:1608 +#: ../src/extension/internal/filter/color.h:1683 msgid "Hue distribution (°):" msgstr "Nokrāsas sadale (°):" -#: ../src/extension/internal/filter/color.h:1619 +#: ../src/extension/internal/filter/color.h:1694 msgid "Create a custom tritone palette with additional glow, blend modes and hue moving" msgstr "Izveido pielāgotu triju toņu paleti ar papildu spīdumu, sajaukšanas režīmiem un nokrāsas pārvietošanos" @@ -6396,7 +6441,7 @@ msgstr "Ārējs" msgid "Open" msgstr "Atvērt" -#: ../src/extension/internal/filter/morphology.h:65 ../src/libgdl/gdl-dock-placeholder.c:167 ../src/libgdl/gdl-dock.c:191 ../src/widgets/rect-toolbar.cpp:318 ../src/widgets/spray-toolbar.cpp:116 ../src/widgets/tweak-toolbar.cpp:128 +#: ../src/extension/internal/filter/morphology.h:65 ../src/libgdl/gdl-dock-placeholder.c:167 ../src/libgdl/gdl-dock.c:191 ../src/widgets/rect-toolbar.cpp:317 ../src/widgets/spray-toolbar.cpp:116 ../src/widgets/tweak-toolbar.cpp:128 #: ../share/extensions/interp_att_g.inx.h:10 msgid "Width" msgstr "Platums" @@ -7586,7 +7631,7 @@ msgstr "Griezt nokrāsu" msgid "Luminance to Alpha" msgstr "Spilgtumu par alfa" -#: ../src/filter-enums.cpp:87 ../src/widgets/mesh-toolbar.cpp:476 ../share/extensions/jessyInk_mouseHandler.inx.h:3 ../share/extensions/jessyInk_transitions.inx.h:7 +#: ../src/filter-enums.cpp:87 ../share/extensions/jessyInk_mouseHandler.inx.h:3 ../share/extensions/jessyInk_transitions.inx.h:7 msgid "Default" msgstr "Noklusētais" @@ -8509,50 +8554,52 @@ msgstr "Vizuālās robežas" msgid "Uses the visual bounding box" msgstr "Izmanto vizuālo robežrāmi" -#. initialise your parameters here: -#. testpointA(_("Test Point A"), _("Test A"), "ptA", &wr, this, -#. Geom::Point(100,100)), -#: ../src/live_effects/lpe-bspline.cpp:60 +#: ../src/live_effects/lpe-bspline.cpp:57 msgid "Steps with CTRL:" msgstr "Soļi ar CTRL:" -#: ../src/live_effects/lpe-bspline.cpp:60 +#: ../src/live_effects/lpe-bspline.cpp:57 msgid "Change number of steps with CTRL pressed" msgstr "Mainiet soļu skaitu, turot nospiestu CTRL" -#: ../src/live_effects/lpe-bspline.cpp:61 +#: ../src/live_effects/lpe-bspline.cpp:58 ../src/live_effects/lpe-simplify.cpp:33 +#, fuzzy +msgid "Helper size:" +msgstr "Subversion palīgprogramma" + +#: ../src/live_effects/lpe-bspline.cpp:58 ../src/live_effects/lpe-simplify.cpp:33 +#, fuzzy +msgid "Helper size" +msgstr "Subversion palīgprogramma" + +#: ../src/live_effects/lpe-bspline.cpp:59 msgid "Ignore cusp nodes" msgstr "Neņemt vērā asos mezglus" -#: ../src/live_effects/lpe-bspline.cpp:61 +#: ../src/live_effects/lpe-bspline.cpp:59 msgid "Change ignoring cusp nodes" msgstr "Mainīt, neņemot vērā asos mezglus" -#: ../src/live_effects/lpe-bspline.cpp:62 ../src/live_effects/lpe-fillet-chamfer.cpp:57 +#: ../src/live_effects/lpe-bspline.cpp:60 ../src/live_effects/lpe-fillet-chamfer.cpp:57 msgid "Change only selected nodes" msgstr "Mainīt tikai atlasītos mezglus" -#: ../src/live_effects/lpe-bspline.cpp:63 -#, fuzzy -msgid "Show helper paths" -msgstr "Rādīt pārvietojumus starp ceļiem" - -#: ../src/live_effects/lpe-bspline.cpp:64 +#: ../src/live_effects/lpe-bspline.cpp:61 #, fuzzy msgid "Change weight:" msgstr "Svars" -#: ../src/live_effects/lpe-bspline.cpp:64 +#: ../src/live_effects/lpe-bspline.cpp:61 #, fuzzy msgid "Change weight of the effect" msgstr "Filtra efektu apgabala augstums" -#: ../src/live_effects/lpe-bspline.cpp:291 +#: ../src/live_effects/lpe-bspline.cpp:290 #, fuzzy msgid "Default weight" msgstr "Noklusētais virsraksts" -#: ../src/live_effects/lpe-bspline.cpp:296 +#: ../src/live_effects/lpe-bspline.cpp:295 msgid "Make cusp" msgstr "Pārvērst par aso" @@ -9037,202 +9084,202 @@ msgid "Control handle 0:" msgstr "Vadības turis 0:" #: ../src/live_effects/lpe-lattice2.cpp:47 -msgid "Control handle 0 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 0 - Ctrl+Alt+Click, lai atiestatītu " +msgid "Control handle 0 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:48 msgid "Control handle 1:" msgstr "Vadības turis 1:" #: ../src/live_effects/lpe-lattice2.cpp:48 -msgid "Control handle 1 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 1 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 1 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:49 msgid "Control handle 2:" msgstr "Vadības turis 2:" #: ../src/live_effects/lpe-lattice2.cpp:49 -msgid "Control handle 2 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 2 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 2 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:50 msgid "Control handle 3:" msgstr "Vadības turis 3:" #: ../src/live_effects/lpe-lattice2.cpp:50 -msgid "Control handle 3 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 3 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 3 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:51 msgid "Control handle 4:" msgstr "Vadības turis 4:" #: ../src/live_effects/lpe-lattice2.cpp:51 -msgid "Control handle 4 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 4 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 4 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:52 msgid "Control handle 5:" msgstr "Vadības turis 5:" #: ../src/live_effects/lpe-lattice2.cpp:52 -msgid "Control handle 5 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 5 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 5 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:53 msgid "Control handle 6:" msgstr "Vadības turis 6:" #: ../src/live_effects/lpe-lattice2.cpp:53 -msgid "Control handle 6 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 6 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 6 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:54 msgid "Control handle 7:" msgstr "Vadības turis 7:" #: ../src/live_effects/lpe-lattice2.cpp:54 -msgid "Control handle 7 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 7 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 7 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:55 msgid "Control handle 8x9:" msgstr "Vadības turis 8x9:" #: ../src/live_effects/lpe-lattice2.cpp:55 -msgid "Control handle 8x9 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 8x9 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 8x9 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:56 msgid "Control handle 10x11:" msgstr "Vadības turis 10x11:" #: ../src/live_effects/lpe-lattice2.cpp:56 -msgid "Control handle 10x11 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 10x11 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 10x11 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:57 msgid "Control handle 12:" msgstr "Vadības turis 12:" #: ../src/live_effects/lpe-lattice2.cpp:57 -msgid "Control handle 12 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 12 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 12 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:58 msgid "Control handle 13:" msgstr "Vadības turis 13:" #: ../src/live_effects/lpe-lattice2.cpp:58 -msgid "Control handle 13 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 13 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 13 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:59 msgid "Control handle 14:" msgstr "Vadības turis 14:" #: ../src/live_effects/lpe-lattice2.cpp:59 -msgid "Control handle 14 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 14 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 14 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:60 msgid "Control handle 15:" msgstr "Vadības turis 15:" #: ../src/live_effects/lpe-lattice2.cpp:60 -msgid "Control handle 15 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 15 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 15 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:61 msgid "Control handle 16:" msgstr "Vadības turis 16:" #: ../src/live_effects/lpe-lattice2.cpp:61 -msgid "Control handle 16 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 16 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 16 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:62 msgid "Control handle 17:" msgstr "Vadības turis 17:" #: ../src/live_effects/lpe-lattice2.cpp:62 -msgid "Control handle 17 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 17 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 17 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:63 msgid "Control handle 18:" msgstr "Vadības turis 18:" #: ../src/live_effects/lpe-lattice2.cpp:63 -msgid "Control handle 18 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 18 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 18 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:64 msgid "Control handle 19:" msgstr "Vadības turis 19:" #: ../src/live_effects/lpe-lattice2.cpp:64 -msgid "Control handle 19 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 19 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 19 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:65 msgid "Control handle 20x21:" msgstr "Vadības turis 20x21:" #: ../src/live_effects/lpe-lattice2.cpp:65 -msgid "Control handle 20x21 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 20x21 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 20x21 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:66 msgid "Control handle 22x23:" msgstr "Vadības turis 22x23:" #: ../src/live_effects/lpe-lattice2.cpp:66 -msgid "Control handle 22x23 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 22x23 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 22x23 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:67 msgid "Control handle 24x26:" msgstr "Vadības turis 24x26:" #: ../src/live_effects/lpe-lattice2.cpp:67 -msgid "Control handle 24x26 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 24x26 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 24x26 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:68 msgid "Control handle 25x27:" msgstr "Vadības turis 25x27:" #: ../src/live_effects/lpe-lattice2.cpp:68 -msgid "Control handle 25x27 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 25x27 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 25x27 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:69 msgid "Control handle 28x30:" msgstr "Vadības turis 28x30:" #: ../src/live_effects/lpe-lattice2.cpp:69 -msgid "Control handle 28x30 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 28x30 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 28x30 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:70 msgid "Control handle 29x31:" msgstr "Vadības turis 29x31:" #: ../src/live_effects/lpe-lattice2.cpp:70 -msgid "Control handle 29x31 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 29x31 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 29x31 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-lattice2.cpp:71 msgid "Control handle 32x33x34x35:" msgstr "Vadības turis 32x33x34x35:" #: ../src/live_effects/lpe-lattice2.cpp:71 -msgid "Control handle 32x33x34x35 - Ctrl+Alt+Click to reset" -msgstr "Vadības turis 32x33x34x35 - Ctrl+Alt+Click, lai atiestatītu" +msgid "Control handle 32x33x34x35 - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" -#: ../src/live_effects/lpe-lattice2.cpp:221 +#: ../src/live_effects/lpe-lattice2.cpp:224 #, fuzzy msgid "Reset grid" msgstr "Atstatīt" @@ -9344,32 +9391,32 @@ msgid "Top Left" msgstr "Augšējais kreisais" #: ../src/live_effects/lpe-perspective-envelope.cpp:47 -msgid "Top Left - Ctrl+Alt+Click to reset" -msgstr "Augšējais kreisais - Ctrl+Alt+Click, lai atiestatītu" +msgid "Top Left - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-perspective-envelope.cpp:48 msgid "Top Right" msgstr "Augšējais labais" #: ../src/live_effects/lpe-perspective-envelope.cpp:48 -msgid "Top Right - Ctrl+Alt+Click to reset" -msgstr "Augšējais labais - Ctrl+Alt+Click, lai atiestatītu" +msgid "Top Right - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-perspective-envelope.cpp:49 msgid "Down Left" msgstr "Apakšējais kreisais" #: ../src/live_effects/lpe-perspective-envelope.cpp:49 -msgid "Down Left - Ctrl+Alt+Click to reset" -msgstr "Apakšējais kreisais - Ctrl+Alt+Click, lai atiestatītu" +msgid "Down Left - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-perspective-envelope.cpp:50 msgid "Down Right" msgstr "Apakšējais labais" #: ../src/live_effects/lpe-perspective-envelope.cpp:50 -msgid "Down Right - Ctrl+Alt+Click to reset" -msgstr "Apakšējais labais - Ctrl+Alt+Click, lai atiestatītu" +msgid "Down Right - Ctrl+Alt+Click: reset, Ctrl: move along axes" +msgstr "" #: ../src/live_effects/lpe-perspective-envelope.cpp:257 msgid "Handles:" @@ -9760,64 +9807,62 @@ msgstr "Pagriezt mezglus" msgid "The \"show handles\" path effect will remove any custom style on the object you are applying it to. If this is not what you want, click Cancel." msgstr "Ceļa efekts \"rādīt turus\" atcels jebkuru pielāgoto stilu objektam, kuram to pielietosiet. Ja tas tas, ko sagaidāt, nospiediet Atcelt." -#: ../src/live_effects/lpe-simplify.cpp:29 +#: ../src/live_effects/lpe-simplify.cpp:30 msgid "Steps:" msgstr "Soļi:" -#: ../src/live_effects/lpe-simplify.cpp:29 +#: ../src/live_effects/lpe-simplify.cpp:30 msgid "Change number of simplify steps " msgstr "Norādiet vienkāršošanas soļu skaitu" -#: ../src/live_effects/lpe-simplify.cpp:30 +#: ../src/live_effects/lpe-simplify.cpp:31 #, fuzzy msgid "Roughly threshold:" msgstr "S_lieksnis..." -#: ../src/live_effects/lpe-simplify.cpp:31 -#, fuzzy -msgid "Helper size:" -msgstr "Subversion palīgprogramma" - -#: ../src/live_effects/lpe-simplify.cpp:31 -#, fuzzy -msgid "Helper size" -msgstr "Subversion palīgprogramma" +#: ../src/live_effects/lpe-simplify.cpp:32 +msgid "Smooth angles:" +msgstr "" #: ../src/live_effects/lpe-simplify.cpp:32 +msgid "Max degree difference on handles to preform a smooth" +msgstr "" + +#: ../src/live_effects/lpe-simplify.cpp:34 #, fuzzy msgid "Helper nodes" msgstr "Subversion palīgprogramma" -#: ../src/live_effects/lpe-simplify.cpp:32 +#: ../src/live_effects/lpe-simplify.cpp:34 #, fuzzy msgid "Show helper nodes" msgstr "Rādīt pārveidošanas turus atsevišķiem mezgliem" -#: ../src/live_effects/lpe-simplify.cpp:34 +#: ../src/live_effects/lpe-simplify.cpp:36 #, fuzzy msgid "Helper handles" msgstr "Subversion palīgprogramma" -#: ../src/live_effects/lpe-simplify.cpp:34 +#: ../src/live_effects/lpe-simplify.cpp:36 #, fuzzy msgid "Show helper handles" msgstr "Rādīt turus" -#: ../src/live_effects/lpe-simplify.cpp:36 +#: ../src/live_effects/lpe-simplify.cpp:38 #, fuzzy msgid "Paths separately" msgstr "Vienkāršo ceļus (atsevišķi):" -#: ../src/live_effects/lpe-simplify.cpp:36 +#: ../src/live_effects/lpe-simplify.cpp:38 msgid "Simplifying paths (separately)" msgstr "Vienkāršo ceļus (atsevišķi)" -#: ../src/live_effects/lpe-simplify.cpp:38 +#: ../src/live_effects/lpe-simplify.cpp:40 #, fuzzy msgid "Just coalesce" msgstr "Tikai tagad..." -#: ../src/live_effects/lpe-simplify.cpp:38 +#: ../src/live_effects/lpe-simplify.cpp:40 #, fuzzy msgid "Simplify just coalesce" msgstr "Vienkāršot:" @@ -10158,7 +10203,7 @@ msgstr "Piesaistīt ceļam starpliktuvē" msgid "Paste path parameter" msgstr "Ielīmēt ceļa parametru" -#: ../src/live_effects/parameter/point.cpp:89 ../src/live_effects/parameter/pointreseteable.cpp:103 +#: ../src/live_effects/parameter/point.cpp:103 msgid "Change point parameter" msgstr "Mainīt punkta parametru" @@ -11325,11 +11370,11 @@ msgstr "Izmantojiet Shift+D, lai sameklētu rāmi" #: ../src/selection-describer.cpp:236 #, c-format -msgid "%i objects selected of type %s" -msgid_plural "%i objects selected of types %s" -msgstr[0] "izvēlēts %i objekts ar tipu %s" -msgstr[1] "izvēlēti %i objekti ar tipu %s" -msgstr[2] "izvēlēti %i objekti ar tipu %s" +msgid "%1$i objects selected of type %2$s" +msgid_plural "%1$i objects selected of types %2$s" +msgstr[0] "" +msgstr[1] "" +msgstr[2] "" #: ../src/selection-describer.cpp:246 #, c-format @@ -17611,7 +17656,7 @@ msgid "Filter effects quality for display" msgstr "Filtru efektu kvalitāte attēlošanai uz ekrāna" #. build custom preferences tab -#: ../src/ui/dialog/inkscape-preferences.cpp:1428 ../src/ui/dialog/print.cpp:232 +#: ../src/ui/dialog/inkscape-preferences.cpp:1428 ../src/ui/dialog/print.cpp:215 msgid "Rendering" msgstr "Renderēšana" @@ -17928,7 +17973,7 @@ msgstr "Aparatūra" msgid "Link:" msgstr "Saite:" -#: ../src/ui/dialog/input.cpp:742 ../src/ui/dialog/input.cpp:743 ../src/ui/dialog/input.cpp:1571 ../src/widgets/mesh-toolbar.cpp:499 +#: ../src/ui/dialog/input.cpp:742 ../src/ui/dialog/input.cpp:743 ../src/ui/dialog/input.cpp:1571 msgid "None" msgstr "Neviens" @@ -18736,20 +18781,20 @@ msgstr "Izkārtot gar elipsi" msgid "Could not open temporary PNG for bitmap printing" msgstr "Nav iespējams atvērt pagaidu PNG bitkartes drukāšanai" -#: ../src/ui/dialog/print.cpp:155 +#: ../src/ui/dialog/print.cpp:138 msgid "Could not set up Document" msgstr "Neizdevās izveidot dokumentu" -#: ../src/ui/dialog/print.cpp:159 +#: ../src/ui/dialog/print.cpp:142 msgid "Failed to set CairoRenderContext" msgstr "Neizdevās iestatīt CairoRenderContext" #. set up dialog title, based on document name -#: ../src/ui/dialog/print.cpp:197 +#: ../src/ui/dialog/print.cpp:180 msgid "SVG Document" msgstr "SVG dokuments" -#: ../src/ui/dialog/print.cpp:198 +#: ../src/ui/dialog/print.cpp:181 msgid "Print" msgstr "Drukāt" @@ -21399,7 +21444,7 @@ msgstr "MetadataLicence|Citas" #: ../src/ui/widget/licensor.cpp:72 msgid "Document license updated" -msgstr "" +msgstr "Dokumenta licence atsvaidzināta" #: ../src/ui/widget/object-composite-settings.cpp:47 ../src/ui/widget/selected-style.cpp:1119 ../src/ui/widget/selected-style.cpp:1120 msgid "Opacity (%)" @@ -24293,14 +24338,14 @@ msgstr "Loks: mainīt sākumu/beigas" msgid "Arc: Change open/closed" msgstr "Loks: mainīt uz atvērtu/slēgtu" -#: ../src/widgets/arc-toolbar.cpp:289 ../src/widgets/arc-toolbar.cpp:319 ../src/widgets/rect-toolbar.cpp:261 ../src/widgets/rect-toolbar.cpp:300 ../src/widgets/spiral-toolbar.cpp:214 ../src/widgets/spiral-toolbar.cpp:238 +#: ../src/widgets/arc-toolbar.cpp:289 ../src/widgets/arc-toolbar.cpp:319 ../src/widgets/rect-toolbar.cpp:260 ../src/widgets/rect-toolbar.cpp:299 ../src/widgets/spiral-toolbar.cpp:214 ../src/widgets/spiral-toolbar.cpp:238 #: ../src/widgets/star-toolbar.cpp:384 ../src/widgets/star-toolbar.cpp:446 msgid "New:" msgstr "Jauns:" #. FIXME: implement averaging of all parameters for multiple selected #. gtk_label_set_markup(GTK_LABEL(l), _("Average:")); -#: ../src/widgets/arc-toolbar.cpp:292 ../src/widgets/arc-toolbar.cpp:303 ../src/widgets/rect-toolbar.cpp:269 ../src/widgets/rect-toolbar.cpp:287 ../src/widgets/spiral-toolbar.cpp:216 ../src/widgets/spiral-toolbar.cpp:227 +#: ../src/widgets/arc-toolbar.cpp:292 ../src/widgets/arc-toolbar.cpp:303 ../src/widgets/rect-toolbar.cpp:268 ../src/widgets/rect-toolbar.cpp:286 ../src/widgets/spiral-toolbar.cpp:216 ../src/widgets/spiral-toolbar.cpp:227 #: ../src/widgets/star-toolbar.cpp:386 msgid "Change:" msgstr "Mainīt:" @@ -25225,7 +25270,7 @@ msgid "Display measuring info for selected items" msgstr "Rādīt atlasīto objektu mērījumu informāciju" #. Add the units menu. -#: ../src/widgets/lpe-toolbar.cpp:387 ../src/widgets/node-toolbar.cpp:613 ../src/widgets/paintbucket-toolbar.cpp:168 ../src/widgets/rect-toolbar.cpp:379 ../src/widgets/select-toolbar.cpp:538 +#: ../src/widgets/lpe-toolbar.cpp:387 ../src/widgets/node-toolbar.cpp:613 ../src/widgets/paintbucket-toolbar.cpp:168 ../src/widgets/rect-toolbar.cpp:378 ../src/widgets/select-toolbar.cpp:538 msgid "Units" msgstr "Mērvienības" @@ -25254,7 +25299,7 @@ msgid "The units to be used for the measurements" msgstr "Mērīšanai izmantojamās mērvienības" #: ../src/widgets/mesh-toolbar.cpp:311 -msgid "Set mesh smoothing" +msgid "Set mesh type" msgstr "" #: ../src/widgets/mesh-toolbar.cpp:334 @@ -25322,47 +25367,27 @@ msgid "Show side and tensor handles" msgstr "Rādīt malas un tenzora turus" #: ../src/widgets/mesh-toolbar.cpp:463 -msgid "WARNING: Mesh SVG Syntax Subject to Change, Smoothing Experimental" +msgid "WARNING: Mesh SVG Syntax Subject to Change" msgstr "" #: ../src/widgets/mesh-toolbar.cpp:473 -msgctxt "Smoothing" -msgid "None" -msgstr "" - -#: ../src/widgets/mesh-toolbar.cpp:479 -msgid "Smooth1" -msgstr "" - -#: ../src/widgets/mesh-toolbar.cpp:482 -msgid "Smooth2" -msgstr "" - -#: ../src/widgets/mesh-toolbar.cpp:485 -msgid "Smooth3" -msgstr "" - -#: ../src/widgets/mesh-toolbar.cpp:488 -msgid "Smooth4" -msgstr "" - -#: ../src/widgets/mesh-toolbar.cpp:491 -msgid "Smooth5" +msgctxt "Type" +msgid "Coons" msgstr "" -#: ../src/widgets/mesh-toolbar.cpp:494 -msgid "Smooth6" +#: ../src/widgets/mesh-toolbar.cpp:476 +msgid "Bicubic" msgstr "" -#: ../src/widgets/mesh-toolbar.cpp:497 -msgid "Smooth7" +#: ../src/widgets/mesh-toolbar.cpp:478 +msgid "Coons" msgstr "" -#: ../src/widgets/mesh-toolbar.cpp:500 -msgid "If the mesh should be smoothed across patch boundaries." +#: ../src/widgets/mesh-toolbar.cpp:479 +msgid "Coons: no smoothing. Bicubic: smoothing across patch boundaries." msgstr "" -#: ../src/widgets/mesh-toolbar.cpp:502 ../src/widgets/pencil-toolbar.cpp:278 +#: ../src/widgets/mesh-toolbar.cpp:481 ../src/widgets/pencil-toolbar.cpp:278 msgid "Smoothing:" msgstr "Nogludināšana:" @@ -25771,55 +25796,55 @@ msgstr "Atiestatīt zīmuļa parametrus uz noklusētajiem (izmantojiet Inkscape msgid "Change rectangle" msgstr "Izveidot taisnstūri" -#: ../src/widgets/rect-toolbar.cpp:318 +#: ../src/widgets/rect-toolbar.cpp:317 msgid "W:" msgstr "P:" -#: ../src/widgets/rect-toolbar.cpp:318 +#: ../src/widgets/rect-toolbar.cpp:317 msgid "Width of rectangle" msgstr "Taisnstūra platums" -#: ../src/widgets/rect-toolbar.cpp:335 +#: ../src/widgets/rect-toolbar.cpp:334 msgid "H:" msgstr "H:" -#: ../src/widgets/rect-toolbar.cpp:335 +#: ../src/widgets/rect-toolbar.cpp:334 msgid "Height of rectangle" msgstr "Taisnstūra augstums" -#: ../src/widgets/rect-toolbar.cpp:349 ../src/widgets/rect-toolbar.cpp:364 +#: ../src/widgets/rect-toolbar.cpp:348 ../src/widgets/rect-toolbar.cpp:363 msgid "not rounded" msgstr "nav noapaļoti" -#: ../src/widgets/rect-toolbar.cpp:352 +#: ../src/widgets/rect-toolbar.cpp:351 msgid "Horizontal radius" msgstr "Horizontālais rādiuss" -#: ../src/widgets/rect-toolbar.cpp:352 +#: ../src/widgets/rect-toolbar.cpp:351 msgid "Rx:" msgstr "Rx:" -#: ../src/widgets/rect-toolbar.cpp:352 +#: ../src/widgets/rect-toolbar.cpp:351 msgid "Horizontal radius of rounded corners" msgstr "Noapaļoto stūru horizontālais rādiuss" -#: ../src/widgets/rect-toolbar.cpp:367 +#: ../src/widgets/rect-toolbar.cpp:366 msgid "Vertical radius" msgstr "Vertikālais rādiuss" -#: ../src/widgets/rect-toolbar.cpp:367 +#: ../src/widgets/rect-toolbar.cpp:366 msgid "Ry:" msgstr "Ry:" -#: ../src/widgets/rect-toolbar.cpp:367 +#: ../src/widgets/rect-toolbar.cpp:366 msgid "Vertical radius of rounded corners" msgstr "Noapaļoto stūru vertikālais rādiuss" -#: ../src/widgets/rect-toolbar.cpp:386 +#: ../src/widgets/rect-toolbar.cpp:385 msgid "Not rounded" msgstr "Nenoapaļoti" -#: ../src/widgets/rect-toolbar.cpp:387 +#: ../src/widgets/rect-toolbar.cpp:386 msgid "Make corners sharp" msgstr "Padarīt stūrus asus" @@ -27194,7 +27219,7 @@ msgstr "Zema precizitāte vienkāršo ceļus, augsta precizitāte saglabā ceļa msgid "Use the pressure of the input device to alter the force of tweak action" msgstr "Izmantojiet spiedienu uz ievadierīci, lai mainītu pieskaņošanas darbības spēku" -#: ../share/extensions/convert2dashes.py:93 +#: ../share/extensions/convert2dashes.py:100 msgid "" "The selected object is not a path.\n" "Try using the procedure Path->Object to Path." @@ -27252,11 +27277,11 @@ msgstr "Atrastas un ignorētas %d POLYLINE tipa ENTITIES. Lūdzu, mēģiniet pā msgid "Failed to import the numpy or numpy.linalg modules. These modules are required by this extension. Please install them and try again." msgstr "Neizdevās importēt numpy vai numpy.linalg moduļus. Šie moduļi ir nepieciešami šim paplašinājuma. Lūdzu, uzstādiet tos un mēģiniet vēlreiz." -#: ../share/extensions/dxf_outlines.py:300 +#: ../share/extensions/dxf_outlines.py:299 msgid "Error: Field 'Layer match name' must be filled when using 'By name match' option" msgstr "Kļūda: laukam 'Slāņa nosaukuma atbilstība' jābūt aizpildītam, ja izmantojat 'Pēc nosaukuma atbilstības' papildiespēju" -#: ../share/extensions/dxf_outlines.py:341 +#: ../share/extensions/dxf_outlines.py:340 #, python-format msgid "Warning: Layer '%s' not found!" msgstr "Uzmanību: slānis '%s' nav atrasts!" @@ -27293,7 +27318,7 @@ msgid "Need at least 2 paths selected" msgstr "Nepieciešami vismaz 2 atlasīti ceļi" #: ../share/extensions/funcplot.py:48 -msgid "x-interval cannot be zero. Please modify 'Start X value' or 'End X alue'" +msgid "x-interval cannot be zero. Please modify 'Start X value' or 'End X value'" msgstr "x-intervāls nevar būt nulle. Lūdzu, mainiet 'Sākuma X' vai 'Beigu X' vērtības" #: ../share/extensions/funcplot.py:60 @@ -28619,7 +28644,6 @@ msgid "Text Font:" msgstr "Teksta fonts:" #: ../share/extensions/dxf_input.inx.h:11 -#, fuzzy msgid "" "- AutoCAD Release 13 and newer.\n" "- for manual scaling, assume dxf drawing is in mm.\n" @@ -28631,10 +28655,12 @@ msgid "" "- limited support for BLOCKS, use AutoCAD Explode Blocks instead, if needed." msgstr "" "- AutoCAD 13 un jaunākām versijām:\n" -"- pieņemt, ka dxf rasējums ir mm.\n" +"- mērogošanai ar roku pieņemt, ka dxf rasējums ir mm.\n" "- pieņemt, ka svg rasējums ir pikseļos ar izšķirtspēju 96 dpi.\n" "- mēroga koeficients un izejas punkts attiecas tikai uz rokas mērogošanu.\n" -"- slāņi tiek saglabāti tikai Fails->Atvērt gadījumā, Importēt - nē.\n" +"- 'Automātiskā mērogošana' ietilpinās platumu A4 lapā.\n" +"- 'Lasīt no datnes' izmanto mainīgo $MEASUREMENT.\n" +"- slāņi tiek saglabāti tikai Datne->Atvērt gadījumā, Importēt - nē.\n" "- ierobežots BLOCKS atbalsts, nepieciešamības gadījumā izmantojiet AutoCAD Explode Blocks." #: ../share/extensions/dxf_input.inx.h:19 @@ -31598,11 +31624,11 @@ msgstr "Izmantojamā komandu valoda. (Noklusētā: HPGL)" #: ../share/extensions/plotter.inx.h:12 msgid "Initialization commands:" -msgstr "" +msgstr "Inicializēšanas komandas:" #: ../share/extensions/plotter.inx.h:13 msgid "Commands that will be sent to the plotter before the main data stream, only use this if you know what you are doing! (Default: Empty)" -msgstr "" +msgstr "Komandas, kas tiks nosūtītas ploterim pirms galvenās datu plūsmas, izmantojiet to tikai gadījumā, ja saprotat, ko darāt (Noklusētais: tukšs)" #: ../share/extensions/plotter.inx.h:14 msgid "Software (XON/XOFF)" @@ -32363,11 +32389,11 @@ msgstr "Mērogojamo vektoru grafika" msgid "Seamless Pattern" msgstr "Pa_darīt viengabalainu" -#: ../share/extensions/seamless_pattern.inx.h:2 +#: ../share/extensions/seamless_pattern.inx.h:2 ../share/extensions/seamless_pattern_procedural.inx.h:2 msgid "Custom Width (px):" msgstr "Pielāgots platums (piks.):" -#: ../share/extensions/seamless_pattern.inx.h:3 +#: ../share/extensions/seamless_pattern.inx.h:3 ../share/extensions/seamless_pattern_procedural.inx.h:3 msgid "Custom Height (px):" msgstr "Pielāgot augstums (piks.):" @@ -32380,14 +32406,6 @@ msgstr "Šis paplašinājums pārrakstīs atvērto dokumentu" msgid "Seamless Pattern Procedural" msgstr "Pa_darīt viengabalainu" -#: ../share/extensions/seamless_pattern_procedural.inx.h:2 -msgid "Custom Width (px.):" -msgstr "Pielāgots platums (piks.):" - -#: ../share/extensions/seamless_pattern_procedural.inx.h:3 -msgid "Custom Height (px.):" -msgstr "Pielāgot augstums (piks.):" - #: ../share/extensions/setup_typography_canvas.inx.h:1 msgid "1 - Setup Typography Canvas" msgstr "1 - Izveidot tipogrāfijas audeklu" @@ -33266,6 +33284,112 @@ msgstr "Bieži lietots galeriju attēlu grafiskais formāts " msgid "XAML Input" msgstr "XAML ievade" +#, fuzzy +#~ msgid "Show helper paths" +#~ msgstr "Rādīt pārvietojumus starp ceļiem" + +#~ msgid "Control handle 0 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 0 - Ctrl+Alt+Click, lai atiestatītu " + +#~ msgid "Control handle 1 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 1 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 2 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 2 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 3 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 3 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 4 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 4 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 5 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 5 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 6 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 6 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 7 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 7 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 8x9 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 8x9 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 10x11 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 10x11 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 12 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 12 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 13 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 13 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 14 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 14 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 15 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 15 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 16 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 16 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 17 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 17 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 18 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 18 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 19 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 19 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 20x21 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 20x21 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 22x23 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 22x23 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 24x26 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 24x26 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 25x27 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 25x27 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 28x30 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 28x30 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 29x31 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 29x31 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Control handle 32x33x34x35 - Ctrl+Alt+Click to reset" +#~ msgstr "Vadības turis 32x33x34x35 - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Top Left - Ctrl+Alt+Click to reset" +#~ msgstr "Augšējais kreisais - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Top Right - Ctrl+Alt+Click to reset" +#~ msgstr "Augšējais labais - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Down Left - Ctrl+Alt+Click to reset" +#~ msgstr "Apakšējais kreisais - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "Down Right - Ctrl+Alt+Click to reset" +#~ msgstr "Apakšējais labais - Ctrl+Alt+Click, lai atiestatītu" + +#~ msgid "%i objects selected of type %s" +#~ msgid_plural "%i objects selected of types %s" +#~ msgstr[0] "izvēlēts %i objekts ar tipu %s" +#~ msgstr[1] "izvēlēti %i objekti ar tipu %s" +#~ msgstr[2] "izvēlēti %i objekti ar tipu %s" + +#~ msgid "x-interval cannot be zero. Please modify 'Start X value' or 'End X alue'" +#~ msgstr "x-intervāls nevar būt nulle. Lūdzu, mainiet 'Sākuma X' vai 'Beigu X' vērtības" + +#~ msgid "Custom Width (px.):" +#~ msgstr "Pielāgots platums (piks.):" + +#~ msgid "Custom Height (px.):" +#~ msgstr "Pielāgot augstums (piks.):" + #~ msgid "Select a file of predefined shortcuts to use. Any customized shortcuts you create will be added seperately to " #~ msgstr "Izvēlieties datni ar iepriekš definētām saīsnēm. Visas Jūsu izveidotās pielāgotās saīsnes tiks pievienotas pie " -- cgit v1.2.3 From 4c09589618475e1846475f5c983ea32ff1638db6 Mon Sep 17 00:00:00 2001 From: "Liam P. White" Date: Sun, 22 Mar 2015 20:59:26 -0400 Subject: well if I had known that existed, I would have used it sooner (bzr r14029) --- src/live_effects/lpe-jointype.cpp | 6 +- src/live_effects/lpe-jointype.h | 1 - src/live_effects/lpe-taperstroke.cpp | 116 ++++------------------------------- 3 files changed, 12 insertions(+), 111 deletions(-) diff --git a/src/live_effects/lpe-jointype.cpp b/src/live_effects/lpe-jointype.cpp index 09869822c..c7ea64b77 100644 --- a/src/live_effects/lpe-jointype.cpp +++ b/src/live_effects/lpe-jointype.cpp @@ -63,7 +63,6 @@ LPEJoinType::LPEJoinType(LivePathEffectObject *lpeobject) : //registerParameter(&end_lean); registerParameter(&miter_limit); registerParameter(&attempt_force_join); - was_initialized = false; //start_lean.param_set_range(-1,1); //start_lean.param_set_increments(0.1, 0.1); //start_lean.param_set_digits(4); @@ -109,10 +108,7 @@ void LPEJoinType::doOnApply(SPLPEItem const* lpeitem) sp_desktop_apply_css_recursive(item, css, true); sp_repr_css_attr_unref (css); - if (!was_initialized) { - was_initialized = true; - line_width.param_set_value(width); - } + line_width.param_set_value(width); } } diff --git a/src/live_effects/lpe-jointype.h b/src/live_effects/lpe-jointype.h index 799901eb6..bca0961c9 100644 --- a/src/live_effects/lpe-jointype.h +++ b/src/live_effects/lpe-jointype.h @@ -37,7 +37,6 @@ private: //ScalarParam end_lean; ScalarParam miter_limit; BoolParam attempt_force_join; - bool was_initialized; }; } //namespace LivePathEffect diff --git a/src/live_effects/lpe-taperstroke.cpp b/src/live_effects/lpe-taperstroke.cpp index d54b2acc0..bdd36df68 100644 --- a/src/live_effects/lpe-taperstroke.cpp +++ b/src/live_effects/lpe-taperstroke.cpp @@ -186,18 +186,8 @@ static Geom::Path return_at_first_cusp(Geom::Path const & path_in, double /*smoo return temp; } -static Geom::CubicBezier sbasis_to_cubicbezier(Geom::D2 const & sbasis_in) -{ - std::vector temp; - Geom::sbasis_to_bezier(temp, sbasis_in, 4); - return Geom::CubicBezier( temp ); -} - Piecewise > stretch_along(Piecewise > pwd2_in, Geom::Path pattern, double width); -// references to pointers -void subdivideCurve(Geom::Curve * curve_in, Geom::Coord t, Geom::Curve *& val_first, Geom::Curve *& val_second); - // actual effect Geom::PathVector LPETaperStroke::doEffect_path(Geom::PathVector const& path_in) @@ -357,85 +347,18 @@ Geom::PathVector LPETaperStroke::doEffect_path(Geom::PathVector const& path_in) */ Geom::PathVector LPETaperStroke::doEffect_simplePath(Geom::PathVector const & path_in) { - size_t size = path_in[0].size(); - - unsigned loc = (unsigned)attach_start; - Geom::Curve * curve_start = path_in[0] [loc].duplicate(); - - std::vector pathv_out; - Geom::Path path_out = Geom::Path(); - - Geom::Path trimmed_start = Geom::Path(); - Geom::Path trimmed_end = Geom::Path(); - - for (size_t i = 0; i < loc; ++i) { - trimmed_start.append(path_in[0] [i]); - } - - Geom::Curve * temp; - subdivideCurve(curve_start, attach_start - loc, temp, curve_start); - trimmed_start.append(*temp); - if (temp) delete temp; temp = 0; - - // special case: path is one segment long - // special case: what if the two knots occupy the same segment? - if ((size == 1) || ( size - unsigned(attach_end) - 1 == loc )) { - - // If you look into it, I don't actually think there is a working way to do this - // with only point math. So we use nearest_point instead. - Geom::Coord t = Geom::nearest_point(end_attach_point, *curve_start); - - // it is just a dumb segment - // we have to do some shifting here because the value changed when we reduced the length - // of the previous segment. - - subdivideCurve(curve_start, t, curve_start, temp); - trimmed_end.append(*temp); - if (temp) delete temp; temp = 0; - - for (size_t j = (size - attach_end) + 1; j < size; ++j) { - trimmed_end.append(path_in[0] [j]); - } - - path_out.append(*curve_start); - pathv_out.push_back(trimmed_start); - pathv_out.push_back(path_out); - pathv_out.push_back(trimmed_end); - return pathv_out; - } - - pathv_out.push_back(trimmed_start); + Geom::Coord endTime = path_in[0].size() - attach_end; - // append almost all of the rest of the path, ignore the curves that the knot is past (we'll get to it in a minute) - path_out.append(*curve_start); - - for (size_t k = loc + 1; k < (size - unsigned(attach_end)) - 1; ++k) { - path_out.append(path_in[0] [k]); - } - - // deal with the last segment in a very similar fashion to the first - loc = size - attach_end; - - Geom::Curve * curve_end = path_in[0] [loc].duplicate(); - - Geom::Coord t = Geom::nearest_point(end_attach_point, *curve_end); - - subdivideCurve(curve_end, t, curve_end, temp); - trimmed_end.append(*temp); - if (temp) delete temp; temp = 0; - - for (size_t j = (size - attach_end) + 1; j < size; ++j) { - trimmed_end.append(path_in[0] [j]); - } - - path_out.append(*curve_end); - pathv_out.push_back(path_out); - - pathv_out.push_back(trimmed_end); - - if (curve_end) delete curve_end; - if (curve_start) delete curve_start; - return pathv_out; + Geom::Path p1 = path_in[0].portion(0., attach_start); + Geom::Path p2 = path_in[0].portion(attach_start, endTime); + Geom::Path p3 = path_in[0].portion(endTime, path_in[0].size()); + + Geom::PathVector out; + out.push_back(p1); + out.push_back(p2); + out.push_back(p3); + + return out; } @@ -523,23 +446,6 @@ Piecewise > stretch_along(Piecewise > pwd2_in, Geom::Path } } -void subdivideCurve(Geom::Curve * curve_in, Geom::Coord t, Geom::Curve *& val_first, Geom::Curve *& val_second) -{ - if (Geom::LineSegment* linear = dynamic_cast(curve_in)) { - // special case for line segments - std::pair seg_pair = linear->subdivide(t); - val_first = seg_pair.first.duplicate(); - val_second = seg_pair.second.duplicate(); - } else { - // all other cases: - Geom::CubicBezier cubic = sbasis_to_cubicbezier(curve_in->toSBasis()); - std::pair cubic_pair = cubic.subdivide(t); - val_first = cubic_pair.first.duplicate(); - val_second = cubic_pair.second.duplicate(); - } -} - - void LPETaperStroke::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item) { KnotHolderEntity *e = new TpS::KnotHolderEntityAttachBegin(this); -- cgit v1.2.3 From 234b0e3149a0a9212c54a79753c1b468e01b0aee Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Mon, 23 Mar 2015 19:25:12 +0100 Subject: Fix a bug introduced by me using path parameters in LPE (bzr r14030) --- src/ui/tool/path-manipulator.cpp | 40 +++++++++++++++++----------------------- 1 file changed, 17 insertions(+), 23 deletions(-) diff --git a/src/ui/tool/path-manipulator.cpp b/src/ui/tool/path-manipulator.cpp index b1e4d641e..ccf75dcde 100644 --- a/src/ui/tool/path-manipulator.cpp +++ b/src/ui/tool/path-manipulator.cpp @@ -1239,14 +1239,11 @@ int PathManipulator::BSplineGetSteps() const { // determines if the trace has bspline effect void PathManipulator::recalculateIsBSpline(){ - SPLPEItem * path = dynamic_cast(_path); - if (path){ - if(path->hasPathEffect()){ - Inkscape::LivePathEffect::Effect const *thisEffect = path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE); - if(thisEffect){ - _is_bspline = true; - return; - } + if (SP_IS_LPE_ITEM(_path) && _path->hasPathEffect()) { + Inkscape::LivePathEffect::Effect const *thisEffect = _path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE); + if(thisEffect){ + _is_bspline = true; + return; } } _is_bspline = false; @@ -1350,22 +1347,19 @@ void PathManipulator::_createGeometryFromControlPoints(bool alert_LPE) _spcurve->set_pathvector(pathv); if (alert_LPE) { /// \todo note that _path can be an Inkscape::LivePathEffect::Effect* too, kind of confusing, rework member naming? - SPLPEItem * path = dynamic_cast(_path); - if (path){ - if(path->hasPathEffect()){ - Inkscape::LivePathEffect::Effect* thisEffect = path->getPathEffectOfType(Inkscape::LivePathEffect::POWERSTROKE); - if(thisEffect){ - LivePathEffect::LPEPowerStroke *lpe_pwr = dynamic_cast(thisEffect->getLPEObj()->get_lpe()); - if (lpe_pwr) { - lpe_pwr->adjustForNewPath(pathv); - } + if (SP_IS_LPE_ITEM(_path) && _path->hasPathEffect()) { + Inkscape::LivePathEffect::Effect* thisEffect = _path->getPathEffectOfType(Inkscape::LivePathEffect::POWERSTROKE); + if(thisEffect){ + LivePathEffect::LPEPowerStroke *lpe_pwr = dynamic_cast(thisEffect->getLPEObj()->get_lpe()); + if (lpe_pwr) { + lpe_pwr->adjustForNewPath(pathv); } - thisEffect = path->getPathEffectOfType(Inkscape::LivePathEffect::FILLET_CHAMFER); - if(thisEffect){ - LivePathEffect::LPEFilletChamfer *lpe_fll = dynamic_cast(thisEffect->getLPEObj()->get_lpe()); - if (lpe_fll) { - lpe_fll->adjustForNewPath(pathv); - } + } + thisEffect = _path->getPathEffectOfType(Inkscape::LivePathEffect::FILLET_CHAMFER); + if(thisEffect){ + LivePathEffect::LPEFilletChamfer *lpe_fll = dynamic_cast(thisEffect->getLPEObj()->get_lpe()); + if (lpe_fll) { + lpe_fll->adjustForNewPath(pathv); } } } -- cgit v1.2.3 From 8114c1ddc31f502875e2100adcf454e2cedb2b50 Mon Sep 17 00:00:00 2001 From: "Liam P. White" Date: Mon, 23 Mar 2015 20:43:28 -0400 Subject: Path outliner: refactor extrapolated joiner, allow joining line segments; some more optimizations all around (bzr r14031) --- src/helper/geom-pathstroke.cpp | 220 +++++++++++++++++++++++++++++------------ 1 file changed, 155 insertions(+), 65 deletions(-) diff --git a/src/helper/geom-pathstroke.cpp b/src/helper/geom-pathstroke.cpp index 6fcfb79d5..d3147f233 100644 --- a/src/helper/geom-pathstroke.cpp +++ b/src/helper/geom-pathstroke.cpp @@ -19,6 +19,74 @@ namespace Geom { // 2geom/circle-circle.cpp, no header int circle_circle_intersection(Point X0, double r0, Point X1, double r1, Point &p0, Point &p1); +/** + * Determine the intersection points between a circle C0 and a line defined + * by two points, X0 and X1. + * + * Which intersection point is assigned to p0 or p1 is unspecified, and callers + * should not depend on any particular intersection always being assigned to p0. + * + * Returns: + * If the line and circle do not cross, 0 is returned. + * If solution(s) exist, 2 is returned, and the results are written to p0 and p1. + */ +static int circle_line_intersection(Circle C0, Point X0, Point X1, Point &p0, Point &p1) +{ + /* equation of a circle: (x - h)^2 + (y - k)^2 = r^2 */ + Coord r = C0.ray(); + Coord h = C0.center()[X]; + Coord k = C0.center()[Y]; + + Coord x0, y0; + Coord x1, y1; + + if (are_near(X1[X], X0[X])) { + /* slope is undefined (vertical line) */ + Coord c = X0[X]; + Coord det = r*r - (c-h)*(c-h); + + /* no intersection */ + if (det < 0) + return 0; + + /* solve for y */ + y0 = k + std::sqrt(det); + y1 = k - std::sqrt(det); + + // x == c (always) + x0 = c; + x1 = c; + } else { + /* equation of a line: y = mx + b */ + Coord m = (X1[Y] - X0[Y]) / (X1[X] - X0[X]); + Coord b = X0[Y] - m*X0[X]; + + /* obtain quadratic for x: */ + Coord A = m*m + 1; + Coord B = 2*h - 2*b*m + 2*k*m; + Coord C = b*b + h*h + k*k - r*r - 2*b*k; + + Coord det = B*B - 4*A*C; + + /* no intersection, circle and line do not cross */ + if (det < 0) + return 0; + + /* solve quadratic */ + x0 = (B + std::sqrt(det)) / (2*A); + x1 = (B - std::sqrt(det)) / (2*A); + + /* substitute the calculated x times to determine the y values */ + y0 = m*x0 + b; + y1 = m*x1 + b; + } + + p0 = Point(x0, y0); + p1 = Point(x1, y1); + + return 2; +} + static Point intersection_point(Point origin_a, Point vector_a, Point origin_b, Point vector_b) { Coord denom = cross(vector_b, vector_a); @@ -88,13 +156,16 @@ void miter_join(Geom::Path& res, Geom::Curve const& outgoing, double miter, doub Geom::Point tang1 = Geom::unitTangentAt(reverse(incoming.toSBasis()), 0.); Geom::Point tang2 = outgoing.unitTangentAt(0); Geom::Point p = Geom::intersection_point(incoming.finalPoint(), tang1, outgoing.initialPoint(), tang2); + + bool satisfied = false; + if (p.isFinite()) { // check size of miter Geom::Point point_on_path = incoming.finalPoint() - Geom::rot90(tang1)*width; - double len = Geom::distance(p, point_on_path); - if (len <= miter) { + satisfied = Geom::distance(p, point_on_path) <= miter; + if (satisfied) { // miter OK, check to see if we can do a relocation - bool ls = dynamic_cast(&res.back_open()); + bool ls = res.back_open().degreesOfFreedom() <= 4; if (ls) { res.setFinal(p); } else { @@ -106,81 +177,93 @@ void miter_join(Geom::Path& res, Geom::Curve const& outgoing, double miter, doub res.appendNew(outgoing.initialPoint()); // check if we can do another relocation + bool ls = outgoing.degreesOfFreedom() <= 4; - bool ls = dynamic_cast(&outgoing); - if (ls) { + if (satisfied && ls) { res.setFinal(outgoing.finalPoint()); } else { res.append(outgoing); } } -// might need a little reworking +Geom::Point pick_solution(Geom::Point points[2], Geom::Point tang2, Geom::Point endPt) +{ + Geom::Point sol; + if ( dot(tang2,points[0]-endPt) > 0 ) { + // points[0] is bad, choose points[1] + sol = points[1]; + } else if ( dot(tang2,points[1]-endPt) > 0 ) { // points[0] could be good, now check points[1] + // points[1] is bad, choose points[0] + sol = points[0]; + } else { + // both points are good, choose nearest + sol = ( distanceSq(endPt, points[0]) < distanceSq(endPt, points[1]) ) ? points[0] : points[1]; + } + return sol; +} + void extrapolate_join(Geom::Path& path_builder, Geom::Curve const& outgoing, double miter_limit, double line_width) { using namespace Geom; Geom::Curve const& incoming = path_builder.back(); Geom::Point endPt = outgoing.initialPoint(); + Geom::Point tang2 = Geom::unitTangentAt(outgoing.toSBasis(), 0); + + Geom::Circle circle1 = Geom::touching_circle(Geom::reverse(incoming.toSBasis()), 0.); + Geom::Circle circle2 = Geom::touching_circle(outgoing.toSBasis(), 0); + + bool inc_ls = !circle1.center().isFinite(); + bool out_ls = !circle2.center().isFinite(); - // The method used when extrapolating curves fails to work when either side of the join to be extrapolated - // is a line segment. When this situation is encountered, fall back to a regular miter join. - bool lineProblem = (dynamic_cast(&incoming)) || (dynamic_cast(&outgoing)); - if (lineProblem == false) { - // Geom::Point tang1 = Geom::unitTangentAt(Geom::reverse(incoming.toSBasis()), 0.); - Geom::Point tang2 = Geom::unitTangentAt(outgoing.toSBasis(), 0); + Geom::Point points[2]; - Geom::Circle circle1 = Geom::touching_circle(Geom::reverse(incoming.toSBasis()), 0.); - Geom::Circle circle2 = Geom::touching_circle(outgoing.toSBasis(), 0); + int solutions = 0; + Geom::EllipticalArc *arc0 = NULL; + Geom::EllipticalArc *arc1 = NULL; - Geom::Point points[2]; - int solutions = Geom::circle_circle_intersection(circle1.center(), circle1.ray(), - circle2.center(), circle2.ray(), - points[0], points[1]); + if (!inc_ls && !out_ls) { + solutions = Geom::circle_circle_intersection(circle1.center(), circle1.ray(), + circle2.center(), circle2.ray(), + points[0], points[1]); if (solutions == 2) { - Geom::Point sol(0,0); - if ( dot(tang2,points[0]-endPt) > 0 ) { - // points[0] is bad, choose points[1] - sol = points[1]; - } else if ( dot(tang2,points[1]-endPt) > 0 ) { // points[0] could be good, now check points[1] - // points[1] is bad, choose points[0] - sol = points[0]; - } else { - // both points are good, choose nearest - sol = ( distanceSq(endPt, points[0]) < distanceSq(endPt, points[1]) ) ? points[0] : points[1]; - } + Geom::Point sol = pick_solution(points, tang2, endPt); - Geom::EllipticalArc *arc0 = circle1.arc(incoming.finalPoint(), 0.5*(incoming.finalPoint()+sol), sol, true); - Geom::EllipticalArc *arc1 = circle2.arc(sol, 0.5*(sol+endPt), endPt, true); - try { - if (arc0) { - path_builder.append(*arc0); - delete arc0; - arc0 = NULL; - } else { - throw std::exception(); - } - - if (arc1) { - path_builder.append(*arc1); - delete arc1; - arc1 = NULL; - } else { - throw std::exception(); - } - - } catch (std::exception const & ex) { - printf("WARNING: Error extrapolating line join: %s\n", ex.what()); - path_builder.appendNew(endPt); - } - path_builder.append(outgoing); - } else { - // 1 or no solutions found, default to miter - miter_join(path_builder, outgoing, miter_limit, line_width); + arc0 = circle1.arc(incoming.finalPoint(), 0.5*(incoming.finalPoint()+sol), sol, true); + arc1 = circle2.arc(sol, 0.5*(sol+endPt), endPt, true); + } + } else if (inc_ls && !out_ls) { + solutions = Geom::circle_line_intersection(circle2, incoming.initialPoint(), incoming.finalPoint(), points[0], points[1]); + + if (solutions == 2) { + Geom::Point sol = pick_solution(points, tang2, endPt); + path_builder.setFinal(sol); + arc1 = circle2.arc(sol, 0.5*(sol+endPt), endPt, true); + } + } else if (!inc_ls && out_ls) { + solutions = Geom::circle_line_intersection(circle1, outgoing.initialPoint(), outgoing.finalPoint(), points[0], points[1]); + + if (solutions == 2) { + Geom::Point sol = pick_solution(points, tang2, endPt); + arc0 = circle1.arc(incoming.finalPoint(), 0.5*(sol+incoming.finalPoint()), sol, true); } - } else { - // Line segments exist - miter_join(path_builder, outgoing, miter_limit, line_width); } + + if (solutions != 2) + // no solutions available, fall back to miter + return miter_join(path_builder, outgoing, miter_limit, line_width); + + if (arc0) + path_builder.append(*arc0); + if (arc1) + path_builder.append(*arc1); + + delete arc0; + delete arc1; + + if (!inc_ls && out_ls) + path_builder.appendNew(outgoing.finalPoint()); + else + path_builder.append(outgoing); } void join_inside(Geom::Path& res, Geom::Curve const& outgoing) @@ -207,6 +290,9 @@ void join_inside(Geom::Path& res, Geom::Curve const& outgoing) void outline_helper(Geom::Path& res, Geom::Path const& to_add, double width, double miter, Inkscape::LineJoinType join) { + if (res.size() == 0 || to_add.size() == 0) + return; + Geom::Curve const& outgoing = to_add[0]; if (Geom::are_near(res.finalPoint(), outgoing.initialPoint())) { // if the points are /that/ close, just ignore this one @@ -216,7 +302,6 @@ void outline_helper(Geom::Path& res, Geom::Path const& to_add, double width, dou } Geom::Point tang1 = -Geom::unitTangentAt(reverse(res.back().toSBasis()), 0.); - //Geom::Point tang2 = to_add[0].unitTangentAt(0); Geom::Point discontinuity_vec = to_add.initialPoint() - res.finalPoint(); bool on_outside = (Geom::dot(tang1, discontinuity_vec) >= 0); @@ -368,9 +453,11 @@ void offset_quadratic(Geom::Path& p, Geom::QuadraticBezier const& bez, double wi void offset_curve(Geom::Path& res, Geom::Curve const* current, double width) { - double const tolerance = 0.0025; + double const tolerance = 0.005; size_t levels = 8; + if (current->isDegenerate()) return; // don't do anything + // TODO: we can handle SVGEllipticalArc here as well, do that! if (Geom::BezierCurve const *b = dynamic_cast(current)) { @@ -390,7 +477,7 @@ void offset_curve(Geom::Path& res, Geom::Curve const* current, double width) break; } default: { - Geom::Path sbasis_path = Geom::cubicbezierpath_from_sbasis(current->toSBasis(), 0.1); + Geom::Path sbasis_path = Geom::cubicbezierpath_from_sbasis(current->toSBasis(), tolerance); for (size_t i = 0; i < sbasis_path.size(); ++i) offset_curve(res, &sbasis_path[i], width); break; @@ -469,6 +556,7 @@ Geom::PathVector outline(Geom::Path const& input, double width, double miter, Li if (!input.closed()) { cf(res, with_dir, against_dir, width); } else { + res.closePath(); res.moveTo(against_dir.initialPoint()); } @@ -476,9 +564,9 @@ Geom::PathVector outline(Geom::Path const& input, double width, double miter, Li if (!input.closed()) { cf(res, against_dir, with_dir, width); - res.closePath(); } + res.closePath(); res.flush(); return res.peek(); } @@ -507,7 +595,8 @@ Geom::Path half_outline(Geom::Path const& input, double width, double miter, Lin res.append(temp); } else { outline_helper(res, temp, width, miter, join); - res.insert(res.end(), ++temp.begin(), temp.end()); + if (temp.size() > 0) + res.insert(res.end(), ++temp.begin(), temp.end()); } // odd number of paths @@ -515,7 +604,8 @@ Geom::Path half_outline(Geom::Path const& input, double width, double miter, Lin temp = Geom::Path(); offset_curve(temp, &input[u+1], width); outline_helper(res, temp, width, miter, join); - res.insert(res.end(), ++temp.begin(), temp.end()); + if (temp.size() > 0) + res.insert(res.end(), ++temp.begin(), temp.end()); } } -- cgit v1.2.3 From 4174a0d797f074d60bd0f6572638ec8684a2ac27 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Tue, 24 Mar 2015 18:16:37 +0100 Subject: Fix a crash on perspective/envelope LPE introduced in recent refactor of point parameter (bzr r14032) --- src/live_effects/lpe-perspective-envelope.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/live_effects/lpe-perspective-envelope.cpp b/src/live_effects/lpe-perspective-envelope.cpp index d60a13c23..b5885bdb3 100644 --- a/src/live_effects/lpe-perspective-envelope.cpp +++ b/src/live_effects/lpe-perspective-envelope.cpp @@ -48,11 +48,11 @@ LPEPerspectiveEnvelope::LPEPerspectiveEnvelope(LivePathEffectObject *lpeobject) Down_Right_Point(_("Down Right"), _("Down Right - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "Down_Right_Point", &wr, this) { // register all your parameters here, so Inkscape knows which parameters this effect has: - registerParameter( dynamic_cast(&deform_type)); - registerParameter( dynamic_cast(&Up_Left_Point) ); - registerParameter( dynamic_cast(&Up_Right_Point) ); - registerParameter( dynamic_cast(&Down_Left_Point) ); - registerParameter( dynamic_cast(&Down_Right_Point) ); + registerParameter(&deform_type); + registerParameter(&Up_Left_Point); + registerParameter(&Up_Right_Point); + registerParameter(&Down_Left_Point); + registerParameter(&Down_Right_Point); } LPEPerspectiveEnvelope::~LPEPerspectiveEnvelope() @@ -340,8 +340,8 @@ LPEPerspectiveEnvelope::resetDefaults(SPItem const* item) { Effect::resetDefaults(item); original_bbox(SP_LPE_ITEM(item)); - resetGrid(); setDefaults(); + resetGrid(); } void -- cgit v1.2.3 From 8c5e33effcd16fac6ff807fa4b1700291892cbf7 Mon Sep 17 00:00:00 2001 From: Tavmjong Bah Date: Fri, 27 Mar 2015 17:37:16 +0100 Subject: Fix calculation of miter limit. Implement 'miter-clip' line join. (bzr r14033) --- src/helper/geom-pathstroke.cpp | 55 ++++++++++++++++++++++++++++++++++----- src/helper/geom-pathstroke.h | 3 ++- src/live_effects/lpe-jointype.cpp | 7 ++--- 3 files changed, 54 insertions(+), 11 deletions(-) diff --git a/src/helper/geom-pathstroke.cpp b/src/helper/geom-pathstroke.cpp index d3147f233..1908f2db7 100644 --- a/src/helper/geom-pathstroke.cpp +++ b/src/helper/geom-pathstroke.cpp @@ -6,6 +6,7 @@ * Released under GNU GPL, read the file 'COPYING' for more information */ +#include #include <2geom/path-sink.h> #include <2geom/point.h> #include <2geom/bezier-curve.h> @@ -150,7 +151,7 @@ void round_join(Geom::Path& res, Geom::Curve const& outgoing, double /*miter*/, res.append(outgoing); } -void miter_join(Geom::Path& res, Geom::Curve const& outgoing, double miter, double width) +void miter_join_internal(Geom::Path& res, Geom::Curve const& outgoing, double miter, double width, bool clip) { Geom::Curve const& incoming = res.back(); Geom::Point tang1 = Geom::unitTangentAt(reverse(incoming.toSBasis()), 0.); @@ -161,8 +162,8 @@ void miter_join(Geom::Path& res, Geom::Curve const& outgoing, double miter, doub if (p.isFinite()) { // check size of miter - Geom::Point point_on_path = incoming.finalPoint() - Geom::rot90(tang1)*width; - satisfied = Geom::distance(p, point_on_path) <= miter; + Geom::Point point_on_path = incoming.finalPoint() + Geom::rot90(tang1)*width; + satisfied = Geom::distance(p, point_on_path) <= miter * 2.0 * width; if (satisfied) { // miter OK, check to see if we can do a relocation bool ls = res.back_open().degreesOfFreedom() <= 4; @@ -171,6 +172,31 @@ void miter_join(Geom::Path& res, Geom::Curve const& outgoing, double miter, doub } else { res.appendNew(p); } + } else if (clip) { + // miter needs clipping, find two points + Geom::Line bisector(point_on_path, p); + Geom::Point point_limit = point_on_path + miter * 2.0 * width * bisector.versor(); + + Geom::Line line_limit = + Geom::Line::from_origin_and_versor( point_limit, bisector.versor().cw() ); + + Geom::Line incoming_line( incoming.finalPoint(), p ); + Geom::Line outgoing_line( p, outgoing.initialPoint() ); + + Geom::OptCrossing i1 = intersection( line_limit, incoming_line ); + Geom::OptCrossing i2 = intersection( line_limit, outgoing_line ); + + // It would be nice to have a simple point returned by intersection! + Geom::Point p1 = line_limit.pointAt( (*i1).ta ); + Geom::Point p2 = line_limit.pointAt( (*i2).ta ); + + bool ls = res.back_open().degreesOfFreedom() <= 4; + if (ls) { + res.setFinal(p1); + } else { + res.appendNew(p1); + } + res.appendNew(p2); } } @@ -179,13 +205,21 @@ void miter_join(Geom::Path& res, Geom::Curve const& outgoing, double miter, doub // check if we can do another relocation bool ls = outgoing.degreesOfFreedom() <= 4; - if (satisfied && ls) { + if ( (satisfied || clip) && ls) { res.setFinal(outgoing.finalPoint()); } else { res.append(outgoing); } } +void miter_join(Geom::Path& res, Geom::Curve const& outgoing, double miter, double width) { + miter_join_internal( res, outgoing, miter, width, false ); +} + +void miter_clip_join(Geom::Path& res, Geom::Curve const& outgoing, double miter, double width) { + miter_join_internal( res, outgoing, miter, width, true ); +} + Geom::Point pick_solution(Geom::Point points[2], Geom::Point tang2, Geom::Point endPt) { Geom::Point sol; @@ -301,9 +335,13 @@ void outline_helper(Geom::Path& res, Geom::Path const& to_add, double width, dou return; } - Geom::Point tang1 = -Geom::unitTangentAt(reverse(res.back().toSBasis()), 0.); - Geom::Point discontinuity_vec = to_add.initialPoint() - res.finalPoint(); - bool on_outside = (Geom::dot(tang1, discontinuity_vec) >= 0); + Geom::Point tang1 = Geom::unitTangentAt(reverse(res.back().toSBasis()), 0.); + Geom::Point tang2 = Geom::unitTangentAt(to_add.front().toSBasis(), 0.); + // Geom::Point discontinuity_vec = to_add.initialPoint() - res.finalPoint(); + bool on_outside = (Geom::cross(tang1, tang2) < 0); + // std::cout << std::fixed << std::setprecision(3) + // << " in: " << tang1 << " out: " << tang2 + // << " side: " << (on_outside?"inside":"outside") << std::endl; if (on_outside) { join_func *jf; @@ -317,6 +355,9 @@ void outline_helper(Geom::Path& res, Geom::Path const& to_add, double width, dou case Inkscape::JOIN_EXTRAPOLATE: jf = &extrapolate_join; break; + case Inkscape::JOIN_MITER_CLIP: + jf = &miter_clip_join; + break; default: jf = &miter_join; } diff --git a/src/helper/geom-pathstroke.h b/src/helper/geom-pathstroke.h index fe79e2777..0cfb9f817 100644 --- a/src/helper/geom-pathstroke.h +++ b/src/helper/geom-pathstroke.h @@ -18,6 +18,7 @@ enum LineJoinType { JOIN_BEVEL, JOIN_ROUND, JOIN_MITER, + JOIN_MITER_CLIP, JOIN_EXTRAPOLATE, }; @@ -34,7 +35,7 @@ enum LineCapType { * * @param input * @param width Amount to offset. - * @param miter Miter limit. Only used with JOIN_EXTRAPOLATE and JOIN_MITER. + * @param miter Miter limit. Only used with JOIN_MITER, JOIN_MITER_CLIP, and JOIN_EXTRAPOLATE. * @param join */ Geom::Path half_outline(Geom::Path const& input, double width, double miter, LineJoinType join = JOIN_BEVEL); diff --git a/src/live_effects/lpe-jointype.cpp b/src/live_effects/lpe-jointype.cpp index c7ea64b77..0111a0f99 100644 --- a/src/live_effects/lpe-jointype.cpp +++ b/src/live_effects/lpe-jointype.cpp @@ -28,9 +28,10 @@ namespace Inkscape { namespace LivePathEffect { static const Util::EnumData JoinTypeData[] = { - {JOIN_BEVEL, N_("Beveled"), "bevel"}, - {JOIN_ROUND, N_("Rounded"), "round"}, - {JOIN_MITER, N_("Miter"), "miter"}, + {JOIN_BEVEL, N_("Beveled"), "bevel"}, + {JOIN_ROUND, N_("Rounded"), "round"}, + {JOIN_MITER, N_("Miter"), "miter"}, + {JOIN_MITER_CLIP, N_("Miter Clip"), "miter-clip"}, {JOIN_EXTRAPOLATE, N_("Extrapolated arc"), "extrp_arc"}, }; -- cgit v1.2.3 From ee2b444706c7fd17c381d4c330185e02fc6d3ec9 Mon Sep 17 00:00:00 2001 From: "Liam P. White" Date: Sat, 28 Mar 2015 22:20:44 -0400 Subject: clean up previous commit (bzr r14034) --- src/helper/geom-pathstroke.cpp | 33 +++++++++------------------------ 1 file changed, 9 insertions(+), 24 deletions(-) diff --git a/src/helper/geom-pathstroke.cpp b/src/helper/geom-pathstroke.cpp index 1908f2db7..e34546d0e 100644 --- a/src/helper/geom-pathstroke.cpp +++ b/src/helper/geom-pathstroke.cpp @@ -159,6 +159,7 @@ void miter_join_internal(Geom::Path& res, Geom::Curve const& outgoing, double mi Geom::Point p = Geom::intersection_point(incoming.finalPoint(), tang1, outgoing.initialPoint(), tang2); bool satisfied = false; + bool inc_ls = res.back_open().degreesOfFreedom() <= 4; if (p.isFinite()) { // check size of miter @@ -166,32 +167,20 @@ void miter_join_internal(Geom::Path& res, Geom::Curve const& outgoing, double mi satisfied = Geom::distance(p, point_on_path) <= miter * 2.0 * width; if (satisfied) { // miter OK, check to see if we can do a relocation - bool ls = res.back_open().degreesOfFreedom() <= 4; - if (ls) { + if (inc_ls) { res.setFinal(p); } else { res.appendNew(p); } } else if (clip) { // miter needs clipping, find two points - Geom::Line bisector(point_on_path, p); - Geom::Point point_limit = point_on_path + miter * 2.0 * width * bisector.versor(); + Geom::Point bisector_versor = Geom::Line(point_on_path, p).versor(); + Geom::Point point_limit = point_on_path + miter * 2.0 * width * bisector_versor; - Geom::Line line_limit = - Geom::Line::from_origin_and_versor( point_limit, bisector.versor().cw() ); + Geom::Point p1 = Geom::intersection_point(incoming.finalPoint(), tang1, point_limit, bisector_versor.cw()); + Geom::Point p2 = Geom::intersection_point(outgoing.initialPoint(), tang2, point_limit, bisector_versor.cw()); - Geom::Line incoming_line( incoming.finalPoint(), p ); - Geom::Line outgoing_line( p, outgoing.initialPoint() ); - - Geom::OptCrossing i1 = intersection( line_limit, incoming_line ); - Geom::OptCrossing i2 = intersection( line_limit, outgoing_line ); - - // It would be nice to have a simple point returned by intersection! - Geom::Point p1 = line_limit.pointAt( (*i1).ta ); - Geom::Point p2 = line_limit.pointAt( (*i2).ta ); - - bool ls = res.back_open().degreesOfFreedom() <= 4; - if (ls) { + if (inc_ls) { res.setFinal(p1); } else { res.appendNew(p1); @@ -203,9 +192,9 @@ void miter_join_internal(Geom::Path& res, Geom::Curve const& outgoing, double mi res.appendNew(outgoing.initialPoint()); // check if we can do another relocation - bool ls = outgoing.degreesOfFreedom() <= 4; + bool out_ls = outgoing.degreesOfFreedom() <= 4; - if ( (satisfied || clip) && ls) { + if ( (satisfied || clip) && out_ls) { res.setFinal(outgoing.finalPoint()); } else { res.append(outgoing); @@ -337,11 +326,7 @@ void outline_helper(Geom::Path& res, Geom::Path const& to_add, double width, dou Geom::Point tang1 = Geom::unitTangentAt(reverse(res.back().toSBasis()), 0.); Geom::Point tang2 = Geom::unitTangentAt(to_add.front().toSBasis(), 0.); - // Geom::Point discontinuity_vec = to_add.initialPoint() - res.finalPoint(); bool on_outside = (Geom::cross(tang1, tang2) < 0); - // std::cout << std::fixed << std::setprecision(3) - // << " in: " << tang1 << " out: " << tang2 - // << " side: " << (on_outside?"inside":"outside") << std::endl; if (on_outside) { join_func *jf; -- cgit v1.2.3 From 953a5c690f328fc989ffc7692312937454ae3677 Mon Sep 17 00:00:00 2001 From: Tavmjong Bah Date: Sun, 29 Mar 2015 22:21:29 +0200 Subject: make_angle_bisector_line(): Return sensible line if three input points are colinear. Add output operator, useful for debugging. (bzr r14035) --- src/2geom/line.h | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/src/2geom/line.h b/src/2geom/line.h index ade67f818..cbd68fa08 100644 --- a/src/2geom/line.h +++ b/src/2geom/line.h @@ -35,6 +35,7 @@ #define LIB2GEOM_SEEN_LINE_H #include +#include #include #include <2geom/bezier-curve.h> // for LineSegment #include <2geom/rect.h> @@ -258,9 +259,19 @@ public: dist = -dot(n, m_origin); return n; } - /// @} + + friend inline std::ostream &operator<< (std::ostream &out_file, const Geom::Line &in_line); +/// @} }; // end class Line +/** @brief Output operator for lines. + * Prints out representation (point + versor) + */ +inline std::ostream &operator<< (std::ostream &out_file, const Geom::Line &in_line) { + out_file << "X: " << in_line.m_origin[X] << " Y: " << in_line.m_origin[Y] + << " dX: " << in_line.m_versor[X] << " dY: " << in_line.m_versor[Y]; + return out_file; +} inline double distance(Point const& _point, Line const& _line) @@ -365,6 +376,10 @@ inline Line make_angle_bisector_line(Point const& A, Point const& O, Point const& B) { Point M = middle_point(A,B); + if (are_near(O,M)) { + Line l(A,B); + M += (make_orthogonal_line(O,l)).versor(); + } return Line(O,M); } -- cgit v1.2.3 From ef9edf66715ddbc498b31e921e2506c6e87116fc Mon Sep 17 00:00:00 2001 From: Tavmjong Bah Date: Sun, 29 Mar 2015 22:33:48 +0200 Subject: Add clipping at miter-length to 'arcs' line join. (bzr r14036) --- src/helper/geom-pathstroke.cpp | 152 +++++++++++++++++++++++++++++++++++------ 1 file changed, 131 insertions(+), 21 deletions(-) diff --git a/src/helper/geom-pathstroke.cpp b/src/helper/geom-pathstroke.cpp index e34546d0e..aaafea98f 100644 --- a/src/helper/geom-pathstroke.cpp +++ b/src/helper/geom-pathstroke.cpp @@ -225,12 +225,14 @@ Geom::Point pick_solution(Geom::Point points[2], Geom::Point tang2, Geom::Point return sol; } -void extrapolate_join(Geom::Path& path_builder, Geom::Curve const& outgoing, double miter_limit, double line_width) +void extrapolate_join(Geom::Path& path_builder, Geom::Curve const& outgoing, double miter, double width) { using namespace Geom; Geom::Curve const& incoming = path_builder.back(); + Geom::Point startPt = incoming.finalPoint(); Geom::Point endPt = outgoing.initialPoint(); - Geom::Point tang2 = Geom::unitTangentAt(outgoing.toSBasis(), 0); + Geom::Point tang1 = Geom::unitTangentAt(reverse(incoming.toSBasis()), 0.); + Geom::Point tang2 = outgoing.unitTangentAt(0); Geom::Circle circle1 = Geom::touching_circle(Geom::reverse(incoming.toSBasis()), 0.); Geom::Circle circle2 = Geom::touching_circle(outgoing.toSBasis(), 0); @@ -241,52 +243,160 @@ void extrapolate_join(Geom::Path& path_builder, Geom::Curve const& outgoing, dou Geom::Point points[2]; int solutions = 0; - Geom::EllipticalArc *arc0 = NULL; Geom::EllipticalArc *arc1 = NULL; + Geom::EllipticalArc *arc2 = NULL; + Geom::Point sol; + Geom::Point p1; + Geom::Point p2; if (!inc_ls && !out_ls) { + // Two circles solutions = Geom::circle_circle_intersection(circle1.center(), circle1.ray(), circle2.center(), circle2.ray(), points[0], points[1]); if (solutions == 2) { - Geom::Point sol = pick_solution(points, tang2, endPt); - - arc0 = circle1.arc(incoming.finalPoint(), 0.5*(incoming.finalPoint()+sol), sol, true); - arc1 = circle2.arc(sol, 0.5*(sol+endPt), endPt, true); + sol = pick_solution(points, tang2, endPt); + arc1 = circle1.arc(startPt, 0.5*(startPt+sol), sol, true); + arc2 = circle2.arc(sol, 0.5*(sol+endPt), endPt, true); } } else if (inc_ls && !out_ls) { + // Line and circle solutions = Geom::circle_line_intersection(circle2, incoming.initialPoint(), incoming.finalPoint(), points[0], points[1]); if (solutions == 2) { - Geom::Point sol = pick_solution(points, tang2, endPt); - path_builder.setFinal(sol); - arc1 = circle2.arc(sol, 0.5*(sol+endPt), endPt, true); + sol = pick_solution(points, tang2, endPt); + arc2 = circle2.arc(sol, 0.5*(sol+endPt), endPt, true); } } else if (!inc_ls && out_ls) { + // Circle and line solutions = Geom::circle_line_intersection(circle1, outgoing.initialPoint(), outgoing.finalPoint(), points[0], points[1]); if (solutions == 2) { - Geom::Point sol = pick_solution(points, tang2, endPt); - arc0 = circle1.arc(incoming.finalPoint(), 0.5*(sol+incoming.finalPoint()), sol, true); + sol = pick_solution(points, tang2, endPt); + arc1 = circle1.arc(startPt, 0.5*(sol+startPt), sol, true); } } if (solutions != 2) // no solutions available, fall back to miter - return miter_join(path_builder, outgoing, miter_limit, line_width); + return miter_clip_join(path_builder, outgoing, miter, width); + + // We have a solution, thus sol is defined. + p1 = sol; + + // See if we need to clip. Miter length is measured along a circular arc that is tangent to the + // bisector of the incoming and out going angles and passes through the end point (sol) of the + // line join. + + // Center of circle is intersection of a line orthogonal to bisector and a line bisecting + // a chord connecting the path end point (point_on_path) and the join end point (sol). + Geom::Point point_on_path = startPt + Geom::rot90(tang1)*width; + Geom::Line bisector = make_angle_bisector_line( startPt, point_on_path, endPt ); + Geom::Line ortho = make_orthogonal_line(point_on_path, bisector); + + Geom::LineSegment chord( point_on_path, sol ); + Geom::Line bisector_chord = make_bisector_line( chord ); + + Geom::Line limit_line; + double miter_limit = 2.0 * width * miter; + bool clipped = false; + + if( are_parallel( bisector_chord, ortho ) ) { + + // No intersection (can happen if curvatures are equal but opposite) + if( Geom::distance( point_on_path, sol ) > miter_limit ) { + clipped = true; + Geom::Point limit_point = point_on_path + miter_limit * bisector.versor(); + limit_line = make_parallel_line( limit_point, ortho ); + } + + } else { + + Geom::Point center = + Geom::intersection_point( bisector_chord.pointAt(0), bisector_chord.versor(), + ortho.pointAt(0), ortho.versor() ); + Geom::Coord radius = distance( center, point_on_path ); + Geom::Circle circle_center( center, radius ); + + double limit_angle = miter_limit / radius; + Geom::Ray start_ray( center, point_on_path ); + Geom::Ray end_ray( center, sol ); + Geom::Line limit_line( center, 0 ); // Angle set below + + if( Geom::cross( start_ray.versor(), end_ray.versor() ) > 0 ) { + limit_line.setAngle( start_ray.angle() - limit_angle ); + } else { + limit_line.setAngle( start_ray.angle() + limit_angle ); + } + + Geom::EllipticalArc* arc_center = circle_center.arc(point_on_path, 0.5*(point_on_path + sol), sol, true); + if( arc_center && arc_center->sweepAngle() > limit_angle ) { + // We need to clip + clipped = true; + + if (!inc_ls ) { + // Incoming circular + solutions = Geom::circle_line_intersection(circle1, limit_line.pointAt(0), limit_line.pointAt(1), points[0], points[1]); + + if (solutions == 2) { + p1 = pick_solution(points, tang2, endPt); + delete arc1; + arc1 = circle1.arc(startPt, 0.5*(p1+startPt), p1, true); + } + } else { + p1 = Geom::intersection_point( startPt, tang1, limit_line.pointAt(0), limit_line.versor() ); + } - if (arc0) - path_builder.append(*arc0); - if (arc1) + if (!out_ls ) { + // Outgoing circular + solutions = Geom::circle_line_intersection(circle2, limit_line.pointAt(0), limit_line.pointAt(1), points[0], points[1]); + + if (solutions == 2) { + p2 = pick_solution(points, tang1, endPt); + delete arc2; + arc2 = circle2.arc(p2, 0.5*(p2+endPt), endPt, true); + } + } else { + p2 = Geom::intersection_point( endPt, tang2, limit_line.pointAt(0), limit_line.versor() ); + } + } + // std::cout << " IFP: " << startPt + // << " POP: " << point_on_path + // << " OIP: " << endPt << std::endl; + // std::cout << " center: " << center << std::endl; + // std::cout << " radius: " << radius << std::endl; + // std::cout << " miter_limit: " << miter_limit << std::endl; + // std::cout << " limit_angle: " << limit_angle << std::endl; + // std::cout << " start_ray: " << Geom::Line( start_ray ) << std::endl; + // std::cout << " limit_line: " << limit_line << std::endl; + // std::cout << " P1 out: " << p1 << std::endl; + // std::cout << " P2 out: " << p2 << std::endl; + } + + // Add initial + if (arc1) { path_builder.append(*arc1); + } else { + // Straight line segment: move last point + path_builder.setFinal(p1); + } - delete arc0; - delete arc1; + if( clipped ) { + path_builder.appendNew(p2); + } - if (!inc_ls && out_ls) - path_builder.appendNew(outgoing.finalPoint()); - else + // Add outgoing + if (arc2) { + path_builder.append(*arc2); path_builder.append(outgoing); + } else { + // Straight line segment: + path_builder.appendNew(outgoing.finalPoint()); + } + + delete arc1; + delete arc2; + } void join_inside(Geom::Path& res, Geom::Curve const& outgoing) -- cgit v1.2.3 From 3c458ee86d50bf9e877b62ea5e30ba6d4b09bdae Mon Sep 17 00:00:00 2001 From: Nicolas Dufour Date: Tue, 31 Mar 2015 12:33:40 +0200 Subject: Updating Potrace from 1.10 to 1.12, fixing Bug #1438366 (CVE-2013-7437 vulnerability). Fixed bugs: - https://launchpad.net/bugs/1438366 (bzr r14037) --- src/trace/potrace/auxiliary.h | 31 ++------------- src/trace/potrace/bitmap.h | 33 +++++++++++----- src/trace/potrace/bitops.h | 83 ++++++++++++++++++++++++++++++++++++++++ src/trace/potrace/curve.cpp | 26 ++++++------- src/trace/potrace/curve.h | 2 +- src/trace/potrace/decompose.cpp | 29 +++++++++++++- src/trace/potrace/decompose.h | 2 +- src/trace/potrace/greymap.cpp | 61 +++++++++++++++++++++++++---- src/trace/potrace/greymap.h | 5 ++- src/trace/potrace/lists.h | 2 +- src/trace/potrace/potracelib.cpp | 2 +- src/trace/potrace/potracelib.h | 2 +- src/trace/potrace/progress.h | 2 +- src/trace/potrace/render.cpp | 4 +- src/trace/potrace/render.h | 2 +- src/trace/potrace/trace.cpp | 66 ++++++++++++++++---------------- src/trace/potrace/trace.h | 2 +- 17 files changed, 251 insertions(+), 103 deletions(-) create mode 100644 src/trace/potrace/bitops.h diff --git a/src/trace/potrace/auxiliary.h b/src/trace/potrace/auxiliary.h index b7480bbb8..dbf124d7c 100644 --- a/src/trace/potrace/auxiliary.h +++ b/src/trace/potrace/auxiliary.h @@ -1,4 +1,4 @@ -/* Copyright (C) 2001-2011 Peter Selinger. +/* Copyright (C) 2001-2015 Peter Selinger. This file is part of Potrace. It is free software and it is covered by the GNU General Public License. See the file COPYING for details. */ @@ -8,6 +8,8 @@ #ifndef AUXILIARY_H #define AUXILIARY_H +#include + #ifdef HAVE_CONFIG_H #include "config.h" #endif @@ -75,31 +77,4 @@ static inline int floordiv(int a, int n) { #define sq(a) ((a)*(a)) #define cu(a) ((a)*(a)*(a)) -/* ---------------------------------------------------------------------- */ -/* deterministically and efficiently hash (x,y) into a pseudo-random bit */ -static inline int detrand(int x, int y) { - unsigned int z; - static const unsigned char t[256] = { - /* non-linear sequence: constant term of inverse in GF(8), - mod x^8+x^4+x^3+x+1 */ - 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, - 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, - 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, - 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, - 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, - 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, - 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, - 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, - 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, - 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, - 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, - }; - - /* 0x04b3e375 and 0x05a8ef93 are chosen to contain every possible - 5-bit sequence */ - z = ((0x04b3e375 * x) ^ y) * 0x05a8ef93; - z = t[z & 0xff] ^ t[(z>>8) & 0xff] ^ t[(z>>16) & 0xff] ^ t[(z>>24) & 0xff]; - return z; -} - #endif /* AUXILIARY_H */ diff --git a/src/trace/potrace/bitmap.h b/src/trace/potrace/bitmap.h index 2df04b46f..086bbb046 100644 --- a/src/trace/potrace/bitmap.h +++ b/src/trace/potrace/bitmap.h @@ -1,4 +1,4 @@ -/* Copyright (C) 2001-2011 Peter Selinger. +/* Copyright (C) 2001-2015 Peter Selinger. This file is part of Potrace. It is free software and it is covered by the GNU General Public License. See the file COPYING for details. */ @@ -7,6 +7,7 @@ #include #include +#include /* The bitmap type is defined in potracelib.h */ #include "potracelib.h" @@ -27,7 +28,7 @@ /* macros for accessing pixel at index (x,y). U* macros omit the bounds check. */ -#define bm_scanline(bm, y) ((bm)->map + (y)*(bm)->dy) +#define bm_scanline(bm, y) ((bm)->map + (ssize_t)(y)*(ssize_t)(bm)->dy) #define bm_index(bm, x, y) (&bm_scanline(bm, y)[(x)/BM_WORDBITS]) #define bm_mask(x) (BM_HIBIT >> ((x) & (BM_WORDBITS-1))) #define bm_range(x, a) ((int)(x) >= 0 && (int)(x) < (a)) @@ -51,10 +52,18 @@ static inline void bm_free(potrace_bitmap_t *bm) { free(bm); } -/* return new un-initialized bitmap. NULL with errno on error */ +/* return new un-initialized bitmap. NULL with errno on error. + Assumes w, h >= 0. */ static inline potrace_bitmap_t *bm_new(int w, int h) { potrace_bitmap_t *bm; - int dy = (w + BM_WORDBITS - 1) / BM_WORDBITS; + int dy = w == 0 ? 0 : (w - 1) / BM_WORDBITS + 1; + ssize_t size = (ssize_t)dy * (ssize_t)h * (ssize_t)BM_WORDSIZE; + + /* check for overflow error */ + if (size < 0 || size / h / dy != BM_WORDSIZE) { + errno = ENOMEM; + return NULL; + } bm = (potrace_bitmap_t *) malloc(sizeof(potrace_bitmap_t)); if (!bm) { @@ -63,7 +72,7 @@ static inline potrace_bitmap_t *bm_new(int w, int h) { bm->w = w; bm->h = h; bm->dy = dy; - bm->map = (potrace_word *) malloc(dy * h * BM_WORDSIZE); + bm->map = (potrace_word *) malloc(size); if (!bm->map) { free(bm); return NULL; @@ -73,23 +82,29 @@ static inline potrace_bitmap_t *bm_new(int w, int h) { /* clear the given bitmap. Set all bits to c. */ static inline void bm_clear(potrace_bitmap_t *bm, int c) { - memset(bm->map, c ? -1 : 0, bm->dy * bm->h * BM_WORDSIZE); + /* Note: if the bitmap was created with bm_new, then it is + guaranteed that size will fit into the ssize_t type. */ + ssize_t size = (ssize_t)bm->dy * (ssize_t)bm->h * (ssize_t)BM_WORDSIZE; + memset(bm->map, c ? -1 : 0, size); } /* duplicate the given bitmap. Return NULL on error with errno set. */ static inline potrace_bitmap_t *bm_dup(const potrace_bitmap_t *bm) { potrace_bitmap_t *bm1 = bm_new(bm->w, bm->h); + ssize_t size = (ssize_t)bm->dy * (ssize_t)bm->h * (ssize_t)BM_WORDSIZE; if (!bm1) { return NULL; } - memcpy(bm1->map, bm->map, bm->dy * bm->h * BM_WORDSIZE); + memcpy(bm1->map, bm->map, size); return bm1; } /* invert the given bitmap. */ static inline void bm_invert(potrace_bitmap_t *bm) { - int i; - for (i = 0; i < bm->dy * bm->h; i++) { + ssize_t i; + ssize_t size = (ssize_t)bm->dy * (ssize_t)bm->h; + + for (i = 0; i < size; i++) { bm->map[i] ^= BM_ALLBITS; } } diff --git a/src/trace/potrace/bitops.h b/src/trace/potrace/bitops.h new file mode 100644 index 000000000..cff734a46 --- /dev/null +++ b/src/trace/potrace/bitops.h @@ -0,0 +1,83 @@ +/* Copyright (C) 2001-2015 Peter Selinger. + This file is part of Potrace. It is free software and it is covered + by the GNU General Public License. See the file COPYING for details. */ + + +/* bits.h: this file defines some macros for bit manipulations. We + provide a generic implementation, as well as machine- and + compiler-specific fast implementations */ + +/* lobit: return the position of the rightmost "1" bit of an int, or + 32 if none. hibit: return 1 + the position of the leftmost "1" bit + of an int, or 0 if none. Note: these functions work on 32-bit + integers. */ + +#ifndef BITOPS_H +#define BITOPS_H + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +/* ---------------------------------------------------------------------- */ +/* machine specific macros */ + +#if defined(HAVE_I386) + +static inline unsigned int lobit(unsigned int x) { + unsigned int res; + asm ("bsf %1,%0\n\t" + "jnz 0f\n\t" + "movl $32,%0\n" + "0:" + : "=r" (res) + : "r" (x) + : "cc"); + return res; +} + +static inline unsigned int hibit(unsigned int x) { + unsigned int res; + + asm ("bsr %1,%0\n\t" + "jnz 0f\n\t" + "movl $-1,%0\n" + "0:" + : "=r" (res) + : "r" (x) + : "cc"); + return res+1; +} + +/* ---------------------------------------------------------------------- */ +#else /* generic macros */ + +static inline unsigned int lobit(unsigned int x) { + unsigned int res = 32; + while (x & 0xffffff) { + x <<= 8; + res -= 8; + } + while (x) { + x <<= 1; + res -= 1; + } + return res; +} + +static inline unsigned int hibit(unsigned int x) { + unsigned int res = 0; + while (x > 0xff) { + x >>= 8; + res += 8; + } + while (x) { + x >>= 1; + res += 1; + } + return res; +} + +#endif + +#endif /* BITOPS_H */ diff --git a/src/trace/potrace/curve.cpp b/src/trace/potrace/curve.cpp index d2e32aa7b..e6a9a4721 100644 --- a/src/trace/potrace/curve.cpp +++ b/src/trace/potrace/curve.cpp @@ -1,4 +1,4 @@ -/* Copyright (C) 2001-2011 Peter Selinger. +/* Copyright (C) 2001-2015 Peter Selinger. This file is part of Potrace. It is free software and it is covered by the GNU General Public License. See the file COPYING for details. */ @@ -12,8 +12,8 @@ #include "lists.h" #include "curve.h" -#define SAFE_MALLOC(var, n, typ) \ - if ((var = (typ *)malloc((n)*sizeof(typ))) == NULL) goto malloc_error +#define SAFE_CALLOC(var, n, typ) \ + if ((var = (typ *)calloc(n, sizeof(typ))) == NULL) goto calloc_error /* ---------------------------------------------------------------------- */ /* allocate and free path objects */ @@ -22,14 +22,14 @@ path_t *path_new(void) { path_t *p = NULL; privpath_t *priv = NULL; - SAFE_MALLOC(p, 1, path_t); + SAFE_CALLOC(p, 1, path_t); memset(p, 0, sizeof(path_t)); - SAFE_MALLOC(priv, 1, privpath_t); + SAFE_CALLOC(priv, 1, privpath_t); memset(priv, 0, sizeof(privpath_t)); p->priv = priv; return p; - malloc_error: + calloc_error: free(p); free(priv); return NULL; @@ -81,15 +81,15 @@ typedef dpoint_t dpoint3_t[3]; int privcurve_init(privcurve_t *curve, int n) { memset(curve, 0, sizeof(privcurve_t)); curve->n = n; - SAFE_MALLOC(curve->tag, n, int); - SAFE_MALLOC(curve->c, n, dpoint3_t); - SAFE_MALLOC(curve->vertex, n, dpoint_t); - SAFE_MALLOC(curve->alpha, n, double); - SAFE_MALLOC(curve->alpha0, n, double); - SAFE_MALLOC(curve->beta, n, double); + SAFE_CALLOC(curve->tag, n, int); + SAFE_CALLOC(curve->c, n, dpoint3_t); + SAFE_CALLOC(curve->vertex, n, dpoint_t); + SAFE_CALLOC(curve->alpha, n, double); + SAFE_CALLOC(curve->alpha0, n, double); + SAFE_CALLOC(curve->beta, n, double); return 0; - malloc_error: + calloc_error: free(curve->tag); free(curve->c); free(curve->vertex); diff --git a/src/trace/potrace/curve.h b/src/trace/potrace/curve.h index 6ceae0c3a..feb95b39b 100644 --- a/src/trace/potrace/curve.h +++ b/src/trace/potrace/curve.h @@ -1,4 +1,4 @@ -/* Copyright (C) 2001-2011 Peter Selinger. +/* Copyright (C) 2001-2015 Peter Selinger. This file is part of Potrace. It is free software and it is covered by the GNU General Public License. See the file COPYING for details. */ diff --git a/src/trace/potrace/decompose.cpp b/src/trace/potrace/decompose.cpp index 6c27a7ebf..7628b202d 100644 --- a/src/trace/potrace/decompose.cpp +++ b/src/trace/potrace/decompose.cpp @@ -1,4 +1,4 @@ -/* Copyright (C) 2001-2011 Peter Selinger. +/* Copyright (C) 2001-2015 Peter Selinger. This file is part of Potrace. It is free software and it is covered by the GNU General Public License. See the file COPYING for details. */ @@ -15,6 +15,33 @@ #include "decompose.h" #include "progress.h" +/* ---------------------------------------------------------------------- */ +/* deterministically and efficiently hash (x,y) into a pseudo-random bit */ + +static inline int detrand(int x, int y) { + unsigned int z; + static const unsigned char t[256] = { + /* non-linear sequence: constant term of inverse in GF(8), + mod x^8+x^4+x^3+x+1 */ + 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, + 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, + 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, + 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, + 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, + 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, + 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, + }; + + /* 0x04b3e375 and 0x05a8ef93 are chosen to contain every possible + 5-bit sequence */ + z = ((0x04b3e375 * x) ^ y) * 0x05a8ef93; + z = t[z & 0xff] ^ t[(z>>8) & 0xff] ^ t[(z>>16) & 0xff] ^ t[(z>>24) & 0xff]; + return z; +} /* ---------------------------------------------------------------------- */ /* auxiliary bitmap manipulations */ diff --git a/src/trace/potrace/decompose.h b/src/trace/potrace/decompose.h index 89b01e504..8ae89b8ad 100644 --- a/src/trace/potrace/decompose.h +++ b/src/trace/potrace/decompose.h @@ -1,4 +1,4 @@ -/* Copyright (C) 2001-2011 Peter Selinger. +/* Copyright (C) 2001-2015 Peter Selinger. This file is part of Potrace. It is free software and it is covered by the GNU General Public License. See the file COPYING for details. */ diff --git a/src/trace/potrace/greymap.cpp b/src/trace/potrace/greymap.cpp index e116021c1..4ef2ec8df 100644 --- a/src/trace/potrace/greymap.cpp +++ b/src/trace/potrace/greymap.cpp @@ -1,4 +1,4 @@ -/* Copyright (C) 2001-2011 Peter Selinger. +/* Copyright (C) 2001-2015 Peter Selinger. This file is part of Potrace. It is free software and it is covered by the GNU General Public License. See the file COPYING for details. */ @@ -9,8 +9,10 @@ #include #include #include +#include #include "greymap.h" +#include "bitops.h" #define INTBITS (8*sizeof(int)) @@ -22,10 +24,17 @@ static int gm_readbody_bmp(FILE *f, greymap_t **gmp); /* ---------------------------------------------------------------------- */ /* basic greymap routines */ -/* return new un-initialized greymap. NULL with errno on error */ - +/* return new un-initialized greymap. NULL with errno on error. + Assumes w, h >= 0. */ greymap_t *gm_new(int w, int h) { greymap_t *gm; + ssize_t size = (ssize_t)w * (ssize_t)h * (ssize_t)sizeof(signed short int); + + /* check for overflow error */ + if (size < 0 || size / w / h != sizeof(signed short int)) { + errno = ENOMEM; + return NULL; + } gm = (greymap_t *) malloc(sizeof(greymap_t)); if (!gm) { @@ -33,7 +42,7 @@ greymap_t *gm_new(int w, int h) { } gm->w = w; gm->h = h; - gm->map = (signed short int *) malloc(w*h*sizeof(signed short int)); + gm->map = (signed short int *) malloc(size); if (!gm->map) { free(gm); return NULL; @@ -405,6 +414,10 @@ struct bmp_info_s { unsigned int YpixelsPerM; unsigned int ncolors; /* number of colors in palette */ unsigned int ColorsImportant; + unsigned int RedMask; + unsigned int GreenMask; + unsigned int BlueMask; + unsigned int AlphaMask; unsigned int ctbits; /* sample size for color table */ int topdown; /* top-down mode? */ }; @@ -495,6 +508,7 @@ static int gm_readbody_bmp(FILE *f, greymap_t **gmp) { int col[2]; unsigned int bitbuf; unsigned int n; + unsigned int redshift, greenshift, blueshift; gm_read_error = NULL; gm = NULL; @@ -523,12 +537,24 @@ static int gm_readbody_bmp(FILE *f, greymap_t **gmp) { TRY(bmp_readint(f, 4, &bmpinfo.YpixelsPerM)); TRY(bmp_readint(f, 4, &bmpinfo.ncolors)); TRY(bmp_readint(f, 4, &bmpinfo.ColorsImportant)); - if ((signed int)bmpinfo.h < 0) { - bmpinfo.h = -bmpinfo.h; + if (bmpinfo.InfoSize >= 108) { /* V4 and V5 bitmaps */ + TRY(bmp_readint(f, 4, &bmpinfo.RedMask)); + TRY(bmp_readint(f, 4, &bmpinfo.GreenMask)); + TRY(bmp_readint(f, 4, &bmpinfo.BlueMask)); + TRY(bmp_readint(f, 4, &bmpinfo.AlphaMask)); + } + if (bmpinfo.w > 0x7fffffff) { + goto format_error; + } + if (bmpinfo.h > 0x7fffffff) { + bmpinfo.h = (-bmpinfo.h) & 0xffffffff; bmpinfo.topdown = 1; } else { bmpinfo.topdown = 0; } + if (bmpinfo.h > 0x7fffffff) { + goto format_error; + } } else if (bmpinfo.InfoSize == 12) { /* old OS/2 format */ bmpinfo.ctbits = 24; /* sample size in color table */ @@ -543,6 +569,11 @@ static int gm_readbody_bmp(FILE *f, greymap_t **gmp) { goto format_error; } + if (bmpinfo.comp == 3 && bmpinfo.InfoSize < 108) { + /* bitfield feature is only understood with V4 and V5 format */ + goto format_error; + } + /* forward to color table (e.g., if bmpinfo.InfoSize == 64) */ TRY(bmp_forward(f, 14+bmpinfo.InfoSize)); @@ -557,7 +588,7 @@ static int gm_readbody_bmp(FILE *f, greymap_t **gmp) { /* color table, present only if bmpinfo.bits <= 8. */ if (bmpinfo.bits <= 8) { - coltable = (int *) malloc(bmpinfo.ncolors * sizeof(int)); + coltable = (int *) calloc(bmpinfo.ncolors, sizeof(int)); if (!coltable) { goto std_error; } @@ -651,6 +682,22 @@ static int gm_readbody_bmp(FILE *f, greymap_t **gmp) { } break; + case 0x320: /* 32-bit encoding with bitfields */ + redshift = lobit(bmpinfo.RedMask); + greenshift = lobit(bmpinfo.GreenMask); + blueshift = lobit(bmpinfo.BlueMask); + + for (y=0; y> redshift) + ((c & bmpinfo.GreenMask) >> greenshift) + ((c & bmpinfo.BlueMask) >> blueshift); + GM_UPUT(gm, x, ycorr(y), c/3); + } + TRY(bmp_pad(f)); + } + break; + case 0x204: /* 4-bit runlength compressed encoding (RLE4) */ x = 0; y = 0; diff --git a/src/trace/potrace/greymap.h b/src/trace/potrace/greymap.h index 1fb5426c1..8c9db9bbf 100644 --- a/src/trace/potrace/greymap.h +++ b/src/trace/potrace/greymap.h @@ -1,4 +1,4 @@ -/* Copyright (C) 2001-2011 Peter Selinger. +/* Copyright (C) 2001-2015 Peter Selinger. This file is part of Potrace. It is free software and it is covered by the GNU General Public License. See the file COPYING for details. */ @@ -7,6 +7,7 @@ #define GREYMAP_H #include +#include /* internal format for greymaps. Note: in this format, rows are ordered from bottom to top. The pixels in each row are given from @@ -22,7 +23,7 @@ typedef struct greymap_s greymap_t; /* macros for accessing pixel at index (x,y). Note that the origin is in the *lower* left corner. U* macros omit the bounds check. */ -#define gm_index(gm, x, y) (&(gm)->map[(x)+(y)*(gm)->w]) +#define gm_index(gm, x, y) (&(gm)->map[(x)+(y)*(ssize_t)(gm)->w]) #define gm_safe(gm, x, y) ((int)(x)>=0 && (int)(x)<(gm)->w && (int)(y)>=0 && (int)(y)<(gm)->h) #define gm_bound(x, m) ((x)<0 ? 0 : (x)>=(m) ? (m)-1 : (x)) #define GM_UGET(gm, x, y) (*gm_index(gm, x, y)) diff --git a/src/trace/potrace/lists.h b/src/trace/potrace/lists.h index 078129afc..394262c23 100644 --- a/src/trace/potrace/lists.h +++ b/src/trace/potrace/lists.h @@ -1,4 +1,4 @@ -/* Copyright (C) 2001-2011 Peter Selinger. +/* Copyright (C) 2001-2015 Peter Selinger. This file is part of Potrace. It is free software and it is covered by the GNU General Public License. See the file COPYING for details. */ diff --git a/src/trace/potrace/potracelib.cpp b/src/trace/potrace/potracelib.cpp index 0fb835593..b5463d676 100644 --- a/src/trace/potrace/potracelib.cpp +++ b/src/trace/potrace/potracelib.cpp @@ -1,4 +1,4 @@ -/* Copyright (C) 2001-2011 Peter Selinger. +/* Copyright (C) 2001-2015 Peter Selinger. This file is part of Potrace. It is free software and it is covered by the GNU General Public License. See the file COPYING for details. */ diff --git a/src/trace/potrace/potracelib.h b/src/trace/potrace/potracelib.h index cd142a6e1..0a6ddbf1f 100644 --- a/src/trace/potrace/potracelib.h +++ b/src/trace/potrace/potracelib.h @@ -1,4 +1,4 @@ -/* Copyright (C) 2001-2011 Peter Selinger. +/* Copyright (C) 2001-2015 Peter Selinger. This file is part of Potrace. It is free software and it is covered by the GNU General Public License. See the file COPYING for details. */ diff --git a/src/trace/potrace/progress.h b/src/trace/potrace/progress.h index 3e1dfb34e..ecc2ba217 100644 --- a/src/trace/potrace/progress.h +++ b/src/trace/potrace/progress.h @@ -1,4 +1,4 @@ -/* Copyright (C) 2001-2011 Peter Selinger. +/* Copyright (C) 2001-2015 Peter Selinger. This file is part of Potrace. It is free software and it is covered by the GNU General Public License. See the file COPYING for details. */ diff --git a/src/trace/potrace/render.cpp b/src/trace/potrace/render.cpp index 3c8f79c05..4f44ae6a6 100644 --- a/src/trace/potrace/render.cpp +++ b/src/trace/potrace/render.cpp @@ -1,4 +1,4 @@ -/* Copyright (C) 2001-2011 Peter Selinger. +/* Copyright (C) 2001-2015 Peter Selinger. This file is part of Potrace. It is free software and it is covered by the GNU General Public License. See the file COPYING for details. */ @@ -52,7 +52,7 @@ render_t *render_new(greymap_t *gm) { } memset(rm, 0, sizeof(render_t)); rm->gm = gm; - rm->incrow_buf = (int *) malloc(gm->h * sizeof(int)); + rm->incrow_buf = (int *) calloc(gm->h, sizeof(int)); if (!rm->incrow_buf) { free(rm); return NULL; diff --git a/src/trace/potrace/render.h b/src/trace/potrace/render.h index ad600156a..0caaedff6 100644 --- a/src/trace/potrace/render.h +++ b/src/trace/potrace/render.h @@ -1,4 +1,4 @@ -/* Copyright (C) 2001-2011 Peter Selinger. +/* Copyright (C) 2001-2015 Peter Selinger. This file is part of Potrace. It is free software and it is covered by the GNU General Public License. See the file COPYING for details. */ diff --git a/src/trace/potrace/trace.cpp b/src/trace/potrace/trace.cpp index f1e88a908..469262b67 100644 --- a/src/trace/potrace/trace.cpp +++ b/src/trace/potrace/trace.cpp @@ -1,4 +1,4 @@ -/* Copyright (C) 2001-2011 Peter Selinger. +/* Copyright (C) 2001-2015 Peter Selinger. This file is part of Potrace. It is free software and it is covered by the GNU General Public License. See the file COPYING for details. */ @@ -21,8 +21,8 @@ #define COS179 -0.999847695156 /* the cosine of 179 degrees */ /* ---------------------------------------------------------------------- */ -#define SAFE_MALLOC(var, n, typ) \ - if ((var = (typ *)malloc((n)*sizeof(typ))) == NULL) goto malloc_error +#define SAFE_CALLOC(var, n, typ) \ + if ((var = (typ *)calloc(n, sizeof(typ))) == NULL) goto calloc_error /* ---------------------------------------------------------------------- */ /* auxiliary functions */ @@ -265,7 +265,7 @@ static int calc_sums(privpath_t *pp) { int i, x, y; int n = pp->len; - SAFE_MALLOC(pp->sums, pp->len+1, sums_t); + SAFE_CALLOC(pp->sums, pp->len+1, sums_t); /* origin */ pp->x0 = pp->pt[0].x; @@ -284,7 +284,7 @@ static int calc_sums(privpath_t *pp) { } return 0; - malloc_error: + calloc_error: return 1; } @@ -331,8 +331,8 @@ static int calc_lon(privpath_t *pp) { point_t dk; /* direction of k-k1 */ int a, b, c, d; - SAFE_MALLOC(pivk, n, int); - SAFE_MALLOC(nc, n, int); + SAFE_CALLOC(pivk, n, int); + SAFE_CALLOC(nc, n, int); /* initialize the nc data structure. Point from each point to the furthest future point to which it is connected by a vertical or @@ -349,7 +349,7 @@ static int calc_lon(privpath_t *pp) { nc[i] = k; } - SAFE_MALLOC(pp->lon, n, int); + SAFE_CALLOC(pp->lon, n, int); /* determine pivot points: for each i, let pivk[i] be the furthest k such that all j with im = m; - SAFE_MALLOC(pp->po, m, int); + SAFE_CALLOC(pp->po, m, int); /* read off shortest path */ for (i=n, j=m-1; i>0; j--) { @@ -620,7 +620,7 @@ static int bestpolygon(privpath_t *pp) free(seg1); return 0; - malloc_error: + calloc_error: free(pen); free(prev); free(clip0); @@ -655,13 +655,13 @@ static int adjust_vertices(privpath_t *pp) { dpoint_t s; int r; - SAFE_MALLOC(ctr, m, dpoint_t); - SAFE_MALLOC(dir, m, dpoint_t); - SAFE_MALLOC(q, m, quadform_t); + SAFE_CALLOC(ctr, m, dpoint_t); + SAFE_CALLOC(dir, m, dpoint_t); + SAFE_CALLOC(q, m, quadform_t); r = privcurve_init(&pp->curve, m); if (r) { - goto malloc_error; + goto calloc_error; } /* calculate "optimal" point-slope representation for each line @@ -827,7 +827,7 @@ static int adjust_vertices(privpath_t *pp) { free(q); return 0; - malloc_error: + calloc_error: free(ctr); free(dir); free(q); @@ -875,7 +875,7 @@ static void smooth(privcurve_t *curve, double alphamax) { } curve->alpha0[j] = alpha; /* remember "original" value of alpha */ - if (alpha > alphamax) { /* pointed corner */ + if (alpha >= alphamax) { /* pointed corner */ curve->tag[j] = POTRACE_CORNER; curve->c[j][1] = curve->vertex[j]; curve->c[j][2] = p4; @@ -1075,12 +1075,12 @@ static int opticurve(privpath_t *pp, double opttolerance) { int *convc = NULL; /* conv[m]: pre-computed convexities */ double *areac = NULL; /* cumarea[m+1]: cache for fast area computation */ - SAFE_MALLOC(pt, m+1, int); - SAFE_MALLOC(pen, m+1, double); - SAFE_MALLOC(len, m+1, int); - SAFE_MALLOC(opt, m+1, opti_t); - SAFE_MALLOC(convc, m, int); - SAFE_MALLOC(areac, m+1, double); + SAFE_CALLOC(pt, m+1, int); + SAFE_CALLOC(pen, m+1, double); + SAFE_CALLOC(len, m+1, int); + SAFE_CALLOC(opt, m+1, opti_t); + SAFE_CALLOC(convc, m, int); + SAFE_CALLOC(areac, m+1, double); /* pre-calculate convexity: +1 = right turn, -1 = left turn, 0 = corner */ for (i=0; iocurve, om); if (r) { - goto malloc_error; + goto calloc_error; } - SAFE_MALLOC(s, om, double); - SAFE_MALLOC(t, om, double); + SAFE_CALLOC(s, om, double); + SAFE_CALLOC(t, om, double); j = m; for (i=om-1; i>=0; i--) { @@ -1182,7 +1182,7 @@ static int opticurve(privpath_t *pp, double opttolerance) { free(areac); return 0; - malloc_error: + calloc_error: free(pt); free(pen); free(len); diff --git a/src/trace/potrace/trace.h b/src/trace/potrace/trace.h index dc2b9247a..c53cdd10f 100644 --- a/src/trace/potrace/trace.h +++ b/src/trace/potrace/trace.h @@ -1,4 +1,4 @@ -/* Copyright (C) 2001-2011 Peter Selinger. +/* Copyright (C) 2001-2015 Peter Selinger. This file is part of Potrace. It is free software and it is covered by the GNU General Public License. See the file COPYING for details. */ -- cgit v1.2.3 From c129639bcc5baa175bbdfacd3c7fed22b0b51b60 Mon Sep 17 00:00:00 2001 From: "Liam P. White" Date: Tue, 31 Mar 2015 16:51:58 -0400 Subject: Update turn angle predicate for outliner (bzr r14038) --- src/helper/geom-pathstroke.cpp | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/src/helper/geom-pathstroke.cpp b/src/helper/geom-pathstroke.cpp index aaafea98f..e7ee3b5f8 100644 --- a/src/helper/geom-pathstroke.cpp +++ b/src/helper/geom-pathstroke.cpp @@ -421,7 +421,14 @@ void join_inside(Geom::Path& res, Geom::Curve const& outgoing) } } -void outline_helper(Geom::Path& res, Geom::Path const& to_add, double width, double miter, Inkscape::LineJoinType join) +bool decide(Geom::Curve const& incoming, Geom::Curve const& outgoing) +{ + Geom::Point tang1 = Geom::unitTangentAt(reverse(incoming.toSBasis()), 0.); + Geom::Point tang2 = outgoing.unitTangentAt(0.); + return (Geom::cross(tang1, tang2) < 0); +} + +void outline_helper(Geom::Path& res, Geom::Path const& to_add, double width, bool on_outside, double miter, Inkscape::LineJoinType join) { if (res.size() == 0 || to_add.size() == 0) return; @@ -434,10 +441,6 @@ void outline_helper(Geom::Path& res, Geom::Path const& to_add, double width, dou return; } - Geom::Point tang1 = Geom::unitTangentAt(reverse(res.back().toSBasis()), 0.); - Geom::Point tang2 = Geom::unitTangentAt(to_add.front().toSBasis(), 0.); - bool on_outside = (Geom::cross(tang1, tang2) < 0); - if (on_outside) { join_func *jf; switch (join) { @@ -730,7 +733,8 @@ Geom::Path half_outline(Geom::Path const& input, double width, double miter, Lin if (u == 0) { res.append(temp); } else { - outline_helper(res, temp, width, miter, join); + bool on_outside = decide(input[u], input[u-1]); + outline_helper(res, temp, width, on_outside, miter, join); if (temp.size() > 0) res.insert(res.end(), ++temp.begin(), temp.end()); } @@ -739,7 +743,8 @@ Geom::Path half_outline(Geom::Path const& input, double width, double miter, Lin if (u < k - 1) { temp = Geom::Path(); offset_curve(temp, &input[u+1], width); - outline_helper(res, temp, width, miter, join); + bool on_outside = decide(input[u], input[u+1]); + outline_helper(res, temp, width, on_outside, miter, join); if (temp.size() > 0) res.insert(res.end(), ++temp.begin(), temp.end()); } @@ -752,7 +757,8 @@ Geom::Path half_outline(Geom::Path const& input, double width, double miter, Lin temp.append(c1); Geom::Path temp2; temp2.append(c2); - outline_helper(temp, temp2, width, miter, join); + bool on_outside = decide(input.back(), input.front()); + outline_helper(temp, temp2, width, on_outside, miter, join); res.erase(res.begin()); res.erase_last(); // -- cgit v1.2.3 From f64c0f8c7974a5ed8844aa07ff220dabf4aa54ca Mon Sep 17 00:00:00 2001 From: "Liam P. White" Date: Tue, 31 Mar 2015 17:47:50 -0400 Subject: Small cleanup: consistency, style (bzr r14039) --- src/helper/geom-pathstroke.cpp | 75 +++++++++++++++++------------------------- 1 file changed, 31 insertions(+), 44 deletions(-) diff --git a/src/helper/geom-pathstroke.cpp b/src/helper/geom-pathstroke.cpp index e7ee3b5f8..56200402b 100644 --- a/src/helper/geom-pathstroke.cpp +++ b/src/helper/geom-pathstroke.cpp @@ -225,10 +225,11 @@ Geom::Point pick_solution(Geom::Point points[2], Geom::Point tang2, Geom::Point return sol; } -void extrapolate_join(Geom::Path& path_builder, Geom::Curve const& outgoing, double miter, double width) +void extrapolate_join(Geom::Path& res, Geom::Curve const& outgoing, double miter, double width) { using namespace Geom; - Geom::Curve const& incoming = path_builder.back(); + + Geom::Curve const& incoming = res.back(); Geom::Point startPt = incoming.finalPoint(); Geom::Point endPt = outgoing.initialPoint(); Geom::Point tang1 = Geom::unitTangentAt(reverse(incoming.toSBasis()), 0.); @@ -279,7 +280,7 @@ void extrapolate_join(Geom::Path& path_builder, Geom::Curve const& outgoing, dou if (solutions != 2) // no solutions available, fall back to miter - return miter_clip_join(path_builder, outgoing, miter, width); + return miter_clip_join(res, outgoing, miter, width); // We have a solution, thus sol is defined. p1 = sol; @@ -291,50 +292,48 @@ void extrapolate_join(Geom::Path& path_builder, Geom::Curve const& outgoing, dou // Center of circle is intersection of a line orthogonal to bisector and a line bisecting // a chord connecting the path end point (point_on_path) and the join end point (sol). Geom::Point point_on_path = startPt + Geom::rot90(tang1)*width; - Geom::Line bisector = make_angle_bisector_line( startPt, point_on_path, endPt ); + Geom::Line bisector = make_angle_bisector_line(startPt, point_on_path, endPt); Geom::Line ortho = make_orthogonal_line(point_on_path, bisector); - Geom::LineSegment chord( point_on_path, sol ); - Geom::Line bisector_chord = make_bisector_line( chord ); + Geom::LineSegment chord(point_on_path, sol); + Geom::Line bisector_chord = make_bisector_line(chord); Geom::Line limit_line; double miter_limit = 2.0 * width * miter; bool clipped = false; - if( are_parallel( bisector_chord, ortho ) ) { - + if (are_parallel(bisector_chord, ortho)) { // No intersection (can happen if curvatures are equal but opposite) - if( Geom::distance( point_on_path, sol ) > miter_limit ) { + if (Geom::distance(point_on_path, sol) > miter_limit) { clipped = true; Geom::Point limit_point = point_on_path + miter_limit * bisector.versor(); limit_line = make_parallel_line( limit_point, ortho ); } - } else { - Geom::Point center = Geom::intersection_point( bisector_chord.pointAt(0), bisector_chord.versor(), ortho.pointAt(0), ortho.versor() ); - Geom::Coord radius = distance( center, point_on_path ); - Geom::Circle circle_center( center, radius ); + Geom::Coord radius = distance(center, point_on_path); + Geom::Circle circle_center(center, radius); double limit_angle = miter_limit / radius; - Geom::Ray start_ray( center, point_on_path ); - Geom::Ray end_ray( center, sol ); - Geom::Line limit_line( center, 0 ); // Angle set below - if( Geom::cross( start_ray.versor(), end_ray.versor() ) > 0 ) { - limit_line.setAngle( start_ray.angle() - limit_angle ); + Geom::Ray start_ray(center, point_on_path); + Geom::Ray end_ray(center, sol); + Geom::Line limit_line(center, 0); // Angle set below + + if (Geom::cross(start_ray.versor(), end_ray.versor()) > 0) { + limit_line.setAngle(start_ray.angle() - limit_angle); } else { - limit_line.setAngle( start_ray.angle() + limit_angle ); + limit_line.setAngle(start_ray.angle() + limit_angle); } - Geom::EllipticalArc* arc_center = circle_center.arc(point_on_path, 0.5*(point_on_path + sol), sol, true); - if( arc_center && arc_center->sweepAngle() > limit_angle ) { + Geom::EllipticalArc *arc_center = circle_center.arc(point_on_path, 0.5*(point_on_path + sol), sol, true); + if (arc_center && arc_center->sweepAngle() > limit_angle) { // We need to clip clipped = true; - if (!inc_ls ) { + if (!inc_ls) { // Incoming circular solutions = Geom::circle_line_intersection(circle1, limit_line.pointAt(0), limit_line.pointAt(1), points[0], points[1]); @@ -344,10 +343,10 @@ void extrapolate_join(Geom::Path& path_builder, Geom::Curve const& outgoing, dou arc1 = circle1.arc(startPt, 0.5*(p1+startPt), p1, true); } } else { - p1 = Geom::intersection_point( startPt, tang1, limit_line.pointAt(0), limit_line.versor() ); + p1 = Geom::intersection_point(startPt, tang1, limit_line.pointAt(0), limit_line.versor()); } - if (!out_ls ) { + if (!out_ls) { // Outgoing circular solutions = Geom::circle_line_intersection(circle2, limit_line.pointAt(0), limit_line.pointAt(1), points[0], points[1]); @@ -357,46 +356,34 @@ void extrapolate_join(Geom::Path& path_builder, Geom::Curve const& outgoing, dou arc2 = circle2.arc(p2, 0.5*(p2+endPt), endPt, true); } } else { - p2 = Geom::intersection_point( endPt, tang2, limit_line.pointAt(0), limit_line.versor() ); + p2 = Geom::intersection_point(endPt, tang2, limit_line.pointAt(0), limit_line.versor()); } } - // std::cout << " IFP: " << startPt - // << " POP: " << point_on_path - // << " OIP: " << endPt << std::endl; - // std::cout << " center: " << center << std::endl; - // std::cout << " radius: " << radius << std::endl; - // std::cout << " miter_limit: " << miter_limit << std::endl; - // std::cout << " limit_angle: " << limit_angle << std::endl; - // std::cout << " start_ray: " << Geom::Line( start_ray ) << std::endl; - // std::cout << " limit_line: " << limit_line << std::endl; - // std::cout << " P1 out: " << p1 << std::endl; - // std::cout << " P2 out: " << p2 << std::endl; } // Add initial if (arc1) { - path_builder.append(*arc1); + res.append(*arc1); } else { // Straight line segment: move last point - path_builder.setFinal(p1); + res.setFinal(p1); } - if( clipped ) { - path_builder.appendNew(p2); + if (clipped) { + res.appendNew(p2); } // Add outgoing if (arc2) { - path_builder.append(*arc2); - path_builder.append(outgoing); + res.append(*arc2); + res.append(outgoing); } else { // Straight line segment: - path_builder.appendNew(outgoing.finalPoint()); + res.appendNew(outgoing.finalPoint()); } delete arc1; delete arc2; - } void join_inside(Geom::Path& res, Geom::Curve const& outgoing) -- cgit v1.2.3 From df56d7f04dd0df1f12891383a06295403dabc341 Mon Sep 17 00:00:00 2001 From: Alvin Penner Date: Thu, 2 Apr 2015 17:36:14 -0400 Subject: more restrictive definition of parentContour. (Bug 499744) Fixed bugs: - https://launchpad.net/bugs/499744 (bzr r14040) --- src/livarot/ShapeMisc.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/livarot/ShapeMisc.cpp b/src/livarot/ShapeMisc.cpp index c0bfe9428..4f63007e7 100644 --- a/src/livarot/ShapeMisc.cpp +++ b/src/livarot/ShapeMisc.cpp @@ -371,9 +371,9 @@ Shape::ConvertToFormeNested (Path * dest, int nbP, Path * *orig, int /*wildPath* int searchInd = 0; int lastPtUsed = 0; + int parentContour=-1; do { - int parentContour=-1; int childEdge = -1; bool foundChild = false; int startBord = -1; @@ -389,8 +389,10 @@ Shape::ConvertToFormeNested (Path * dest, int nbP, Path * *orig, int /*wildPath* if (askTo < 0 || askTo >= numberOfEdges() ) { parentContour=-1; } else { - parentContour = GPOINTER_TO_INT(swdData[askTo].misc); - parentContour-=1; // pour compenser le decalage + if (getEdge(askTo).prevS >= 0) { + parentContour = GPOINTER_TO_INT(swdData[askTo].misc); + parentContour-=1; // pour compenser le decalage + } childEdge = getPoint(fi).incidentEdge[FIRST]; } } -- cgit v1.2.3 From 8970eb01735453cd35d4d163891e97dc0cf31a2b Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Fri, 3 Apr 2015 00:01:17 +0200 Subject: inicialice a header variable (bzr r14041) --- src/ui/tool/path-manipulator.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/ui/tool/path-manipulator.cpp b/src/ui/tool/path-manipulator.cpp index ccf75dcde..dbae69f2c 100644 --- a/src/ui/tool/path-manipulator.cpp +++ b/src/ui/tool/path-manipulator.cpp @@ -124,6 +124,7 @@ PathManipulator::PathManipulator(MultiPathManipulator &mpm, SPPath *path, , _show_path_direction(false) , _live_outline(true) , _live_objects(true) + , _is_bspline(false) , _lpe_key(lpe_key) { if (_lpe_key.empty()) { -- cgit v1.2.3 From b7c42a14e19393318be0031b6c75443dd34f9b43 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Fri, 3 Apr 2015 21:40:44 +0200 Subject: Add helper path to guide BSpline if path outline is hidden (bzr r14042) --- src/live_effects/lpe-bspline.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/live_effects/lpe-bspline.cpp b/src/live_effects/lpe-bspline.cpp index dba501f42..5d5a6e616 100644 --- a/src/live_effects/lpe-bspline.cpp +++ b/src/live_effects/lpe-bspline.cpp @@ -74,13 +74,15 @@ void LPEBSpline::doEffect(SPCurve *curve) } // Make copy of old path as it is changed during processing Geom::PathVector const original_pathv = curve->get_pathvector(); + curve->reset(); for (Geom::PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) { - if (path_it->empty()) + if (path_it->empty()){ continue; - + } + hp.push_back(*path_it); Geom::Path::const_iterator curve_it1 = path_it->begin(); Geom::Path::const_iterator curve_it2 = ++(path_it->begin()); Geom::Path::const_iterator curve_endit = path_it->end_default(); -- cgit v1.2.3 From ffdf1e9b2ecc1be4469678d0fbe7120bb709e3cc Mon Sep 17 00:00:00 2001 From: Tavmjong Bah Date: Sat, 4 Apr 2015 08:51:44 +0200 Subject: Call decide() with subpaths in proper order. (bzr r14043) --- src/helper/geom-pathstroke.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/helper/geom-pathstroke.cpp b/src/helper/geom-pathstroke.cpp index 56200402b..4b5a437b2 100644 --- a/src/helper/geom-pathstroke.cpp +++ b/src/helper/geom-pathstroke.cpp @@ -720,7 +720,7 @@ Geom::Path half_outline(Geom::Path const& input, double width, double miter, Lin if (u == 0) { res.append(temp); } else { - bool on_outside = decide(input[u], input[u-1]); + bool on_outside = decide(input[u-1], input[u]); outline_helper(res, temp, width, on_outside, miter, join); if (temp.size() > 0) res.insert(res.end(), ++temp.begin(), temp.end()); -- cgit v1.2.3 From 6c059f826b8e43e0bfb0516e4c9a2ecab77bdacf Mon Sep 17 00:00:00 2001 From: "Liam P. White" Date: Sat, 4 Apr 2015 09:32:14 -0400 Subject: herpderp (bzr r14044) --- src/helper/geom-pathstroke.cpp | 2 +- src/live_effects/lpe-taperstroke.cpp | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/helper/geom-pathstroke.cpp b/src/helper/geom-pathstroke.cpp index 4b5a437b2..eb0c432c6 100644 --- a/src/helper/geom-pathstroke.cpp +++ b/src/helper/geom-pathstroke.cpp @@ -411,7 +411,7 @@ void join_inside(Geom::Path& res, Geom::Curve const& outgoing) bool decide(Geom::Curve const& incoming, Geom::Curve const& outgoing) { Geom::Point tang1 = Geom::unitTangentAt(reverse(incoming.toSBasis()), 0.); - Geom::Point tang2 = outgoing.unitTangentAt(0.); + Geom::Point tang2 = outgoing.unitTangentAt(0.); return (Geom::cross(tang1, tang2) < 0); } diff --git a/src/live_effects/lpe-taperstroke.cpp b/src/live_effects/lpe-taperstroke.cpp index bdd36df68..2c74af6d6 100644 --- a/src/live_effects/lpe-taperstroke.cpp +++ b/src/live_effects/lpe-taperstroke.cpp @@ -285,7 +285,7 @@ Geom::PathVector LPETaperStroke::doEffect_path(Geom::PathVector const& path_in) // although this seems obvious, it can probably lead to bugs. if (!metInMiddle) { // append the outside outline of the path (goes with the direction of the path) - throwaway_path = half_outline(pathv_out[1], -fabs(line_width)/2., miter_limit, static_cast(join_type.get_value())); + throwaway_path = half_outline(pathv_out[1], fabs(line_width)/2., miter_limit, static_cast(join_type.get_value())); if (!zeroStart && real_path.size() >= 1 && throwaway_path.size() >= 1) { if (!Geom::are_near(real_path.finalPoint(), throwaway_path.initialPoint())) { real_path.appendNew(throwaway_path.initialPoint()); @@ -317,7 +317,7 @@ Geom::PathVector LPETaperStroke::doEffect_path(Geom::PathVector const& path_in) if (!metInMiddle) { // append the inside outline of the path (against direction) - throwaway_path = half_outline(pathv_out[1].reverse(), -fabs(line_width)/2., miter_limit, static_cast(join_type.get_value())); + throwaway_path = half_outline(pathv_out[1].reverse(), fabs(line_width)/2., miter_limit, static_cast(join_type.get_value())); if (!Geom::are_near(real_path.finalPoint(), throwaway_path.initialPoint()) && real_path.size() >= 1) { real_path.appendNew(throwaway_path.initialPoint()); -- cgit v1.2.3 From 42b2c95e22b12a3637d439939578c6fee86402e5 Mon Sep 17 00:00:00 2001 From: "Jon A. Cruz" Date: Tue, 7 Apr 2015 18:54:48 -0700 Subject: Cleaned up cmake files to build successfully on Linux. (bzr r14045) --- src/CMakeLists.txt | 44 ++++++++++++++--------------------- src/inkgc/CMakeLists.txt | 5 ++-- src/live_effects/CMakeLists.txt | 51 +++++++++++++++++++++++------------------ src/ui/CMakeLists.txt | 29 ++++++++++++++--------- 4 files changed, 66 insertions(+), 63 deletions(-) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 6659e8c0a..27c5e49db 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,4 +1,3 @@ - # ----------------------------------------------------------------------------- # Define the main source # ----------------------------------------------------------------------------- @@ -33,8 +32,8 @@ set(sp_SRC sp-gradient-reference.cpp sp-gradient.cpp sp-guide.cpp - sp-hatch.cpp sp-hatch-path.cpp + sp-hatch.cpp sp-image.cpp sp-item-group.cpp sp-item-notify-moveto.cpp @@ -47,10 +46,10 @@ set(sp_SRC sp-lpe-item.cpp sp-marker.cpp sp-mask.cpp - sp-mesh.cpp sp-mesh-array.cpp sp-mesh-patch.cpp sp-mesh-row.cpp + sp-mesh.cpp sp-metadata.cpp sp-missing-glyph.cpp sp-namedview.cpp @@ -75,6 +74,9 @@ set(sp_SRC sp-style-elem.cpp sp-switch.cpp sp-symbol.cpp + sp-tag-use-reference.cpp + sp-tag-use.cpp + sp-tag.cpp sp-text.cpp sp-title.cpp sp-tref-reference.cpp @@ -119,8 +121,8 @@ set(sp_SRC sp-guide-attachment.h sp-guide-constraint.h sp-guide.h - sp-hatch.h sp-hatch-path.h + sp-hatch.h sp-image.h sp-item-group.h sp-item-notify-moveto.h @@ -131,13 +133,13 @@ set(sp_SRC sp-line.h sp-linear-gradient.h sp-lpe-item.h - sp-marker.h sp-marker-loc.h + sp-marker.h sp-mask.h - sp-mesh.h sp-mesh-array.h sp-mesh-patch.h sp-mesh-row.h + sp-mesh.h sp-metadata.h sp-missing-glyph.h sp-namedview.h @@ -203,21 +205,17 @@ set(inkscape_SRC filter-enums.cpp gc-anchored.cpp gc-finalized.cpp - gc.cpp gradient-chemistry.cpp gradient-drag.cpp graphlayout.cpp guide-snapper.cpp help.cpp id-clash.cpp - # ige-mac-menu.c inkscape.cpp - inkscape.rc - interface.cpp knot-holder-entity.cpp + knot-ptr.cpp knot.cpp knotholder.cpp - knot-ptr.cpp layer-fns.cpp layer-manager.cpp layer-model.cpp @@ -257,8 +255,8 @@ set(inkscape_SRC snapped-line.cpp snapped-point.cpp snapper.cpp - style.cpp style-internal.cpp + style.cpp svg-view-widget.cpp svg-view.cpp text-chemistry.cpp @@ -313,18 +311,12 @@ set(inkscape_SRC event.h extract-uri-test.h extract-uri.h - factory.h file.h fill-or-stroke.h filter-chemistry.h filter-enums.h - gc-alloc.h - gc-allocator.h gc-anchored.h - gc-core.h gc-finalized.h - gc-managed.h - gc-soft-ptr.h gradient-chemistry.h gradient-drag.h graphlayout.h @@ -333,16 +325,14 @@ set(inkscape_SRC helper-fns.h icon-size.h id-clash.h - # ige-mac-menu.h inkscape-version.h inkscape.h - interface.h isinf.h knot-enums.h knot-holder-entity.h + knot-ptr.h knot.h knotholder.h - knot-ptr.h layer-fns.h layer-manager.h layer-model.h @@ -351,7 +341,6 @@ set(inkscape_SRC macros.h main-cmdlineact.h marker-test.h - marker.h media.h menus-skeleton.h message-context.h @@ -376,7 +365,6 @@ set(inkscape_SRC profile-manager.h proj_pt.h rdf.h - registrytool.h remove-last.h removeoverlap.h require-config.h @@ -403,10 +391,10 @@ set(inkscape_SRC splivarot.h streq.h strneq.h - style-test.h - style.h style-enums.h style-internal.h + style-test.h + style.h svg-profile.h svg-view-widget.h svg-view.h @@ -430,8 +418,10 @@ set(inkscape_SRC if(WIN32) list(APPEND inkscape_SRC + inkscape.rc registrytool.cpp #deptool.cpp + winconsole.cpp winmain.cpp ) endif() @@ -471,7 +461,6 @@ list(APPEND inkscape_SRC # All folders for internal inkscape # these call add_inkscape_source add_subdirectory(debug) -add_subdirectory(dialogs) add_subdirectory(display) add_subdirectory(extension) add_subdirectory(filters) @@ -545,6 +534,8 @@ target_link_libraries(inkscape uemf_LIB 2geom_LIB depixelize_LIB + util_LIB + gc_LIB ${INKSCAPE_LIBS} ) @@ -553,4 +544,3 @@ target_link_libraries(inkscape # make executable for INKVIEW #add_executable(inkview inkview.cpp) # ... - diff --git a/src/inkgc/CMakeLists.txt b/src/inkgc/CMakeLists.txt index 22dd464e1..a4b96d5ee 100644 --- a/src/inkgc/CMakeLists.txt +++ b/src/inkgc/CMakeLists.txt @@ -1,11 +1,10 @@ - set(libgc_SRC gc.cpp - + # ------- # Headers gc-alloc.h - gc-anchored.h + ../gc-anchored.h gc-core.h gc-managed.h gc-soft-ptr.h diff --git a/src/live_effects/CMakeLists.txt b/src/live_effects/CMakeLists.txt index c8a02c810..c4b92e579 100644 --- a/src/live_effects/CMakeLists.txt +++ b/src/live_effects/CMakeLists.txt @@ -1,4 +1,3 @@ - set(live_effects_SRC effect.cpp lpe-angle_bisector.cpp @@ -6,6 +5,7 @@ set(live_effects_SRC lpe-bendpath.cpp lpe-boolops.cpp lpe-bounding-box.cpp + lpe-bspline.cpp lpe-circle_3pts.cpp lpe-circle_with_radius.cpp lpe-clone-original.cpp @@ -13,7 +13,7 @@ set(live_effects_SRC lpe-copy_rotate.cpp lpe-curvestitch.cpp lpe-dynastroke.cpp - lpe-ellipse-5pts.cpp + lpe-ellipse_5pts.cpp lpe-envelope.cpp lpe-extrude.cpp lpe-fill-between-many.cpp @@ -21,8 +21,11 @@ set(live_effects_SRC lpe-fillet-chamfer.cpp lpe-gears.cpp lpe-interpolate.cpp + lpe-interpolate_points.cpp + lpe-jointype.cpp lpe-knot.cpp lpe-lattice.cpp + lpe-lattice2.cpp lpe-line_segment.cpp lpe-mirror_symmetry.cpp lpe-offset.cpp @@ -30,43 +33,43 @@ set(live_effects_SRC lpe-path_length.cpp lpe-patternalongpath.cpp lpe-perp_bisector.cpp - lpe-perspective_path.cpp lpe-perspective-envelope.cpp + lpe-perspective_path.cpp lpe-powerstroke.cpp lpe-recursiveskeleton.cpp lpe-rough-hatches.cpp + lpe-roughen.cpp lpe-ruler.cpp lpe-show_handles.cpp lpe-simplify.cpp - # lpe-skeleton.cpp + lpe-skeleton.cpp lpe-sketch.cpp lpe-spiro.cpp - lpe-roughen.cpp lpe-tangent_to_curve.cpp + lpe-taperstroke.cpp lpe-test-doEffect-stack.cpp - lpe-bspline.cpp lpe-text_label.cpp - lpe-vonkoch.cpp lpegroupbbox.cpp lpeobject-reference.cpp + lpe-vonkoch.cpp lpeobject.cpp - spiro.cpp spiro-converters.cpp + spiro.cpp parameter/array.cpp parameter/bool.cpp parameter/filletchamferpointarray.cpp - parameter/parameter.cpp - parameter/path.cpp parameter/originalpath.cpp parameter/originalpatharray.cpp + parameter/parameter.cpp parameter/path-reference.cpp + parameter/path.cpp parameter/point.cpp parameter/powerstrokepointarray.cpp parameter/random.cpp parameter/text.cpp - paramter/transformedpoint.cpp parameter/togglebutton.cpp + parameter/transformedpoint.cpp parameter/unit.cpp parameter/vector.cpp @@ -80,6 +83,7 @@ set(live_effects_SRC lpe-bendpath.h lpe-boolops.h lpe-bounding-box.h + lpe-bspline.h lpe-circle_3pts.h lpe-circle_with_radius.h lpe-clone-original.h @@ -87,7 +91,7 @@ set(live_effects_SRC lpe-copy_rotate.h lpe-curvestitch.h lpe-dynastroke.h - lpe-ellipse-5pts.h + lpe-ellipse_5pts.h lpe-envelope.h lpe-extrude.h lpe-fill-between-many.h @@ -95,8 +99,11 @@ set(live_effects_SRC lpe-fillet-chamfer.h lpe-gears.h lpe-interpolate.h + lpe-interpolate_points.h + lpe-jointype.h lpe-knot.h lpe-lattice.h + lpe-lattice2.h lpe-line_segment.h lpe-mirror_symmetry.h lpe-offset.h @@ -104,47 +111,47 @@ set(live_effects_SRC lpe-path_length.h lpe-patternalongpath.h lpe-perp_bisector.h - lpe-perspective_path.h lpe-perspective-envelope.h - lpe-powerstroke.h + lpe-perspective_path.h lpe-powerstroke-interpolators.h + lpe-powerstroke.h lpe-recursiveskeleton.h lpe-rough-hatches.h + lpe-roughen.h lpe-ruler.h - lpe-simplify.h lpe-show_handles.h + lpe-simplify.h lpe-skeleton.h lpe-sketch.h lpe-spiro.h - lpe-roughen.h lpe-tangent_to_curve.h + lpe-taperstroke.h lpe-test-doEffect-stack.h - lpe-bspline.h lpe-text_label.h lpe-vonkoch.h lpegroupbbox.h lpeobject-reference.h lpeobject.h - spiro.h spiro-converters.h + spiro.h parameter/array.h parameter/bool.h - parameter/filletchamferpointarray.h parameter/enum.h + parameter/filletchamferpointarray.h + parameter/originalpath.h + parameter/originalpatharray.h parameter/parameter.h parameter/path-reference.h parameter/path.h - parameter/originalpath.h - parameter/originalpatharray.h parameter/point.h parameter/powerstrokepointarray.h parameter/random.h parameter/text.h parameter/togglebutton.h + parameter/transformedpoint.h parameter/unit.h parameter/vector.h - ) # add_inkscape_lib(live_effects_LIB "${live_effects_SRC}") diff --git a/src/ui/CMakeLists.txt b/src/ui/CMakeLists.txt index 674254686..991d11feb 100644 --- a/src/ui/CMakeLists.txt +++ b/src/ui/CMakeLists.txt @@ -1,11 +1,10 @@ - set(ui_SRC clipboard.cpp control-manager.cpp dialog-events.cpp draw-anchor.cpp - interface.cpp - object-edit.cpp + interface.cpp + object-edit.cpp previewholder.cpp shape-editor.cpp tool-factory.cpp @@ -56,8 +55,8 @@ set(ui_SRC dialog/aboutbox.cpp dialog/align-and-distribute.cpp dialog/calligraphic-profile-rename.cpp - dialog/color-item.cpp dialog/clonetiler.cpp + dialog/color-item.cpp dialog/debug.cpp dialog/desktop-tracker.cpp dialog/dialog-manager.cpp @@ -86,31 +85,36 @@ set(ui_SRC dialog/livepatheffect-add.cpp dialog/livepatheffect-editor.cpp dialog/lpe-fillet-chamfer-properties.cpp + dialog/lpe-powerstroke-properties.cpp dialog/memory.cpp dialog/messages.cpp dialog/new-from-template.cpp dialog/object-attributes.cpp dialog/object-properties.cpp + dialog/objects.cpp dialog/ocaldialogs.cpp + dialog/pixelartdialog.cpp dialog/polar-arrange-tab.cpp dialog/print-colors-preview-dialog.cpp dialog/print.cpp - dialog/symbols.cpp - dialog/xml-tree.cpp dialog/spellcheck.cpp dialog/svg-fonts-dialog.cpp dialog/swatches.cpp + dialog/symbols.cpp + dialog/tags.cpp dialog/template-load-tab.cpp dialog/template-widget.cpp dialog/text-edit.cpp dialog/tile.cpp dialog/tracedialog.cpp - dialog/pixelartdialog.cpp dialog/transformation.cpp dialog/undo-history.cpp + dialog/xml-tree.cpp + widget/addtoicon.cpp widget/anchor-selector.cpp widget/button.cpp + widget/clipmaskicon.cpp widget/color-picker.cpp widget/color-preview.cpp widget/dock-item.cpp @@ -121,10 +125,13 @@ set(ui_SRC widget/frame.cpp widget/gimpcolorwheel.c widget/gimpspinscale.c + widget/highlight-picker.cpp widget/imageicon.cpp widget/imagetoggler.cpp + widget/insertordericon.cpp widget/labelled.cpp widget/layer-selector.cpp + widget/layertypeicon.cpp widget/licensor.cpp widget/notebook-page.cpp widget/object-composite-settings.cpp @@ -179,8 +186,8 @@ set(ui_SRC dialog/arrange-tab.h dialog/behavior.h dialog/calligraphic-profile-rename.h - dialog/color-item.h dialog/clonetiler.h + dialog/color-item.h dialog/debug.h dialog/desktop-tracker.h dialog/dialog-manager.h @@ -200,8 +207,8 @@ set(ui_SRC dialog/floating-behavior.h dialog/font-substitution.h dialog/glyphs.h - dialog/guides.h dialog/grid-arrange-tab.h + dialog/guides.h dialog/icon-preview.h dialog/inkscape-preferences.h dialog/input.h @@ -215,13 +222,13 @@ set(ui_SRC dialog/new-from-template.h dialog/object-attributes.h dialog/object-properties.h + dialog/objects.h dialog/ocaldialogs.h dialog/panel-dialog.h - dialog/polar-arrange-tab.h dialog/pixelartdialog.h + dialog/polar-arrange-tab.h dialog/print-colors-preview-dialog.h dialog/print.h - dialog/spellcheck.h dialog/svg-fonts-dialog.h dialog/swatches.h -- cgit v1.2.3 From a9469b254f4d9546f3619a688f845da53b065178 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Thu, 9 Apr 2015 21:38:17 +0200 Subject: Fix coding style issues in simplify LPE (bzr r14046) --- src/live_effects/lpe-simplify.cpp | 190 +++++++++++++++++++------------------- src/live_effects/lpe-simplify.h | 48 +++++----- 2 files changed, 119 insertions(+), 119 deletions(-) diff --git a/src/live_effects/lpe-simplify.cpp b/src/live_effects/lpe-simplify.cpp index 1fe18dd5e..7fc20ede1 100644 --- a/src/live_effects/lpe-simplify.cpp +++ b/src/live_effects/lpe-simplify.cpp @@ -27,39 +27,39 @@ namespace LivePathEffect { LPESimplify::LPESimplify(LivePathEffectObject *lpeobject) : Effect(lpeobject), - steps(_("Steps:"),_("Change number of simplify steps "), "steps", &wr, this,1), - threshold(_("Roughly threshold:"), _("Roughly threshold:"), "threshold", &wr, this, 0.003), - smooth_angles(_("Smooth angles:"), _("Max degree difference on handles to preform a smooth"), "smooth_angles", &wr, this, 20.), - helper_size(_("Helper size:"), _("Helper size"), "helper_size", &wr, this, 5), - simplifyindividualpaths(_("Paths separately"), _("Simplifying paths (separately)"), "simplifyindividualpaths", &wr, this, false, - "", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), - simplifyJustCoalesce(_("Just coalesce"), _("Simplify just coalesce"), "simplifyJustCoalesce", &wr, this, false, - "", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")) - { - registerParameter(&steps); - registerParameter(&threshold); - registerParameter(&smooth_angles); - registerParameter(&helper_size); - registerParameter(&simplifyindividualpaths); - registerParameter(&simplifyJustCoalesce); + steps(_("Steps:"),_("Change number of simplify steps "), "steps", &wr, this,1), + threshold(_("Roughly threshold:"), _("Roughly threshold:"), "threshold", &wr, this, 0.003), + smooth_angles(_("Smooth angles:"), _("Max degree difference on handles to preform a smooth"), "smooth_angles", &wr, this, 20.), + helper_size(_("Helper size:"), _("Helper size"), "helper_size", &wr, this, 5), + simplify_individual_paths(_("Paths separately"), _("Simplifying paths (separately)"), "simplify_individual_paths", &wr, this, false, + "", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), + simplify_just_coalesce(_("Just coalesce"), _("Simplify just coalesce"), "simplify_just_coalesce", &wr, this, false, + "", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")) +{ + registerParameter(&steps); + registerParameter(&threshold); + registerParameter(&smooth_angles); + registerParameter(&helper_size); + registerParameter(&simplify_individual_paths); + registerParameter(&simplify_just_coalesce); - threshold.param_set_range(0.0001, Geom::infinity()); - threshold.param_set_increments(0.0001, 0.0001); - threshold.param_set_digits(6); + threshold.param_set_range(0.0001, Geom::infinity()); + threshold.param_set_increments(0.0001, 0.0001); + threshold.param_set_digits(6); - steps.param_set_range(0, 100); - steps.param_set_increments(1, 1); - steps.param_set_digits(0); + steps.param_set_range(0, 100); + steps.param_set_increments(1, 1); + steps.param_set_digits(0); - smooth_angles.param_set_range(0.0, 365.0); - smooth_angles.param_set_increments(10, 10); - smooth_angles.param_set_digits(2); + smooth_angles.param_set_range(0.0, 365.0); + smooth_angles.param_set_increments(10, 10); + smooth_angles.param_set_digits(2); - helper_size.param_set_range(0.0, 999.0); - helper_size.param_set_increments(5, 5); - helper_size.param_set_digits(2); + helper_size.param_set_range(0.0, 999.0); + helper_size.param_set_increments(5, 5); + helper_size.param_set_digits(2); - radiusHelperNodes = 6.0; + radius_helper_nodes = 6.0; } LPESimplify::~LPESimplify() {} @@ -67,12 +67,12 @@ LPESimplify::~LPESimplify() {} void LPESimplify::doBeforeEffect (SPLPEItem const* lpeitem) { - if(!hp.empty()){ + if(!hp.empty()) { hp.clear(); } bbox = SP_ITEM(lpeitem)->visualBounds(); SPLPEItem * item = const_cast(lpeitem); - radiusHelperNodes = helper_size; + radius_helper_nodes = helper_size; item->apply_to_clippath(item); item->apply_to_mask(item); } @@ -91,9 +91,8 @@ LPESimplify::newWidget() if ((*it)->widget_is_visible) { Parameter * param = *it; Gtk::Widget * widg = dynamic_cast(param->param_newWidget()); - if (param->param_key == "simplifyindividualpaths" || - param->param_key == "simplifyJustCoalesce") - { + if (param->param_key == "simplify_individual_paths" || + param->param_key == "simplify_just_coalesce") { Glib::ustring * tip = param->param_getTooltip(); if (widg) { buttons->pack_start(*widg, true, true, 2); @@ -104,13 +103,13 @@ LPESimplify::newWidget() widg->set_has_tooltip(false); } } - } else{ + } else { Glib::ustring * tip = param->param_getTooltip(); if (widg) { - Gtk::HBox * scalarParameter = dynamic_cast(widg); - std::vector< Gtk::Widget* > childList = scalarParameter->get_children(); - Gtk::Entry* entryWidg = dynamic_cast(childList[1]); - entryWidg->set_width_chars(8); + Gtk::HBox * horizontal_box = dynamic_cast(widg); + std::vector< Gtk::Widget* > child_list = horizontal_box->get_children(); + Gtk::Entry* entry_widg = dynamic_cast(child_list[1]); + entry_widg->set_width_chars(8); vbox->pack_start(*widg, true, true, 2); if (tip) { widg->set_tooltip_text(*tip); @@ -128,28 +127,29 @@ LPESimplify::newWidget() return dynamic_cast(vbox); } -void -LPESimplify::doEffect(SPCurve *curve) { +void +LPESimplify::doEffect(SPCurve *curve) +{ Geom::PathVector const original_pathv = pathv_to_linear_and_cubic_beziers(curve->get_pathvector()); gdouble size = Geom::L2(bbox->dimensions()); //size /= Geom::Affine(0,0,0,0,0,0).descrim(); Path* pathliv = Path_for_pathvector(original_pathv); - if(simplifyindividualpaths){ + if(simplify_individual_paths) { size = Geom::L2(Geom::bounds_fast(original_pathv)->dimensions()); } - for (int unsigned i = 0; i < steps; i++){ - if ( simplifyJustCoalesce ) { - pathliv->Coalesce(threshold * size); - }else{ - pathliv->ConvertEvenLines(threshold * size); - pathliv->Simplify(threshold * size); + for (int unsigned i = 0; i < steps; i++) { + if ( simplify_just_coalesce ) { + pathliv->Coalesce(threshold * size); + } else { + pathliv->ConvertEvenLines(threshold * size); + pathliv->Simplify(threshold * size); } } Geom::PathVector result = Geom::parse_svg_path(pathliv->svg_dump_path()); generateHelperPathAndSmooth(result); curve->set_pathvector(result); SPDesktop* desktop = SP_ACTIVE_DESKTOP; - if(desktop && INK_IS_NODE_TOOL(desktop->event_context)){ + if(desktop && INK_IS_NODE_TOOL(desktop->event_context)) { Inkscape::UI::Tools::NodeTool *nt = static_cast(desktop->event_context); nt->update_helperpath(); } @@ -158,15 +158,15 @@ LPESimplify::doEffect(SPCurve *curve) { void LPESimplify::generateHelperPathAndSmooth(Geom::PathVector &result) { - if(steps < 1){ + if(steps < 1) { return; } - Geom::PathVector tmpPath; + Geom::PathVector tmp_path; Geom::CubicBezier const *cubic = NULL; for (Geom::PathVector::iterator path_it = result.begin(); path_it != result.end(); ++path_it) { //Si está vacío... - if (path_it->empty()){ - continue; + if (path_it->empty()) { + continue; } //Itreadores Geom::Path::const_iterator curve_it1 = path_it->begin(); // incoming curve @@ -174,68 +174,68 @@ LPESimplify::generateHelperPathAndSmooth(Geom::PathVector &result) Geom::Path::const_iterator curve_endit = path_it->end_default(); // this determines when the loop has to stop SPCurve *nCurve = new SPCurve(); if (path_it->closed()) { - // if the path is closed, maybe we have to stop a bit earlier because the - // closing line segment has zerolength. - const Geom::Curve &closingline = - path_it->back_closed(); // the closing line segment is always of type - // Geom::LineSegment. - if (are_near(closingline.initialPoint(), closingline.finalPoint())) { - // closingline.isDegenerate() did not work, because it only checks for - // *exact* zero length, which goes wrong for relative coordinates and - // rounding errors... - // the closing line segment has zero-length. So stop before that one! - curve_endit = path_it->end_open(); - } + // if the path is closed, maybe we have to stop a bit earlier because the + // closing line segment has zerolength. + const Geom::Curve &closingline = + path_it->back_closed(); // the closing line segment is always of type + // Geom::LineSegment. + if (are_near(closingline.initialPoint(), closingline.finalPoint())) { + // closingline.isDegenerate() did not work, because it only checks for + // *exact* zero length, which goes wrong for relative coordinates and + // rounding errors... + // the closing line segment has zero-length. So stop before that one! + curve_endit = path_it->end_open(); + } } - if(helper_size > 0){ + if(helper_size > 0) { drawNode(curve_it1->initialPoint()); } nCurve->moveto(curve_it1->initialPoint()); Geom::Point start = Geom::Point(0,0); while (curve_it1 != curve_endit) { cubic = dynamic_cast(&*curve_it1); - Geom::Point pointAt1 = curve_it1->initialPoint(); - Geom::Point pointAt2 = curve_it1->finalPoint(); - Geom::Point pointAt3 = curve_it1->finalPoint(); - Geom::Point pointAt4 = curve_it1->finalPoint(); + Geom::Point point_at1 = curve_it1->initialPoint(); + Geom::Point point_at2 = curve_it1->finalPoint(); + Geom::Point point_at3 = curve_it1->finalPoint(); + Geom::Point point_at4 = curve_it1->finalPoint(); if (cubic) { - pointAt1 = (*cubic)[1]; - pointAt2 = (*cubic)[2]; + point_at1 = (*cubic)[1]; + point_at2 = (*cubic)[2]; } - if(start == Geom::Point(0,0)){ - start = pointAt1; + if(start == Geom::Point(0,0)) { + start = point_at1; } - - if(path_it->closed() && curve_it2 == curve_endit){ - pointAt4 = start; + + if(path_it->closed() && curve_it2 == curve_endit) { + point_at4 = start; } - if(curve_it2 != curve_endit){ + if(curve_it2 != curve_endit) { cubic = dynamic_cast(&*curve_it2); if (cubic) { - pointAt4 = (*cubic)[1]; + point_at4 = (*cubic)[1]; } } - Geom::Ray ray1(pointAt2, pointAt3); - Geom::Ray ray2(pointAt3, pointAt4); + Geom::Ray ray1(point_at2, point_at3); + Geom::Ray ray2(point_at3, point_at4); double angle1 = Geom::rad_to_deg(ray1.angle()); double angle2 = Geom::rad_to_deg(ray2.angle()); - if((smooth_angles >= angle2 - angle1) && !are_near(pointAt4,pointAt3) && !are_near(pointAt2,pointAt3)){ - double dist = Geom::distance(pointAt2,pointAt3); + if((smooth_angles >= angle2 - angle1) && !are_near(point_at4,point_at3) && !are_near(point_at2,point_at3)) { + double dist = Geom::distance(point_at2,point_at3); Geom::Angle angleFixed = ray2.angle(); angleFixed -= Geom::Angle::from_degrees(180.0); - pointAt2 = Geom::Point::polar(angleFixed,dist) + pointAt3; + point_at2 = Geom::Point::polar(angleFixed,dist) + point_at3; } - nCurve->curveto(pointAt1, pointAt2, curve_it1->finalPoint()); + nCurve->curveto(point_at1, point_at2, curve_it1->finalPoint()); cubic = dynamic_cast(nCurve->last_segment()); if (cubic) { - pointAt1 = (*cubic)[1]; - pointAt2 = (*cubic)[2]; + point_at1 = (*cubic)[1]; + point_at2 = (*cubic)[2]; if(helper_size > 0) { - if(!are_near((*cubic)[0],(*cubic)[1])){ + if(!are_near((*cubic)[0],(*cubic)[1])) { drawHandle((*cubic)[1]); drawHandleLine((*cubic)[0],(*cubic)[1]); } - if(!are_near((*cubic)[3],(*cubic)[2])){ + if(!are_near((*cubic)[3],(*cubic)[2])) { drawHandle((*cubic)[2]); drawHandleLine((*cubic)[3],(*cubic)[2]); } @@ -250,17 +250,17 @@ LPESimplify::generateHelperPathAndSmooth(Geom::PathVector &result) if (path_it->closed()) { nCurve->closepath_current(); } - tmpPath.push_back(nCurve->get_pathvector()[0]); + tmp_path.push_back(nCurve->get_pathvector()[0]); nCurve->reset(); delete nCurve; } - result = tmpPath; + result = tmp_path; } -void +void LPESimplify::drawNode(Geom::Point p) { - double r = radiusHelperNodes; + double r = radius_helper_nodes; char const * svgd; svgd = "M 0.55,0.5 A 0.05,0.05 0 0 1 0.5,0.55 0.05,0.05 0 0 1 0.45,0.5 0.05,0.05 0 0 1 0.5,0.45 0.05,0.05 0 0 1 0.55,0.5 Z M 0,0 1,0 1,1 0,1 Z"; Geom::PathVector pathv = sp_svg_read_pathv(svgd); @@ -273,7 +273,7 @@ LPESimplify::drawNode(Geom::Point p) void LPESimplify::drawHandle(Geom::Point p) { - double r = radiusHelperNodes; + double r = radius_helper_nodes; char const * svgd; svgd = "M 0.7,0.35 A 0.35,0.35 0 0 1 0.35,0.7 0.35,0.35 0 0 1 0,0.35 0.35,0.35 0 0 1 0.35,0 0.35,0.35 0 0 1 0.7,0.35 Z"; Geom::PathVector pathv = sp_svg_read_pathv(svgd); @@ -288,8 +288,8 @@ LPESimplify::drawHandleLine(Geom::Point p,Geom::Point p2) { Geom::Path path; path.start( p ); - double diameter = radiusHelperNodes; - if(helper_size > 0 && Geom::distance(p,p2) > (diameter * 0.35)){ + double diameter = radius_helper_nodes; + if(helper_size > 0 && Geom::distance(p,p2) > (diameter * 0.35)) { Geom::Ray ray2(p, p2); p2 = p2 - Geom::Point::polar(ray2.angle(),(diameter * 0.35)); } diff --git a/src/live_effects/lpe-simplify.h b/src/live_effects/lpe-simplify.h index c18c3ecdf..294d77b35 100644 --- a/src/live_effects/lpe-simplify.h +++ b/src/live_effects/lpe-simplify.h @@ -14,43 +14,43 @@ namespace Inkscape { namespace LivePathEffect { -class LPESimplify : public Effect , GroupBBoxEffect{ +class LPESimplify : public Effect , GroupBBoxEffect { public: - LPESimplify(LivePathEffectObject *lpeobject); - virtual ~LPESimplify(); + LPESimplify(LivePathEffectObject *lpeobject); + virtual ~LPESimplify(); - virtual void doEffect(SPCurve *curve); + virtual void doEffect(SPCurve *curve); - virtual void doBeforeEffect (SPLPEItem const* lpeitem); + virtual void doBeforeEffect (SPLPEItem const* lpeitem); - virtual void generateHelperPathAndSmooth(Geom::PathVector &result); + virtual void generateHelperPathAndSmooth(Geom::PathVector &result); - virtual Gtk::Widget * newWidget(); + virtual Gtk::Widget * newWidget(); - virtual void drawNode(Geom::Point p); - - virtual void drawHandle(Geom::Point p); + virtual void drawNode(Geom::Point p); - virtual void drawHandleLine(Geom::Point p,Geom::Point p2); + virtual void drawHandle(Geom::Point p); + + virtual void drawHandleLine(Geom::Point p,Geom::Point p2); protected: void addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector &hp_vec); private: - ScalarParam steps; - ScalarParam threshold; - ScalarParam smooth_angles; - ScalarParam helper_size; - ToggleButtonParam simplifyindividualpaths; - ToggleButtonParam simplifyJustCoalesce; - - double radiusHelperNodes; - Geom::PathVector hp; - Geom::OptRect bbox; - - LPESimplify(const LPESimplify &); - LPESimplify &operator=(const LPESimplify &); + ScalarParam steps; + ScalarParam threshold; + ScalarParam smooth_angles; + ScalarParam helper_size; + ToggleButtonParam simplify_individual_paths; + ToggleButtonParam simplify_just_coalesce; + + double radius_helper_nodes; + Geom::PathVector hp; + Geom::OptRect bbox; + + LPESimplify(const LPESimplify &); + LPESimplify &operator=(const LPESimplify &); }; -- cgit v1.2.3 From 060edc50dba23acbbb05d6fdd98aa366956337f6 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Fri, 10 Apr 2015 00:01:23 +0200 Subject: Fix coding style issues in lattice2 LPE (bzr r14047) --- src/live_effects/lpe-lattice2.cpp | 560 +++++++++++++++++++------------------- src/live_effects/lpe-lattice2.h | 63 ++--- 2 files changed, 310 insertions(+), 313 deletions(-) diff --git a/src/live_effects/lpe-lattice2.cpp b/src/live_effects/lpe-lattice2.cpp index 08bbbd504..abd6e7786 100644 --- a/src/live_effects/lpe-lattice2.cpp +++ b/src/live_effects/lpe-lattice2.cpp @@ -1,6 +1,6 @@ /** \file * LPE implementation - + */ /* * Authors: @@ -11,7 +11,7 @@ * ~suv * Jabiertxo Arraiza * -* Copyright (C) 2007-2008 Authors +* Copyright (C) 2007-2008 Authors * * Released under GNU GPL, read the file 'COPYING' for more information */ @@ -42,63 +42,63 @@ namespace LivePathEffect { LPELattice2::LPELattice2(LivePathEffectObject *lpeobject) : Effect(lpeobject), - horizontalMirror(_("Mirror movements in horizontal"), _("Mirror movements in horizontal"), "horizontalMirror", &wr, this, false), - verticalMirror(_("Mirror movements in vertical"), _("Mirror movements in vertical"), "verticalMirror", &wr, this, false), - grid_point0(_("Control 0:"), _("Control 0 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint0", &wr, this), - grid_point1(_("Control 1:"), _("Control 1 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint1", &wr, this), - grid_point2(_("Control 2:"), _("Control 2 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint2", &wr, this), - grid_point3(_("Control 3:"), _("Control 3 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint3", &wr, this), - grid_point4(_("Control 4:"), _("Control 4 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint4", &wr, this), - grid_point5(_("Control 5:"), _("Control 5 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint5", &wr, this), - grid_point6(_("Control 6:"), _("Control 6 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint6", &wr, this), - grid_point7(_("Control 7:"), _("Control 7 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint7", &wr, this), - grid_point8x9(_("Control 8x9:"), _("Control 8x9 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint8x9", &wr, this), - grid_point10x11(_("Control 10x11:"), _("Control 10x11 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint10x11", &wr, this), - grid_point12(_("Control 12:"), _("Control 12 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint12", &wr, this), - grid_point13(_("Control 13:"), _("Control 13 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint13", &wr, this), - grid_point14(_("Control 14:"), _("Control 14 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint14", &wr, this), - grid_point15(_("Control 15:"), _("Control 15 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint15", &wr, this), - grid_point16(_("Control 16:"), _("Control 16 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint16", &wr, this), - grid_point17(_("Control 17:"), _("Control 17 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint17", &wr, this), - grid_point18(_("Control 18:"), _("Control 18 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint18", &wr, this), - grid_point19(_("Control 19:"), _("Control 19 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint19", &wr, this), - grid_point20x21(_("Control 20x21:"), _("Control 20x21 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint20x21", &wr, this), - grid_point22x23(_("Control 22x23:"), _("Control 22x23 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint22x23", &wr, this), - grid_point24x26(_("Control 24x26:"), _("Control 24x26 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint24x26", &wr, this), - grid_point25x27(_("Control 25x27:"), _("Control 25x27 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint25x27", &wr, this), - grid_point28x30(_("Control 28x30:"), _("Control 28x30 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint28x30", &wr, this), - grid_point29x31(_("Control 29x31:"), _("Control 29x31 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint29x31", &wr, this), - grid_point32x33x34x35(_("Control 32x33x34x35:"), _("Control 32x33x34x35 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint32x33x34x35", &wr, this), + horizontal_mirror(_("Mirror movements in horizontal"), _("Mirror movements in horizontal"), "horizontal_mirror", &wr, this, false), + vertical_mirror(_("Mirror movements in vertical"), _("Mirror movements in vertical"), "vertical_mirror", &wr, this, false), + grid_point_0(_("Control 0:"), _("Control 0 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint0", &wr, this), + grid_point_1(_("Control 1:"), _("Control 1 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint1", &wr, this), + grid_point_2(_("Control 2:"), _("Control 2 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint2", &wr, this), + grid_point_3(_("Control 3:"), _("Control 3 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint3", &wr, this), + grid_point_4(_("Control 4:"), _("Control 4 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint4", &wr, this), + grid_point_5(_("Control 5:"), _("Control 5 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint5", &wr, this), + grid_point_6(_("Control 6:"), _("Control 6 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint6", &wr, this), + grid_point_7(_("Control 7:"), _("Control 7 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint7", &wr, this), + grid_point_8x9(_("Control 8x9:"), _("Control 8x9 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint8x9", &wr, this), + grid_point_10x11(_("Control 10x11:"), _("Control 10x11 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint10x11", &wr, this), + grid_point_12(_("Control 12:"), _("Control 12 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint12", &wr, this), + grid_point_13(_("Control 13:"), _("Control 13 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint13", &wr, this), + grid_point_14(_("Control 14:"), _("Control 14 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint14", &wr, this), + grid_point_15(_("Control 15:"), _("Control 15 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint15", &wr, this), + grid_point_16(_("Control 16:"), _("Control 16 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint16", &wr, this), + grid_point_17(_("Control 17:"), _("Control 17 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint17", &wr, this), + grid_point_18(_("Control 18:"), _("Control 18 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint18", &wr, this), + grid_point_19(_("Control 19:"), _("Control 19 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint19", &wr, this), + grid_point_20x21(_("Control 20x21:"), _("Control 20x21 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint20x21", &wr, this), + grid_point_22x23(_("Control 22x23:"), _("Control 22x23 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint22x23", &wr, this), + grid_point_24x26(_("Control 24x26:"), _("Control 24x26 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint24x26", &wr, this), + grid_point_25x27(_("Control 25x27:"), _("Control 25x27 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint25x27", &wr, this), + grid_point_28x30(_("Control 28x30:"), _("Control 28x30 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint28x30", &wr, this), + grid_point_29x31(_("Control 29x31:"), _("Control 29x31 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint29x31", &wr, this), + grid_point_32x33x34x35(_("Control 32x33x34x35:"), _("Control 32x33x34x35 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint32x33x34x35", &wr, this), expanded(false) { // register all your parameters here, so Inkscape knows which parameters this effect has: - registerParameter(&horizontalMirror); - registerParameter(&verticalMirror); - registerParameter(&grid_point0); - registerParameter(&grid_point1); - registerParameter(&grid_point2); - registerParameter(&grid_point3); - registerParameter(&grid_point4); - registerParameter(&grid_point5); - registerParameter(&grid_point6); - registerParameter(&grid_point7); - registerParameter(&grid_point8x9); - registerParameter(&grid_point10x11); - registerParameter(&grid_point12); - registerParameter(&grid_point13); - registerParameter(&grid_point14); - registerParameter(&grid_point15); - registerParameter(&grid_point16); - registerParameter(&grid_point17); - registerParameter(&grid_point18); - registerParameter(&grid_point19); - registerParameter(&grid_point20x21); - registerParameter(&grid_point22x23); - registerParameter(&grid_point24x26); - registerParameter(&grid_point25x27); - registerParameter(&grid_point28x30); - registerParameter(&grid_point29x31); - registerParameter(&grid_point32x33x34x35); + registerParameter(&horizontal_mirror); + registerParameter(&vertical_mirror); + registerParameter(&grid_point_0); + registerParameter(&grid_point_1); + registerParameter(&grid_point_2); + registerParameter(&grid_point_3); + registerParameter(&grid_point_4); + registerParameter(&grid_point_5); + registerParameter(&grid_point_6); + registerParameter(&grid_point_7); + registerParameter(&grid_point_8x9); + registerParameter(&grid_point_10x11); + registerParameter(&grid_point_12); + registerParameter(&grid_point_13); + registerParameter(&grid_point_14); + registerParameter(&grid_point_15); + registerParameter(&grid_point_16); + registerParameter(&grid_point_17); + registerParameter(&grid_point_18); + registerParameter(&grid_point_19); + registerParameter(&grid_point_20x21); + registerParameter(&grid_point_22x23); + registerParameter(&grid_point_24x26); + registerParameter(&grid_point_25x27); + registerParameter(&grid_point_28x30); + registerParameter(&grid_point_29x31); + registerParameter(&grid_point_32x33x34x35); } LPELattice2::~LPELattice2() @@ -113,7 +113,7 @@ LPELattice2::doEffect_pwd2 (Geom::Piecewise > const & pwd PathVector cubic = pathv_to_cubicbezier(pathv); Geom::Piecewise > const &pwd2_in_linear_and_cubic = paths_to_pw(cubic); D2 sb2; - + //Initialisation of the sb2 for(unsigned dim = 0; dim < 2; dim++) { sb2[dim].us = 3; @@ -125,46 +125,46 @@ LPELattice2::doEffect_pwd2 (Geom::Piecewise > const & pwd //Grouping the point params in a convenient vector std::vector handles(36); - - handles[0] = grid_point0; - handles[1] = grid_point1; - handles[2] = grid_point2; - handles[3] = grid_point3; - handles[4] = grid_point4; - handles[5] = grid_point5; - handles[6] = grid_point6; - handles[7] = grid_point7; - handles[8] = grid_point8x9; - handles[9] = grid_point8x9; - handles[10] = grid_point10x11; - handles[11] = grid_point10x11; - handles[12] = grid_point12; - handles[13] = grid_point13; - handles[14] = grid_point14; - handles[15] = grid_point15; - handles[16] = grid_point16; - handles[17] = grid_point17; - handles[18] = grid_point18; - handles[19] = grid_point19; - handles[20] = grid_point20x21; - handles[21] = grid_point20x21; - handles[22] = grid_point22x23; - handles[23] = grid_point22x23; - handles[24] = grid_point24x26; - handles[25] = grid_point25x27; - handles[26] = grid_point24x26; - handles[27] = grid_point25x27; - handles[28] = grid_point28x30; - handles[29] = grid_point29x31; - handles[30] = grid_point28x30; - handles[31] = grid_point29x31; - handles[32] = grid_point32x33x34x35; - handles[33] = grid_point32x33x34x35; - handles[34] = grid_point32x33x34x35; - handles[35] = grid_point32x33x34x35; + + handles[0] = grid_point_0; + handles[1] = grid_point_1; + handles[2] = grid_point_2; + handles[3] = grid_point_3; + handles[4] = grid_point_4; + handles[5] = grid_point_5; + handles[6] = grid_point_6; + handles[7] = grid_point_7; + handles[8] = grid_point_8x9; + handles[9] = grid_point_8x9; + handles[10] = grid_point_10x11; + handles[11] = grid_point_10x11; + handles[12] = grid_point_12; + handles[13] = grid_point_13; + handles[14] = grid_point_14; + handles[15] = grid_point_15; + handles[16] = grid_point_16; + handles[17] = grid_point_17; + handles[18] = grid_point_18; + handles[19] = grid_point_19; + handles[20] = grid_point_20x21; + handles[21] = grid_point_20x21; + handles[22] = grid_point_22x23; + handles[23] = grid_point_22x23; + handles[24] = grid_point_24x26; + handles[25] = grid_point_25x27; + handles[26] = grid_point_24x26; + handles[27] = grid_point_25x27; + handles[28] = grid_point_28x30; + handles[29] = grid_point_29x31; + handles[30] = grid_point_28x30; + handles[31] = grid_point_29x31; + handles[32] = grid_point_32x33x34x35; + handles[33] = grid_point_32x33x34x35; + handles[34] = grid_point_32x33x34x35; + handles[35] = grid_point_32x33x34x35; Geom::Point origin = Geom::Point(boundingbox_X.min(),boundingbox_Y.min()); - + double width = boundingbox_X.extent(); double height = boundingbox_Y.extent(); @@ -178,16 +178,16 @@ LPELattice2::doEffect_pwd2 (Geom::Piecewise > const & pwd for(unsigned iu = 0; iu < 2; iu++) { unsigned corner = iu + 2*iv; unsigned i = ui + vi*sb2[dim].us; - + //This is the offset from the Upperleft point Geom::Point base( (ui + iu*(4-2*ui))*width/4., (vi + iv*(4-2*vi))*height/4.); - + //Special action for corners if(vi == 0 && ui == 0) { base = Geom::Point(0,0); } - + // i = Upperleft corner of the considerated rectangle // corner = actual corner of the rectangle // origin = Upperleft point @@ -198,7 +198,7 @@ LPELattice2::doEffect_pwd2 (Geom::Piecewise > const & pwd } } } - + Piecewise > output; output.push_cut(0.); for(unsigned i = 0; i < pwd2_in_linear_and_cubic.size(); i++) { @@ -228,28 +228,28 @@ LPELattice2::newWidget() vbox->set_homogeneous(false); vbox->set_spacing(6); Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false,0)); - Gtk::VBox * vboxExpander = Gtk::manage( new Gtk::VBox(Effect::newWidget()) ); - vboxExpander->set_border_width(0); - vboxExpander->set_spacing(2); - Gtk::Button * resetButton = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset grid")))); - resetButton->signal_clicked().connect(sigc::mem_fun (*this,&LPELattice2::resetGrid)); - resetButton->set_size_request(140,30); + Gtk::VBox * vbox_expander = Gtk::manage( new Gtk::VBox(Effect::newWidget()) ); + vbox_expander->set_border_width(0); + vbox_expander->set_spacing(2); + Gtk::Button * reset_button = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset grid")))); + reset_button->signal_clicked().connect(sigc::mem_fun (*this,&LPELattice2::resetGrid)); + reset_button->set_size_request(140,30); vbox->pack_start(*hbox, true,true,2); - hbox->pack_start(*resetButton, false, false,2); + hbox->pack_start(*reset_button, false, false,2); std::vector::iterator it = param_vector.begin(); while (it != param_vector.end()) { if ((*it)->widget_is_visible) { Parameter * param = *it; Gtk::Widget * widg = dynamic_cast(param->param_newWidget()); - if(param->param_key == "grid"){ + if(param->param_key == "grid") { widg = NULL; } Glib::ustring * tip = param->param_getTooltip(); if (widg) { - if (param->param_key == "horizontalMirror" || param->param_key == "verticalMirror") { + if (param->param_key == "horizontal_mirror" || param->param_key == "vertical_mirror") { vbox->pack_start(*widg, true, true, 2); } else { - vboxExpander->pack_start(*widg, true, true, 2); + vbox_expander->pack_start(*widg, true, true, 2); } if (tip) { widg->set_tooltip_text(*tip); @@ -262,63 +262,65 @@ LPELattice2::newWidget() ++it; } - + expander = Gtk::manage(new Gtk::Expander(Glib::ustring(_("Show Points")))); - expander->add(*vboxExpander); + expander->add(*vbox_expander); expander->set_expanded(expanded); vbox->pack_start(*expander, true, true, 2); - expander->property_expanded().signal_changed().connect(sigc::mem_fun(*this, &LPELattice2::on_expander_changed) ); + expander->property_expanded().signal_changed().connect(sigc::mem_fun(*this, &LPELattice2::onExpanderChanged) ); return dynamic_cast(vbox); } void -LPELattice2::on_expander_changed() +LPELattice2::onExpanderChanged() { expanded = expander->get_expanded(); - if(expander->get_expanded()){ + if(expander->get_expanded()) { expander->set_label (Glib::ustring(_("Hide Points"))); } else { expander->set_label (Glib::ustring(_("Show Points"))); } } void -LPELattice2::vertical(PointParam ¶mA, PointParam ¶mB, Geom::Line vert){ - Geom::Point A = paramA; - Geom::Point B = paramB; +LPELattice2::vertical(PointParam ¶m_one, PointParam ¶m_two, Geom::Line vert) +{ + Geom::Point A = param_one; + Geom::Point B = param_two; double Y = (A[Geom::Y] + B[Geom::Y])/2; A[Geom::Y] = Y; B[Geom::Y] = Y; Geom::Point nearest = vert.pointAt(vert.nearestPoint(A)); - double distA = Geom::distance(A,nearest); - double distB = Geom::distance(B,nearest); - double distanceMed = (distA + distB)/2; - if(A[Geom::X] > B[Geom::X]){ - distanceMed *= -1; + double distance_one = Geom::distance(A,nearest); + double distance_two = Geom::distance(B,nearest); + double distance_middle = (distance_one + distance_two)/2; + if(A[Geom::X] > B[Geom::X]) { + distance_middle *= -1; } - A[Geom::X] = nearest[Geom::X] - distanceMed; - B[Geom::X] = nearest[Geom::X] + distanceMed; - paramA.param_setValue(A, true); - paramB.param_setValue(B, true); + A[Geom::X] = nearest[Geom::X] - distance_middle; + B[Geom::X] = nearest[Geom::X] + distance_middle; + param_one.param_setValue(A, true); + param_two.param_setValue(B, true); } void -LPELattice2::horizontal(PointParam ¶mA, PointParam ¶mB, Geom::Line horiz){ - Geom::Point A = paramA; - Geom::Point B = paramB; +LPELattice2::horizontal(PointParam ¶m_one, PointParam ¶m_two, Geom::Line horiz) +{ + Geom::Point A = param_one; + Geom::Point B = param_two; double X = (A[Geom::X] + B[Geom::X])/2; A[Geom::X] = X; B[Geom::X] = X; Geom::Point nearest = horiz.pointAt(horiz.nearestPoint(A)); - double distA = Geom::distance(A,nearest); - double distB = Geom::distance(B,nearest); - double distanceMed = (distA + distB)/2; - if(A[Geom::Y] > B[Geom::Y]){ - distanceMed *= -1; + double distance_one = Geom::distance(A,nearest); + double distance_two = Geom::distance(B,nearest); + double distance_middle = (distance_one + distance_two)/2; + if(A[Geom::Y] > B[Geom::Y]) { + distance_middle *= -1; } - A[Geom::Y] = nearest[Geom::Y] - distanceMed; - B[Geom::Y] = nearest[Geom::Y] + distanceMed; - paramA.param_setValue(A, true); - paramB.param_setValue(B, true); + A[Geom::Y] = nearest[Geom::Y] - distance_middle; + B[Geom::Y] = nearest[Geom::Y] + distance_middle; + param_one.param_setValue(A, true); + param_two.param_setValue(B, true); } void @@ -326,31 +328,31 @@ LPELattice2::doBeforeEffect (SPLPEItem const* lpeitem) { original_bbox(lpeitem); setDefaults(); - Geom::Line vert(grid_point8x9.param_get_default(),grid_point10x11.param_get_default()); - Geom::Line horiz(grid_point24x26.param_get_default(),grid_point25x27.param_get_default()); - if(verticalMirror){ - vertical(grid_point0, grid_point1,vert); - vertical(grid_point2, grid_point3,vert); - vertical(grid_point4, grid_point5,vert); - vertical(grid_point6, grid_point7,vert); - vertical(grid_point12, grid_point13,vert); - vertical(grid_point14, grid_point15,vert); - vertical(grid_point16, grid_point17,vert); - vertical(grid_point18, grid_point19,vert); - vertical(grid_point24x26, grid_point25x27,vert); - vertical(grid_point28x30, grid_point29x31,vert); + Geom::Line vert(grid_point_8x9.param_get_default(),grid_point_10x11.param_get_default()); + Geom::Line horiz(grid_point_24x26.param_get_default(),grid_point_25x27.param_get_default()); + if(vertical_mirror) { + vertical(grid_point_0, grid_point_1,vert); + vertical(grid_point_2, grid_point_3,vert); + vertical(grid_point_4, grid_point_5,vert); + vertical(grid_point_6, grid_point_7,vert); + vertical(grid_point_12, grid_point_13,vert); + vertical(grid_point_14, grid_point_15,vert); + vertical(grid_point_16, grid_point_17,vert); + vertical(grid_point_18, grid_point_19,vert); + vertical(grid_point_24x26, grid_point_25x27,vert); + vertical(grid_point_28x30, grid_point_29x31,vert); } - if(horizontalMirror){ - horizontal(grid_point0, grid_point2,horiz); - horizontal(grid_point1, grid_point3,horiz); - horizontal(grid_point4, grid_point6,horiz); - horizontal(grid_point5, grid_point7,horiz); - horizontal(grid_point8x9, grid_point10x11,horiz); - horizontal(grid_point12, grid_point14,horiz); - horizontal(grid_point13, grid_point15,horiz); - horizontal(grid_point16, grid_point18,horiz); - horizontal(grid_point17, grid_point19,horiz); - horizontal(grid_point20x21, grid_point22x23,horiz); + if(horizontal_mirror) { + horizontal(grid_point_0, grid_point_2,horiz); + horizontal(grid_point_1, grid_point_3,horiz); + horizontal(grid_point_4, grid_point_6,horiz); + horizontal(grid_point_5, grid_point_7,horiz); + horizontal(grid_point_8x9, grid_point_10x11,horiz); + horizontal(grid_point_12, grid_point_14,horiz); + horizontal(grid_point_13, grid_point_15,horiz); + horizontal(grid_point_16, grid_point_18,horiz); + horizontal(grid_point_17, grid_point_19,horiz); + horizontal(grid_point_20x21, grid_point_22x23,horiz); } SPLPEItem * item = const_cast(lpeitem); item->apply_to_clippath(item); @@ -385,111 +387,111 @@ LPELattice2::setDefaults() (boundingbox_Y.max()-boundingbox_Y.min())/4*4+boundingbox_Y.min()); Geom::Point gp8x9((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*0+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*0+boundingbox_Y.min()); Geom::Point gp10x11((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*4+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*4+boundingbox_Y.min()); Geom::Point gp12((boundingbox_X.max()-boundingbox_X.min())/4*0+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); Geom::Point gp13((boundingbox_X.max()-boundingbox_X.min())/4*4+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); Geom::Point gp14((boundingbox_X.max()-boundingbox_X.min())/4*0+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); Geom::Point gp15((boundingbox_X.max()-boundingbox_X.min())/4*4+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); Geom::Point gp16((boundingbox_X.max()-boundingbox_X.min())/4*1+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); Geom::Point gp17((boundingbox_X.max()-boundingbox_X.min())/4*3+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); Geom::Point gp18((boundingbox_X.max()-boundingbox_X.min())/4*1+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); Geom::Point gp19((boundingbox_X.max()-boundingbox_X.min())/4*3+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); Geom::Point gp20x21((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); Geom::Point gp22x23((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); Geom::Point gp24x26((boundingbox_X.max()-boundingbox_X.min())/4*0+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); Geom::Point gp25x27((boundingbox_X.max()-boundingbox_X.min())/4*4+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); Geom::Point gp28x30((boundingbox_X.max()-boundingbox_X.min())/4*1+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); Geom::Point gp29x31((boundingbox_X.max()-boundingbox_X.min())/4*3+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); Geom::Point gp32x33x34x35((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); - - grid_point0.param_update_default(gp0); - grid_point1.param_update_default(gp1); - grid_point2.param_update_default(gp2); - grid_point3.param_update_default(gp3); - grid_point4.param_update_default(gp4); - grid_point5.param_update_default(gp5); - grid_point6.param_update_default(gp6); - grid_point7.param_update_default(gp7); - grid_point8x9.param_update_default(gp8x9); - grid_point10x11.param_update_default(gp10x11); - grid_point12.param_update_default(gp12); - grid_point13.param_update_default(gp13); - grid_point14.param_update_default(gp14); - grid_point15.param_update_default(gp15); - grid_point16.param_update_default(gp16); - grid_point17.param_update_default(gp17); - grid_point18.param_update_default(gp18); - grid_point19.param_update_default(gp19); - grid_point20x21.param_update_default(gp20x21); - grid_point22x23.param_update_default(gp22x23); - grid_point24x26.param_update_default(gp24x26); - grid_point25x27.param_update_default(gp25x27); - grid_point28x30.param_update_default(gp28x30); - grid_point29x31.param_update_default(gp29x31); - grid_point32x33x34x35.param_update_default(gp32x33x34x35); + (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); + + grid_point_0.param_update_default(gp0); + grid_point_1.param_update_default(gp1); + grid_point_2.param_update_default(gp2); + grid_point_3.param_update_default(gp3); + grid_point_4.param_update_default(gp4); + grid_point_5.param_update_default(gp5); + grid_point_6.param_update_default(gp6); + grid_point_7.param_update_default(gp7); + grid_point_8x9.param_update_default(gp8x9); + grid_point_10x11.param_update_default(gp10x11); + grid_point_12.param_update_default(gp12); + grid_point_13.param_update_default(gp13); + grid_point_14.param_update_default(gp14); + grid_point_15.param_update_default(gp15); + grid_point_16.param_update_default(gp16); + grid_point_17.param_update_default(gp17); + grid_point_18.param_update_default(gp18); + grid_point_19.param_update_default(gp19); + grid_point_20x21.param_update_default(gp20x21); + grid_point_22x23.param_update_default(gp22x23); + grid_point_24x26.param_update_default(gp24x26); + grid_point_25x27.param_update_default(gp25x27); + grid_point_28x30.param_update_default(gp28x30); + grid_point_29x31.param_update_default(gp29x31); + grid_point_32x33x34x35.param_update_default(gp32x33x34x35); } void LPELattice2::resetGrid() { - grid_point0.param_set_default(); - grid_point1.param_set_default(); - grid_point2.param_set_default(); - grid_point3.param_set_default(); - grid_point4.param_set_default(); - grid_point5.param_set_default(); - grid_point6.param_set_default(); - grid_point7.param_set_default(); - grid_point8x9.param_set_default(); - grid_point10x11.param_set_default(); - grid_point12.param_set_default(); - grid_point13.param_set_default(); - grid_point14.param_set_default(); - grid_point15.param_set_default(); - grid_point16.param_set_default(); - grid_point17.param_set_default(); - grid_point18.param_set_default(); - grid_point19.param_set_default(); - grid_point20x21.param_set_default(); - grid_point22x23.param_set_default(); - grid_point24x26.param_set_default(); - grid_point25x27.param_set_default(); - grid_point28x30.param_set_default(); - grid_point29x31.param_set_default(); - grid_point32x33x34x35.param_set_default(); + grid_point_0.param_set_default(); + grid_point_1.param_set_default(); + grid_point_2.param_set_default(); + grid_point_3.param_set_default(); + grid_point_4.param_set_default(); + grid_point_5.param_set_default(); + grid_point_6.param_set_default(); + grid_point_7.param_set_default(); + grid_point_8x9.param_set_default(); + grid_point_10x11.param_set_default(); + grid_point_12.param_set_default(); + grid_point_13.param_set_default(); + grid_point_14.param_set_default(); + grid_point_15.param_set_default(); + grid_point_16.param_set_default(); + grid_point_17.param_set_default(); + grid_point_18.param_set_default(); + grid_point_19.param_set_default(); + grid_point_20x21.param_set_default(); + grid_point_22x23.param_set_default(); + grid_point_24x26.param_set_default(); + grid_point_25x27.param_set_default(); + grid_point_28x30.param_set_default(); + grid_point_29x31.param_set_default(); + grid_point_32x33x34x35.param_set_default(); } void @@ -519,55 +521,55 @@ LPELattice2::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vectorget_pathvector()); } diff --git a/src/live_effects/lpe-lattice2.h b/src/live_effects/lpe-lattice2.h index 086bdab7e..ff2e75641 100644 --- a/src/live_effects/lpe-lattice2.h +++ b/src/live_effects/lpe-lattice2.h @@ -34,7 +34,7 @@ public: virtual ~LPELattice2(); virtual Geom::Piecewise > doEffect_pwd2 (Geom::Piecewise > const & pwd2_in); - + virtual void resetDefaults(SPItem const* item); virtual void doBeforeEffect(SPLPEItem const* lpeitem); @@ -49,46 +49,41 @@ public: virtual void setDefaults(); - virtual void on_expander_changed(); + virtual void onExpanderChanged(); virtual void resetGrid(); - //virtual void original_bbox(SPLPEItem const* lpeitem, bool absolute = false); - - //virtual void addCanvasIndicators(SPLPEItem const*/*lpeitem*/, std::vector &/*hp_vec*/); - - //virtual std::vector getHelperPaths(SPLPEItem const* lpeitem); protected: void addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector &hp_vec); private: - BoolParam horizontalMirror; - BoolParam verticalMirror; - PointParam grid_point0; - PointParam grid_point1; - PointParam grid_point2; - PointParam grid_point3; - PointParam grid_point4; - PointParam grid_point5; - PointParam grid_point6; - PointParam grid_point7; - PointParam grid_point8x9; - PointParam grid_point10x11; - PointParam grid_point12; - PointParam grid_point13; - PointParam grid_point14; - PointParam grid_point15; - PointParam grid_point16; - PointParam grid_point17; - PointParam grid_point18; - PointParam grid_point19; - PointParam grid_point20x21; - PointParam grid_point22x23; - PointParam grid_point24x26; - PointParam grid_point25x27; - PointParam grid_point28x30; - PointParam grid_point29x31; - PointParam grid_point32x33x34x35; + BoolParam horizontal_mirror; + BoolParam vertical_mirror; + PointParam grid_point_0; + PointParam grid_point_1; + PointParam grid_point_2; + PointParam grid_point_3; + PointParam grid_point_4; + PointParam grid_point_5; + PointParam grid_point_6; + PointParam grid_point_7; + PointParam grid_point_8x9; + PointParam grid_point_10x11; + PointParam grid_point_12; + PointParam grid_point_13; + PointParam grid_point_14; + PointParam grid_point_15; + PointParam grid_point_16; + PointParam grid_point_17; + PointParam grid_point_18; + PointParam grid_point_19; + PointParam grid_point_20x21; + PointParam grid_point_22x23; + PointParam grid_point_24x26; + PointParam grid_point_25x27; + PointParam grid_point_28x30; + PointParam grid_point_29x31; + PointParam grid_point_32x33x34x35; bool expanded; Gtk::Expander * expander; -- cgit v1.2.3 From 857b0edbfff90b9271be66f0ab8b86ff214b8740 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Fri, 10 Apr 2015 00:17:05 +0200 Subject: Fix coding style issues in roughen LPE (bzr r14048) --- src/live_effects/lpe-roughen.cpp | 206 +++++++++++++++++++-------------------- src/live_effects/lpe-roughen.h | 14 +-- 2 files changed, 110 insertions(+), 110 deletions(-) diff --git a/src/live_effects/lpe-roughen.cpp b/src/live_effects/lpe-roughen.cpp index 8cef9a3a3..9d1c3152b 100644 --- a/src/live_effects/lpe-roughen.cpp +++ b/src/live_effects/lpe-roughen.cpp @@ -39,36 +39,36 @@ LPERoughen::LPERoughen(LivePathEffectObject *lpeobject) unit(_("Unit"), _("Unit"), "unit", &wr, this), method(_("Method"), _("Division method"), "method", DMConverter, &wr, this, DM_SEGMENTS), - maxSegmentSize(_("Max. segment size"), _("Max. segment size"), - "maxSegmentSize", &wr, this, 10.), + max_segment_size(_("Max. segment size"), _("Max. segment size"), + "max_segment_size", &wr, this, 10.), segments(_("Number of segments"), _("Number of segments"), "segments", &wr, this, 2), - displaceX(_("Max. displacement in X"), _("Max. displacement in X"), - "displaceX", &wr, this, 10.), - displaceY(_("Max. displacement in Y"), _("Max. displacement in Y"), - "displaceY", &wr, this, 10.), - globalRandomize(_("Global randomize"), _("Global randomize"), - "globalRandomize", &wr, this, 1.), - shiftNodes(_("Shift nodes"), _("Shift nodes"), "shiftNodes", &wr, this, + displace_x(_("Max. displacement in X"), _("Max. displacement in X"), + "displace_x", &wr, this, 10.), + displace_y(_("Max. displacement in Y"), _("Max. displacement in Y"), + "displace_y", &wr, this, 10.), + global_randomize(_("Global randomize"), _("Global randomize"), + "global_randomize", &wr, this, 1.), + shift_nodes(_("Shift nodes"), _("Shift nodes"), "shift_nodes", &wr, this, true), - shiftNodeHandles(_("Shift node handles"), _("Shift node handles"), - "shiftNodeHandles", &wr, this, true) + shift_node_handles(_("Shift node handles"), _("Shift node handles"), + "shift_node_handles", &wr, this, true) { registerParameter(&unit); registerParameter(&method); - registerParameter(&maxSegmentSize); + registerParameter(&max_segment_size); registerParameter(&segments); - registerParameter(&displaceX); - registerParameter(&displaceY); - registerParameter(&globalRandomize); - registerParameter(&shiftNodes); - registerParameter(&shiftNodeHandles); - displaceX.param_set_range(0., Geom::infinity()); - displaceY.param_set_range(0., Geom::infinity()); - globalRandomize.param_set_range(0., Geom::infinity()); - maxSegmentSize.param_set_range(0., Geom::infinity()); - maxSegmentSize.param_set_increments(1, 1); - maxSegmentSize.param_set_digits(1); + registerParameter(&displace_x); + registerParameter(&displace_y); + registerParameter(&global_randomize); + registerParameter(&shift_nodes); + registerParameter(&shift_node_handles); + displace_x.param_set_range(0., Geom::infinity()); + displace_y.param_set_range(0., Geom::infinity()); + global_randomize.param_set_range(0., Geom::infinity()); + max_segment_size.param_set_range(0., Geom::infinity()); + max_segment_size.param_set_increments(1, 1); + max_segment_size.param_set_digits(1); segments.param_set_range(1, Geom::infinity()); segments.param_set_increments(1, 1); segments.param_set_digits(0); @@ -78,9 +78,9 @@ LPERoughen::~LPERoughen() {} void LPERoughen::doBeforeEffect(SPLPEItem const *lpeitem) { - displaceX.resetRandomizer(); - displaceY.resetRandomizer(); - globalRandomize.resetRandomizer(); + displace_x.resetRandomizer(); + displace_y.resetRandomizer(); + global_randomize.resetRandomizer(); srand(1); SPLPEItem * item = const_cast(lpeitem); item->apply_to_clippath(item); @@ -99,37 +99,37 @@ Gtk::Widget *LPERoughen::newWidget() Parameter *param = *it; Gtk::Widget *widg = dynamic_cast(param->param_newWidget()); if (param->param_key == "unit") { - Gtk::Label *unitLabel = Gtk::manage(new Gtk::Label( + Gtk::Label *unit_label = Gtk::manage(new Gtk::Label( Glib::ustring(_("Roughen unit")), Gtk::ALIGN_START)); - unitLabel->set_use_markup(true); - vbox->pack_start(*unitLabel, false, false, 2); + unit_label->set_use_markup(true); + vbox->pack_start(*unit_label, false, false, 2); vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_EXPAND_WIDGET); } if (param->param_key == "method") { - Gtk::Label *methodLabel = Gtk::manage(new Gtk::Label( + Gtk::Label *method_label = Gtk::manage(new Gtk::Label( Glib::ustring(_("Add nodes Subdivide each segment")), Gtk::ALIGN_START)); - methodLabel->set_use_markup(true); - vbox->pack_start(*methodLabel, false, false, 2); + method_label->set_use_markup(true); + vbox->pack_start(*method_label, false, false, 2); vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_EXPAND_WIDGET); } - if (param->param_key == "displaceX") { - Gtk::Label *displaceXLabel = Gtk::manage(new Gtk::Label( + if (param->param_key == "displace_x") { + Gtk::Label *displace_x_label = Gtk::manage(new Gtk::Label( Glib::ustring(_("Jitter nodes Move nodes/handles")), Gtk::ALIGN_START)); - displaceXLabel->set_use_markup(true); - vbox->pack_start(*displaceXLabel, false, false, 2); + displace_x_label->set_use_markup(true); + vbox->pack_start(*displace_x_label, false, false, 2); vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_EXPAND_WIDGET); } - if (param->param_key == "globalRandomize") { - Gtk::Label *displaceXLabel = Gtk::manage(new Gtk::Label( + if (param->param_key == "global_randomize") { + Gtk::Label *global_rand = Gtk::manage(new Gtk::Label( Glib::ustring(_("Extra roughen Add a extra layer of rough")), Gtk::ALIGN_START)); - displaceXLabel->set_use_markup(true); - vbox->pack_start(*displaceXLabel, false, false, 2); + global_rand->set_use_markup(true); + vbox->pack_start(*global_rand, false, false, 2); vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_EXPAND_WIDGET); } @@ -150,23 +150,23 @@ Gtk::Widget *LPERoughen::newWidget() return dynamic_cast(vbox); } -double LPERoughen::sign(double randNumber) +double LPERoughen::sign(double random_number) { if (rand() % 100 < 49) { - randNumber *= -1.; + random_number *= -1.; } - return randNumber; + return random_number; } Geom::Point LPERoughen::randomize() { Inkscape::Util::Unit const *svg_units = SP_ACTIVE_DESKTOP->namedview->svg_units; - double displaceXParsed = Inkscape::Util::Quantity::convert( - displaceX * globalRandomize, unit.get_abbreviation(), svg_units->abbr); - double displaceYParsed = Inkscape::Util::Quantity::convert( - displaceY * globalRandomize, unit.get_abbreviation(), svg_units->abbr); + double displace_x_parsed = Inkscape::Util::Quantity::convert( + displace_x * global_randomize, unit.get_abbreviation(), svg_units->abbr); + double displace_y_parsed = Inkscape::Util::Quantity::convert( + displace_y * global_randomize, unit.get_abbreviation(), svg_units->abbr); - Geom::Point output = Geom::Point(sign(displaceXParsed), sign(displaceYParsed)); + Geom::Point output = Geom::Point(sign(displace_x_parsed), sign(displace_y_parsed)); return output; } @@ -193,32 +193,32 @@ void LPERoughen::doEffect(SPCurve *curve) } } Geom::Point initialMove(0, 0); - if (shiftNodes) { + if (shift_nodes) { initialMove = randomize(); } Geom::Point initialPoint = curve_it1->initialPoint() + initialMove; nCurve->moveto(initialPoint); - Geom::Point A0(0, 0); - Geom::Point A1(0, 0); - Geom::Point A2(0, 0); - Geom::Point A3(0, 0); + Geom::Point point0(0, 0); + Geom::Point point1(0, 0); + Geom::Point point2(0, 0); + Geom::Point point3(0, 0); bool first = true; while (curve_it1 != curve_endit) { Geom::CubicBezier const *cubic = NULL; - A0 = curve_it1->initialPoint(); - A1 = curve_it1->initialPoint(); - A2 = curve_it1->finalPoint(); - A3 = curve_it1->finalPoint(); + point0 = curve_it1->initialPoint(); + point1 = curve_it1->initialPoint(); + point2 = curve_it1->finalPoint(); + point3 = curve_it1->finalPoint(); cubic = dynamic_cast(&*curve_it1); if (cubic) { - A1 = (*cubic)[1]; - if (shiftNodes && first) { - A1 = (*cubic)[1] + initialMove; + point1 = (*cubic)[1]; + if (shift_nodes && first) { + point1 = (*cubic)[1] + initialMove; } - A2 = (*cubic)[2]; - nCurve->curveto(A1, A2, A3); + point2 = (*cubic)[2]; + nCurve->curveto(point1, point2, point3); } else { - nCurve->lineto(A3); + nCurve->lineto(point3); } double length = Inkscape::Util::Quantity::convert( curve_it1->length(0.001), svg_units->abbr, unit.get_abbreviation()); @@ -226,7 +226,7 @@ void LPERoughen::doEffect(SPCurve *curve) if (method == DM_SEGMENTS) { splits = segments; } else { - splits = ceil(length / maxSegmentSize); + splits = ceil(length / max_segment_size); } for (unsigned int t = splits; t >= 1; t--) { if (t == 1 && splits != 1) { @@ -265,42 +265,42 @@ SPCurve *LPERoughen::addNodesAndJitter(const Geom::Curve *A, double t) { SPCurve *out = new SPCurve(); Geom::CubicBezier const *cubic = dynamic_cast(&*A); - Geom::Point A1(0, 0); - Geom::Point A2(0, 0); - Geom::Point A3(0, 0); - Geom::Point B1(0, 0); - Geom::Point B2(0, 0); - Geom::Point B3(0, 0); - if (shiftNodes) { - A3 = randomize(); - B3 = randomize(); + Geom::Point point1(0, 0); + Geom::Point point2(0, 0); + Geom::Point point3(0, 0); + Geom::Point point_b1(0, 0); + Geom::Point point_b2(0, 0); + Geom::Point point_b3(0, 0); + if (shift_nodes) { + point3 = randomize(); + point_b3 = randomize(); } - if (shiftNodeHandles) { - A1 = randomize(); - A2 = randomize(); - B1 = randomize(); - B2 = randomize(); + if (shift_node_handles) { + point1 = randomize(); + point2 = randomize(); + point_b1 = randomize(); + point_b2 = randomize(); } else { - A2 = A3; - B1 = A3; - B2 = B3; + point2 = point3; + point_b1 = point3; + point_b2 = point_b3; } if (cubic) { std::pair div = cubic->subdivide(t); std::vector seg1 = div.first.points(), seg2 = div.second.points(); out->moveto(seg1[0]); - out->curveto(seg1[1] + A1, seg1[2] + A2, seg1[3] + A3); - out->curveto(seg2[1] + B1, seg2[2], seg2[3]); - } else if (shiftNodeHandles) { + out->curveto(seg1[1] + point1, seg1[2] + point2, seg1[3] + point3); + out->curveto(seg2[1] + point_b1, seg2[2], seg2[3]); + } else if (shift_node_handles) { out->moveto(A->initialPoint()); - out->curveto(A->pointAt(t / 3) + A1, A->pointAt((t / 3) * 2) + A2, - A->pointAt(t) + A3); - out->curveto(A->pointAt(t + (t / 3)) + B1, A->pointAt(t + ((t / 3) * 2)), + out->curveto(A->pointAt(t / 3) + point1, A->pointAt((t / 3) * 2) + point2, + A->pointAt(t) + point3); + out->curveto(A->pointAt(t + (t / 3)) + point_b1, A->pointAt(t + ((t / 3) * 2)), A->finalPoint()); } else { out->moveto(A->initialPoint()); - out->lineto(A->pointAt(t) + A3); + out->lineto(A->pointAt(t) + point3); out->lineto(A->finalPoint()); } return out; @@ -310,33 +310,33 @@ SPCurve *LPERoughen::jitter(const Geom::Curve *A) { SPCurve *out = new SPCurve(); Geom::CubicBezier const *cubic = dynamic_cast(&*A); - Geom::Point A1(0, 0); - Geom::Point A2(0, 0); - Geom::Point A3(0, 0); - if (shiftNodes) { - A3 = randomize(); + Geom::Point point1(0, 0); + Geom::Point point2(0, 0); + Geom::Point point3(0, 0); + if (shift_nodes) { + point3 = randomize(); } - if (shiftNodeHandles) { - A1 = randomize(); - A2 = randomize(); + if (shift_node_handles) { + point1 = randomize(); + point2 = randomize(); } else { - A2 = A3; + point2 = point3; } if (cubic) { out->moveto((*cubic)[0]); - out->curveto((*cubic)[1] + A1, (*cubic)[2] + A2, (*cubic)[3] + A3); - } else if (shiftNodeHandles) { + out->curveto((*cubic)[1] + point1, (*cubic)[2] + point2, (*cubic)[3] + point3); + } else if (shift_node_handles) { out->moveto(A->initialPoint()); - out->curveto(A->pointAt(0.3333) + A1, A->pointAt(0.6666) + A2, - A->finalPoint() + A3); + out->curveto(A->pointAt(0.3333) + point1, A->pointAt(0.6666) + point2, + A->finalPoint() + point3); } else { out->moveto(A->initialPoint()); - out->lineto(A->finalPoint() + A3); + out->lineto(A->finalPoint() + point3); } return out; } -Geom::Point LPERoughen::tpoint(Geom::Point A, Geom::Point B, double t) +Geom::Point LPERoughen::tPoint(Geom::Point A, Geom::Point B, double t) { using Geom::X; using Geom::Y; diff --git a/src/live_effects/lpe-roughen.h b/src/live_effects/lpe-roughen.h index 74331f1ef..ed9f06cf7 100644 --- a/src/live_effects/lpe-roughen.h +++ b/src/live_effects/lpe-roughen.h @@ -41,19 +41,19 @@ public: virtual void doBeforeEffect(SPLPEItem const * lpeitem); virtual SPCurve *addNodesAndJitter(const Geom::Curve *A, double t); virtual SPCurve *jitter(const Geom::Curve *A); - virtual Geom::Point tpoint(Geom::Point A, Geom::Point B, double t = 0.5); + virtual Geom::Point tPoint(Geom::Point A, Geom::Point B, double t = 0.5); virtual Gtk::Widget *newWidget(); private: UnitParam unit; EnumParam method; - ScalarParam maxSegmentSize; + ScalarParam max_segment_size; ScalarParam segments; - RandomParam displaceX; - RandomParam displaceY; - RandomParam globalRandomize; - BoolParam shiftNodes; - BoolParam shiftNodeHandles; + RandomParam displace_x; + RandomParam displace_y; + RandomParam global_randomize; + BoolParam shift_nodes; + BoolParam shift_node_handles; LPERoughen(const LPERoughen &); LPERoughen &operator=(const LPERoughen &); -- cgit v1.2.3 From 9c184a450842df13226e870e6e50c0515e53a659 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20W=C3=BCst?= Date: Fri, 10 Apr 2015 16:51:16 +0200 Subject: Fixes bug #1409568: added possibility to use multiple pens (when using pen plotters, cutting plotters ignore it) via marking layers with pen information Fixed bugs: - https://launchpad.net/bugs/1409568 (bzr r14049) --- share/extensions/hpgl_encoder.py | 76 +++++++++++++++++++++++----------------- share/extensions/hpgl_output.py | 4 +-- share/extensions/plotter.py | 15 ++++---- 3 files changed, 53 insertions(+), 42 deletions(-) diff --git a/share/extensions/hpgl_encoder.py b/share/extensions/hpgl_encoder.py index a16561e97..75c5fa889 100644 --- a/share/extensions/hpgl_encoder.py +++ b/share/extensions/hpgl_encoder.py @@ -23,7 +23,6 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import math import re import string -#from StringIO import StringIO # local libraries import bezmisc import cspsubdiv @@ -66,6 +65,7 @@ class hpglEncoder: self.sizeY = 'False' self.dryRun = True self.lastPoint = [0, 0, 0] + self.lastPen = -1 self.offsetX = 0 self.offsetY = 0 self.scaleX = self.options.resolutionX / effect.unittouu("1.0in") # dots per inch to dots per user unit @@ -109,7 +109,7 @@ class hpglEncoder: # dryRun to find edges groupmat = [[self.mirrorX * self.scaleX * self.viewBoxTransformX, 0.0, 0.0], [0.0, self.mirrorY * self.scaleY * self.viewBoxTransformY, 0.0]] groupmat = simpletransform.composeTransform(groupmat, simpletransform.parseTransform('rotate(' + self.options.orientation + ')')) - self.vData = [['', -1.0, -1.0], ['', -1.0, -1.0], ['', -1.0, -1.0], ['', -1.0, -1.0]] + self.vData = [['', 'False', 0, 0], ['', 'False', 0, 0], ['', 'False', 0, 0], ['', 'False', 0, 0]] self.processGroups(self.doc, groupmat) if self.divergenceX == 'False' or self.divergenceY == 'False' or self.sizeX == 'False' or self.sizeY == 'False': raise Exception('NO_PATHS') @@ -156,11 +156,11 @@ class hpglEncoder: groupmat = [[self.mirrorX * self.scaleX * self.viewBoxTransformX, 0.0, -self.divergenceX + self.offsetX], [0.0, self.mirrorY * self.scaleY * self.viewBoxTransformY, -self.divergenceY + self.offsetY]] groupmat = simpletransform.composeTransform(groupmat, simpletransform.parseTransform('rotate(' + self.options.orientation + ')')) - self.vData = [['', -1.0, -1.0], ['', -1.0, -1.0], ['', -1.0, -1.0], ['', -1.0, -1.0]] + self.vData = [['', 'False', 0, 0], ['', 'False', 0, 0], ['', 'False', 0, 0], ['', 'False', 0, 0]] # add move to zero point and precut if self.toolOffset > 0.0 and self.options.precut: if self.options.center: - # position precut outside of drawing plus one times the tooloffset + # position precut outside of drawing plus one time the tooloffset if self.offsetX >= 0.0: precutX = self.offsetX + self.toolOffset else: @@ -169,17 +169,15 @@ class hpglEncoder: precutY = self.offsetY + self.toolOffset else: precutY = self.offsetY - self.toolOffset - self.processOffset('PU', precutX, precutY) - self.processOffset('PD', precutX, precutY + self.toolOffset * 8) + self.processOffset('PU', precutX, precutY, self.options.pen) + self.processOffset('PD', precutX, precutY + self.toolOffset * 8, self.options.pen) else: - self.processOffset('PU', 0, 0) - self.processOffset('PD', 0, self.toolOffset * 8) - else: - self.processOffset('PU', 0, 0) + self.processOffset('PU', 0, 0, self.options.pen) + self.processOffset('PD', 0, self.toolOffset * 8, self.options.pen) # start conversion self.processGroups(self.doc, groupmat) # shift an empty node in in order to process last node in cache - self.processOffset('PU', 0, 0) + self.processOffset('PU', 0, 0, 0) if self.options.debug: return self.hpgl, self else: @@ -190,7 +188,7 @@ class hpglEncoder: paths = [] for node in doc: if (node.tag == inkex.addNS('g', 'svg') and self.isGroupVisible(node)) or node.tag == inkex.addNS('path', 'svg'): - paths.append([node.tag, node, self.mergeTransform(node, groupmat)]) + paths.append([node.tag, node, self.mergeTransform(node, groupmat), self.getPenNumber(node)]) doc = '' hasGroups = True while hasGroups: @@ -200,11 +198,19 @@ class hpglEncoder: hasGroups = True for path in paths[i][1]: if (path.tag == inkex.addNS('g', 'svg') and self.isGroupVisible(path)) or path.tag == inkex.addNS('path', 'svg'): - paths.append([path.tag, path, self.mergeTransform(path, paths[i][2])]) + paths.insert(i + 1, [path.tag, path, self.mergeTransform(path, paths[i][2]), paths[i][3]]) paths[i][0] = '' for node in paths: if node[0] == inkex.addNS('path', 'svg'): - self.processPath(node[1], node[2]) + self.processPath(node[1], node[2], node[3]) + + def getPenNumber(self, doc): + penNum = str(doc.get('{' + inkex.NSS['inkscape'] + '}label')).lower().strip(' \t\n\r') + if re.search(r'( |\A)pen *\d+( |\Z)', penNum): + penNum = re.sub(r'(.* |\A)pen *(\d+)( .*|\Z)', r'\2', penNum, 1) + return int(penNum) + else: + return self.options.pen def mergeTransform(self, doc, matrix): # get and merge two matrixes into one @@ -222,7 +228,7 @@ class hpglEncoder: return False return True - def processPath(self, node, mat): + def processPath(self, node, mat, pen): # process path path = node.get('d') if path: @@ -239,7 +245,7 @@ class hpglEncoder: posX, posY = singlePathPoint[1] # check if point is repeating, if so, ignore if int(round(posX)) != int(round(oldPosX)) or int(round(posY)) != int(round(oldPosY)): - self.processOffset(cmd, posX, posY) + self.processOffset(cmd, posX, posY, pen) cmd = 'PD' oldPosX = posX oldPosY = posY @@ -255,10 +261,10 @@ class hpglEncoder: overcutLength += self.getLength(oldPosX, oldPosY, posX, posY) if overcutLength >= self.overcut: newLength = self.changeLength(oldPosX, oldPosY, posX, posY, - (overcutLength - self.overcut)) - self.processOffset(cmd, newLength[0], newLength[1]) + self.processOffset(cmd, newLength[0], newLength[1], pen) break else: - self.processOffset(cmd, posX, posY) + self.processOffset(cmd, posX, posY, pen) oldPosX = posX oldPosY = posY @@ -277,34 +283,34 @@ class hpglEncoder: y = y2 + (y2 - y1) / self.getLength(x1, y1, x2, y2, False) * offset return [x, y] - def processOffset(self, cmd, posX, posY): + def processOffset(self, cmd, posX, posY, pen): # calculate offset correction (or dont) if self.toolOffset == 0.0 or self.dryRun: - self.storePoint(cmd, posX, posY) + self.storePoint(cmd, posX, posY, pen) else: # insert data into cache self.vData.pop(0) - self.vData.insert(3, [cmd, posX, posY]) + self.vData.insert(3, [cmd, posX, posY, pen]) # decide if enough data is availabe - if self.vData[2][1] != -1.0: - if self.vData[1][1] == -1.0: - self.storePoint(self.vData[2][0], self.vData[2][1], self.vData[2][2]) + if self.vData[2][1] != 'False': + if self.vData[1][1] == 'False': + self.storePoint(self.vData[2][0], self.vData[2][1], self.vData[2][2], self.vData[2][3]) else: # perform tool offset correction (It's a *tad* complicated, if you want to understand it draw the data as lines on paper) if self.vData[2][0] == 'PD': # If the 3rd entry in the cache is a pen down command make the line longer by the tool offset pointThree = self.changeLength(self.vData[1][1], self.vData[1][2], self.vData[2][1], self.vData[2][2], self.toolOffset) - self.storePoint('PD', pointThree[0], pointThree[1]) - elif self.vData[0][1] != -1.0: + self.storePoint('PD', pointThree[0], pointThree[1], self.vData[2][3]) + elif self.vData[0][1] != 'False': # Elif the 1st entry in the cache is filled with data and the 3rd entry is a pen up command shift # the 3rd entry by the current tool offset position according to the 2nd command pointThree = self.changeLength(self.vData[0][1], self.vData[0][2], self.vData[1][1], self.vData[1][2], self.toolOffset) pointThree[0] = self.vData[2][1] - (self.vData[1][1] - pointThree[0]) pointThree[1] = self.vData[2][2] - (self.vData[1][2] - pointThree[1]) - self.storePoint('PU', pointThree[0], pointThree[1]) + self.storePoint('PU', pointThree[0], pointThree[1], self.vData[2][3]) else: # Else just write the 3rd entry pointThree = [self.vData[2][1], self.vData[2][2]] - self.storePoint('PU', pointThree[0], pointThree[1]) + self.storePoint('PU', pointThree[0], pointThree[1], self.vData[2][3]) if self.vData[3][0] == 'PD': # If the 4th entry in the cache is a pen down command guide tool to next line with a circle between the prolonged 3rd and 4th entry if self.getLength(self.vData[2][1], self.vData[2][2], self.vData[3][1], self.vData[3][2]) >= self.toolOffset: @@ -324,16 +330,16 @@ class hpglEncoder: if angleVector >= 0: angle = angleStart + self.toolOffsetFlat while angle < angleStart + angleVector: - self.storePoint('PD', self.vData[2][1] + math.cos(angle) * self.toolOffset, self.vData[2][2] + math.sin(angle) * self.toolOffset) + self.storePoint('PD', self.vData[2][1] + math.cos(angle) * self.toolOffset, self.vData[2][2] + math.sin(angle) * self.toolOffset, self.vData[2][3]) angle += self.toolOffsetFlat else: angle = angleStart - self.toolOffsetFlat while angle > angleStart + angleVector: - self.storePoint('PD', self.vData[2][1] + math.cos(angle) * self.toolOffset, self.vData[2][2] + math.sin(angle) * self.toolOffset) + self.storePoint('PD', self.vData[2][1] + math.cos(angle) * self.toolOffset, self.vData[2][2] + math.sin(angle) * self.toolOffset, self.vData[2][3]) angle -= self.toolOffsetFlat - self.storePoint('PD', pointFour[0], pointFour[1]) + self.storePoint('PD', pointFour[0], pointFour[1], self.vData[3][3]) - def storePoint(self, command, x, y): + def storePoint(self, command, x, y, pen): x = int(round(x)) y = int(round(y)) # skip when no change in movement @@ -357,11 +363,15 @@ class hpglEncoder: x = 0 if y < 0: y = 0 + # select correct pen + if self.lastPen != pen: + self.hpgl += ';SP%d' % pen # do not repeat command - if command == 'PD' and self.lastPoint[0] == 'PD': + if command == 'PD' and self.lastPoint[0] == 'PD' and self.lastPen == pen: self.hpgl += ',%d,%d' % (x, y) else: self.hpgl += ';%s%d,%d' % (command, x, y) + self.lastPen = pen self.lastPoint = [command, x, y] # vim: expandtab shiftwidth=4 tabstop=8 softtabstop=4 fileencoding=utf-8 textwidth=99 \ No newline at end of file diff --git a/share/extensions/hpgl_output.py b/share/extensions/hpgl_output.py index c6713cb65..fc4f248af 100755 --- a/share/extensions/hpgl_output.py +++ b/share/extensions/hpgl_output.py @@ -62,12 +62,12 @@ class HpglOutput(inkex.Effect): type, value, traceback = sys.exc_info() raise ValueError, ("", type, value), traceback # convert raw HPGL to HPGL - hpglInit = 'IN;SP%d' % self.options.pen + hpglInit = 'IN' if self.options.force > 0: hpglInit += ';FS%d' % self.options.force if self.options.speed > 0: hpglInit += ';VS%d' % self.options.speed - self.hpgl = hpglInit + self.hpgl + ';PU0,0;SP0;IN;' + self.hpgl = hpglInit + self.hpgl + ';SP0;PU0,0;IN; ' def output(self): # print to file diff --git a/share/extensions/plotter.py b/share/extensions/plotter.py index 7e24d0824..2e4fd5dd5 100644 --- a/share/extensions/plotter.py +++ b/share/extensions/plotter.py @@ -98,12 +98,12 @@ class Plot(inkex.Effect): def convertToHpgl(self): # convert raw HPGL to HPGL - hpglInit = 'IN;SP%d' % self.options.pen + hpglInit = 'IN' if self.options.force > 0: hpglInit += ';FS%d' % self.options.force if self.options.speed > 0: hpglInit += ';VS%d' % self.options.speed - self.hpgl = hpglInit + self.hpgl + ';PU0,0;SP0;IN; ' + self.hpgl = hpglInit + self.hpgl + ';SP0;PU0,0;IN; ' def convertToDmpl(self): # convert HPGL to DMPL @@ -119,22 +119,23 @@ class Plot(inkex.Effect): # Z = Reset plotter # n,n, = Coordinate pair self.hpgl = self.hpgl.replace(';', ',') + self.hpgl = self.hpgl.replace('SP', 'P') self.hpgl = self.hpgl.replace('PU', 'U') self.hpgl = self.hpgl.replace('PD', 'D') - dmplInit = ';:HAL0P%d' % self.options.pen + dmplInit = ';:HAL0' if self.options.speed > 0: dmplInit += 'V%d' % self.options.speed dmplInit += 'EC1' - self.hpgl = dmplInit + self.hpgl[1:] + ',U0,0,P0Z ' + self.hpgl = dmplInit + self.hpgl[1:] + ',P0,U0,0,Z ' def convertToKNK(self): # convert HPGL to KNK Plotter Language - hpglInit = 'ZG;SP%d' % self.options.pen + hpglInit = 'ZG' if self.options.force > 0: hpglInit += ';FS%d' % self.options.force if self.options.speed > 0: hpglInit += ';VS%d' % self.options.speed - self.hpgl = hpglInit + self.hpgl + ';PU0,0;SP0;@ ' + self.hpgl = hpglInit + self.hpgl + ';SP0;PU0,0;@ ' def sendHpglToSerial(self): # gracefully exit script when pySerial is missing @@ -223,7 +224,7 @@ class Plot(inkex.Effect): inkex.errormsg(' Flatness: ' + str(debugObject.flat) + ' plotter steps') inkex.errormsg(' Tool offset flatness: ' + str(debugObject.toolOffsetFlat) + ' plotter steps') inkex.errormsg("\n" + self.options.commandLanguage + " data:\n") - inkex.errormsg(self.hpgl) + inkex.errormsg(self.options.initCommands + self.hpgl) if __name__ == '__main__': # start extension -- cgit v1.2.3 From a729eeb50789ae7bc4e7f5a0c69f62c50212ab87 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20W=C3=BCst?= Date: Fri, 10 Apr 2015 18:55:39 +0200 Subject: added option to set non-standard bytesize, stopbits and parity settings (bzr r14050) --- share/extensions/plotter.inx | 20 +++++++++- share/extensions/plotter.py | 91 +++++++++++++++++++++++++++++++------------- 2 files changed, 84 insertions(+), 27 deletions(-) diff --git a/share/extensions/plotter.inx b/share/extensions/plotter.inx index 5a6d8ce06..cc916fe08 100644 --- a/share/extensions/plotter.inx +++ b/share/extensions/plotter.inx @@ -27,7 +27,25 @@ 57600 115200 - + + 8 Bits + 7 Bits + 6 Bits + 5 Bits + + + 1 Bit + 1.5 Bits + 2 Bits + + + None + Even + Odd + Mark + Space + + <_item value="xonxoff">Software (XON/XOFF) <_item value="rtscts">Hardware (RTS/CTS) <_item value="dsrdtrrtscts">Hardware (DSR/DTR + RTS/CTS) diff --git a/share/extensions/plotter.py b/share/extensions/plotter.py index 2e4fd5dd5..c0f180f60 100644 --- a/share/extensions/plotter.py +++ b/share/extensions/plotter.py @@ -34,27 +34,30 @@ class Plot(inkex.Effect): def __init__(self): inkex.Effect.__init__(self) - self.OptionParser.add_option('--tab', action='store', type='string', dest='tab') - self.OptionParser.add_option('--serialPort', action='store', type='string', dest='serialPort', default='COM1', help='Serial port') - self.OptionParser.add_option('--serialBaudRate', action='store', type='string', dest='serialBaudRate', default='9600', help='Serial Baud rate') - self.OptionParser.add_option('--flowControl', action='store', type='string', dest='flowControl', default='0', help='Flow control') - self.OptionParser.add_option('--commandLanguage', action='store', type='string', dest='commandLanguage', default='hpgl', help='Command Language') - self.OptionParser.add_option('--initCommands', action='store', type='string', dest='initCommands', default='', help='Initialization commands') - self.OptionParser.add_option('--resolutionX', action='store', type='float', dest='resolutionX', default=1016.0, help='Resolution X (dpi)') - self.OptionParser.add_option('--resolutionY', action='store', type='float', dest='resolutionY', default=1016.0, help='Resolution Y (dpi)') - self.OptionParser.add_option('--pen', action='store', type='int', dest='pen', default=1, help='Pen number') - self.OptionParser.add_option('--force', action='store', type='int', dest='force', default=24, help='Pen force (g)') - self.OptionParser.add_option('--speed', action='store', type='int', dest='speed', default=20, help='Pen speed (cm/s)') - self.OptionParser.add_option('--orientation', action='store', type='string', dest='orientation', default='90', help='Rotation (Clockwise)') - self.OptionParser.add_option('--mirrorX', action='store', type='inkbool', dest='mirrorX', default='FALSE', help='Mirror X axis') - self.OptionParser.add_option('--mirrorY', action='store', type='inkbool', dest='mirrorY', default='FALSE', help='Mirror Y axis') - self.OptionParser.add_option('--center', action='store', type='inkbool', dest='center', default='FALSE', help='Center zero point') - self.OptionParser.add_option('--overcut', action='store', type='float', dest='overcut', default=1.0, help='Overcut (mm)') - self.OptionParser.add_option('--toolOffset', action='store', type='float', dest='toolOffset', default=0.25, help='Tool offset (mm)') - self.OptionParser.add_option('--precut', action='store', type='inkbool', dest='precut', default='TRUE', help='Use precut') - self.OptionParser.add_option('--flat', action='store', type='float', dest='flat', default=1.2, help='Curve flatness') - self.OptionParser.add_option('--autoAlign', action='store', type='inkbool', dest='autoAlign', default='TRUE', help='Auto align') - self.OptionParser.add_option('--debug', action='store', type='inkbool', dest='debug', default='FALSE', help='Show debug information') + self.OptionParser.add_option('--tab', action='store', type='string', dest='tab') + self.OptionParser.add_option('--serialPort', action='store', type='string', dest='serialPort', default='COM1', help='Serial port') + self.OptionParser.add_option('--serialBaudRate', action='store', type='string', dest='serialBaudRate', default='9600', help='Serial Baud rate') + self.OptionParser.add_option('--serialByteSize', action='store', type='string', dest='serialByteSize', default='eight', help='Serial byte size') + self.OptionParser.add_option('--serialStopBits', action='store', type='string', dest='serialStopBits', default='one', help='Serial stop bits') + self.OptionParser.add_option('--serialParity', action='store', type='string', dest='serialParity', default='none', help='Serial parity') + self.OptionParser.add_option('--serialFlowControl', action='store', type='string', dest='serialFlowControl', default='0', help='Flow control') + self.OptionParser.add_option('--commandLanguage', action='store', type='string', dest='commandLanguage', default='hpgl', help='Command Language') + self.OptionParser.add_option('--initCommands', action='store', type='string', dest='initCommands', default='', help='Initialization commands') + self.OptionParser.add_option('--resolutionX', action='store', type='float', dest='resolutionX', default=1016.0, help='Resolution X (dpi)') + self.OptionParser.add_option('--resolutionY', action='store', type='float', dest='resolutionY', default=1016.0, help='Resolution Y (dpi)') + self.OptionParser.add_option('--pen', action='store', type='int', dest='pen', default=1, help='Pen number') + self.OptionParser.add_option('--force', action='store', type='int', dest='force', default=24, help='Pen force (g)') + self.OptionParser.add_option('--speed', action='store', type='int', dest='speed', default=20, help='Pen speed (cm/s)') + self.OptionParser.add_option('--orientation', action='store', type='string', dest='orientation', default='90', help='Rotation (Clockwise)') + self.OptionParser.add_option('--mirrorX', action='store', type='inkbool', dest='mirrorX', default='FALSE', help='Mirror X axis') + self.OptionParser.add_option('--mirrorY', action='store', type='inkbool', dest='mirrorY', default='FALSE', help='Mirror Y axis') + self.OptionParser.add_option('--center', action='store', type='inkbool', dest='center', default='FALSE', help='Center zero point') + self.OptionParser.add_option('--overcut', action='store', type='float', dest='overcut', default=1.0, help='Overcut (mm)') + self.OptionParser.add_option('--toolOffset', action='store', type='float', dest='toolOffset', default=0.25, help='Tool offset (mm)') + self.OptionParser.add_option('--precut', action='store', type='inkbool', dest='precut', default='TRUE', help='Use precut') + self.OptionParser.add_option('--flat', action='store', type='float', dest='flat', default=1.2, help='Curve flatness') + self.OptionParser.add_option('--autoAlign', action='store', type='inkbool', dest='autoAlign', default='TRUE', help='Auto align') + self.OptionParser.add_option('--debug', action='store', type='inkbool', dest='debug', default='FALSE', help='Show debug information') def effect(self): # get hpgl data @@ -147,17 +150,49 @@ class Plot(inkex.Effect): + "\n2. Extract the \"serial\" subfolder from the zip to the following folder: C:\\[Program files]\\inkscape\\python\\Lib\\" + "\n3. Restart Inkscape.")) return - # send data to plotter + # init serial framework mySerial = serial.Serial() + # set serial port mySerial.port = self.options.serialPort + # set baudrate mySerial.baudrate = self.options.serialBaudRate + # set bytesize + if self.options.serialByteSize == 'five': + mySerial.bytesize = serial.FIVEBITS + if self.options.serialByteSize == 'six': + mySerial.bytesize = serial.SIXBITS + if self.options.serialByteSize == 'seven': + mySerial.bytesize = serial.SEVENBITS + if self.options.serialByteSize == 'eight': + mySerial.bytesize = serial.EIGHTBITS + # set stopbits + if self.options.serialStopBits == 'one': + mySerial.stopbits = serial.STOPBITS_ONE + if self.options.serialStopBits == 'onePointFive': + mySerial.stopbits = serial.STOPBITS_ONE_POINT_FIVE + if self.options.serialStopBits == 'two': + mySerial.stopbits = serial.STOPBITS_TWO + # set parity + if self.options.serialParity == 'none': + mySerial.parity = serial.PARITY_NONE + if self.options.serialParity == 'even': + mySerial.parity = serial.PARITY_EVEN + if self.options.serialParity == 'odd': + mySerial.parity = serial.PARITY_ODD + if self.options.serialParity == 'mark': + mySerial.parity = serial.PARITY_MARK + if self.options.serialParity == 'space': + mySerial.parity = serial.PARITY_SPACE + # set short timeout to avoid locked up interface mySerial.timeout = 0.1 - if self.options.flowControl == 'xonxoff': + # set flow control + if self.options.serialFlowControl == 'xonxoff': mySerial.xonxoff = True - if self.options.flowControl == 'rtscts' or self.options.flowControl == 'dsrdtrrtscts': + if self.options.serialFlowControl == 'rtscts' or self.options.serialFlowControl == 'dsrdtrrtscts': mySerial.rtscts = True - if self.options.flowControl == 'dsrdtrrtscts': + if self.options.serialFlowControl == 'dsrdtrrtscts': mySerial.dsrdtr = True + # try to establish connection try: mySerial.open() except Exception as inst: @@ -167,6 +202,7 @@ class Plot(inkex.Effect): else: type, value, traceback = sys.exc_info() raise ValueError, ('', type, value), traceback + # send data to plotter if self.options.initCommands != '': mySerial.write(self.options.initCommands.decode('string_escape')) mySerial.write(self.hpgl) @@ -178,7 +214,10 @@ class Plot(inkex.Effect): inkex.errormsg("---------------------------------\nDebug information\n---------------------------------\n\nSettings:\n") inkex.errormsg(' Serial Port: ' + self.options.serialPort) inkex.errormsg(' Serial baud rate: ' + self.options.serialBaudRate) - inkex.errormsg(' Flow control: ' + self.options.flowControl) + inkex.errormsg(' Serial byte size: ' + self.options.serialByteSize + ' Bits') + inkex.errormsg(' Serial stop bits: ' + self.options.serialStopBits + ' Bits') + inkex.errormsg(' Serial parity: ' + self.options.serialParity) + inkex.errormsg(' Serial Flow control: ' + self.options.serialFlowControl) inkex.errormsg(' Command language: ' + self.options.commandLanguage) inkex.errormsg(' Initialization commands: ' + self.options.initCommands) inkex.errormsg(' Resolution X (dpi): ' + str(self.options.resolutionX)) -- cgit v1.2.3 From fb014446df14a373bd1a4f8a9bb970ff730b024d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20W=C3=BCst?= Date: Fri, 10 Apr 2015 19:11:00 +0200 Subject: fixed bug: when no tool offset is used uninitialize commands (SP0;PU0,0) are sent twice (bzr r14051) --- share/extensions/hpgl_encoder.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/share/extensions/hpgl_encoder.py b/share/extensions/hpgl_encoder.py index 75c5fa889..83b1b7297 100644 --- a/share/extensions/hpgl_encoder.py +++ b/share/extensions/hpgl_encoder.py @@ -177,7 +177,8 @@ class hpglEncoder: # start conversion self.processGroups(self.doc, groupmat) # shift an empty node in in order to process last node in cache - self.processOffset('PU', 0, 0, 0) + if self.toolOffset > 0.0 and not self.dryRun: + self.processOffset('PU', 0, 0, 0) if self.options.debug: return self.hpgl, self else: -- cgit v1.2.3 From cbbae063a9be5015fbc290b318aa9371e2f2a5ab Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Fri, 10 Apr 2015 19:25:52 +0200 Subject: Fix coding style issues in perspective/envelope LPE (bzr r14052) --- src/live_effects/lpe-perspective-envelope.cpp | 273 +++++++++++++------------- src/live_effects/lpe-perspective-envelope.h | 18 +- 2 files changed, 147 insertions(+), 144 deletions(-) diff --git a/src/live_effects/lpe-perspective-envelope.cpp b/src/live_effects/lpe-perspective-envelope.cpp index b5885bdb3..4eac2d6eb 100644 --- a/src/live_effects/lpe-perspective-envelope.cpp +++ b/src/live_effects/lpe-perspective-envelope.cpp @@ -1,6 +1,6 @@ /** \file * LPE implementation - + */ /* * Authors: @@ -8,8 +8,8 @@ * Aaron Spike, aaron@ekips.org from envelope and perspective phyton code * Dmitry Platonov, shadowjack@mail.ru, 2006 perspective approach & math * Jose Hevia (freon) Transform algorithm from envelope - * - * Copyright (C) 2007-2014 Authors + * + * Copyright (C) 2007-2014 Authors * * Released under GNU GPL, read the file 'COPYING' for more information */ @@ -27,8 +27,8 @@ namespace Inkscape { namespace LivePathEffect { enum DeformationType { - DEFORMATION_PERSPECTIVE, - DEFORMATION_ENVELOPE + DEFORMATION_PERSPECTIVE, + DEFORMATION_ENVELOPE }; static const Util::EnumData DeformationTypeData[] = { @@ -42,52 +42,53 @@ LPEPerspectiveEnvelope::LPEPerspectiveEnvelope(LivePathEffectObject *lpeobject) Effect(lpeobject), // initialise your parameters here: deform_type(_("Type"), _("Select the type of deformation"), "deform_type", DeformationTypeConverter, &wr, this, DEFORMATION_PERSPECTIVE), - Up_Left_Point(_("Top Left"), _("Top Left - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "Up_Left_Point", &wr, this), - Up_Right_Point(_("Top Right"), _("Top Right - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "Up_Right_Point", &wr, this), - Down_Left_Point(_("Down Left"), _("Down Left - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "Down_Left_Point", &wr, this), - Down_Right_Point(_("Down Right"), _("Down Right - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "Down_Right_Point", &wr, this) + up_left_point(_("Top Left"), _("Top Left - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "up_left_point", &wr, this), + up_right_point(_("Top Right"), _("Top Right - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "up_right_point", &wr, this), + down_left_point(_("Down Left"), _("Down Left - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "down_left_point", &wr, this), + down_right_point(_("Down Right"), _("Down Right - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "down_right_point", &wr, this) { // register all your parameters here, so Inkscape knows which parameters this effect has: registerParameter(&deform_type); - registerParameter(&Up_Left_Point); - registerParameter(&Up_Right_Point); - registerParameter(&Down_Left_Point); - registerParameter(&Down_Right_Point); + registerParameter(&up_left_point); + registerParameter(&up_right_point); + registerParameter(&down_left_point); + registerParameter(&down_right_point); } LPEPerspectiveEnvelope::~LPEPerspectiveEnvelope() { } -void LPEPerspectiveEnvelope::doEffect(SPCurve *curve) { +void LPEPerspectiveEnvelope::doEffect(SPCurve *curve) +{ using Geom::X; using Geom::Y; double projmatrix[3][3]; - if(deform_type == DEFORMATION_PERSPECTIVE){ + if(deform_type == DEFORMATION_PERSPECTIVE) { std::vector handles(4); - handles[0] = Down_Left_Point; - handles[1] = Up_Left_Point; - handles[2] = Up_Right_Point; - handles[3] = Down_Right_Point; - std::vector sourceHandles(4); - sourceHandles[0] = Geom::Point(boundingbox_X.min(), boundingbox_Y.max()); - sourceHandles[1] = Geom::Point(boundingbox_X.min(), boundingbox_Y.min()); - sourceHandles[2] = Geom::Point(boundingbox_X.max(), boundingbox_Y.min()); - sourceHandles[3] = Geom::Point(boundingbox_X.max(), boundingbox_Y.max()); + handles[0] = down_left_point; + handles[1] = up_left_point; + handles[2] = up_right_point; + handles[3] = down_right_point; + std::vector source_handles(4); + source_handles[0] = Geom::Point(boundingbox_X.min(), boundingbox_Y.max()); + source_handles[1] = Geom::Point(boundingbox_X.min(), boundingbox_Y.min()); + source_handles[2] = Geom::Point(boundingbox_X.max(), boundingbox_Y.min()); + source_handles[3] = Geom::Point(boundingbox_X.max(), boundingbox_Y.max()); double solmatrix[8][8] = {{0}}; double free_term[8] = {0}; double gslSolmatrix[64]; - for(unsigned int i = 0; i < 4; ++i){ - solmatrix[i][0] = sourceHandles[i][X]; - solmatrix[i][1] = sourceHandles[i][Y]; + for(unsigned int i = 0; i < 4; ++i) { + solmatrix[i][0] = source_handles[i][X]; + solmatrix[i][1] = source_handles[i][Y]; solmatrix[i][2] = 1; - solmatrix[i][6] = -handles[i][X] * sourceHandles[i][X]; - solmatrix[i][7] = -handles[i][X] * sourceHandles[i][Y]; - solmatrix[i+4][3] = sourceHandles[i][X]; - solmatrix[i+4][4] = sourceHandles[i][Y]; + solmatrix[i][6] = -handles[i][X] * source_handles[i][X]; + solmatrix[i][7] = -handles[i][X] * source_handles[i][Y]; + solmatrix[i+4][3] = source_handles[i][X]; + solmatrix[i+4][4] = source_handles[i][Y]; solmatrix[i+4][5] = 1; - solmatrix[i+4][6] = -handles[i][Y] * sourceHandles[i][X]; - solmatrix[i+4][7] = -handles[i][Y] * sourceHandles[i][Y]; + solmatrix[i+4][6] = -handles[i][Y] * source_handles[i][X]; + solmatrix[i+4][7] = -handles[i][Y] * source_handles[i][Y]; free_term[i] = handles[i][X]; free_term[i+4] = handles[i][Y]; } @@ -110,7 +111,7 @@ void LPEPerspectiveEnvelope::doEffect(SPCurve *curve) { h = 0; for( int i = 0; i < 3; i++ ) { for( int j = 0; j < 3; j++ ) { - if(h==8){ + if(h==8) { projmatrix[2][2] = 1.0; continue; } @@ -124,19 +125,19 @@ void LPEPerspectiveEnvelope::doEffect(SPCurve *curve) { Geom::PathVector const original_pathv = pathv_to_linear_and_cubic_beziers(curve->get_pathvector()); curve->reset(); Geom::CubicBezier const *cubic = NULL; - Geom::Point pointAt1(0, 0); - Geom::Point pointAt2(0, 0); - Geom::Point pointAt3(0, 0); + Geom::Point point_at1(0, 0); + Geom::Point point_at2(0, 0); + Geom::Point point_at3(0, 0); for (Geom::PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) { //Si está vacío... if (path_it->empty()) - continue; + continue; //Itreadores SPCurve *nCurve = new SPCurve(); Geom::Path::const_iterator curve_it1 = path_it->begin(); Geom::Path::const_iterator curve_it2 = ++(path_it->begin()); Geom::Path::const_iterator curve_endit = path_it->end_default(); - + if (path_it->closed()) { const Geom::Curve &closingline = path_it->back_closed(); @@ -144,40 +145,40 @@ void LPEPerspectiveEnvelope::doEffect(SPCurve *curve) { curve_endit = path_it->end_open(); } } - if(deform_type == DEFORMATION_PERSPECTIVE){ - nCurve->moveto(project_point(curve_it1->initialPoint(),projmatrix)); - }else{ - nCurve->moveto(project_point(curve_it1->initialPoint())); + if(deform_type == DEFORMATION_PERSPECTIVE) { + nCurve->moveto(projectPoint(curve_it1->initialPoint(),projmatrix)); + } else { + nCurve->moveto(projectPoint(curve_it1->initialPoint())); } while (curve_it1 != curve_endit) { - cubic = dynamic_cast(&*curve_it1); - if (cubic) { - pointAt1 = (*cubic)[1]; - pointAt2 = (*cubic)[2]; - } else { - pointAt1 = curve_it1->initialPoint(); - pointAt2 = curve_it1->finalPoint(); - } - pointAt3 = curve_it1->finalPoint(); - if(deform_type == DEFORMATION_PERSPECTIVE){ - pointAt1 = project_point(pointAt1,projmatrix); - pointAt2 = project_point(pointAt2,projmatrix); - pointAt3 = project_point(pointAt3,projmatrix); - }else{ - pointAt1 = project_point(pointAt1); - pointAt2 = project_point(pointAt2); - pointAt3 = project_point(pointAt3); - } - nCurve->curveto(pointAt1, pointAt2, pointAt3); - ++curve_it1; - if(curve_it2 != curve_endit) { - ++curve_it2; - } + cubic = dynamic_cast(&*curve_it1); + if (cubic) { + point_at1 = (*cubic)[1]; + point_at2 = (*cubic)[2]; + } else { + point_at1 = curve_it1->initialPoint(); + point_at2 = curve_it1->finalPoint(); + } + point_at3 = curve_it1->finalPoint(); + if(deform_type == DEFORMATION_PERSPECTIVE) { + point_at1 = projectPoint(point_at1,projmatrix); + point_at2 = projectPoint(point_at2,projmatrix); + point_at3 = projectPoint(point_at3,projmatrix); + } else { + point_at1 = projectPoint(point_at1); + point_at2 = projectPoint(point_at2); + point_at3 = projectPoint(point_at3); + } + nCurve->curveto(point_at1, point_at2, point_at3); + ++curve_it1; + if(curve_it2 != curve_endit) { + ++curve_it2; + } } //y cerramos la curva if (path_it->closed()) { - nCurve->move_endpoints(pointAt3, pointAt3); - nCurve->closepath_current(); + nCurve->move_endpoints(point_at3, point_at3); + nCurve->closepath_current(); } curve->append(nCurve, false); nCurve->reset(); @@ -185,41 +186,44 @@ void LPEPerspectiveEnvelope::doEffect(SPCurve *curve) { } } -Geom::Point -LPEPerspectiveEnvelope::project_point(Geom::Point p){ +Geom::Point +LPEPerspectiveEnvelope::projectPoint(Geom::Point p) +{ double width = boundingbox_X.extent(); double height = boundingbox_Y.extent(); double delta_x = boundingbox_X.min() - p[X]; double delta_y = boundingbox_Y.max() - p[Y]; - Geom::Coord xratio = (delta_x * -1) / width; - Geom::Coord yratio = delta_y / height; + Geom::Coord x_ratio = (delta_x * -1) / width; + Geom::Coord y_ratio = delta_y / height; Geom::Line* horiz = new Geom::Line(); Geom::Line* vert = new Geom::Line(); - vert->setPoints (pointAtRatio(yratio,Down_Left_Point,Up_Left_Point),pointAtRatio(yratio,Down_Right_Point,Up_Right_Point)); - horiz->setPoints (pointAtRatio(xratio,Down_Left_Point,Down_Right_Point),pointAtRatio(xratio,Up_Left_Point,Up_Right_Point)); + vert->setPoints (pointAtRatio(y_ratio,down_left_point,up_left_point),pointAtRatio(y_ratio,down_right_point,up_right_point)); + horiz->setPoints (pointAtRatio(x_ratio,down_left_point,down_right_point),pointAtRatio(x_ratio,up_left_point,up_right_point)); OptCrossing crossPoint = intersection(*horiz,*vert); - if(crossPoint){ + if(crossPoint) { return horiz->pointAt(Geom::Coord(crossPoint->ta)); - }else{ + } else { return p; } } -Geom::Point -LPEPerspectiveEnvelope::project_point(Geom::Point p, double m[][3]){ +Geom::Point +LPEPerspectiveEnvelope::projectPoint(Geom::Point p, double m[][3]) +{ Geom::Coord x = p[0]; Geom::Coord y = p[1]; return Geom::Point( - Geom::Coord((x*m[0][0] + y*m[0][1] + m[0][2])/(x*m[2][0]+y*m[2][1]+m[2][2])), - Geom::Coord((x*m[1][0] + y*m[1][1] + m[1][2])/(x*m[2][0]+y*m[2][1]+m[2][2]))); + Geom::Coord((x*m[0][0] + y*m[0][1] + m[0][2])/(x*m[2][0]+y*m[2][1]+m[2][2])), + Geom::Coord((x*m[1][0] + y*m[1][1] + m[1][2])/(x*m[2][0]+y*m[2][1]+m[2][2]))); } Geom::Point -LPEPerspectiveEnvelope::pointAtRatio(Geom::Coord ratio,Geom::Point A, Geom::Point B){ - Geom::Coord x = A[X] + (ratio * (B[X]-A[X])); - Geom::Coord y = A[Y]+ (ratio * (B[Y]-A[Y])); - return Point(x, y); +LPEPerspectiveEnvelope::pointAtRatio(Geom::Coord ratio,Geom::Point A, Geom::Point B) +{ + Geom::Coord x = A[X] + (ratio * (B[X]-A[X])); + Geom::Coord y = A[Y]+ (ratio * (B[Y]-A[Y])); + return Point(x, y); } @@ -233,36 +237,35 @@ LPEPerspectiveEnvelope::newWidget() vbox->set_homogeneous(false); vbox->set_spacing(6); std::vector::iterator it = param_vector.begin(); - Gtk::HBox * hboxUpHandles = Gtk::manage(new Gtk::HBox(false,0)); - Gtk::HBox * hboxDownHandles = Gtk::manage(new Gtk::HBox(false,0)); + Gtk::HBox * hbox_up_handles = Gtk::manage(new Gtk::HBox(false,0)); + Gtk::HBox * hbox_down_handles = Gtk::manage(new Gtk::HBox(false,0)); while (it != param_vector.end()) { if ((*it)->widget_is_visible) { Parameter * param = *it; Gtk::Widget * widg = dynamic_cast(param->param_newWidget()); - if (param->param_key == "Up_Left_Point" || - param->param_key == "Up_Right_Point" || - param->param_key == "Down_Left_Point" || - param->param_key == "Down_Right_Point") - { - Gtk::HBox * pointParameter = dynamic_cast(widg); - std::vector< Gtk::Widget* > childList = pointParameter->get_children(); - Gtk::HBox * pointParameterHBox = dynamic_cast(childList[0]); - std::vector< Gtk::Widget* > childList2 = pointParameterHBox->get_children(); - pointParameterHBox->remove(childList2[0][0]); + if (param->param_key == "up_left_point" || + param->param_key == "up_right_point" || + param->param_key == "down_left_point" || + param->param_key == "down_right_point") { + Gtk::HBox * point_hbox = dynamic_cast(widg); + std::vector< Gtk::Widget* > child_list = point_hbox->get_children(); + Gtk::HBox * point_hboxHBox = dynamic_cast(child_list[0]); + std::vector< Gtk::Widget* > child_list2 = point_hboxHBox->get_children(); + point_hboxHBox->remove(child_list2[0][0]); Glib::ustring * tip = param->param_getTooltip(); if (widg) { - if(param->param_key == "Up_Left_Point"){ + if(param->param_key == "up_left_point") { Gtk::Label* handles = Gtk::manage(new Gtk::Label(Glib::ustring(_("Handles:")),Gtk::ALIGN_START)); vbox->pack_start(*handles, false, false, 2); - hboxUpHandles->pack_start(*widg, true, true, 2); - hboxUpHandles->pack_start(*Gtk::manage(new Gtk::VSeparator()), Gtk::PACK_EXPAND_WIDGET); - }else if(param->param_key == "Up_Right_Point"){ - hboxUpHandles->pack_start(*widg, true, true, 2); - }else if(param->param_key == "Down_Left_Point"){ - hboxDownHandles->pack_start(*widg, true, true, 2); - hboxDownHandles->pack_start(*Gtk::manage(new Gtk::VSeparator()), Gtk::PACK_EXPAND_WIDGET); - }else{ - hboxDownHandles->pack_start(*widg, true, true, 2); + hbox_up_handles->pack_start(*widg, true, true, 2); + hbox_up_handles->pack_start(*Gtk::manage(new Gtk::VSeparator()), Gtk::PACK_EXPAND_WIDGET); + } else if(param->param_key == "up_right_point") { + hbox_up_handles->pack_start(*widg, true, true, 2); + } else if(param->param_key == "down_left_point") { + hbox_down_handles->pack_start(*widg, true, true, 2); + hbox_down_handles->pack_start(*Gtk::manage(new Gtk::VSeparator()), Gtk::PACK_EXPAND_WIDGET); + } else { + hbox_down_handles->pack_start(*widg, true, true, 2); } if (tip) { widg->set_tooltip_text(*tip); @@ -271,7 +274,7 @@ LPEPerspectiveEnvelope::newWidget() widg->set_has_tooltip(false); } } - }else{ + } else { Glib::ustring * tip = param->param_getTooltip(); if (widg) { vbox->pack_start(*widg, true, true, 2); @@ -287,18 +290,18 @@ LPEPerspectiveEnvelope::newWidget() ++it; } - vbox->pack_start(*hboxUpHandles,true, true, 2); - Gtk::HBox * hboxMiddle = Gtk::manage(new Gtk::HBox(true,2)); - hboxMiddle->pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_EXPAND_WIDGET); - hboxMiddle->pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_EXPAND_WIDGET); - vbox->pack_start(*hboxMiddle, false, true, 2); - vbox->pack_start(*hboxDownHandles, true, true, 2); + vbox->pack_start(*hbox_up_handles,true, true, 2); + Gtk::HBox * hbox_middle = Gtk::manage(new Gtk::HBox(true,2)); + hbox_middle->pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_EXPAND_WIDGET); + hbox_middle->pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_EXPAND_WIDGET); + vbox->pack_start(*hbox_middle, false, true, 2); + vbox->pack_start(*hbox_down_handles, true, true, 2); Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false,0)); - Gtk::Button* resetButton = Gtk::manage(new Gtk::Button(Gtk::Stock::CLEAR)); - resetButton->signal_clicked().connect(sigc::mem_fun (*this,&LPEPerspectiveEnvelope::resetGrid)); - resetButton->set_size_request(140,30); + Gtk::Button* reset_button = Gtk::manage(new Gtk::Button(Gtk::Stock::CLEAR)); + reset_button->signal_clicked().connect(sigc::mem_fun (*this,&LPEPerspectiveEnvelope::resetGrid)); + reset_button->set_size_request(140,30); vbox->pack_start(*hbox, true,true,2); - hbox->pack_start(*resetButton, false, false,2); + hbox->pack_start(*reset_button, false, false,2); return dynamic_cast(vbox); } @@ -315,24 +318,24 @@ LPEPerspectiveEnvelope::doBeforeEffect (SPLPEItem const* lpeitem) void LPEPerspectiveEnvelope::setDefaults() { - Geom::Point Up_Left(boundingbox_X.min(), boundingbox_Y.min()); - Geom::Point Up_Right(boundingbox_X.max(), boundingbox_Y.min()); - Geom::Point Down_Left(boundingbox_X.min(), boundingbox_Y.max()); - Geom::Point Down_Right(boundingbox_X.max(), boundingbox_Y.max()); - - Up_Left_Point.param_update_default(Up_Left); - Up_Right_Point.param_update_default(Up_Right); - Down_Right_Point.param_update_default(Down_Right); - Down_Left_Point.param_update_default(Down_Left); + Geom::Point up_left(boundingbox_X.min(), boundingbox_Y.min()); + Geom::Point up_right(boundingbox_X.max(), boundingbox_Y.min()); + Geom::Point down_left(boundingbox_X.min(), boundingbox_Y.max()); + Geom::Point down_right(boundingbox_X.max(), boundingbox_Y.max()); + + up_left_point.param_update_default(up_left); + up_right_point.param_update_default(up_right); + down_right_point.param_update_default(down_right); + down_left_point.param_update_default(down_left); } void LPEPerspectiveEnvelope::resetGrid() { - Up_Left_Point.param_set_default(); - Up_Right_Point.param_set_default(); - Down_Right_Point.param_set_default(); - Down_Left_Point.param_set_default(); + up_left_point.param_set_default(); + up_right_point.param_set_default(); + down_right_point.param_set_default(); + down_left_point.param_set_default(); } void @@ -351,11 +354,11 @@ LPEPerspectiveEnvelope::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::v SPCurve *c = new SPCurve(); c->reset(); - c->moveto(Up_Left_Point); - c->lineto(Up_Right_Point); - c->lineto(Down_Right_Point); - c->lineto(Down_Left_Point); - c->lineto(Up_Left_Point); + c->moveto(up_left_point); + c->lineto(up_right_point); + c->lineto(down_right_point); + c->lineto(down_left_point); + c->lineto(up_left_point); hp_vec.push_back(c->get_pathvector()); } diff --git a/src/live_effects/lpe-perspective-envelope.h b/src/live_effects/lpe-perspective-envelope.h index d3ff76445..e25f059a3 100644 --- a/src/live_effects/lpe-perspective-envelope.h +++ b/src/live_effects/lpe-perspective-envelope.h @@ -3,7 +3,7 @@ /** \file * LPE implementation , see lpe-perspective-envelope.cpp. - + */ /* * Authors: @@ -11,8 +11,8 @@ * Aaron Spike, aaron@ekips.org from envelope and perspective phyton code * Dmitry Platonov, shadowjack@mail.ru, 2006 perspective approach & math * Jose Hevia (freon) Transform algorithm from envelope - * - * Copyright (C) 2007-2014 Authors + * + * Copyright (C) 2007-2014 Authors * * Released under GNU GPL, read the file 'COPYING' for more information */ @@ -34,9 +34,9 @@ public: virtual void doEffect(SPCurve *curve); - virtual Geom::Point project_point(Geom::Point p); + virtual Geom::Point projectPoint(Geom::Point p); - virtual Geom::Point project_point(Geom::Point p, double m[][3]); + virtual Geom::Point projectPoint(Geom::Point p, double m[][3]); virtual Geom::Point pointAtRatio(Geom::Coord ratio,Geom::Point A, Geom::Point B); @@ -55,10 +55,10 @@ protected: private: EnumParam deform_type; - PointParam Up_Left_Point; - PointParam Up_Right_Point; - PointParam Down_Left_Point; - PointParam Down_Right_Point; + PointParam up_left_point; + PointParam up_right_point; + PointParam down_left_point; + PointParam down_right_point; LPEPerspectiveEnvelope(const LPEPerspectiveEnvelope&); LPEPerspectiveEnvelope& operator=(const LPEPerspectiveEnvelope&); -- cgit v1.2.3 From a4c5658e46ba9c792ab794d39b71e344bc95e3b6 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Fri, 10 Apr 2015 19:38:28 +0200 Subject: Fix coding style issues in show/handles LPE (bzr r14053) --- src/live_effects/lpe-show_handles.cpp | 76 +++++++++++++++++------------------ src/live_effects/lpe-show_handles.h | 14 +++---- 2 files changed, 45 insertions(+), 45 deletions(-) diff --git a/src/live_effects/lpe-show_handles.cpp b/src/live_effects/lpe-show_handles.cpp index 2d8148730..2638f312e 100644 --- a/src/live_effects/lpe-show_handles.cpp +++ b/src/live_effects/lpe-show_handles.cpp @@ -24,25 +24,25 @@ LPEShowHandles::LPEShowHandles(LivePathEffectObject *lpeobject) : Effect(lpeobject), nodes(_("Show nodes"), _("Show nodes"), "nodes", &wr, this, true), handles(_("Show handles"), _("Show handles"), "handles", &wr, this, true), - originalPath(_("Show path"), _("Show path"), "originalPath", &wr, this, true), - scaleNodesAndHandles(_("Scale nodes and handles"), _("Scale nodes and handles"), "scaleNodesAndHandles", &wr, this, 10), - rotateNodes(_("Rotate nodes"), _("Rotate nodes"), "rotateNodes", &wr, this, 0) + original_path(_("Show path"), _("Show path"), "original_path", &wr, this, true), + scale_nodes_and_handles(_("Scale nodes and handles"), _("Scale nodes and handles"), "scale_nodes_and_handles", &wr, this, 10), + rotate_nodes(_("Rotate nodes"), _("Rotate nodes"), "rotate_nodes", &wr, this, 0) { - registerParameter(dynamic_cast(&nodes)); - registerParameter(dynamic_cast(&handles)); - registerParameter(dynamic_cast(&originalPath)); - registerParameter(dynamic_cast(&scaleNodesAndHandles)); - registerParameter(dynamic_cast(&rotateNodes)); - scaleNodesAndHandles.param_set_range(0, 500.); - scaleNodesAndHandles.param_set_increments(1, 1); - scaleNodesAndHandles.param_set_digits(2); - rotateNodes.param_set_range(0, 365); - rotateNodes.param_set_increments(1, 1); - rotateNodes.param_set_digits(0); - strokeWidth = 1.0; + registerParameter(&nodes); + registerParameter(&handles); + registerParameter(&original_path); + registerParameter(&scale_nodes_and_handles); + registerParameter(&rotate_nodes); + scale_nodes_and_handles.param_set_range(0, 500.); + scale_nodes_and_handles.param_set_increments(1, 1); + scale_nodes_and_handles.param_set_digits(2); + rotate_nodes.param_set_range(0, 365); + rotate_nodes.param_set_increments(1, 1); + rotate_nodes.param_set_digits(0); + stroke_width = 1.0; } -bool LPEShowHandles::alertsOff = false; +bool LPEShowHandles::alerts_off = false; /** * Sets default styles to element @@ -51,11 +51,11 @@ bool LPEShowHandles::alertsOff = false; void LPEShowHandles::doOnApply(SPLPEItem const* lpeitem) { - if(!alertsOff) { + if(!alerts_off) { char *msg = _("The \"show handles\" path effect will remove any custom style on the object you are applying it to. If this is not what you want, click Cancel."); Gtk::MessageDialog dialog(msg, false, Gtk::MESSAGE_QUESTION, Gtk::BUTTONS_OK_CANCEL, true); gint response = dialog.run(); - alertsOff = true; + alerts_off = true; if(response == GTK_RESPONSE_CANCEL) { SPLPEItem* item = const_cast(lpeitem); item->removeCurrentPathEffect(false); @@ -76,24 +76,24 @@ void LPEShowHandles::doOnApply(SPLPEItem const* lpeitem) void LPEShowHandles::doBeforeEffect (SPLPEItem const* lpeitem) { SPItem const* item = SP_ITEM(lpeitem); - strokeWidth = item->style->stroke_width.computed; + stroke_width = item->style->stroke_width.computed; } std::vector LPEShowHandles::doEffect_path (std::vector const & path_in) { std::vector path_out; Geom::PathVector const original_pathv = pathv_to_linear_and_cubic_beziers(path_in); - if(originalPath) { + if(original_path) { for (unsigned int i=0; i < path_in.size(); i++) { path_out.push_back(path_in[i]); } } - if(!outlinepath.empty()) { - outlinepath.clear(); + if(!outline_path.empty()) { + outline_path.clear(); } generateHelperPath(original_pathv); - for (unsigned int i=0; i < outlinepath.size(); i++) { - path_out.push_back(outlinepath[i]); + for (unsigned int i=0; i < outline_path.size(); i++) { + path_out.push_back(outline_path[i]); } return path_out; } @@ -136,11 +136,11 @@ LPEShowHandles::generateHelperPath(Geom::PathVector result) cubic = dynamic_cast(&*curve_it1); if (cubic) { if(handles) { - if(!are_near((*cubic)[0],(*cubic)[1])){ + if(!are_near((*cubic)[0],(*cubic)[1])) { drawHandle((*cubic)[1]); drawHandleLine((*cubic)[0],(*cubic)[1]); } - if(!are_near((*cubic)[3],(*cubic)[2])){ + if(!are_near((*cubic)[3],(*cubic)[2])) { drawHandle((*cubic)[2]); drawHandleLine((*cubic)[3],(*cubic)[2]); } @@ -150,7 +150,7 @@ LPEShowHandles::generateHelperPath(Geom::PathVector result) drawNode(curve_it1->finalPoint()); } ++curve_it1; - if(curve_it2 != curve_endit){ + if(curve_it2 != curve_endit) { ++curve_it2; } } @@ -160,30 +160,30 @@ LPEShowHandles::generateHelperPath(Geom::PathVector result) void LPEShowHandles::drawNode(Geom::Point p) { - if(strokeWidth * scaleNodesAndHandles > 0.0) { - double diameter = strokeWidth * scaleNodesAndHandles; + if(stroke_width * scale_nodes_and_handles > 0.0) { + double diameter = stroke_width * scale_nodes_and_handles; char const * svgd; svgd = "M 0.05,0 A 0.05,0.05 0 0 1 0,0.05 0.05,0.05 0 0 1 -0.05,0 0.05,0.05 0 0 1 0,-0.05 0.05,0.05 0 0 1 0.05,0 Z M -0.5,-0.5 0.5,-0.5 0.5,0.5 -0.5,0.5 Z"; Geom::PathVector pathv = sp_svg_read_pathv(svgd); - pathv *= Geom::Rotate::from_degrees(rotateNodes); + pathv *= Geom::Rotate::from_degrees(rotate_nodes); pathv *= Geom::Scale (diameter); pathv += p; - outlinepath.push_back(pathv[0]); - outlinepath.push_back(pathv[1]); + outline_path.push_back(pathv[0]); + outline_path.push_back(pathv[1]); } } void LPEShowHandles::drawHandle(Geom::Point p) { - if(strokeWidth * scaleNodesAndHandles > 0.0) { - double diameter = strokeWidth * scaleNodesAndHandles; + if(stroke_width * scale_nodes_and_handles > 0.0) { + double diameter = stroke_width * scale_nodes_and_handles; char const * svgd; svgd = "M 0.7,0.35 A 0.35,0.35 0 0 1 0.35,0.7 0.35,0.35 0 0 1 0,0.35 0.35,0.35 0 0 1 0.35,0 0.35,0.35 0 0 1 0.7,0.35 Z"; Geom::PathVector pathv = sp_svg_read_pathv(svgd); pathv *= Geom::Scale (diameter); pathv += p-Geom::Point(diameter * 0.35,diameter * 0.35); - outlinepath.push_back(pathv[0]); + outline_path.push_back(pathv[0]); } } @@ -192,14 +192,14 @@ void LPEShowHandles::drawHandleLine(Geom::Point p,Geom::Point p2) { Geom::Path path; - double diameter = strokeWidth * scaleNodesAndHandles; - if(diameter > 0.0 && Geom::distance(p,p2) > (diameter * 0.35)){ + double diameter = stroke_width * scale_nodes_and_handles; + if(diameter > 0.0 && Geom::distance(p,p2) > (diameter * 0.35)) { Geom::Ray ray2(p, p2); p2 = p2 - Geom::Point::polar(ray2.angle(),(diameter * 0.35)); } path.start( p ); path.appendNew( p2 ); - outlinepath.push_back(path); + outline_path.push_back(path); } }; //namespace LivePathEffect diff --git a/src/live_effects/lpe-show_handles.h b/src/live_effects/lpe-show_handles.h index a405c26ee..77b28e77a 100644 --- a/src/live_effects/lpe-show_handles.h +++ b/src/live_effects/lpe-show_handles.h @@ -20,7 +20,7 @@ class LPEShowHandles : public Effect , GroupBBoxEffect { public: LPEShowHandles(LivePathEffectObject *lpeobject); - virtual ~LPEShowHandles(){} + virtual ~LPEShowHandles() {} virtual void doOnApply(SPLPEItem const* lpeitem); @@ -42,13 +42,13 @@ private: BoolParam nodes; BoolParam handles; - BoolParam originalPath; - ScalarParam scaleNodesAndHandles; - ScalarParam rotateNodes; - double strokeWidth; - static bool alertsOff; + BoolParam original_path; + ScalarParam scale_nodes_and_handles; + ScalarParam rotate_nodes; + double stroke_width; + static bool alerts_off; - Geom::PathVector outlinepath; + Geom::PathVector outline_path; LPEShowHandles(const LPEShowHandles &); LPEShowHandles &operator=(const LPEShowHandles &); -- cgit v1.2.3 From 79c874ab182858f6d400e41771981d8fe1c58921 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Fri, 10 Apr 2015 20:49:29 +0200 Subject: Fix coding style issues in bspline/spirolive code (bzr r14054) --- src/live_effects/lpe-bspline.cpp | 320 +++++++++++++++--------------- src/live_effects/lpe-bspline.h | 7 +- src/ui/tool/curve-drag-point.cpp | 4 +- src/ui/tool/node.cpp | 98 +++++----- src/ui/tool/path-manipulator.cpp | 122 ++++++------ src/ui/tool/path-manipulator.h | 12 +- src/ui/tools/freehand-base.cpp | 12 +- src/ui/tools/freehand-base.h | 2 +- src/ui/tools/pen-tool.cpp | 407 ++++++++++++++++++++------------------- src/ui/tools/pen-tool.h | 28 +-- src/ui/tools/pencil-tool.cpp | 22 +-- 11 files changed, 521 insertions(+), 513 deletions(-) diff --git a/src/live_effects/lpe-bspline.cpp b/src/live_effects/lpe-bspline.cpp index 5d5a6e616..ecbfef76a 100644 --- a/src/live_effects/lpe-bspline.cpp +++ b/src/live_effects/lpe-bspline.cpp @@ -15,26 +15,26 @@ namespace Inkscape { namespace LivePathEffect { -const double handleCubicGap = 0.01; -const double noPower = 0.0; -const double defaultStartPower = 0.3334; -const double defaultEndPower = 0.6667; +const double HANDLE_CUBIC_GAP = 0.01; +const double NO_POWER = 0.0; +const double DEFAULT_START_POWER = 0.3334; +const double DEFAULT_END_POWER = 0.6667; LPEBSpline::LPEBSpline(LivePathEffectObject *lpeobject) : Effect(lpeobject), steps(_("Steps with CTRL:"), _("Change number of steps with CTRL pressed"), "steps", &wr, this, 2), helper_size(_("Helper size:"), _("Helper size"), "helper_size", &wr, this, 0), - ignoreCusp(_("Ignore cusp nodes"), _("Change ignoring cusp nodes"), "ignoreCusp", &wr, this, true), - onlySelected(_("Change only selected nodes"), _("Change only selected nodes"), "onlySelected", &wr, this, false), - weight(_("Change weight:"), _("Change weight of the effect"), "weight", &wr, this, defaultStartPower) + ignore_cusp(_("Ignore cusp nodes"), _("Change ignoring cusp nodes"), "ignore_cusp", &wr, this, true), + only_selected(_("Change only selected nodes"), _("Change only selected nodes"), "only_selected", &wr, this, false), + weight(_("Change weight:"), _("Change weight of the effect"), "weight", &wr, this, DEFAULT_START_POWER) { registerParameter(&weight); registerParameter(&steps); registerParameter(&helper_size); - registerParameter(&ignoreCusp); - registerParameter(&onlySelected); + registerParameter(&ignore_cusp); + registerParameter(&only_selected); - weight.param_set_range(noPower, 1); + weight.param_set_range(NO_POWER, 1); weight.param_set_increments(0.1, 0.1); weight.param_set_digits(4); @@ -51,7 +51,7 @@ LPEBSpline::~LPEBSpline() {} void LPEBSpline::doBeforeEffect (SPLPEItem const* /*lpeitem*/) { - if(!hp.empty()){ + if(!hp.empty()) { hp.clear(); } } @@ -69,7 +69,7 @@ void LPEBSpline::doOnApply(SPLPEItem const* lpeitem) void LPEBSpline::doEffect(SPCurve *curve) { - if (curve->get_segment_count() < 1){ + if (curve->get_segment_count() < 1) { return; } // Make copy of old path as it is changed during processing @@ -79,22 +79,22 @@ void LPEBSpline::doEffect(SPCurve *curve) for (Geom::PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) { - if (path_it->empty()){ + if (path_it->empty()) { continue; } hp.push_back(*path_it); Geom::Path::const_iterator curve_it1 = path_it->begin(); Geom::Path::const_iterator curve_it2 = ++(path_it->begin()); Geom::Path::const_iterator curve_endit = path_it->end_default(); - SPCurve *nCurve = new SPCurve(); + SPCurve *curve_n = new SPCurve(); Geom::Point previousNode(0, 0); Geom::Point node(0, 0); - Geom::Point pointAt1(0, 0); - Geom::Point pointAt2(0, 0); - Geom::Point nextPointAt1(0, 0); - Geom::D2 SBasisIn; - Geom::D2 SBasisOut; - Geom::D2 SBasisHelper; + Geom::Point point_at1(0, 0); + Geom::Point point_at2(0, 0); + Geom::Point next_point_at1(0, 0); + Geom::D2 sbasis_in; + Geom::D2 sbasis_out; + Geom::D2 sbasis_helper; Geom::CubicBezier const *cubic = NULL; if (path_it->closed()) { // if the path is closed, maybe we have to stop a bit earlier because the @@ -110,27 +110,27 @@ void LPEBSpline::doEffect(SPCurve *curve) curve_endit = path_it->end_open(); } } - nCurve->moveto(curve_it1->initialPoint()); + curve_n->moveto(curve_it1->initialPoint()); while (curve_it1 != curve_endit) { SPCurve *in = new SPCurve(); in->moveto(curve_it1->initialPoint()); in->lineto(curve_it1->finalPoint()); cubic = dynamic_cast(&*curve_it1); if (cubic) { - SBasisIn = in->first_segment()->toSBasis(); + sbasis_in = in->first_segment()->toSBasis(); if(are_near((*cubic)[1],(*cubic)[0]) && !are_near((*cubic)[2],(*cubic)[3])) { - pointAt1 = SBasisIn.valueAt(defaultStartPower); + point_at1 = sbasis_in.valueAt(DEFAULT_START_POWER); } else { - pointAt1 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[1], *in->first_segment())); + point_at1 = sbasis_in.valueAt(Geom::nearest_point((*cubic)[1], *in->first_segment())); } if(are_near((*cubic)[2],(*cubic)[3]) && !are_near((*cubic)[1],(*cubic)[0])) { - pointAt2 = SBasisIn.valueAt(defaultEndPower); + point_at2 = sbasis_in.valueAt(DEFAULT_END_POWER); } else { - pointAt2 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[2], *in->first_segment())); + point_at2 = sbasis_in.valueAt(Geom::nearest_point((*cubic)[2], *in->first_segment())); } } else { - pointAt1 = in->first_segment()->initialPoint(); - pointAt2 = in->first_segment()->finalPoint(); + point_at1 = in->first_segment()->initialPoint(); + point_at2 = in->first_segment()->finalPoint(); } in->reset(); delete in; @@ -140,14 +140,14 @@ void LPEBSpline::doEffect(SPCurve *curve) out->lineto(curve_it2->finalPoint()); cubic = dynamic_cast(&*curve_it2); if (cubic) { - SBasisOut = out->first_segment()->toSBasis(); + sbasis_out = out->first_segment()->toSBasis(); if(are_near((*cubic)[1],(*cubic)[0]) && !are_near((*cubic)[2],(*cubic)[3])) { - nextPointAt1 = SBasisIn.valueAt(defaultStartPower); + next_point_at1 = sbasis_in.valueAt(DEFAULT_START_POWER); } else { - nextPointAt1 = SBasisOut.valueAt(Geom::nearest_point((*cubic)[1], *out->first_segment())); + next_point_at1 = sbasis_out.valueAt(Geom::nearest_point((*cubic)[1], *out->first_segment())); } } else { - nextPointAt1 = out->first_segment()->initialPoint(); + next_point_at1 = out->first_segment()->initialPoint(); } out->reset(); delete out; @@ -156,14 +156,14 @@ void LPEBSpline::doEffect(SPCurve *curve) SPCurve *start = new SPCurve(); start->moveto(path_it->begin()->initialPoint()); start->lineto(path_it->begin()->finalPoint()); - Geom::D2 SBasisStart = start->first_segment()->toSBasis(); - SPCurve *lineHelper = new SPCurve(); + Geom::D2 sbasis_start = start->first_segment()->toSBasis(); + SPCurve *line_helper = new SPCurve(); cubic = dynamic_cast(&*path_it->begin()); if (cubic) { - lineHelper->moveto(SBasisStart.valueAt( + line_helper->moveto(sbasis_start.valueAt( Geom::nearest_point((*cubic)[1], *start->first_segment()))); } else { - lineHelper->moveto(start->first_segment()->initialPoint()); + line_helper->moveto(start->first_segment()->initialPoint()); } start->reset(); delete start; @@ -171,41 +171,41 @@ void LPEBSpline::doEffect(SPCurve *curve) SPCurve *end = new SPCurve(); end->moveto(curve_it1->initialPoint()); end->lineto(curve_it1->finalPoint()); - Geom::D2 SBasisEnd = end->first_segment()->toSBasis(); + Geom::D2 sbasis_end = end->first_segment()->toSBasis(); cubic = dynamic_cast(&*curve_it1); if (cubic) { - lineHelper->lineto(SBasisEnd.valueAt( + line_helper->lineto(sbasis_end.valueAt( Geom::nearest_point((*cubic)[2], *end->first_segment()))); } else { - lineHelper->lineto(end->first_segment()->finalPoint()); + line_helper->lineto(end->first_segment()->finalPoint()); } end->reset(); delete end; - SBasisHelper = lineHelper->first_segment()->toSBasis(); - lineHelper->reset(); - delete lineHelper; - node = SBasisHelper.valueAt(0.5); - nCurve->curveto(pointAt1, pointAt2, node); - nCurve->move_endpoints(node, node); + sbasis_helper = line_helper->first_segment()->toSBasis(); + line_helper->reset(); + delete line_helper; + node = sbasis_helper.valueAt(0.5); + curve_n->curveto(point_at1, point_at2, node); + curve_n->move_endpoints(node, node); } else if ( curve_it2 == curve_endit) { - nCurve->curveto(pointAt1, pointAt2, curve_it1->finalPoint()); - nCurve->move_endpoints(path_it->begin()->initialPoint(), curve_it1->finalPoint()); + curve_n->curveto(point_at1, point_at2, curve_it1->finalPoint()); + curve_n->move_endpoints(path_it->begin()->initialPoint(), curve_it1->finalPoint()); } else { - SPCurve *lineHelper = new SPCurve(); - lineHelper->moveto(pointAt2); - lineHelper->lineto(nextPointAt1); - SBasisHelper = lineHelper->first_segment()->toSBasis(); - lineHelper->reset(); - delete lineHelper; + SPCurve *line_helper = new SPCurve(); + line_helper->moveto(point_at2); + line_helper->lineto(next_point_at1); + sbasis_helper = line_helper->first_segment()->toSBasis(); + line_helper->reset(); + delete line_helper; previousNode = node; - node = SBasisHelper.valueAt(0.5); + node = sbasis_helper.valueAt(0.5); Geom::CubicBezier const *cubic2 = dynamic_cast(&*curve_it1); if((cubic && are_near((*cubic)[0],(*cubic)[1])) || (cubic2 && are_near((*cubic2)[2],(*cubic2)[3]))) { node = curve_it1->finalPoint(); } - nCurve->curveto(pointAt1, pointAt2, node); + curve_n->curveto(point_at1, point_at2, node); } - if(!are_near(node,curve_it1->finalPoint()) && helper_size > 0.0){ + if(!are_near(node,curve_it1->finalPoint()) && helper_size > 0.0) { drawHandle(node, helper_size); } ++curve_it1; @@ -213,15 +213,15 @@ void LPEBSpline::doEffect(SPCurve *curve) } //y cerramos la curva if (path_it->closed()) { - nCurve->closepath_current(); + curve_n->closepath_current(); } - curve->append(nCurve, false); - nCurve->reset(); - delete nCurve; + curve->append(curve_n, false); + curve_n->reset(); + delete curve_n; } - if(helper_size > 0.0){ + if(helper_size > 0.0) { Geom::PathVector const pathv = curve->get_pathvector(); - hp.push_back(pathv[0]); + hp.push_back(pathv[0]); } } @@ -256,40 +256,40 @@ Gtk::Widget *LPEBSpline::newWidget() Gtk::Widget *widg = dynamic_cast(param->param_newWidget()); if (param->param_key == "weight") { Gtk::HBox * buttons = Gtk::manage(new Gtk::HBox(true,0)); - Gtk::Button *defaultWeight = + Gtk::Button *default_weight = Gtk::manage(new Gtk::Button(Glib::ustring(_("Default weight")))); - defaultWeight->signal_clicked() + default_weight->signal_clicked() .connect(sigc::mem_fun(*this, &LPEBSpline::toDefaultWeight)); - buttons->pack_start(*defaultWeight, true, true, 2); - Gtk::Button *makeCusp = + buttons->pack_start(*default_weight, true, true, 2); + Gtk::Button *make_cusp = Gtk::manage(new Gtk::Button(Glib::ustring(_("Make cusp")))); - makeCusp->signal_clicked() + make_cusp->signal_clicked() .connect(sigc::mem_fun(*this, &LPEBSpline::toMakeCusp)); - buttons->pack_start(*makeCusp, true, true, 2); + buttons->pack_start(*make_cusp, true, true, 2); vbox->pack_start(*buttons, true, true, 2); } if (param->param_key == "weight" || param->param_key == "steps") { - Inkscape::UI::Widget::Scalar *widgRegistered = + Inkscape::UI::Widget::Scalar *widg_registered = Gtk::manage(dynamic_cast(widg)); - widgRegistered->signal_value_changed() + widg_registered->signal_value_changed() .connect(sigc::mem_fun(*this, &LPEBSpline::toWeight)); - widg = dynamic_cast(widgRegistered); + widg = dynamic_cast(widg_registered); if (widg) { - Gtk::HBox * scalarParameter = dynamic_cast(widg); - std::vector< Gtk::Widget* > childList = scalarParameter->get_children(); - Gtk::Entry* entryWidg = dynamic_cast(childList[1]); - entryWidg->set_width_chars(6); + Gtk::HBox * hbox_weight_steps = dynamic_cast(widg); + std::vector< Gtk::Widget* > childList = hbox_weight_steps->get_children(); + Gtk::Entry* entry_widget = dynamic_cast(childList[1]); + entry_widget->set_width_chars(6); } } - if (param->param_key == "onlySelected") { - Gtk::CheckButton *widgRegistered = + if (param->param_key == "only_selected") { + Gtk::CheckButton *widg_registered = Gtk::manage(dynamic_cast(widg)); - widg = dynamic_cast(widgRegistered); + widg = dynamic_cast(widg_registered); } - if (param->param_key == "ignoreCusp") { - Gtk::CheckButton *widgRegistered = + if (param->param_key == "ignore_cusp") { + Gtk::CheckButton *widg_registered = Gtk::manage(dynamic_cast(widg)); - widg = dynamic_cast(widgRegistered); + widg = dynamic_cast(widg_registered); } Glib::ustring *tip = param->param_getTooltip(); if (widg) { @@ -310,12 +310,12 @@ Gtk::Widget *LPEBSpline::newWidget() void LPEBSpline::toDefaultWeight() { - changeWeight(defaultStartPower); + changeWeight(DEFAULT_START_POWER); } void LPEBSpline::toMakeCusp() { - changeWeight(noPower); + changeWeight(NO_POWER); } void LPEBSpline::toWeight() @@ -323,22 +323,22 @@ void LPEBSpline::toWeight() changeWeight(weight); } -void LPEBSpline::changeWeight(double weightValue) +void LPEBSpline::changeWeight(double weight_ammount) { SPPath *path = dynamic_cast(sp_lpe_item); - if(path){ + if(path) { SPCurve *curve = path->get_curve_for_edit(); - LPEBSpline::doBSplineFromWidget(curve, weightValue); + doBSplineFromWidget(curve, weight_ammount); gchar *str = sp_svg_write_path(curve->get_pathvector()); path->getRepr()->setAttribute("inkscape:original-d", str); } } -void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue) +void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weight_ammount) { using Geom::X; using Geom::Y; - + if (curve->get_segment_count() < 1) return; // Make copy of old path as it is changed during processing @@ -348,20 +348,20 @@ void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue) for (Geom::PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) { - if (path_it->empty()){ + if (path_it->empty()) { continue; } Geom::Path::const_iterator curve_it1 = path_it->begin(); Geom::Path::const_iterator curve_it2 = ++(path_it->begin()); Geom::Path::const_iterator curve_endit = path_it->end_default(); - SPCurve *nCurve = new SPCurve(); - Geom::Point pointAt0(0, 0); - Geom::Point pointAt1(0, 0); - Geom::Point pointAt2(0, 0); - Geom::Point pointAt3(0, 0); - Geom::D2 SBasisIn; - Geom::D2 SBasisOut; + SPCurve *curve_n = new SPCurve(); + Geom::Point point_at0(0, 0); + Geom::Point point_at1(0, 0); + Geom::Point point_at2(0, 0); + Geom::Point point_at3(0, 0); + Geom::D2 sbasis_in; + Geom::D2 sbasis_out; Geom::CubicBezier const *cubic = NULL; if (path_it->closed()) { // if the path is closed, maybe we have to stop a bit earlier because the @@ -377,120 +377,120 @@ void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue) curve_endit = path_it->end_open(); } } - nCurve->moveto(curve_it1->initialPoint()); + curve_n->moveto(curve_it1->initialPoint()); while (curve_it1 != curve_endit) { SPCurve *in = new SPCurve(); in->moveto(curve_it1->initialPoint()); in->lineto(curve_it1->finalPoint()); cubic = dynamic_cast(&*curve_it1); - pointAt0 = in->first_segment()->initialPoint(); - pointAt3 = in->first_segment()->finalPoint(); - SBasisIn = in->first_segment()->toSBasis(); - if (!onlySelected) { + point_at0 = in->first_segment()->initialPoint(); + point_at3 = in->first_segment()->finalPoint(); + sbasis_in = in->first_segment()->toSBasis(); + if (!only_selected) { if (cubic) { - if (!ignoreCusp || !Geom::are_near((*cubic)[1], pointAt0)) { - pointAt1 = SBasisIn.valueAt(weightValue); - if (weightValue != noPower) { - pointAt1 = - Geom::Point(pointAt1[X] + handleCubicGap, pointAt1[Y] + handleCubicGap); + if (!ignore_cusp || !Geom::are_near((*cubic)[1], point_at0)) { + point_at1 = sbasis_in.valueAt(weight_ammount); + if (weight_ammount != NO_POWER) { + point_at1 = + Geom::Point(point_at1[X] + HANDLE_CUBIC_GAP, point_at1[Y] + HANDLE_CUBIC_GAP); } } else { - pointAt1 = in->first_segment()->initialPoint(); + point_at1 = in->first_segment()->initialPoint(); } - if (!ignoreCusp || !Geom::are_near((*cubic)[2], pointAt3)) { - pointAt2 = SBasisIn.valueAt(1 - weightValue); - if (weightValue != noPower) { - pointAt2 = - Geom::Point(pointAt2[X] + handleCubicGap, pointAt2[Y] + handleCubicGap); + if (!ignore_cusp || !Geom::are_near((*cubic)[2], point_at3)) { + point_at2 = sbasis_in.valueAt(1 - weight_ammount); + if (weight_ammount != NO_POWER) { + point_at2 = + Geom::Point(point_at2[X] + HANDLE_CUBIC_GAP, point_at2[Y] + HANDLE_CUBIC_GAP); } } else { - pointAt2 = in->first_segment()->finalPoint(); + point_at2 = in->first_segment()->finalPoint(); } } else { - if (!ignoreCusp && weightValue != noPower) { - pointAt1 = SBasisIn.valueAt(weightValue); - if (weightValue != noPower) { - pointAt1 = - Geom::Point(pointAt1[X] + handleCubicGap, pointAt1[Y] + handleCubicGap); + if (!ignore_cusp && weight_ammount != NO_POWER) { + point_at1 = sbasis_in.valueAt(weight_ammount); + if (weight_ammount != NO_POWER) { + point_at1 = + Geom::Point(point_at1[X] + HANDLE_CUBIC_GAP, point_at1[Y] + HANDLE_CUBIC_GAP); } - pointAt2 = SBasisIn.valueAt(1 - weightValue); - if (weightValue != noPower) { - pointAt2 = - Geom::Point(pointAt2[X] + handleCubicGap, pointAt2[Y] + handleCubicGap); + point_at2 = sbasis_in.valueAt(1 - weight_ammount); + if (weight_ammount != NO_POWER) { + point_at2 = + Geom::Point(point_at2[X] + HANDLE_CUBIC_GAP, point_at2[Y] + HANDLE_CUBIC_GAP); } } else { - pointAt1 = in->first_segment()->initialPoint(); - pointAt2 = in->first_segment()->finalPoint(); + point_at1 = in->first_segment()->initialPoint(); + point_at2 = in->first_segment()->finalPoint(); } } } else { if (cubic) { - if (!ignoreCusp || !Geom::are_near((*cubic)[1], pointAt0)) { - if (isNodePointSelected(pointAt0)) { - pointAt1 = SBasisIn.valueAt(weightValue); - if (weightValue != noPower) { - pointAt1 = - Geom::Point(pointAt1[X] + handleCubicGap, pointAt1[Y] + handleCubicGap); + if (!ignore_cusp || !Geom::are_near((*cubic)[1], point_at0)) { + if (isNodePointSelected(point_at0)) { + point_at1 = sbasis_in.valueAt(weight_ammount); + if (weight_ammount != NO_POWER) { + point_at1 = + Geom::Point(point_at1[X] + HANDLE_CUBIC_GAP, point_at1[Y] + HANDLE_CUBIC_GAP); } } else { - pointAt1 = (*cubic)[1]; + point_at1 = (*cubic)[1]; } } else { - pointAt1 = in->first_segment()->initialPoint(); + point_at1 = in->first_segment()->initialPoint(); } - if (!ignoreCusp || !Geom::are_near((*cubic)[2], pointAt3)) { - if (isNodePointSelected(pointAt3)) { - pointAt2 = SBasisIn.valueAt(1 - weightValue); - if (weightValue != noPower) { - pointAt2 = - Geom::Point(pointAt2[X] + handleCubicGap, pointAt2[Y] + handleCubicGap); + if (!ignore_cusp || !Geom::are_near((*cubic)[2], point_at3)) { + if (isNodePointSelected(point_at3)) { + point_at2 = sbasis_in.valueAt(1 - weight_ammount); + if (weight_ammount != NO_POWER) { + point_at2 = + Geom::Point(point_at2[X] + HANDLE_CUBIC_GAP, point_at2[Y] + HANDLE_CUBIC_GAP); } } else { - pointAt2 = (*cubic)[2]; + point_at2 = (*cubic)[2]; } } else { - pointAt2 = in->first_segment()->finalPoint(); + point_at2 = in->first_segment()->finalPoint(); } } else { - if (!ignoreCusp && weightValue != noPower) { - if (isNodePointSelected(pointAt0)) { - pointAt1 = SBasisIn.valueAt(weightValue); - pointAt1 = - Geom::Point(pointAt1[X] + handleCubicGap, pointAt1[Y] + handleCubicGap); + if (!ignore_cusp && weight_ammount != NO_POWER) { + if (isNodePointSelected(point_at0)) { + point_at1 = sbasis_in.valueAt(weight_ammount); + point_at1 = + Geom::Point(point_at1[X] + HANDLE_CUBIC_GAP, point_at1[Y] + HANDLE_CUBIC_GAP); } else { - pointAt1 = in->first_segment()->initialPoint(); + point_at1 = in->first_segment()->initialPoint(); } - if (isNodePointSelected(pointAt3)) { - pointAt2 = SBasisIn.valueAt(weightValue); - pointAt2 = - Geom::Point(pointAt2[X] + handleCubicGap, pointAt2[Y] + handleCubicGap); + if (isNodePointSelected(point_at3)) { + point_at2 = sbasis_in.valueAt(weight_ammount); + point_at2 = + Geom::Point(point_at2[X] + HANDLE_CUBIC_GAP, point_at2[Y] + HANDLE_CUBIC_GAP); } else { - pointAt2 = in->first_segment()->finalPoint(); + point_at2 = in->first_segment()->finalPoint(); } } else { - pointAt1 = in->first_segment()->initialPoint(); - pointAt2 = in->first_segment()->finalPoint(); + point_at1 = in->first_segment()->initialPoint(); + point_at2 = in->first_segment()->finalPoint(); } } } in->reset(); delete in; - nCurve->curveto(pointAt1, pointAt2, pointAt3); + curve_n->curveto(point_at1, point_at2, point_at3); ++curve_it1; ++curve_it2; } if (path_it->closed()) { - nCurve->move_endpoints(path_it->begin()->initialPoint(), + curve_n->move_endpoints(path_it->begin()->initialPoint(), path_it->begin()->initialPoint()); } else { - nCurve->move_endpoints(path_it->begin()->initialPoint(), pointAt3); + curve_n->move_endpoints(path_it->begin()->initialPoint(), point_at3); } if (path_it->closed()) { - nCurve->closepath_current(); + curve_n->closepath_current(); } - curve->append(nCurve, false); - nCurve->reset(); - delete nCurve; + curve->append(curve_n, false); + curve_n->reset(); + delete curve_n; } } diff --git a/src/live_effects/lpe-bspline.h b/src/live_effects/lpe-bspline.h index 8017e39ef..fc0f66353 100644 --- a/src/live_effects/lpe-bspline.h +++ b/src/live_effects/lpe-bspline.h @@ -18,7 +18,8 @@ public: LPEBSpline(LivePathEffectObject *lpeobject); virtual ~LPEBSpline(); - virtual LPEPathFlashType pathFlashType() const { + virtual LPEPathFlashType pathFlashType() const + { return SUPPRESS_FLASH; } virtual void doOnApply(SPLPEItem const* lpeitem); @@ -38,8 +39,8 @@ public: private: ScalarParam helper_size; - BoolParam ignoreCusp; - BoolParam onlySelected; + BoolParam ignore_cusp; + BoolParam only_selected; ScalarParam weight; Geom::PathVector hp; diff --git a/src/ui/tool/curve-drag-point.cpp b/src/ui/tool/curve-drag-point.cpp index a90dfb155..23640456e 100644 --- a/src/ui/tool/curve-drag-point.cpp +++ b/src/ui/tool/curve-drag-point.cpp @@ -54,7 +54,7 @@ bool CurveDragPoint::grabbed(GdkEventMotion */*event*/) // delta is a vector equal 1/3 of distance from first to second Geom::Point delta = (second->position() - first->position()) / 3.0; // only update the nodes if the mode is bspline - if(!_pm.isBSpline()){ + if(!_pm._isBSpline()){ first->front()->move(first->front()->position() + delta); second->back()->move(second->back()->position() - delta); } @@ -91,7 +91,7 @@ void CurveDragPoint::dragged(Geom::Point &new_pos, GdkEventMotion *event) Geom::Point offset1 = (weight/(3*t*t*(1-t))) * delta; //modified so that, if the trace is bspline, it only acts if the SHIFT key is pressed - if(!_pm.isBSpline()){ + if(!_pm._isBSpline()){ first->front()->move(first->front()->position() + offset0); second->back()->move(second->back()->position() + offset1); }else if(weight>=0.8){ diff --git a/src/ui/tool/node.cpp b/src/ui/tool/node.cpp index 08cc6708d..aa5365265 100644 --- a/src/ui/tool/node.cpp +++ b/src/ui/tool/node.cpp @@ -175,9 +175,9 @@ void Handle::move(Geom::Point const &new_pos) setPosition(new_pos); //move the handler and its oposite the same proportion - if(_pm().isBSpline()){ - setPosition(_pm().BSplineHandleReposition(this,this)); - this->other()->setPosition(_pm().BSplineHandleReposition(this->other(),this)); + if(_pm()._isBSpline()){ + setPosition(_pm()._bsplineHandleReposition(this,this)); + this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(),this)); } return; } @@ -192,9 +192,9 @@ void Handle::move(Geom::Point const &new_pos) setRelativePos(new_delta); //move the handler and its oposite the same proportion - if(_pm().isBSpline()){ - setPosition(_pm().BSplineHandleReposition(this,this)); - this->other()->setPosition(_pm().BSplineHandleReposition(this->other(),this)); + if(_pm()._isBSpline()){ + setPosition(_pm()._bsplineHandleReposition(this,this)); + this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(),this)); } return; @@ -218,9 +218,9 @@ void Handle::move(Geom::Point const &new_pos) setPosition(new_pos); // moves the handler and its oposite the same proportion - if(_pm().isBSpline()){ - setPosition(_pm().BSplineHandleReposition(this,this)); - this->other()->setPosition(_pm().BSplineHandleReposition(this->other(),this)); + if(_pm()._isBSpline()){ + setPosition(_pm()._bsplineHandleReposition(this,this)); + this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(),this)); } } @@ -312,9 +312,9 @@ bool Handle::_eventHandler(Inkscape::UI::Tools::ToolBase *event_context, GdkEven //this function moves the handler and its oposite to the default proportion of defaultStartPower void Handle::handle_2button_press(){ - if(_pm().isBSpline()){ - setPosition(_pm().BSplineHandleReposition(this,defaultStartPower)); - this->other()->setPosition(_pm().BSplineHandleReposition(this->other(),defaultStartPower)); + if(_pm()._isBSpline()){ + setPosition(_pm()._bsplineHandleReposition(this,defaultStartPower)); + this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(),defaultStartPower)); _pm().update(); } } @@ -372,16 +372,16 @@ void Handle::dragged(Geom::Point &new_pos, GdkEventMotion *event) new_pos = result; // moves the handler and its oposite in X fixed positions depending on parameter "steps with control" // by default in live BSpline - if(_pm().isBSpline()){ + if(_pm()._isBSpline()){ setPosition(new_pos); - int steps = _pm().BSplineGetSteps(); - new_pos=_pm().BSplineHandleReposition(this,ceilf(_pm().BSplineHandlePosition(this,this)*steps)/steps); + int steps = _pm()._bsplineGetSteps(); + new_pos=_pm()._bsplineHandleReposition(this,ceilf(_pm()._bsplineHandlePosition(this,this)*steps)/steps); } } std::vector unselected; //if the snap adjustment is activated and it is not bspline - if (snap && !_pm().isBSpline()) { + if (snap && !_pm()._isBSpline()) { ControlPointSelection::Set &nodes = _parent->_selection.allPoints(); for (ControlPointSelection::Set::iterator i = nodes.begin(); i != nodes.end(); ++i) { Node *n = static_cast(*i); @@ -422,7 +422,7 @@ void Handle::dragged(Geom::Point &new_pos, GdkEventMotion *event) } } //if it is bspline but SHIFT or CONTROL are not pressed it fixes it in the original position - if(_pm().isBSpline() && !held_shift(*event) && !held_control(*event)){ + if(_pm()._isBSpline() && !held_shift(*event) && !held_control(*event)){ new_pos=_last_drag_origin(); } move(new_pos); // needed for correct update, even though it's redundant @@ -486,7 +486,7 @@ Glib::ustring Handle::_getTip(unsigned state) const // a trick to mark as bspline if the node has no strength, we are going to use it later // to show the appropiate messages. We cannot do it in any different way becasue the function is constant Handle *h = const_cast(this); - bool isBSpline = _pm().isBSpline(); + bool isBSpline = _pm()._isBSpline(); bool can_shift_rotate = _parent->type() == NODE_CUSP && !other()->isDegenerate(); if (can_shift_rotate && !isBSpline) { more = C_("Path handle tip", "more: Shift, Ctrl, Alt"); @@ -549,7 +549,7 @@ Glib::ustring Handle::_getTip(unsigned state) const "Auto node handle: drag to convert to smooth node (%s)"), more); }else{ return format_tip(C_("Path handle tip", - "BSpline node handle: Shift to drag, double click to reset (%s). %g power"),more,_pm().BSplineHandlePosition(h,NULL)); + "BSpline node handle: Shift to drag, double click to reset (%s). %g power"),more,_pm()._bsplineHandlePosition(h,NULL)); } } } @@ -633,15 +633,15 @@ void Node::move(Geom::Point const &new_pos) Node *n = this; Node * nextNode = n->nodeToward(n->front()); Node * prevNode = n->nodeToward(n->back()); - nodeWeight = fmax(_pm().BSplineHandlePosition(n->front()),_pm().BSplineHandlePosition(n->back())); + nodeWeight = fmax(_pm()._bsplineHandlePosition(n->front()),_pm()._bsplineHandlePosition(n->back())); if(prevNode){ if(prevNode->isEndNode()){ - prevNodeWeight = _pm().BSplineHandlePosition(prevNode->front(),prevNode->front()); + prevNodeWeight = _pm()._bsplineHandlePosition(prevNode->front(),prevNode->front()); } } if(nextNode){ if(nextNode->isEndNode()){ - nextNodeWeight = _pm().BSplineHandlePosition(nextNode->back(),nextNode->back()); + nextNodeWeight = _pm()._bsplineHandlePosition(nextNode->back(),nextNode->back()); } } @@ -655,21 +655,21 @@ void Node::move(Geom::Point const &new_pos) _fixNeighbors(old_pos, new_pos); // move the affected handlers. First the node ones, later the adjoining ones. - if(_pm().isBSpline()){ - _front.setPosition(_pm().BSplineHandleReposition(this->front(),nodeWeight)); - _back.setPosition(_pm().BSplineHandleReposition(this->back(),nodeWeight)); + if(_pm()._isBSpline()){ + _front.setPosition(_pm()._bsplineHandleReposition(this->front(),nodeWeight)); + _back.setPosition(_pm()._bsplineHandleReposition(this->back(),nodeWeight)); if(prevNode){ if(prevNode->isEndNode()){ - prevNode->front()->setPosition(_pm().BSplineHandleReposition(prevNode->front(),prevNodeWeight)); + prevNode->front()->setPosition(_pm()._bsplineHandleReposition(prevNode->front(),prevNodeWeight)); }else{ - prevNode->front()->setPosition(_pm().BSplineHandleReposition(prevNode->front(),prevNode->back())); + prevNode->front()->setPosition(_pm()._bsplineHandleReposition(prevNode->front(),prevNode->back())); } } if(nextNode){ if(nextNode->isEndNode()){ - nextNode->back()->setPosition(_pm().BSplineHandleReposition(nextNode->back(),nextNodeWeight)); + nextNode->back()->setPosition(_pm()._bsplineHandleReposition(nextNode->back(),nextNodeWeight)); }else{ - nextNode->back()->setPosition(_pm().BSplineHandleReposition(nextNode->back(),nextNode->front())); + nextNode->back()->setPosition(_pm()._bsplineHandleReposition(nextNode->back(),nextNode->front())); } } } @@ -687,15 +687,15 @@ void Node::transform(Geom::Affine const &m) Node *n = this; Node * nextNode = n->nodeToward(n->front()); Node * prevNode = n->nodeToward(n->back()); - nodeWeight = _pm().BSplineHandlePosition(n->front()); + nodeWeight = _pm()._bsplineHandlePosition(n->front()); if(prevNode){ if(prevNode->isEndNode()){ - prevNodeWeight = _pm().BSplineHandlePosition(prevNode->front(),prevNode->front()); + prevNodeWeight = _pm()._bsplineHandlePosition(prevNode->front(),prevNode->front()); } } if(nextNode){ if(nextNode->isEndNode()){ - nextNodeWeight = _pm().BSplineHandlePosition(nextNode->back(),nextNode->back()); + nextNodeWeight = _pm()._bsplineHandlePosition(nextNode->back(),nextNode->back()); } } @@ -708,21 +708,21 @@ void Node::transform(Geom::Affine const &m) _fixNeighbors(old_pos, position()); // move the involved handlers, first the node ones, later the adjoining ones - if(_pm().isBSpline()){ - _front.setPosition(_pm().BSplineHandleReposition(this->front(),nodeWeight)); - _back.setPosition(_pm().BSplineHandleReposition(this->back(),nodeWeight)); + if(_pm()._isBSpline()){ + _front.setPosition(_pm()._bsplineHandleReposition(this->front(),nodeWeight)); + _back.setPosition(_pm()._bsplineHandleReposition(this->back(),nodeWeight)); if(prevNode){ if(prevNode->isEndNode()){ - prevNode->front()->setPosition(_pm().BSplineHandleReposition(prevNode->front(),prevNodeWeight)); + prevNode->front()->setPosition(_pm()._bsplineHandleReposition(prevNode->front(),prevNodeWeight)); }else{ - prevNode->front()->setPosition(_pm().BSplineHandleReposition(prevNode->front(),prevNode->back())); + prevNode->front()->setPosition(_pm()._bsplineHandleReposition(prevNode->front(),prevNode->back())); } } if(nextNode){ if(nextNode->isEndNode()){ - nextNode->back()->setPosition(_pm().BSplineHandleReposition(nextNode->back(),nextNodeWeight)); + nextNode->back()->setPosition(_pm()._bsplineHandleReposition(nextNode->back(),nextNodeWeight)); }else{ - nextNode->back()->setPosition(_pm().BSplineHandleReposition(nextNode->back(),nextNode->front())); + nextNode->back()->setPosition(_pm()._bsplineHandleReposition(nextNode->back(),nextNode->front())); } } } @@ -915,13 +915,13 @@ void Node::setType(NodeType type, bool update_handles) } /* in node type changes, about bspline traces, we can mantain them with noPower power in border mode, or we give them the default power in curve mode */ - if(_pm().isBSpline()){ + if(_pm()._isBSpline()){ double weight = noPower; - if(_pm().BSplineHandlePosition(this->front()) != noPower ){ + if(_pm()._bsplineHandlePosition(this->front()) != noPower ){ weight = defaultStartPower; } - _front.setPosition(_pm().BSplineHandleReposition(this->front(),weight)); - _back.setPosition(_pm().BSplineHandleReposition(this->back(),weight)); + _front.setPosition(_pm()._bsplineHandleReposition(this->front(),weight)); + _back.setPosition(_pm()._bsplineHandleReposition(this->back(),weight)); } } _type = type; @@ -1171,9 +1171,9 @@ void Node::_setState(State state) mgr.setActive(_canvas_item, true); mgr.setPrelight(_canvas_item, false); //this shows the handlers when selecting the nodes - if(_pm().isBSpline()){ - this->front()->setPosition(_pm().BSplineHandleReposition(this->front())); - this->back()->setPosition(_pm().BSplineHandleReposition(this->back())); + if(_pm()._isBSpline()){ + this->front()->setPosition(_pm()._bsplineHandleReposition(this->front())); + this->back()->setPosition(_pm()._bsplineHandleReposition(this->back())); } break; } @@ -1433,7 +1433,7 @@ Node *Node::nodeAwayFrom(Handle *h) Glib::ustring Node::_getTip(unsigned state) const { - bool isBSpline = _pm().isBSpline(); + bool isBSpline = _pm()._isBSpline(); Handle *h = const_cast(&_front); Handle *h2 = const_cast(&_back); if (state_held_shift(state)) { @@ -1470,7 +1470,7 @@ Glib::ustring Node::_getTip(unsigned state) const "%s: drag to shape the path (more: Shift, Ctrl, Alt)"), nodetype); }else if(_selection.size() == 1){ return format_tip(C_("Path node tip", - "BSpline node: drag to shape the path (more: Shift, Ctrl, Alt). %g power"),_pm().BSplineHandlePosition(h,h2)); + "BSpline node: drag to shape the path (more: Shift, Ctrl, Alt). %g power"),_pm()._bsplineHandlePosition(h,h2)); } return format_tip(C_("Path node tip", "%s: drag to shape the path, click to toggle scale/rotation handles (more: Shift, Ctrl, Alt)"), nodetype); @@ -1480,7 +1480,7 @@ Glib::ustring Node::_getTip(unsigned state) const "%s: drag to shape the path, click to select only this node (more: Shift, Ctrl, Alt)"), nodetype); }else{ return format_tip(C_("Path node tip", - "BSpline node: drag to shape the path, click to select only this node (more: Shift, Ctrl, Alt). %g power"),_pm().BSplineHandlePosition(h,h2)); + "BSpline node: drag to shape the path, click to select only this node (more: Shift, Ctrl, Alt). %g power"),_pm()._bsplineHandlePosition(h,h2)); } } diff --git a/src/ui/tool/path-manipulator.cpp b/src/ui/tool/path-manipulator.cpp index dbae69f2c..6b0c95f68 100644 --- a/src/ui/tool/path-manipulator.cpp +++ b/src/ui/tool/path-manipulator.cpp @@ -56,8 +56,8 @@ enum PathChange { }; } // anonymous namespace -const double handleCubicGap = 0.01; -const double noPower = 0.0; +const double HANDLE_CUBIC_GAP = 0.01; +const double NO_POWER = 0.0; const double defaultStartPower = 0.3334; @@ -152,7 +152,7 @@ PathManipulator::PathManipulator(MultiPathManipulator &mpm, SPPath *path, _createControlPointsFromGeometry(); //Define if the path is BSpline on construction - recalculateIsBSpline(); + _recalculateIsBSpline(); } PathManipulator::~PathManipulator() @@ -671,12 +671,12 @@ unsigned PathManipulator::_deleteStretch(NodeList::iterator start, NodeList::ite start = next; } // if we are removing, we readjust the handlers - if(isBSpline()){ + if(_isBSpline()){ if(start.prev()){ - start.prev()->front()->setPosition(BSplineHandleReposition(start.prev()->front(),start.prev()->back())); + start.prev()->front()->setPosition(_bsplineHandleReposition(start.prev()->front(),start.prev()->back())); } if(end){ - end->back()->setPosition(BSplineHandleReposition(end->back(),end->front())); + end->back()->setPosition(_bsplineHandleReposition(end->back(),end->front())); } } @@ -1000,30 +1000,30 @@ NodeList::iterator PathManipulator::subdivideSegment(NodeList::iterator first, d // set new handle positions Node *n = new Node(_multi_path_manipulator._path_data.node_data, seg2[0]); - if(!isBSpline()){ + if(!_isBSpline()){ n->back()->setPosition(seg1[2]); n->front()->setPosition(seg2[1]); n->setType(NODE_SMOOTH, false); } else { - Geom::D2< Geom::SBasis > SBasisInsideNodes; - SPCurve *lineInsideNodes = new SPCurve(); + Geom::D2< Geom::SBasis > sbasis_inside_nodes; + SPCurve *line_inside_nodes = new SPCurve(); if(second->back()->isDegenerate()){ - lineInsideNodes->moveto(n->position()); - lineInsideNodes->lineto(second->position()); - SBasisInsideNodes = lineInsideNodes->first_segment()->toSBasis(); - Geom::Point next = SBasisInsideNodes.valueAt(defaultStartPower); - next = Geom::Point(next[Geom::X] + handleCubicGap,next[Geom::Y] + handleCubicGap); - lineInsideNodes->reset(); + line_inside_nodes->moveto(n->position()); + line_inside_nodes->lineto(second->position()); + sbasis_inside_nodes = line_inside_nodes->first_segment()->toSBasis(); + Geom::Point next = sbasis_inside_nodes.valueAt(defaultStartPower); + next = Geom::Point(next[Geom::X] + HANDLE_CUBIC_GAP,next[Geom::Y] + HANDLE_CUBIC_GAP); + line_inside_nodes->reset(); n->front()->setPosition(next); }else{ n->front()->setPosition(seg2[1]); } if(first->front()->isDegenerate()){ - lineInsideNodes->moveto(n->position()); - lineInsideNodes->lineto(first->position()); - SBasisInsideNodes = lineInsideNodes->first_segment()->toSBasis(); - Geom::Point previous = SBasisInsideNodes.valueAt(defaultStartPower); - previous = Geom::Point(previous[Geom::X] + handleCubicGap,previous[Geom::Y] + handleCubicGap); + line_inside_nodes->moveto(n->position()); + line_inside_nodes->lineto(first->position()); + sbasis_inside_nodes = line_inside_nodes->first_segment()->toSBasis(); + Geom::Point previous = sbasis_inside_nodes.valueAt(defaultStartPower); + previous = Geom::Point(previous[Geom::X] + HANDLE_CUBIC_GAP,previous[Geom::Y] + HANDLE_CUBIC_GAP); n->back()->setPosition(previous); }else{ n->back()->setPosition(seg1[2]); @@ -1218,16 +1218,16 @@ void PathManipulator::_createControlPointsFromGeometry() } //determines if the trace has a bspline effect and the number of steps that it takes -int PathManipulator::BSplineGetSteps() const { +int PathManipulator::_bsplineGetSteps() const { LivePathEffect::LPEBSpline const *lpe_bsp = NULL; SPLPEItem * path = dynamic_cast(_path); if (path){ if(path->hasPathEffect()){ - Inkscape::LivePathEffect::Effect const *thisEffect = path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE); - if(thisEffect){ - lpe_bsp = dynamic_cast(thisEffect->getLPEObj()->get_lpe()); + Inkscape::LivePathEffect::Effect const *this_effect = path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE); + if(this_effect){ + lpe_bsp = dynamic_cast(this_effect->getLPEObj()->get_lpe()); } } } @@ -1239,10 +1239,10 @@ int PathManipulator::BSplineGetSteps() const { } // determines if the trace has bspline effect -void PathManipulator::recalculateIsBSpline(){ +void PathManipulator::_recalculateIsBSpline(){ if (SP_IS_LPE_ITEM(_path) && _path->hasPathEffect()) { - Inkscape::LivePathEffect::Effect const *thisEffect = _path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE); - if(thisEffect){ + Inkscape::LivePathEffect::Effect const *this_effect = _path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE); + if(this_effect){ _is_bspline = true; return; } @@ -1250,61 +1250,61 @@ void PathManipulator::recalculateIsBSpline(){ _is_bspline = false; } -bool PathManipulator::isBSpline() const { +bool PathManipulator::_isBSpline() const { return _is_bspline; } // returns the corresponding strength to the position of the handlers -double PathManipulator::BSplineHandlePosition(Handle *h, Handle *h2) +double PathManipulator::_bsplineHandlePosition(Handle *h, Handle *h2) { using Geom::X; using Geom::Y; if(h2){ h = h2; } - double pos = noPower; + double pos = NO_POWER; Node *n = h->parent(); - Node * nextNode = NULL; - nextNode = n->nodeToward(h); - if(nextNode){ - SPCurve *lineInsideNodes = new SPCurve(); - lineInsideNodes->moveto(n->position()); - lineInsideNodes->lineto(nextNode->position()); + Node * next_node = NULL; + next_node = n->nodeToward(h); + if(next_node){ + SPCurve *line_inside_nodes = new SPCurve(); + line_inside_nodes->moveto(n->position()); + line_inside_nodes->lineto(next_node->position()); if(!are_near(h->position(), n->position())){ - pos = Geom::nearest_point(Geom::Point(h->position()[X] - handleCubicGap, h->position()[Y] - handleCubicGap), *lineInsideNodes->first_segment()); + pos = Geom::nearest_point(Geom::Point(h->position()[X] - HANDLE_CUBIC_GAP, h->position()[Y] - HANDLE_CUBIC_GAP), *line_inside_nodes->first_segment()); } } - if (pos == noPower && !h2){ - return BSplineHandlePosition(h, h->other()); + if (pos == NO_POWER && !h2){ + return _bsplineHandlePosition(h, h->other()); } return pos; } // give the location for the handler in the corresponding position -Geom::Point PathManipulator::BSplineHandleReposition(Handle *h, Handle *h2) +Geom::Point PathManipulator::_bsplineHandleReposition(Handle *h, Handle *h2) { - double pos = this->BSplineHandlePosition(h, h2); - return BSplineHandleReposition(h,pos); + double pos = this->_bsplineHandlePosition(h, h2); + return _bsplineHandleReposition(h,pos); } // give the location for the handler to the specified position -Geom::Point PathManipulator::BSplineHandleReposition(Handle *h,double pos){ +Geom::Point PathManipulator::_bsplineHandleReposition(Handle *h,double pos){ using Geom::X; using Geom::Y; Geom::Point ret = h->position(); Node *n = h->parent(); - Geom::D2< Geom::SBasis > SBasisInsideNodes; - SPCurve *lineInsideNodes = new SPCurve(); - Node * nextNode = NULL; - nextNode = n->nodeToward(h); - if(nextNode && pos != noPower){ - lineInsideNodes->moveto(n->position()); - lineInsideNodes->lineto(nextNode->position()); - SBasisInsideNodes = lineInsideNodes->first_segment()->toSBasis(); - ret = SBasisInsideNodes.valueAt(pos); - ret = Geom::Point(ret[X] + handleCubicGap,ret[Y] + handleCubicGap); + Geom::D2< Geom::SBasis > sbasis_inside_nodes; + SPCurve *line_inside_nodes = new SPCurve(); + Node * next_node = NULL; + next_node = n->nodeToward(h); + if(next_node && pos != NO_POWER){ + line_inside_nodes->moveto(n->position()); + line_inside_nodes->lineto(next_node->position()); + sbasis_inside_nodes = line_inside_nodes->first_segment()->toSBasis(); + ret = sbasis_inside_nodes.valueAt(pos); + ret = Geom::Point(ret[X] + HANDLE_CUBIC_GAP, ret[Y] + HANDLE_CUBIC_GAP); }else{ - if(pos == noPower){ + if(pos == NO_POWER){ ret = n->position(); } } @@ -1319,7 +1319,7 @@ void PathManipulator::_createGeometryFromControlPoints(bool alert_LPE) { Geom::PathBuilder builder; //Refresh if is bspline some times -think on path change selection, this value get lost - recalculateIsBSpline(); + _recalculateIsBSpline(); for (std::list::iterator spi = _subpaths.begin(); spi != _subpaths.end(); ) { SubpathPtr subpath = *spi; if (subpath->empty()) { @@ -1349,16 +1349,16 @@ void PathManipulator::_createGeometryFromControlPoints(bool alert_LPE) if (alert_LPE) { /// \todo note that _path can be an Inkscape::LivePathEffect::Effect* too, kind of confusing, rework member naming? if (SP_IS_LPE_ITEM(_path) && _path->hasPathEffect()) { - Inkscape::LivePathEffect::Effect* thisEffect = _path->getPathEffectOfType(Inkscape::LivePathEffect::POWERSTROKE); - if(thisEffect){ - LivePathEffect::LPEPowerStroke *lpe_pwr = dynamic_cast(thisEffect->getLPEObj()->get_lpe()); + Inkscape::LivePathEffect::Effect* this_effect = _path->getPathEffectOfType(Inkscape::LivePathEffect::POWERSTROKE); + if(this_effect){ + LivePathEffect::LPEPowerStroke *lpe_pwr = dynamic_cast(this_effect->getLPEObj()->get_lpe()); if (lpe_pwr) { lpe_pwr->adjustForNewPath(pathv); } } - thisEffect = _path->getPathEffectOfType(Inkscape::LivePathEffect::FILLET_CHAMFER); - if(thisEffect){ - LivePathEffect::LPEFilletChamfer *lpe_fll = dynamic_cast(thisEffect->getLPEObj()->get_lpe()); + this_effect = _path->getPathEffectOfType(Inkscape::LivePathEffect::FILLET_CHAMFER); + if(this_effect){ + LivePathEffect::LPEFilletChamfer *lpe_fll = dynamic_cast(this_effect->getLPEObj()->get_lpe()); if (lpe_fll) { lpe_fll->adjustForNewPath(pathv); } diff --git a/src/ui/tool/path-manipulator.h b/src/ui/tool/path-manipulator.h index 6dc1c9d09..2219af849 100644 --- a/src/ui/tool/path-manipulator.h +++ b/src/ui/tool/path-manipulator.h @@ -96,7 +96,7 @@ public: NodeList::iterator extremeNode(NodeList::iterator origin, bool search_selected, bool search_unselected, bool closest); - int BSplineGetSteps() const; + int _bsplineGetSteps() const; // this is necessary for Tab-selection in MultiPathManipulator SubpathList &subpathList() { return _subpaths; } @@ -107,11 +107,11 @@ private: void _createControlPointsFromGeometry(); - void recalculateIsBSpline(); - bool isBSpline() const; - double BSplineHandlePosition(Handle *h, Handle *h2 = NULL); - Geom::Point BSplineHandleReposition(Handle *h, Handle *h2 = NULL); - Geom::Point BSplineHandleReposition(Handle *h, double pos); + void _recalculateIsBSpline(); + bool _isBSpline() const; + double _bsplineHandlePosition(Handle *h, Handle *h2 = NULL); + Geom::Point _bsplineHandleReposition(Handle *h, Handle *h2 = NULL); + Geom::Point _bsplineHandleReposition(Handle *h, double pos); void _createGeometryFromControlPoints(bool alert_LPE = false); unsigned _deleteStretch(NodeList::iterator first, NodeList::iterator last, bool keep_shape); std::string _createTypeString(); diff --git a/src/ui/tools/freehand-base.cpp b/src/ui/tools/freehand-base.cpp index 0f14d7534..e8cbfcdbf 100644 --- a/src/ui/tools/freehand-base.cpp +++ b/src/ui/tools/freehand-base.cpp @@ -92,7 +92,7 @@ FreehandBase::FreehandBase(gchar const *const *cursor_shape, gint hot_x, gint ho , white_item(NULL) , white_curves(NULL) , white_anchors(NULL) - , overwriteCurve(NULL) + , overwrite_curve(NULL) , sa(NULL) , ea(NULL) , waiting_LPE_type(Inkscape::LivePathEffect::INVALID_LPE) @@ -149,7 +149,7 @@ void FreehandBase::setup() { this->green_closed = FALSE; // Create start anchor alternative curve - this->overwriteCurve = new SPCurve(); + this->overwrite_curve = new SPCurve(); this->attach = TRUE; spdc_attach_selection(this, this->selection); @@ -575,12 +575,12 @@ void spdc_concat_colors_and_flush(FreehandBase *dc, gboolean forceclosed) } if(prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 1 || prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 2){ - dc->overwriteCurve->append_continuous(c, 0.0625); + dc->overwrite_curve->append_continuous(c, 0.0625); c->unref(); - dc->overwriteCurve->closepath_current(); + dc->overwrite_curve->closepath_current(); if(dc->sa){ dc->white_curves = g_slist_remove(dc->white_curves, dc->sa->curve); - dc->white_curves = g_slist_append(dc->white_curves, dc->overwriteCurve); + dc->white_curves = g_slist_append(dc->white_curves, dc->overwrite_curve); } }else{ dc->sa->curve->append_continuous(c, 0.0625); @@ -597,7 +597,7 @@ void spdc_concat_colors_and_flush(FreehandBase *dc, gboolean forceclosed) dc->white_curves = g_slist_remove(dc->white_curves, s); if(prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 1 || prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 2){ - s = dc->overwriteCurve; + s = dc->overwrite_curve; } if (dc->sa->start) { s = reverse_then_unref(s); diff --git a/src/ui/tools/freehand-base.h b/src/ui/tools/freehand-base.h index 6b4265215..a3e7b42f9 100644 --- a/src/ui/tools/freehand-base.h +++ b/src/ui/tools/freehand-base.h @@ -78,7 +78,7 @@ public: //ALternative curve to use on continuing exisiting curve in case of bspline or spirolive //because usigh anchor curves give memory and random bugs, - and obscure code- in some plataform reported by su_v in mac - SPCurve *overwriteCurve; + SPCurve *overwrite_curve; // Start anchor SPDrawAnchor *sa; diff --git a/src/ui/tools/pen-tool.cpp b/src/ui/tools/pen-tool.cpp index d5f501163..daffc7032 100644 --- a/src/ui/tools/pen-tool.cpp +++ b/src/ui/tools/pen-tool.cpp @@ -85,7 +85,7 @@ namespace Tools { static Geom::Point pen_drag_origin_w(0, 0); static bool pen_within_tolerance = false; static int pen_last_paraxial_dir = 0; // last used direction in horizontal/vertical mode; 0 = horizontal, 1 = vertical -const double handleCubicGap = 0.01; +const double HANDLE_CUBIC_GAP = 0.01; const std::string& PenTool::getPrefsPath() { return PenTool::prefsPath; @@ -165,17 +165,17 @@ void PenTool::setPolylineMode() { this->polylines_paraxial = (mode == 4); //we call the function which defines the Spiro modes and the BSpline //todo: merge to one function only - this->_pen_context_set_mode(mode); + this->_penContextSetMode(mode); } /* *.Set the mode of draw spiro, and bsplines */ -void PenTool::_pen_context_set_mode(guint mode) { +void PenTool::_penContextSetMode(guint mode) { // define the nodes this->spiro = (mode == 1); this->bspline = (mode == 2); - this->_bspline_spiro_color(); + this->_bsplineSpiroColor(); } /** @@ -429,7 +429,7 @@ bool PenTool::_handleButtonPress(GdkEventButton const &bevent) { // This is allowed, if we just canceled curve case PenTool::POINT: if (this->npoints == 0) { - this->_bspline_spiro_color(); + this->_bsplineSpiroColor(); Geom::Point p; if ((bevent.state & GDK_CONTROL_MASK) && (this->polylines_only || this->polylines_paraxial)) { p = event_dt; @@ -451,7 +451,7 @@ bool PenTool::_handleButtonPress(GdkEventButton const &bevent) { this->sa = anchor; if(anchor){ - this->_bspline_spiro_start_anchor(bevent.state & GDK_SHIFT_MASK); + this->_bsplineSpiroStartAnchor(bevent.state & GDK_SHIFT_MASK); } if (anchor && (!this->hasWaitingLPE()|| this->bspline || this->spiro)) { // Adjust point to anchor if needed; if we have a waiting LPE, we need @@ -700,10 +700,10 @@ bool PenTool::_handleMotionNotify(GdkEventMotion const &mevent) { } // calls the function "bspline_spiro_motion" when the mouse starts or stops moving if(this->bspline){ - this->_bspline_spiro_motion(mevent.state & GDK_SHIFT_MASK); + this->_bsplineSpiroMotion(mevent.state & GDK_SHIFT_MASK); }else{ if ( Geom::LInfty( event_w - pen_drag_origin_w ) > (tolerance/2) || mevent.time == 0) { - this->_bspline_spiro_motion(mevent.state & GDK_SHIFT_MASK); + this->_bsplineSpiroMotion(mevent.state & GDK_SHIFT_MASK); pen_drag_origin_w = event_w; } } @@ -742,7 +742,7 @@ bool PenTool::_handleButtonRelease(GdkEventButton const &revent) { case PenTool::POINT: if ( this->npoints == 0 ) { // Start new thread only with button release - this->_bspline_spiro_color(); + this->_bsplineSpiroColor(); if (anchor) { p = anchor->dp; } @@ -750,7 +750,7 @@ bool PenTool::_handleButtonRelease(GdkEventButton const &revent) { // continue the existing curve if (anchor) { if(this->bspline || this->spiro){ - this->_bspline_spiro_start_anchor(revent.state & GDK_SHIFT_MASK);; + this->_bsplineSpiroStartAnchor(revent.state & GDK_SHIFT_MASK);; } } this->_setInitialPoint(p); @@ -879,11 +879,11 @@ void PenTool::_redrawAll() { this->green_bpaths = g_slist_remove(this->green_bpaths, this->green_bpaths->data); } // one canvas bpath for all of green_curve - SPCanvasItem *cshape = sp_canvas_bpath_new(this->desktop->getSketch(), this->green_curve); - sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); - sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(cshape), 0, SP_WIND_RULE_NONZERO); + SPCanvasItem *canvas_shape = sp_canvas_bpath_new(this->desktop->getSketch(), this->green_curve); + sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvas_shape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); + sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(canvas_shape), 0, SP_WIND_RULE_NONZERO); - this->green_bpaths = g_slist_prepend(this->green_bpaths, cshape); + this->green_bpaths = g_slist_prepend(this->green_bpaths, canvas_shape); } if (this->green_anchor) SP_CTRL(this->green_anchor->ctrl)->moveto(this->green_anchor->dp); @@ -925,7 +925,7 @@ void PenTool::_redrawAll() { // simply redraw the spiro. because its a redrawing, we don't call the global function, // but we call the redrawing at the ending. - this->_bspline_spiro_build(); + this->_bsplineSpiroBuild(); } void PenTool::_lastpointMove(gdouble x, gdouble y) { @@ -1001,7 +1001,7 @@ void PenTool::_lastpointToCurve() { } //if the last node is an union with another curve if (this->green_curve->is_empty() && this->sa && !this->sa->curve->is_empty()) { - this->_bspline_spiro_start_anchor(false); + this->_bsplineSpiroStartAnchor(false); } } @@ -1048,7 +1048,7 @@ void PenTool::_lastpointToLine() { } // if the last node is an union with another curve if(this->green_curve->is_empty() && this->sa && !this->sa->curve->is_empty()){ - this->_bspline_spiro_start_anchor(true); + this->_bsplineSpiroStartAnchor(true); } } @@ -1312,7 +1312,7 @@ void PenTool::_setAngleDistanceStatusMessage(Geom::Point const p, int pc_point_t } // this function changes the colors red, green and blue making them transparent or not, depending on if spiro is being used. -void PenTool::_bspline_spiro_color() +void PenTool::_bsplineSpiroColor() { static Inkscape::Preferences *prefs = Inkscape::Preferences::get(); if(this->spiro){ @@ -1346,25 +1346,25 @@ void PenTool::_bspline_spiro_color() this->green_bpaths = g_slist_remove(this->green_bpaths, this->green_bpaths->data); } // one canvas bpath for all of green_curve - SPCanvasItem *cshape = sp_canvas_bpath_new(this->desktop->getSketch(), this->green_curve); - sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); - sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(cshape), 0, SP_WIND_RULE_NONZERO); - this->green_bpaths = g_slist_prepend(this->green_bpaths, cshape); + SPCanvasItem *canvas_shape = sp_canvas_bpath_new(this->desktop->getSketch(), this->green_curve); + sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvas_shape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); + sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(canvas_shape), 0, SP_WIND_RULE_NONZERO); + this->green_bpaths = g_slist_prepend(this->green_bpaths, canvas_shape); } sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(this->red_bpath), this->red_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); } -void PenTool::_bspline_spiro(bool shift) +void PenTool::_bsplineSpiro(bool shift) { if(!this->spiro && !this->bspline) return; - shift?this->_bspline_spiro_off():this->_bspline_spiro_on(); - this->_bspline_spiro_build(); + shift?this->_bsplineSpiroOff():this->_bsplineSpiroOn(); + this->_bsplineSpiroBuild(); } -void PenTool::_bspline_spiro_on() +void PenTool::_bsplineSpiroOn() { if(!this->red_curve->is_empty()){ using Geom::X; @@ -1373,11 +1373,11 @@ void PenTool::_bspline_spiro_on() this->p[0] = this->red_curve->first_segment()->initialPoint(); this->p[3] = this->red_curve->first_segment()->finalPoint(); this->p[2] = this->p[3] + (1./3)*(this->p[0] - this->p[3]); - this->p[2] = Geom::Point(this->p[2][X] + handleCubicGap,this->p[2][Y] + handleCubicGap); + this->p[2] = Geom::Point(this->p[2][X] + HANDLE_CUBIC_GAP,this->p[2][Y] + HANDLE_CUBIC_GAP); } } -void PenTool::_bspline_spiro_off() +void PenTool::_bsplineSpiroOff() { if(!this->red_curve->is_empty()){ this->npoints = 5; @@ -1387,7 +1387,7 @@ void PenTool::_bspline_spiro_off() } } -void PenTool::_bspline_spiro_start_anchor(bool shift) +void PenTool::_bsplineSpiroStartAnchor(bool shift) { if(this->sa->curve->is_empty()){ return; @@ -1423,73 +1423,73 @@ void PenTool::_bspline_spiro_start_anchor(bool shift) return; if(shift) - this->_bspline_spiro_start_anchor_off(); + this->_bsplineSpiroStartAnchorOff(); else - this->_bspline_spiro_start_anchor_on(); + this->_bsplineSpiroStartAnchorOn(); } -void PenTool::_bspline_spiro_start_anchor_on() +void PenTool::_bsplineSpiroStartAnchorOn() { using Geom::X; using Geom::Y; - SPCurve *tmpCurve = new SPCurve(); - tmpCurve = this->sa->curve->copy(); + SPCurve *tmp_curve = new SPCurve(); + tmp_curve = this->sa->curve->copy(); if(this->sa->start) - tmpCurve = tmpCurve->create_reverse(); - Geom::CubicBezier const * cubic = dynamic_cast(&*tmpCurve->last_segment()); - SPCurve *lastSeg = new SPCurve(); - Geom::Point A = tmpCurve->last_segment()->initialPoint(); - Geom::Point D = tmpCurve->last_segment()->finalPoint(); - Geom::Point C = D + (1./3)*(A - D); - C = Geom::Point(C[X] + handleCubicGap,C[Y] + handleCubicGap); + tmp_curve = tmp_curve ->create_reverse(); + Geom::CubicBezier const * cubic = dynamic_cast(&*tmp_curve ->last_segment()); + SPCurve *last_segment = new SPCurve(); + Geom::Point point_a = tmp_curve ->last_segment()->initialPoint(); + Geom::Point point_d = tmp_curve ->last_segment()->finalPoint(); + Geom::Point point_c = point_d + (1./3)*(point_a - point_d); + point_c = Geom::Point(point_c[X] + HANDLE_CUBIC_GAP, point_c[Y] + HANDLE_CUBIC_GAP); if(cubic){ - lastSeg->moveto(A); - lastSeg->curveto((*cubic)[1],C,D); + last_segment->moveto(point_a); + last_segment->curveto((*cubic)[1],point_c,point_d); }else{ - lastSeg->moveto(A); - lastSeg->curveto(A,C,D); + last_segment->moveto(point_a); + last_segment->curveto(point_a,point_c,point_d); } - if( tmpCurve->get_segment_count() == 1){ - tmpCurve = lastSeg; + if( tmp_curve ->get_segment_count() == 1){ + tmp_curve = last_segment; }else{ //we eliminate the last segment - tmpCurve->backspace(); + tmp_curve ->backspace(); //and we add it again with the recreation - tmpCurve->append_continuous(lastSeg, 0.0625); + tmp_curve ->append_continuous(last_segment, 0.0625); } if (this->sa->start) { - tmpCurve = tmpCurve->create_reverse(); + tmp_curve = tmp_curve ->create_reverse(); } - this->overwriteCurve = tmpCurve; + this->overwrite_curve = tmp_curve ; } -void PenTool::_bspline_spiro_start_anchor_off() +void PenTool::_bsplineSpiroStartAnchorOff() { - SPCurve *tmpCurve = new SPCurve(); - tmpCurve = this->sa->curve->copy(); + SPCurve *tmp_curve = new SPCurve(); + tmp_curve = this->sa->curve->copy(); if(this->sa->start) - tmpCurve = tmpCurve->create_reverse(); - Geom::CubicBezier const * cubic = dynamic_cast(&*tmpCurve->last_segment()); + tmp_curve = tmp_curve ->create_reverse(); + Geom::CubicBezier const * cubic = dynamic_cast(&*tmp_curve ->last_segment()); if(cubic){ - SPCurve *lastSeg = new SPCurve(); - lastSeg->moveto((*cubic)[0]); - lastSeg->curveto((*cubic)[1],(*cubic)[3],(*cubic)[3]); - if( tmpCurve->get_segment_count() == 1){ - tmpCurve = lastSeg; + SPCurve *last_segment = new SPCurve(); + last_segment->moveto((*cubic)[0]); + last_segment->curveto((*cubic)[1],(*cubic)[3],(*cubic)[3]); + if( tmp_curve ->get_segment_count() == 1){ + tmp_curve = last_segment; }else{ //we eliminate the last segment - tmpCurve->backspace(); + tmp_curve ->backspace(); //and we add it again with the recreation - tmpCurve->append_continuous(lastSeg, 0.0625); + tmp_curve ->append_continuous(last_segment, 0.0625); } } if (this->sa->start) { - tmpCurve = tmpCurve->create_reverse(); + tmp_curve = tmp_curve ->create_reverse(); } - this->overwriteCurve = tmpCurve; + this->overwrite_curve = tmp_curve ; } -void PenTool::_bspline_spiro_motion(bool shift){ +void PenTool::_bsplineSpiroMotion(bool shift){ if(!this->spiro && !this->bspline) return; @@ -1497,40 +1497,40 @@ void PenTool::_bspline_spiro_motion(bool shift){ using Geom::Y; if(this->red_curve->is_empty()) return; this->npoints = 5; - SPCurve *tmpCurve = new SPCurve(); + SPCurve *tmp_curve = new SPCurve(); this->p[2] = this->p[3] + (1./3)*(this->p[0] - this->p[3]); - this->p[2] = Geom::Point(this->p[2][X] + handleCubicGap,this->p[2][Y] + handleCubicGap); + this->p[2] = Geom::Point(this->p[2][X] + HANDLE_CUBIC_GAP,this->p[2][Y] + HANDLE_CUBIC_GAP); if(this->green_curve->is_empty() && !this->sa){ this->p[1] = this->p[0] + (1./3)*(this->p[3] - this->p[0]); - this->p[1] = Geom::Point(this->p[1][X] + handleCubicGap,this->p[1][Y] + handleCubicGap); + this->p[1] = Geom::Point(this->p[1][X] + HANDLE_CUBIC_GAP,this->p[1][Y] + HANDLE_CUBIC_GAP); if(shift){ this->p[2] = this->p[3]; } }else if(!this->green_curve->is_empty()){ - tmpCurve = this->green_curve->copy(); + tmp_curve = this->green_curve->copy(); }else{ - tmpCurve = this->overwriteCurve->copy(); + tmp_curve = this->overwrite_curve->copy(); if(this->sa->start) - tmpCurve = tmpCurve->create_reverse(); + tmp_curve = tmp_curve ->create_reverse(); } - if(!tmpCurve->is_empty()){ - Geom::CubicBezier const * cubic = dynamic_cast(&*tmpCurve->last_segment()); + if(!tmp_curve ->is_empty()){ + Geom::CubicBezier const * cubic = dynamic_cast(&*tmp_curve ->last_segment()); if(cubic){ if(this->bspline){ - SPCurve * WPower = new SPCurve(); - Geom::D2< Geom::SBasis > SBasisWPower; - WPower->moveto(tmpCurve->last_segment()->finalPoint()); - WPower->lineto(tmpCurve->last_segment()->initialPoint()); - float WP = Geom::nearest_point((*cubic)[2],*WPower->first_segment()); - WPower->reset(); - WPower->moveto(this->red_curve->last_segment()->initialPoint()); - WPower->lineto(this->red_curve->last_segment()->finalPoint()); - SBasisWPower = WPower->first_segment()->toSBasis(); - WPower->reset(); - this->p[1] = SBasisWPower.valueAt(WP); + SPCurve * weight_power = new SPCurve(); + Geom::D2< Geom::SBasis > SBasisweight_power; + weight_power->moveto(tmp_curve ->last_segment()->finalPoint()); + weight_power->lineto(tmp_curve ->last_segment()->initialPoint()); + float WP = Geom::nearest_point((*cubic)[2],*weight_power->first_segment()); + weight_power->reset(); + weight_power->moveto(this->red_curve->last_segment()->initialPoint()); + weight_power->lineto(this->red_curve->last_segment()->finalPoint()); + SBasisweight_power = weight_power->first_segment()->toSBasis(); + weight_power->reset(); + this->p[1] = SBasisweight_power.valueAt(WP); if(!Geom::are_near(this->p[1],this->p[0])){ - this->p[1] = Geom::Point(this->p[1][X] + handleCubicGap,this->p[1][Y] + handleCubicGap); + this->p[1] = Geom::Point(this->p[1][X] + HANDLE_CUBIC_GAP,this->p[1][Y] + HANDLE_CUBIC_GAP); } else { this->p[1] = this->p[0]; } @@ -1548,129 +1548,129 @@ void PenTool::_bspline_spiro_motion(bool shift){ if(this->anchor_statusbar && !this->red_curve->is_empty()){ if(shift){ - this->_bspline_spiro_end_anchor_off(); + this->_bsplineSpiroEndAnchorOff(); }else{ - this->_bspline_spiro_end_anchor_on(); + this->_bsplineSpiroEndAnchorOn(); } } - this->_bspline_spiro_build(); + this->_bsplineSpiroBuild(); } -void PenTool::_bspline_spiro_end_anchor_on() +void PenTool::_bsplineSpiroEndAnchorOn() { using Geom::X; using Geom::Y; this->p[2] = this->p[3] + (1./3)*(this->p[0] - this->p[3]); - this->p[2] = Geom::Point(this->p[2][X] + handleCubicGap,this->p[2][Y] + handleCubicGap); - SPCurve *tmpCurve = new SPCurve(); - SPCurve *lastSeg = new SPCurve(); - Geom::Point C(0,0); + this->p[2] = Geom::Point(this->p[2][X] + HANDLE_CUBIC_GAP,this->p[2][Y] + HANDLE_CUBIC_GAP); + SPCurve *tmp_curve = new SPCurve(); + SPCurve *last_segment = new SPCurve(); + Geom::Point point_c(0,0); bool reverse = false; if( this->green_anchor && this->green_anchor->active ){ - tmpCurve = this->green_curve->create_reverse(); + tmp_curve = this->green_curve->create_reverse(); if(this->green_curve->get_segment_count()==0){ return; } reverse = true; } else if(this->sa){ - tmpCurve = this->overwriteCurve->copy(); + tmp_curve = this->overwrite_curve->copy(); if(!this->sa->start){ - tmpCurve = tmpCurve->create_reverse(); + tmp_curve = tmp_curve ->create_reverse(); reverse = true; } }else{ return; } - Geom::CubicBezier const * cubic = dynamic_cast(&*tmpCurve->last_segment()); + Geom::CubicBezier const * cubic = dynamic_cast(&*tmp_curve ->last_segment()); if(this->bspline){ - C = tmpCurve->last_segment()->finalPoint() + (1./3)*(tmpCurve->last_segment()->initialPoint() - tmpCurve->last_segment()->finalPoint()); - C = Geom::Point(C[X] + handleCubicGap,C[Y] + handleCubicGap); + point_c = tmp_curve ->last_segment()->finalPoint() + (1./3)*(tmp_curve ->last_segment()->initialPoint() - tmp_curve ->last_segment()->finalPoint()); + point_c = Geom::Point(point_c[X] + HANDLE_CUBIC_GAP, point_c[Y] + HANDLE_CUBIC_GAP); }else{ - C = this->p[3] + this->p[3] - this->p[2]; + point_c = this->p[3] + this->p[3] - this->p[2]; } if(cubic){ - lastSeg->moveto((*cubic)[0]); - lastSeg->curveto((*cubic)[1],C,(*cubic)[3]); + last_segment->moveto((*cubic)[0]); + last_segment->curveto((*cubic)[1],point_c,(*cubic)[3]); }else{ - lastSeg->moveto(tmpCurve->last_segment()->initialPoint()); - lastSeg->lineto(tmpCurve->last_segment()->finalPoint()); + last_segment->moveto(tmp_curve ->last_segment()->initialPoint()); + last_segment->lineto(tmp_curve ->last_segment()->finalPoint()); } - if( tmpCurve->get_segment_count() == 1){ - tmpCurve = lastSeg; + if( tmp_curve ->get_segment_count() == 1){ + tmp_curve = last_segment; }else{ //we eliminate the last segment - tmpCurve->backspace(); + tmp_curve ->backspace(); //and we add it again with the recreation - tmpCurve->append_continuous(lastSeg, 0.0625); + tmp_curve ->append_continuous(last_segment, 0.0625); } if (reverse) { - tmpCurve = tmpCurve->create_reverse(); + tmp_curve = tmp_curve ->create_reverse(); } if( this->green_anchor && this->green_anchor->active ) { this->green_curve->reset(); - this->green_curve = tmpCurve; + this->green_curve = tmp_curve ; }else{ - this->overwriteCurve->reset(); - this->overwriteCurve = tmpCurve; + this->overwrite_curve->reset(); + this->overwrite_curve = tmp_curve ; } } -void PenTool::_bspline_spiro_end_anchor_off() +void PenTool::_bsplineSpiroEndAnchorOff() { - SPCurve *tmpCurve = new SPCurve(); - SPCurve *lastSeg = new SPCurve(); + SPCurve *tmp_curve = new SPCurve(); + SPCurve *last_segment = new SPCurve(); bool reverse = false; this->p[2] = this->p[3]; if( this->green_anchor && this->green_anchor->active ){ - tmpCurve = this->green_curve->create_reverse(); + tmp_curve = this->green_curve->create_reverse(); if(this->green_curve->get_segment_count()==0){ return; } reverse = true; } else if(this->sa){ - tmpCurve = this->overwriteCurve->copy(); + tmp_curve = this->overwrite_curve->copy(); if(!this->sa->start){ - tmpCurve = tmpCurve->create_reverse(); + tmp_curve = tmp_curve ->create_reverse(); reverse = true; } }else{ return; } - Geom::CubicBezier const * cubic = dynamic_cast(&*tmpCurve->last_segment()); + Geom::CubicBezier const * cubic = dynamic_cast(&*tmp_curve ->last_segment()); if(cubic){ - lastSeg->moveto((*cubic)[0]); - lastSeg->curveto((*cubic)[1],(*cubic)[3],(*cubic)[3]); + last_segment->moveto((*cubic)[0]); + last_segment->curveto((*cubic)[1],(*cubic)[3],(*cubic)[3]); }else{ - lastSeg->moveto(tmpCurve->last_segment()->initialPoint()); - lastSeg->lineto(tmpCurve->last_segment()->finalPoint()); + last_segment->moveto(tmp_curve ->last_segment()->initialPoint()); + last_segment->lineto(tmp_curve ->last_segment()->finalPoint()); } - if( tmpCurve->get_segment_count() == 1){ - tmpCurve = lastSeg; + if( tmp_curve ->get_segment_count() == 1){ + tmp_curve = last_segment; }else{ //we eliminate the last segment - tmpCurve->backspace(); + tmp_curve ->backspace(); //and we add it again with the recreation - tmpCurve->append_continuous(lastSeg, 0.0625); + tmp_curve ->append_continuous(last_segment, 0.0625); } if (reverse) { - tmpCurve = tmpCurve->create_reverse(); + tmp_curve = tmp_curve ->create_reverse(); } if( this->green_anchor && this->green_anchor->active ) { this->green_curve->reset(); - this->green_curve = tmpCurve; + this->green_curve = tmp_curve ; }else{ - this->overwriteCurve->reset(); - this->overwriteCurve = tmpCurve; + this->overwrite_curve->reset(); + this->overwrite_curve = tmp_curve ; } } //prepares the curves for its transformation into BSpline curve. -void PenTool::_bspline_spiro_build() +void PenTool::_bsplineSpiroBuild() { if(!this->spiro && !this->bspline){ return; @@ -1680,7 +1680,7 @@ void PenTool::_bspline_spiro_build() SPCurve *curve = new SPCurve(); //If we continuate the existing curve we add it at the start if(this->sa && !this->sa->curve->is_empty()){ - curve = this->overwriteCurve->copy(); + curve = this->overwrite_curve->copy(); if (this->sa->start) { curve = curve->create_reverse(); } @@ -1715,9 +1715,9 @@ void PenTool::_bspline_spiro_build() //Effect *spr = static_cast ( new LPEbspline(lpeobj) ); //spr->doEffect(curve); if(this->bspline){ - this->_bspline_doEffect(curve); + this->_bsplineDoEffect(curve); }else{ - this->_spiro_doEffect(curve); + this->_spiroDoEffect(curve); } sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->blue_bpath), curve); @@ -1741,66 +1741,73 @@ void PenTool::_bspline_spiro_build() } } -void PenTool::_bspline_doEffect(SPCurve * curve) +//from LPE BSPLINE: +void PenTool::_bsplineDoEffect(SPCurve * curve) { - // commenting the function doEffect in src/live_effects/lpe-bspline.cpp - if (curve->get_segment_count() < 1){ + const double NO_POWER = 0.0; + const double DEFAULT_START_POWER = 0.3334; + const double DEFAULT_END_POWER = 0.6667; + if (curve->get_segment_count() < 1) { return; } // Make copy of old path as it is changed during processing Geom::PathVector const original_pathv = curve->get_pathvector(); + curve->reset(); - //Recorremos todos los paths a los que queremos aplicar el efecto, hasta el - //penúltimo for (Geom::PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) { - //Si está vacío... - if (path_it->empty()) + if (path_it->empty()) { continue; - //Itreadores - + } Geom::Path::const_iterator curve_it1 = path_it->begin(); Geom::Path::const_iterator curve_it2 = ++(path_it->begin()); - Geom::Path::const_iterator curve_endit = path_it->end_default(); - SPCurve *nCurve = new SPCurve(); + Geom::Path::const_iterator curve_endit = path_it->end_default(); + SPCurve *curve_n = new SPCurve(); Geom::Point previousNode(0, 0); Geom::Point node(0, 0); - Geom::Point pointAt1(0, 0); - Geom::Point pointAt2(0, 0); - Geom::Point nextPointAt1(0, 0); - Geom::D2 SBasisIn; - Geom::D2 SBasisOut; - Geom::D2 SBasisHelper; + Geom::Point point_at1(0, 0); + Geom::Point point_at2(0, 0); + Geom::Point next_point_at1(0, 0); + Geom::D2 sbasis_in; + Geom::D2 sbasis_out; + Geom::D2 sbasis_helper; Geom::CubicBezier const *cubic = NULL; if (path_it->closed()) { + // if the path is closed, maybe we have to stop a bit earlier because the + // closing line segment has zerolength. const Geom::Curve &closingline = path_it->back_closed(); // the closing line segment is always of type + // Geom::LineSegment. if (are_near(closingline.initialPoint(), closingline.finalPoint())) { + // closingline.isDegenerate() did not work, because it only checks for + // *exact* zero length, which goes wrong for relative coordinates and + // rounding errors... + // the closing line segment has zero-length. So stop before that one! curve_endit = path_it->end_open(); } } - nCurve->moveto(curve_it1->initialPoint()); + curve_n->moveto(curve_it1->initialPoint()); while (curve_it1 != curve_endit) { SPCurve *in = new SPCurve(); in->moveto(curve_it1->initialPoint()); in->lineto(curve_it1->finalPoint()); cubic = dynamic_cast(&*curve_it1); if (cubic) { - SBasisIn = in->first_segment()->toSBasis(); + sbasis_in = in->first_segment()->toSBasis(); if(are_near((*cubic)[1],(*cubic)[0]) && !are_near((*cubic)[2],(*cubic)[3])) { - pointAt1 = SBasisIn.valueAt(0.3334); + point_at1 = sbasis_in.valueAt(DEFAULT_START_POWER); } else { - pointAt1 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[1], *in->first_segment())); + point_at1 = sbasis_in.valueAt(Geom::nearest_point((*cubic)[1], *in->first_segment())); } if(are_near((*cubic)[2],(*cubic)[3]) && !are_near((*cubic)[1],(*cubic)[0])) { - pointAt2 = SBasisIn.valueAt(0.6667); + point_at2 = sbasis_in.valueAt(DEFAULT_END_POWER); } else { - pointAt2 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[2], *in->first_segment())); + point_at2 = sbasis_in.valueAt(Geom::nearest_point((*cubic)[2], *in->first_segment())); } } else { - pointAt1 = in->first_segment()->initialPoint(); - pointAt2 = in->first_segment()->finalPoint(); + point_at1 = in->first_segment()->initialPoint(); + point_at2 = in->first_segment()->finalPoint(); } in->reset(); delete in; @@ -1810,31 +1817,30 @@ void PenTool::_bspline_doEffect(SPCurve * curve) out->lineto(curve_it2->finalPoint()); cubic = dynamic_cast(&*curve_it2); if (cubic) { - SBasisOut = out->first_segment()->toSBasis(); + sbasis_out = out->first_segment()->toSBasis(); if(are_near((*cubic)[1],(*cubic)[0]) && !are_near((*cubic)[2],(*cubic)[3])) { - nextPointAt1 = SBasisIn.valueAt(0.3334); + next_point_at1 = sbasis_in.valueAt(DEFAULT_START_POWER); } else { - nextPointAt1 = SBasisOut.valueAt(Geom::nearest_point((*cubic)[1], *out->first_segment())); + next_point_at1 = sbasis_out.valueAt(Geom::nearest_point((*cubic)[1], *out->first_segment())); } } else { - nextPointAt1 = out->first_segment()->initialPoint(); + next_point_at1 = out->first_segment()->initialPoint(); } out->reset(); delete out; } - Geom::Point startNode = path_it->begin()->initialPoint(); if (path_it->closed() && curve_it2 == curve_endit) { SPCurve *start = new SPCurve(); start->moveto(path_it->begin()->initialPoint()); start->lineto(path_it->begin()->finalPoint()); - Geom::D2 SBasisStart = start->first_segment()->toSBasis(); - SPCurve *lineHelper = new SPCurve(); + Geom::D2 sbasis_start = start->first_segment()->toSBasis(); + SPCurve *line_helper = new SPCurve(); cubic = dynamic_cast(&*path_it->begin()); if (cubic) { - lineHelper->moveto(SBasisStart.valueAt( + line_helper->moveto(sbasis_start.valueAt( Geom::nearest_point((*cubic)[1], *start->first_segment()))); } else { - lineHelper->moveto(start->first_segment()->initialPoint()); + line_helper->moveto(start->first_segment()->initialPoint()); } start->reset(); delete start; @@ -1842,55 +1848,56 @@ void PenTool::_bspline_doEffect(SPCurve * curve) SPCurve *end = new SPCurve(); end->moveto(curve_it1->initialPoint()); end->lineto(curve_it1->finalPoint()); - Geom::D2 SBasisEnd = end->first_segment()->toSBasis(); + Geom::D2 sbasis_end = end->first_segment()->toSBasis(); cubic = dynamic_cast(&*curve_it1); if (cubic) { - lineHelper->lineto(SBasisEnd.valueAt( + line_helper->lineto(sbasis_end.valueAt( Geom::nearest_point((*cubic)[2], *end->first_segment()))); } else { - lineHelper->lineto(end->first_segment()->finalPoint()); + line_helper->lineto(end->first_segment()->finalPoint()); } end->reset(); delete end; - SBasisHelper = lineHelper->first_segment()->toSBasis(); - lineHelper->reset(); - delete lineHelper; - startNode = SBasisHelper.valueAt(0.5); - nCurve->curveto(pointAt1, pointAt2, startNode); - nCurve->move_endpoints(startNode, startNode); + sbasis_helper = line_helper->first_segment()->toSBasis(); + line_helper->reset(); + delete line_helper; + node = sbasis_helper.valueAt(0.5); + curve_n->curveto(point_at1, point_at2, node); + curve_n->move_endpoints(node, node); } else if ( curve_it2 == curve_endit) { - nCurve->curveto(pointAt1, pointAt2, curve_it1->finalPoint()); - nCurve->move_endpoints(path_it->begin()->initialPoint(), curve_it1->finalPoint()); + curve_n->curveto(point_at1, point_at2, curve_it1->finalPoint()); + curve_n->move_endpoints(path_it->begin()->initialPoint(), curve_it1->finalPoint()); } else { - SPCurve *lineHelper = new SPCurve(); - lineHelper->moveto(pointAt2); - lineHelper->lineto(nextPointAt1); - SBasisHelper = lineHelper->first_segment()->toSBasis(); - lineHelper->reset(); - delete lineHelper; + SPCurve *line_helper = new SPCurve(); + line_helper->moveto(point_at2); + line_helper->lineto(next_point_at1); + sbasis_helper = line_helper->first_segment()->toSBasis(); + line_helper->reset(); + delete line_helper; previousNode = node; - node = SBasisHelper.valueAt(0.5); + node = sbasis_helper.valueAt(0.5); Geom::CubicBezier const *cubic2 = dynamic_cast(&*curve_it1); if((cubic && are_near((*cubic)[0],(*cubic)[1])) || (cubic2 && are_near((*cubic2)[2],(*cubic2)[3]))) { node = curve_it1->finalPoint(); } - nCurve->curveto(pointAt1, pointAt2, node); + curve_n->curveto(point_at1, point_at2, node); } ++curve_it1; ++curve_it2; } + //y cerramos la curva if (path_it->closed()) { - nCurve->closepath_current(); + curve_n->closepath_current(); } - curve->append(nCurve, false); - nCurve->reset(); - delete nCurve; + curve->append(curve_n, false); + curve_n->reset(); + delete curve_n; } } //Spiro function cloned from lpe-spiro.cpp // commenting the function "doEffect" from src/live_effects/lpe-spiro.cpp -void PenTool::_spiro_doEffect(SPCurve * curve) +void PenTool::_spiroDoEffect(SPCurve * curve) { using Geom::X; using Geom::Y; @@ -2087,16 +2094,16 @@ void PenTool::_finishSegment(Geom::Point const p, guint const state) { if (!this->red_curve->is_empty()) { - this->_bspline_spiro(state & GDK_SHIFT_MASK); + this->_bsplineSpiro(state & GDK_SHIFT_MASK); this->green_curve->append_continuous(this->red_curve, 0.0625); SPCurve *curve = this->red_curve->copy(); /// \todo fixme: - SPCanvasItem *cshape = sp_canvas_bpath_new(this->desktop->getSketch(), curve); + SPCanvasItem *canvas_shape = sp_canvas_bpath_new(this->desktop->getSketch(), curve); curve->unref(); - sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); + sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvas_shape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); - this->green_bpaths = g_slist_prepend(this->green_bpaths, cshape); + this->green_bpaths = g_slist_prepend(this->green_bpaths, canvas_shape); this->p[0] = this->p[3]; this->p[1] = this->p[4]; @@ -2185,7 +2192,7 @@ bool PenTool::_undoLastPoint() { pen_last_paraxial_dir = !pen_last_paraxial_dir; //redraw - this->_bspline_spiro_build(); + this->_bsplineSpiroBuild(); ret = true; } @@ -2210,7 +2217,7 @@ void PenTool::_finish(gboolean const closed) { // cancelate line without a created segment this->red_curve->reset(); spdc_concat_colors_and_flush(this, closed); - this->overwriteCurve = NULL; + this->overwrite_curve = NULL; this->sa = NULL; this->ea = NULL; diff --git a/src/ui/tools/pen-tool.h b/src/ui/tools/pen-tool.h index 2208005c5..0ae16caf0 100644 --- a/src/ui/tools/pen-tool.h +++ b/src/ui/tools/pen-tool.h @@ -89,33 +89,33 @@ private: bool _handle2ButtonPress(GdkEventButton const &bevent); bool _handleKeyPress(GdkEvent *event); //adds spiro & bspline modes - void _pen_context_set_mode(guint mode); + void _penContextSetMode(guint mode); //this function changes the colors red, green and blue making them transparent or not depending on if the function uses spiro - void _bspline_spiro_color(); + void _bsplineSpiroColor(); //creates a node in bspline or spiro modes - void _bspline_spiro(bool shift); + void _bsplineSpiro(bool shift); //creates a node in bspline or spiro modes - void _bspline_spiro_on(); + void _bsplineSpiroOn(); //creates a CUSP node - void _bspline_spiro_off(); + void _bsplineSpiroOff(); //continues the existing curve in bspline or spiro mode - void _bspline_spiro_start_anchor(bool shift); + void _bsplineSpiroStartAnchor(bool shift); //continues the existing curve with the union node in bspline or spiro modes - void _bspline_spiro_start_anchor_on(); + void _bsplineSpiroStartAnchorOn(); //continues an existing curve with the union node in CUSP mode - void _bspline_spiro_start_anchor_off(); + void _bsplineSpiroStartAnchorOff(); //modifies the "red_curve" when it detects movement - void _bspline_spiro_motion(bool shift); + void _bsplineSpiroMotion(bool shift); //closes the curve with the last node in bspline or spiro mode - void _bspline_spiro_end_anchor_on(); + void _bsplineSpiroEndAnchorOn(); //closes the curve with the last node in CUSP mode - void _bspline_spiro_end_anchor_off(); + void _bsplineSpiroEndAnchorOff(); //CHECK: join all the curves "in game" and we call doEffect function - void _bspline_spiro_build(); + void _bsplineSpiroBuild(); //function bspline cloned from lpe-bspline.cpp - void _bspline_doEffect(SPCurve * curve); + void _bsplineDoEffect(SPCurve * curve); //function spiro cloned from lpe-spiro.cpp - void _spiro_doEffect(SPCurve * curve); + void _spiroDoEffect(SPCurve * curve); void _setInitialPoint(Geom::Point const p); void _setSubsequentPoint(Geom::Point const p, bool statusbar, guint status = 0); diff --git a/src/ui/tools/pencil-tool.cpp b/src/ui/tools/pencil-tool.cpp index db24c7432..008804162 100644 --- a/src/ui/tools/pencil-tool.cpp +++ b/src/ui/tools/pencil-tool.cpp @@ -191,7 +191,7 @@ bool PencilTool::_handleButtonPress(GdkEventButton const &bevent) { } if (anchor) { p = anchor->dp; - this->overwriteCurve = anchor->curve; + this->overwrite_curve = anchor->curve; desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Continuing selected path")); } else { m.setup(desktop); @@ -663,11 +663,11 @@ void PencilTool::_interpolate() { for (int c = 0; c < n_segs; c++) { // if we are in BSpline we modify the trace to create adhoc nodes if(mode == 2){ - Geom::Point BP = b[4*c+0] + (1./3)*(b[4*c+3] - b[4*c+0]); - BP = Geom::Point(BP[X] + 0.0001,BP[Y] + 0.0001); - Geom::Point CP = b[4*c+3] + (1./3)*(b[4*c+0] - b[4*c+3]); - CP = Geom::Point(CP[X] + 0.0001,CP[Y] + 0.0001); - this->green_curve->curveto(BP,CP,b[4*c+3]); + Geom::Point point_at1 = b[4*c+0] + (1./3)*(b[4*c+3] - b[4*c+0]); + point_at1 = Geom::Point(point_at1[X] + 0.0001,point_at1[Y] + 0.0001); + Geom::Point point_at2 = b[4*c+3] + (1./3)*(b[4*c+0] - b[4*c+3]); + point_at2 = Geom::Point(point_at2[X] + 0.0001,point_at2[Y] + 0.0001); + this->green_curve->curveto(point_at1,point_at2,b[4*c+3]); }else{ this->green_curve->curveto(b[4 * c + 1], b[4 * c + 2], b[4 * c + 3]); } @@ -810,11 +810,11 @@ void PencilTool::_fitAndSplit() { // if we are in BSpline we modify the trace to create adhoc nodes guint mode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0); if(mode == 2){ - Geom::Point B = b[0] + (1./3)*(b[3] - b[0]); - B = Geom::Point(B[X] + 0.0001,B[Y] + 0.0001); - Geom::Point C = b[3] + (1./3)*(b[0] - b[3]); - C = Geom::Point(C[X] + 0.0001,C[Y] + 0.0001); - this->red_curve->curveto(B,C,b[3]); + Geom::Point point_at1 = b[0] + (1./3)*(b[3] - b[0]); + point_at1 = Geom::Point(point_at1[X] + 0.0001,point_at1[Y] + 0.0001); + Geom::Point point_at2 = b[3] + (1./3)*(b[0] - b[3]); + point_at2 = Geom::Point(point_at2[X] + 0.0001,point_at2[Y] + 0.0001); + this->red_curve->curveto(point_at1,point_at2,b[3]); }else{ this->red_curve->curveto(b[1], b[2], b[3]); } -- cgit v1.2.3 From d5f4e25e196928fdc80e076432ea486d89abf931 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20W=C3=BCst?= Date: Fri, 10 Apr 2015 20:52:44 +0200 Subject: added info about multiple pen feature in gui (bzr r14055) --- share/extensions/hpgl_output.inx | 14 ++++++++------ share/extensions/plotter.inx | 24 +++++++++++++----------- 2 files changed, 21 insertions(+), 17 deletions(-) diff --git a/share/extensions/hpgl_output.inx b/share/extensions/hpgl_output.inx index bfb3e3567..7fa900dc8 100644 --- a/share/extensions/hpgl_output.inx +++ b/share/extensions/hpgl_output.inx @@ -22,14 +22,16 @@ false false - false + false +   + <_param name="multiplePensHelp" type="description">If you want to use multiple pens on your pen plotter create one layer for each pen, name the layers "Pen 1", "Pen 2", etc., and put your drawings in the corresponding layers. This overrules the pen number option above. - 1.00 - 0.25 - true - 1.2 - true + 1.00 + 0.25 + true + 1.2 + true <_param name="settingsHelp" type="description">All these settings depend on the plotter you use, for more information please consult the manual or homepage for your plotter. diff --git a/share/extensions/plotter.inx b/share/extensions/plotter.inx index cc916fe08..17b2ff185 100644 --- a/share/extensions/plotter.inx +++ b/share/extensions/plotter.inx @@ -65,9 +65,9 @@ 1016.0 1016.0 - 1 - 0 - 0 + 1 + 0 + 0 0 90 @@ -76,16 +76,18 @@ false false - false + false +   + <_param name="multiplePensHelp" type="description">If you want to use multiple pens on your pen plotter create one layer for each pen, name the layers "Pen 1", "Pen 2", etc., and put your drawings in the corresponding layers. This overrules the pen number option above. - 1.00 - 0.25 - true - 1.2 - true -   - false + 1.00 + 0.25 + true + 1.2 + true +   + false <_param name="settingsHelp" type="description">All these settings depend on the plotter you use, for more information please consult the manual or homepage for your plotter. -- cgit v1.2.3