![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
diff --git a/src/sp-star.cpp b/src/sp-star.cpp
index f5649e19f059b531c35a2770b8203458d0e8a303..9cffd952ca2c72bb2ea91ec0b26ebdc4a9eb1933 100644 (file)
--- a/src/sp-star.cpp
+++ b/src/sp-star.cpp
#include "xml/repr.h"
#include "document.h"
+#include <2geom/pathvector.h>
+
#include "sp-star.h"
static void sp_star_class_init (SPStarClass *klass);
static void sp_star_update (SPObject *object, SPCtx *ctx, guint flags);
static gchar * sp_star_description (SPItem * item);
-static void sp_star_snappoints(SPItem const *item, SnapPointsIter p, Inkscape::SnapPreferences const *snapprefs);
+static void sp_star_snappoints(SPItem const *item, bool const target, SnapPointsWithType &p, Inkscape::SnapPreferences const *snapprefs);
static void sp_star_set_shape (SPShape *shape);
static void sp_star_update_patheffect (SPLPEItem *lpeitem, bool write);
sp_star_init (SPStar * star)
{
star->sides = 5;
- star->center = NR::Point(0, 0);
+ star->center = Geom::Point(0, 0);
star->r[0] = 1.0;
star->r[1] = 0.001;
star->arg[0] = star->arg[1] = 0.0;
@@ -140,8 +142,8 @@ sp_star_write (SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML
if (flags & SP_OBJECT_WRITE_EXT) {
repr->setAttribute("sodipodi:type", "star");
sp_repr_set_int (repr, "sodipodi:sides", star->sides);
- sp_repr_set_svg_double(repr, "sodipodi:cx", star->center[NR::X]);
- sp_repr_set_svg_double(repr, "sodipodi:cy", star->center[NR::Y]);
+ sp_repr_set_svg_double(repr, "sodipodi:cx", star->center[Geom::X]);
+ sp_repr_set_svg_double(repr, "sodipodi:cy", star->center[Geom::Y]);
sp_repr_set_svg_double(repr, "sodipodi:r1", star->r[0]);
sp_repr_set_svg_double(repr, "sodipodi:r2", star->r[1]);
sp_repr_set_svg_double(repr, "sodipodi:arg1", star->arg[0]);
case SP_ATTR_SODIPODI_SIDES:
if (value) {
star->sides = atoi (value);
- star->sides = CLAMP (star->sides, 3, 1024);
+ star->sides = NR_CLAMP(star->sides, 3, 1024);
} else {
star->sides = 5;
}
object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
break;
case SP_ATTR_SODIPODI_CX:
- if (!sp_svg_length_read_ldd (value, &unit, NULL, &star->center[NR::X]) ||
+ if (!sp_svg_length_read_ldd (value, &unit, NULL, &star->center[Geom::X]) ||
(unit == SVGLength::EM) ||
(unit == SVGLength::EX) ||
(unit == SVGLength::PERCENT)) {
- star->center[NR::X] = 0.0;
+ star->center[Geom::X] = 0.0;
}
object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
break;
case SP_ATTR_SODIPODI_CY:
- if (!sp_svg_length_read_ldd (value, &unit, NULL, &star->center[NR::Y]) ||
+ if (!sp_svg_length_read_ldd (value, &unit, NULL, &star->center[Geom::Y]) ||
(unit == SVGLength::EM) ||
(unit == SVGLength::EX) ||
(unit == SVGLength::PERCENT)) {
- star->center[NR::Y] = 0.0;
+ star->center[Geom::Y] = 0.0;
}
object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
break;
/**
Returns a unit-length vector at 90 degrees to the direction from o to n
*/
-static NR::Point
-rot90_rel (NR::Point o, NR::Point n)
+static Geom::Point
+rot90_rel (Geom::Point o, Geom::Point n)
{
- return ((1/NR::L2(n - o)) * NR::Point ((n - o)[NR::Y], (o - n)[NR::X]));
+ return ((1/Geom::L2(n - o)) * Geom::Point ((n - o)[Geom::Y], (o - n)[Geom::X]));
}
/**
- returned value is unchanged when the point is moved by less than 1/1024 of px
*/
static guint32
-point_unique_int (NR::Point o)
+point_unique_int (Geom::Point o)
{
return ((guint32)
65536 *
- (((int) floor (o[NR::X] * 64)) % 1024 + ((int) floor (o[NR::X] * 1024)) % 64)
+ (((int) floor (o[Geom::X] * 64)) % 1024 + ((int) floor (o[Geom::X] * 1024)) % 64)
+
- (((int) floor (o[NR::Y] * 64)) % 1024 + ((int) floor (o[NR::Y] * 1024)) % 64)
+ (((int) floor (o[Geom::Y] * 64)) % 1024 + ((int) floor (o[Geom::Y] * 1024)) % 64)
);
}
return ( lcg / 4294967296. ) - 0.5;
}
-static NR::Point
+static Geom::Point
sp_star_get_curvepoint (SPStar *star, SPStarPoint point, gint index, bool previ)
{
// the point whose neighboring curve handle we're calculating
- NR::Point o = sp_star_get_xy (star, point, index);
+ Geom::Point o = sp_star_get_xy (star, point, index);
// indices of previous and next points
gint pi = (index > 0)? (index - 1) : (star->sides - 1);
@@ -376,25 +378,25 @@ sp_star_get_curvepoint (SPStar *star, SPStarPoint point, gint index, bool previ)
SPStarPoint other = (point == SP_STAR_POINT_KNOT2? SP_STAR_POINT_KNOT1 : SP_STAR_POINT_KNOT2);
// the neighbors of o; depending on flatsided, they're either the same type (polygon) or the other type (star)
- NR::Point prev = (star->flatsided? sp_star_get_xy (star, point, pi) : sp_star_get_xy (star, other, point == SP_STAR_POINT_KNOT2? index : pi));
- NR::Point next = (star->flatsided? sp_star_get_xy (star, point, ni) : sp_star_get_xy (star, other, point == SP_STAR_POINT_KNOT1? index : ni));
+ Geom::Point prev = (star->flatsided? sp_star_get_xy (star, point, pi) : sp_star_get_xy (star, other, point == SP_STAR_POINT_KNOT2? index : pi));
+ Geom::Point next = (star->flatsided? sp_star_get_xy (star, point, ni) : sp_star_get_xy (star, other, point == SP_STAR_POINT_KNOT1? index : ni));
// prev-next midpoint
- NR::Point mid = 0.5 * (prev + next);
+ Geom::Point mid = 0.5 * (prev + next);
// point to which we direct the bissector of the curve handles;
// it's far enough outside the star on the perpendicular to prev-next through mid
- NR::Point biss = mid + 100000 * rot90_rel (mid, next);
+ Geom::Point biss = mid + 100000 * rot90_rel (mid, next);
// lengths of vectors to prev and next
- gdouble prev_len = NR::L2 (prev - o);
- gdouble next_len = NR::L2 (next - o);
+ gdouble prev_len = Geom::L2 (prev - o);
+ gdouble next_len = Geom::L2 (next - o);
// unit-length vector perpendicular to o-biss
- NR::Point rot = rot90_rel (o, biss);
+ Geom::Point rot = rot90_rel (o, biss);
// multiply rot by star->rounded coefficient and the distance to the star point; flip for next
- NR::Point ret;
+ Geom::Point ret;
if (previ) {
ret = (star->rounded * prev_len) * rot;
} else {
@@ -409,11 +411,11 @@ sp_star_get_curvepoint (SPStar *star, SPStarPoint point, gint index, bool previ)
guint32 seed = point_unique_int (o);
// randomly rotate (by step 3 from the seed) and scale (by step 4) the vector
- ret = ret * NR::Matrix (Geom::Rotate (star->randomized * M_PI * rnd (seed, 3)));
+ ret = ret * Geom::Matrix (Geom::Rotate (star->randomized * M_PI * rnd (seed, 3)));
ret *= ( 1 + star->randomized * rnd (seed, 4));
// the randomized corner point
- NR::Point o_randomized = sp_star_get_xy (star, point, index, true);
+ Geom::Point o_randomized = sp_star_get_xy (star, point, index, true);
return o_randomized + ret;
}
{
SPStar *star = SP_STAR (shape);
+ // perhaps we should convert all our shapes into LPEs without source path
+ // and with knotholders for parameters, then this situation will be handled automatically
+ // by disabling the entire stack (including the shape LPE)
+ if (sp_lpe_item_has_broken_path_effect(SP_LPE_ITEM(shape))) {
+ g_warning ("The star shape has unknown LPE on it! Convert to path to make it editable preserving the appearance; editing it as star will remove the bad LPE");
+ if (SP_OBJECT_REPR(shape)->attribute("d")) {
+ // unconditionally read the curve from d, if any, to preserve appearance
+ Geom::PathVector pv = sp_svg_read_pathv(SP_OBJECT_REPR(shape)->attribute("d"));
+ SPCurve *cold = new SPCurve(pv);
+ sp_shape_set_curve_insync (shape, cold, TRUE);
+ cold->unref();
+ }
+ return;
+ }
+
SPCurve *c = new SPCurve ();
-
+
gint sides = star->sides;
bool not_rounded = (fabs (star->rounded) < 1e-4);
}
}
}
-
+
// draw last segment
if (not_rounded) {
c->lineto(sp_star_get_xy (star, SP_STAR_POINT_KNOT1, 0, true));
}
c->closepath();
- sp_lpe_item_perform_path_effect(SP_LPE_ITEM (star), c);
- sp_shape_set_curve_insync (SP_SHAPE (star), c, TRUE);
+
+ /* Reset the shape'scurve to the "original_curve"
+ * This is very important for LPEs to work properly! (the bbox might be recalculated depending on the curve in shape)*/
+ sp_shape_set_curve_insync (shape, c, TRUE);
+ if (sp_lpe_item_has_path_effect(SP_LPE_ITEM(shape)) && sp_lpe_item_path_effects_enabled(SP_LPE_ITEM(shape))) {
+ SPCurve *c_lpe = c->copy();
+ bool success = sp_lpe_item_perform_path_effect(SP_LPE_ITEM (shape), c_lpe);
+ if (success) {
+ sp_shape_set_curve_insync (shape, c_lpe, TRUE);
+ }
+ c_lpe->unref();
+ }
c->unref();
}
void
-sp_star_position_set (SPStar *star, gint sides, NR::Point center, gdouble r1, gdouble r2, gdouble arg1, gdouble arg2, bool isflat, double rounded, double randomized)
+sp_star_position_set (SPStar *star, gint sides, Geom::Point center, gdouble r1, gdouble r2, gdouble arg1, gdouble arg2, bool isflat, double rounded, double randomized)
{
g_return_if_fail (star != NULL);
g_return_if_fail (SP_IS_STAR (star));
-
- star->sides = CLAMP (sides, 3, 1024);
+
+ star->sides = NR_CLAMP(sides, 3, 1024);
star->center = center;
star->r[0] = MAX (r1, 0.001);
if (isflat == false) {
- star->r[1] = CLAMP (r2, 0.0, star->r[0]);
+ star->r[1] = NR_CLAMP(r2, 0.0, star->r[0]);
} else {
- star->r[1] = CLAMP ( r1*cos(M_PI/sides) ,0.0, star->r[0] );
+ star->r[1] = NR_CLAMP( r1*cos(M_PI/sides) ,0.0, star->r[0] );
}
star->arg[0] = arg1;
star->arg[1] = arg2;
@@ -518,12 +545,26 @@ sp_star_position_set (SPStar *star, gint sides, NR::Point center, gdouble r1, gd
SP_OBJECT(star)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
}
-/* fixme: We should use all corners of star (Lauris) */
-
-static void sp_star_snappoints(SPItem const *item, SnapPointsIter p, Inkscape::SnapPreferences const *snapprefs)
+static void sp_star_snappoints(SPItem const *item, bool const target, SnapPointsWithType &p, Inkscape::SnapPreferences const *snapprefs)
{
+ // We will determine the star's midpoint ourselves, instead of trusting on the base class
+ // Therefore setSnapObjectMidpoints() is set to false temporarily
+ Inkscape::SnapPreferences local_snapprefs = *snapprefs;
+ local_snapprefs.setSnapObjectMidpoints(false);
+
if (((SPItemClass *) parent_class)->snappoints) {
- ((SPItemClass *) parent_class)->snappoints (item, p, snapprefs);
+ ((SPItemClass *) parent_class)->snappoints (item, target, p, &local_snapprefs);
+ }
+
+ // Help enforcing strict snapping, i.e. only return nodes when we're snapping nodes to nodes or a guide to nodes
+ if (!(snapprefs->getSnapModeNode() || snapprefs->getSnapModeGuide())) {
+ return;
+ }
+
+ if (snapprefs->getSnapObjectMidpoints()) {
+ Geom::Matrix const i2d (sp_item_i2d_affine (item));
+ int type = target ? int(Inkscape::SNAPTARGET_OBJECT_MIDPOINT) : int(Inkscape::SNAPSOURCE_OBJECT_MIDPOINT);
+ p.push_back(std::make_pair(SP_STAR(item)->center * i2d, type));
}
}
@@ -538,7 +579,7 @@ static void sp_star_snappoints(SPItem const *item, SnapPointsIter p, Inkscape::S
* Initial item coordinate system is same as document coordinate system.
*/
-NR::Point
+Geom::Point
sp_star_get_xy (SPStar *star, SPStarPoint point, gint index, bool randomized)
{
gdouble darg = 2.0 * M_PI / (double) star->sides;
double arg = star->arg[point];
arg += index * darg;
- NR::Point xy = star->r[point] * NR::Point(cos(arg), sin(arg)) + star->center;
+ Geom::Point xy = star->r[point] * Geom::Point(cos(arg), sin(arg)) + star->center;
if (!randomized || star->randomized == 0) {
// return the exact point
// the full range (corresponding to star->randomized == 1.0) is equal to the star's diameter
double range = 2 * MAX (star->r[0], star->r[1]);
// find out the random displacement; x is controlled by step 1 from the seed, y by the step 2
- NR::Point shift (star->randomized * range * rnd (seed, 1), star->randomized * range * rnd (seed, 2));
+ Geom::Point shift (star->randomized * range * rnd (seed, 1), star->randomized * range * rnd (seed, 2));
// add the shift to the exact point
return xy + shift;
}
}
+/*
+ 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:textwidth=99 :