X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;ds=sidebyside;f=src%2Fsp-item.cpp;h=33f140de24417947879a3e595e78ec74aa55be05;hb=d5b7e1b1e4973311fcc2a2530fb1f526eefca5f6;hp=f94a5e404b2970629d14ccaef471df041bc0e9ef;hpb=9608cf1b33040767b837e6be3a4cbbb72a09cc36;p=inkscape.git diff --git a/src/sp-item.cpp b/src/sp-item.cpp index f94a5e404..33f140de2 100644 --- a/src/sp-item.cpp +++ b/src/sp-item.cpp @@ -34,6 +34,8 @@ #include "attributes.h" #include "document.h" #include "uri.h" +#include "inkscape.h" +#include "desktop-handles.h" #include "style.h" #include @@ -50,6 +52,9 @@ #include "prefs-utils.h" #include "conn-avoid-ref.h" #include "conditions.h" +#include "sp-filter-reference.h" +#include "filter-chemistry.h" +#include "sp-guide.h" #include "libnr/nr-matrix-div.h" #include "libnr/nr-matrix-fns.h" @@ -57,10 +62,18 @@ #include "libnr/nr-matrix-translate-ops.h" #include "libnr/nr-scale-translate-ops.h" #include "libnr/nr-translate-scale-ops.h" +#include "libnr/nr-convert2geom.h" #include "algorithms/find-last-if.h" #include "util/reverse-list.h" +#include <2geom/rect.h> +#include <2geom/transforms.h> #include "xml/repr.h" +#include "extract-uri.h" + +#include "live_effects/lpeobject.h" +#include "live_effects/effect.h" +#include "live_effects/lpeobject-reference.h" #define noSP_ITEM_DEBUG_IDLE @@ -71,7 +84,7 @@ static void sp_item_build(SPObject *object, SPDocument *document, Inkscape::XML: static void sp_item_release(SPObject *object); static void sp_item_set(SPObject *object, unsigned key, gchar const *value); static void sp_item_update(SPObject *object, SPCtx *ctx, guint flags); -static Inkscape::XML::Node *sp_item_write(SPObject *object, Inkscape::XML::Node *repr, guint flags); +static Inkscape::XML::Node *sp_item_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags); static gchar *sp_item_private_description(SPItem *item); static void sp_item_private_snappoints(SPItem const *item, SnapPointsIter p); @@ -159,8 +172,6 @@ void SPItem::init() { sigc::slot2 sl2=sigc::bind(sigc::ptr_fun(mask_ref_changed), this); _mask_ref_connection = cs2.connect(sl2); - if (!this->style) this->style = sp_style_new_from_object(this); - this->avoidRef = new SPAvoidRef(this); new (&this->_transformed_signal) sigc::signal(); @@ -277,12 +288,12 @@ SPItem::setExplicitlyHidden(bool const val) { */ void SPItem::setCenter(NR::Point object_centre) { - NR::Rect bbox = invokeBbox(sp_item_i2d_affine(this)); - if (!bbox.isEmpty()) { - transform_center_x = object_centre[NR::X] - bbox.midpoint()[NR::X]; + NR::Maybe bbox = getBounds(from_2geom(sp_item_i2d_affine(this))); + if (bbox) { + transform_center_x = object_centre[NR::X] - bbox->midpoint()[NR::X]; if (fabs(transform_center_x) < 1e-5) // rounding error transform_center_x = 0; - transform_center_y = object_centre[NR::Y] - bbox.midpoint()[NR::Y]; + transform_center_y = object_centre[NR::Y] - bbox->midpoint()[NR::Y]; if (fabs(transform_center_y) < 1e-5) // rounding error transform_center_y = 0; } @@ -298,10 +309,10 @@ bool SPItem::isCenterSet() { return (transform_center_x != 0 || transform_center_y != 0); } -NR::Point SPItem::getCenter() { - NR::Rect bbox = invokeBbox(sp_item_i2d_affine(this)); - if (!bbox.isEmpty()) { - return bbox.midpoint() + NR::Point (this->transform_center_x, this->transform_center_y); +NR::Point SPItem::getCenter() const { + NR::Maybe bbox = getBounds(from_2geom(sp_item_i2d_affine(this))); + if (bbox) { + return bbox->midpoint() + NR::Point (this->transform_center_x, this->transform_center_y); } else { return NR::Point (0, 0); // something's wrong! } @@ -404,6 +415,14 @@ sp_item_release(SPObject *object) item->_clip_ref_connection.disconnect(); item->_mask_ref_connection.disconnect(); + // Note: do this here before the clip_ref is deleted, since calling + // sp_document_ensure_up_to_date for triggered routing may reference + // the deleted clip_ref. + if (item->avoidRef) { + delete item->avoidRef; + item->avoidRef = NULL; + } + if (item->clip_ref) { item->clip_ref->detach(); delete item->clip_ref; @@ -416,11 +435,6 @@ sp_item_release(SPObject *object) item->mask_ref = NULL; } - if (item->avoidRef) { - delete item->avoidRef; - item->avoidRef = NULL; - } - if (((SPObjectClass *) (parent_class))->release) { ((SPObjectClass *) parent_class)->release(object); } @@ -449,7 +463,7 @@ sp_item_set(SPObject *object, unsigned key, gchar const *value) break; } case SP_PROP_CLIP_PATH: { - gchar *uri = Inkscape::parse_css_url(value); + gchar *uri = extract_uri(value); if (uri) { try { item->clip_ref->attach(Inkscape::URI(uri)); @@ -465,7 +479,7 @@ sp_item_set(SPObject *object, unsigned key, gchar const *value) break; } case SP_PROP_MASK: { - gchar *uri=Inkscape::parse_css_url(value); + gchar *uri = extract_uri(value); if (uri) { try { item->mask_ref->attach(Inkscape::URI(uri)); @@ -486,10 +500,6 @@ sp_item_set(SPObject *object, unsigned key, gchar const *value) nr_arena_item_set_sensitive(v->arenaitem, item->sensitive); } break; - case SP_ATTR_STYLE: - sp_style_read_from_object(object->style, object); - object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG); - break; case SP_ATTR_CONNECTOR_AVOID: item->avoidRef->setAvoid(value); break; @@ -499,6 +509,7 @@ sp_item_set(SPObject *object, unsigned key, gchar const *value) } else { item->transform_center_x = 0; } + object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG); break; case SP_ATTR_TRANSFORM_CENTER_Y: if (value) { @@ -506,6 +517,7 @@ sp_item_set(SPObject *object, unsigned key, gchar const *value) } else { item->transform_center_y = 0; } + object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG); break; case SP_PROP_SYSTEM_LANGUAGE: case SP_PROP_REQUIRED_FEATURES: @@ -599,8 +611,8 @@ sp_item_update(SPObject *object, SPCtx *ctx, guint flags) } } - SPClipPath *clip_path = item->clip_ref->getObject(); - SPMask *mask = item->mask_ref->getObject(); + SPClipPath *clip_path = item->clip_ref ? item->clip_ref->getObject() : NULL; + SPMask *mask = item->mask_ref ? item->mask_ref->getObject() : NULL; if ( clip_path || mask ) { NRRect bbox; @@ -625,61 +637,32 @@ sp_item_update(SPObject *object, SPCtx *ctx, guint flags) } } + /* Update bounding box data used by filters */ + if (item->style->filter.set && item->display) { + NRRect item_bbox; + sp_item_invoke_bbox(item, &item_bbox, NR::identity(), TRUE, SPItem::GEOMETRIC_BBOX); + NR::Maybe i_bbox = item_bbox; + + SPItemView *itemview = item->display; + do { + if (itemview->arenaitem) + nr_arena_item_set_item_bbox(itemview->arenaitem, i_bbox); + } while ( (itemview = itemview->next) ); + } + // Update libavoid with item geometry (for connector routing). - item->avoidRef->handleSettingChange(); + if (item->avoidRef) + item->avoidRef->handleSettingChange(); } static Inkscape::XML::Node * -sp_item_write(SPObject *const object, Inkscape::XML::Node *repr, guint flags) +sp_item_write(SPObject *const object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags) { SPItem *item = SP_ITEM(object); - gchar c[256]; - if (sp_svg_transform_write(c, 256, item->transform)) { - repr->setAttribute("transform", c); - } else { - repr->setAttribute("transform", NULL); - } - - SPObject const *const parent = SP_OBJECT_PARENT(object); - /** \todo Can someone please document why this is conditional on having - * a parent? The only parentless thing I can think of is the top-level - * element (SPRoot). SPRoot is derived from SPGroup, and can have - * style. I haven't looked at callers. - */ - if (parent) { - SPStyle const *const obj_style = SP_OBJECT_STYLE(object); - if (obj_style) { - gchar *s = sp_style_write_string(obj_style, SP_STYLE_FLAG_IFSET); - repr->setAttribute("style", ( *s ? s : NULL )); - g_free(s); - } else { - /** \todo I'm not sure what to do in this case. Bug #1165868 - * suggests that it can arise, but the submitter doesn't know - * how to do so reliably. The main two options are either - * leave repr's style attribute unchanged, or explicitly clear it. - * Must also consider what to do with property attributes for - * the element; see below. - */ - char const *style_str = repr->attribute("style"); - if (!style_str) { - style_str = "NULL"; - } - g_warning("Item's style is NULL; repr style attribute is %s", style_str); - } - - /** \note We treat object->style as authoritative. Its effects have - * been written to the style attribute above; any properties that are - * unset we take to be deliberately unset (e.g. so that clones can - * override the property). - * - * Note that the below has an undesirable consequence of changing the - * appearance on renderers that lack CSS support (e.g. SVG tiny); - * possibly we should write property attributes instead of a style - * attribute. - */ - sp_style_unset_property_attrs (object); - } + gchar *c = sp_svg_transform_write(item->transform); + repr->setAttribute("transform", c); + g_free(c); if (flags & SP_OBJECT_WRITE_EXT) { repr->setAttribute("sodipodi:insensitive", ( item->sensitive ? NULL : "true" )); @@ -705,38 +688,152 @@ sp_item_write(SPObject *const object, Inkscape::XML::Node *repr, guint flags) } if (((SPObjectClass *) (parent_class))->write) { - ((SPObjectClass *) (parent_class))->write(object, repr, flags); + ((SPObjectClass *) (parent_class))->write(object, xml_doc, repr, flags); } return repr; } -NR::Rect SPItem::invokeBbox(NR::Matrix const &transform) const +NR::Maybe SPItem::getBounds(NR::Matrix const &transform, + SPItem::BBoxType type, + unsigned int /*dkey*/) const { - NRRect r; - sp_item_invoke_bbox_full(this, &r, transform, 0, TRUE); - return NR::Rect(r); + NR::Maybe r = NR::Nothing(); + sp_item_invoke_bbox_full(this, &r, transform, type, TRUE); + return r; } -NR::Maybe SPItem::getBBox(NR::Matrix const &transform, - SPItem::BBoxType type, - unsigned int dkey) const +NR::Maybe +SPItem::getBounds(Geom::Matrix const &transform, SPItem::BBoxType type, unsigned int /*dkey*/) +const { - NRRect r; - sp_item_invoke_bbox_full(this, &r, transform, 0, TRUE); - if (nr_rect_d_test_empty(&r)) { - return NR::Nothing(); - } else { - return NR::Rect(r); - } + NR::Maybe r = NR::Nothing(); + sp_item_invoke_bbox_full(this, &r, from_2geom(transform), type, TRUE); + return NR::Maybe(to_2geom(*r)); +} + +void +sp_item_invoke_bbox(SPItem const *item, NR::Maybe *bbox, NR::Matrix const &transform, unsigned const clear, SPItem::BBoxType type) +{ + sp_item_invoke_bbox_full(item, bbox, transform, type, clear); +} + +// DEPRECATED to phase out the use of NRRect in favor of NR::Maybe +void +sp_item_invoke_bbox(SPItem const *item, NRRect *bbox, NR::Matrix const &transform, unsigned const clear, SPItem::BBoxType type) +{ + sp_item_invoke_bbox_full(item, bbox, transform, type, clear); } +/** Calls \a item's subclass' bounding box method; clips it by the bbox of clippath, if any; and + * unions the resulting bbox with \a bbox. If \a clear is true, empties \a bbox first. Passes the + * transform and the flags to the actual bbox methods. Note that many of subclasses (e.g. groups, + * clones), in turn, call this function in their bbox methods. */ void -sp_item_invoke_bbox(SPItem const *item, NRRect *bbox, NR::Matrix const &transform, unsigned const clear) +sp_item_invoke_bbox_full(SPItem const *item, NR::Maybe *bbox, NR::Matrix const &transform, unsigned const flags, unsigned const clear) { - sp_item_invoke_bbox_full(item, bbox, transform, 0, clear); + g_assert(item != NULL); + g_assert(SP_IS_ITEM(item)); + g_assert(bbox != NULL); + + if (clear) { + *bbox = NR::Nothing(); + } + + // TODO: replace NRRect by NR::Rect, for all SPItemClasses, and for SP_CLIPPATH + + NRRect temp_bbox; + temp_bbox.x0 = temp_bbox.y0 = NR_HUGE; + temp_bbox.x1 = temp_bbox.y1 = -NR_HUGE; + + // call the subclass method + if (((SPItemClass *) G_OBJECT_GET_CLASS(item))->bbox) { + ((SPItemClass *) G_OBJECT_GET_CLASS(item))->bbox(item, &temp_bbox, transform, flags); + } + + // unless this is geometric bbox, extend by filter area and crop the bbox by clip path, if any + if ((SPItem::BBoxType) flags != SPItem::GEOMETRIC_BBOX) { + if (SP_OBJECT_STYLE(item) && SP_OBJECT_STYLE(item)->filter.href) { + SPObject *filter = SP_OBJECT_STYLE(item)->getFilter(); + if (filter && SP_IS_FILTER(filter)) { + // default filer area per the SVG spec: + double x = -0.1; + double y = -0.1; + double w = 1.2; + double h = 1.2; + + // if area is explicitly set, override: + if (SP_FILTER(filter)->x._set) + x = SP_FILTER(filter)->x.computed; + if (SP_FILTER(filter)->y._set) + y = SP_FILTER(filter)->y.computed; + if (SP_FILTER(filter)->width._set) + w = SP_FILTER(filter)->width.computed; + if (SP_FILTER(filter)->height._set) + h = SP_FILTER(filter)->height.computed; + + double dx0 = 0; + double dx1 = 0; + double dy0 = 0; + double dy1 = 0; + if (filter_is_single_gaussian_blur(SP_FILTER(filter))) { + // if this is a single blur, use 2.4*radius + // which may be smaller than the default area; + // see set_filter_area for why it's 2.4 + double r = get_single_gaussian_blur_radius (SP_FILTER(filter)); + dx0 = -2.4 * r; + dx1 = 2.4 * r; + dy0 = -2.4 * r; + dy1 = 2.4 * r; + } else { + // otherwise, calculate expansion from relative to absolute units: + dx0 = x * (temp_bbox.x1 - temp_bbox.x0); + dx1 = (w + x - 1) * (temp_bbox.x1 - temp_bbox.x0); + dy0 = y * (temp_bbox.y1 - temp_bbox.y0); + dy1 = (h + y - 1) * (temp_bbox.y1 - temp_bbox.y0); + } + + // transform the expansions by the item's transform: + NR::Matrix i2d = from_2geom(sp_item_i2d_affine (item)); + dx0 *= NR::expansionX(i2d); + dx1 *= NR::expansionX(i2d); + dy0 *= NR::expansionY(i2d); + dy1 *= NR::expansionY(i2d); + + // expand the bbox + temp_bbox.x0 += dx0; + temp_bbox.x1 += dx1; + temp_bbox.y0 += dy0; + temp_bbox.y1 += dy1; + } + } + if (item->clip_ref->getObject()) { + NRRect b; + sp_clippath_get_bbox(SP_CLIPPATH(item->clip_ref->getObject()), &b, transform, flags); + nr_rect_d_intersect (&temp_bbox, &temp_bbox, &b); + } + } + + if (temp_bbox.x0 > temp_bbox.x1 || temp_bbox.y0 > temp_bbox.y1) { + // Either the bbox hasn't been touched by the SPItemClass' bbox method + // (it still has its initial values, see above: x0 = y0 = NR_HUGE and x1 = y1 = -NR_HUGE) + // or it has explicitely been set to be like this (e.g. in sp_shape_bbox) + + // When x0 > x1 or y0 > y1, the bbox is considered to be "nothing", although it has not been + // explicitely defined this way for NRRects (as opposed to NR::Maybe) + // So union bbox with nothing = do nothing, just return + return; + } + + // Do not use temp_bbox.upgrade() here, because it uses a test that returns NR::Nothing + // for any rectangle with zero area. The geometrical bbox of for example a vertical line + // would therefore be translated into NR::Nothing (see bug https://bugs.launchpad.net/inkscape/+bug/168684) + NR::Maybe temp_bbox_new = NR::Rect(NR::Point(temp_bbox.x0, temp_bbox.y0), NR::Point(temp_bbox.x1, temp_bbox.y1)); + + *bbox = NR::union_bounds(*bbox, temp_bbox_new); } +// DEPRECATED to phase out the use of NRRect in favor of NR::Maybe /** Calls \a item's subclass' bounding box method; clips it by the bbox of clippath, if any; and * unions the resulting bbox with \a bbox. If \a clear is true, empties \a bbox first. Passes the * transform and the flags to the actual bbox methods. Note that many of subclasses (e.g. groups, @@ -762,8 +859,8 @@ sp_item_invoke_bbox_full(SPItem const *item, NRRect *bbox, NR::Matrix const &tra ((SPItemClass *) G_OBJECT_GET_CLASS(item))->bbox(item, &this_bbox, transform, flags); } - // crop the bbox by clip path, if any - if (item->clip_ref->getObject()) { + // unless this is geometric bbox, crop the bbox by clip path, if any + if ((SPItem::BBoxType) flags != SPItem::GEOMETRIC_BBOX && item->clip_ref->getObject()) { NRRect b; sp_clippath_get_bbox(SP_CLIPPATH(item->clip_ref->getObject()), &b, transform, flags); nr_rect_d_intersect (&this_bbox, &this_bbox, &b); @@ -801,33 +898,40 @@ unsigned sp_item_pos_in_parent(SPItem *item) } void -sp_item_bbox_desktop(SPItem *item, NRRect *bbox) +sp_item_bbox_desktop(SPItem *item, NRRect *bbox, SPItem::BBoxType type) { g_assert(item != NULL); g_assert(SP_IS_ITEM(item)); g_assert(bbox != NULL); - sp_item_invoke_bbox(item, bbox, sp_item_i2d_affine(item), TRUE); + sp_item_invoke_bbox(item, bbox, from_2geom(sp_item_i2d_affine(item)), TRUE, type); } -NR::Rect sp_item_bbox_desktop(SPItem *item) +NR::Maybe sp_item_bbox_desktop(SPItem *item, SPItem::BBoxType type) { - NRRect ret; - sp_item_invoke_bbox(item, &ret, sp_item_i2d_affine(item), TRUE); - return NR::Rect(ret); + NR::Maybe rect = NR::Nothing(); + sp_item_invoke_bbox(item, &rect, from_2geom(sp_item_i2d_affine(item)), TRUE, type); + return rect; } static void sp_item_private_snappoints(SPItem const *item, SnapPointsIter p) { - NR::Rect const bbox = item->invokeBbox(sp_item_i2d_affine(item)); - /* Just a pair of opposite corners of the bounding box suffices given that we don't yet + NR::Maybe bbox = item->getBounds(from_2geom(sp_item_i2d_affine(item))); + /* Just the corners of the bounding box suffices given that we don't yet support angled guide lines. */ - *p = bbox.min(); - *p = bbox.max(); + if (bbox) { + NR::Point p1, p2; + p1 = bbox->min(); + p2 = bbox->max(); + *p = p1; + *p = NR::Point(p1[NR::X], p2[NR::Y]); + *p = p2; + *p = NR::Point(p1[NR::Y], p2[NR::X]); + } } -void sp_item_snappoints(SPItem const *item, SnapPointsIter p) +void sp_item_snappoints(SPItem const *item, bool includeItemCenter, SnapPointsIter p) { g_assert (item != NULL); g_assert (SP_IS_ITEM(item)); @@ -836,6 +940,10 @@ void sp_item_snappoints(SPItem const *item, SnapPointsIter p) if (item_class.snappoints) { item_class.snappoints(item, p); } + + if (includeItemCenter) { + *p = item->getCenter(); + } } void @@ -857,7 +965,7 @@ sp_item_invoke_print(SPItem *item, SPPrintContext *ctx) } static gchar * -sp_item_private_description(SPItem *item) +sp_item_private_description(SPItem */*item*/) { return g_strdup(_("Object")); } @@ -885,6 +993,11 @@ sp_item_description(SPItem *item) g_free (s); s = snew; } + if (SP_OBJECT_STYLE(item) && SP_OBJECT_STYLE(item)->filter.href) { + gchar *snew = g_strdup_printf (_("%s; filtered"), s); + g_free (s); + s = snew; + } return s; } @@ -966,6 +1079,10 @@ sp_item_invoke_show(SPItem *item, NRArena *arena, unsigned key, unsigned flags) SP_OBJECT(mask)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG); } NR_ARENA_ITEM_SET_DATA(ai, item); + NRRect item_bbox; + sp_item_invoke_bbox(item, &item_bbox, NR::identity(), TRUE, SPItem::GEOMETRIC_BBOX); + NR::Maybe i_bbox = item_bbox; + nr_arena_item_set_item_bbox(ai, i_bbox); } return ai; @@ -1016,7 +1133,7 @@ sp_item_adjust_pattern (SPItem *item, NR::Matrix const &postmul, bool set) { SPStyle *style = SP_OBJECT_STYLE (item); - if (style && (style->fill.type == SP_PAINT_TYPE_PAINTSERVER)) { + if (style && (style->fill.isPaintserver())) { SPObject *server = SP_OBJECT_STYLE_FILL_SERVER (item); if (SP_IS_PATTERN (server)) { SPPattern *pattern = sp_pattern_clone_if_necessary (item, SP_PATTERN (server), "fill"); @@ -1024,7 +1141,7 @@ sp_item_adjust_pattern (SPItem *item, NR::Matrix const &postmul, bool set) } } - if (style && (style->stroke.type == SP_PAINT_TYPE_PAINTSERVER)) { + if (style && (style->stroke.isPaintserver())) { SPObject *server = SP_OBJECT_STYLE_STROKE_SERVER (item); if (SP_IS_PATTERN (server)) { SPPattern *pattern = sp_pattern_clone_if_necessary (item, SP_PATTERN (server), "stroke"); @@ -1039,7 +1156,7 @@ sp_item_adjust_gradient (SPItem *item, NR::Matrix const &postmul, bool set) { SPStyle *style = SP_OBJECT_STYLE (item); - if (style && (style->fill.type == SP_PAINT_TYPE_PAINTSERVER)) { + if (style && (style->fill.isPaintserver())) { SPObject *server = SP_OBJECT_STYLE_FILL_SERVER(item); if (SP_IS_GRADIENT (server)) { @@ -1058,7 +1175,7 @@ sp_item_adjust_gradient (SPItem *item, NR::Matrix const &postmul, bool set) } } - if (style && (style->stroke.type == SP_PAINT_TYPE_PAINTSERVER)) { + if (style && (style->stroke.isPaintserver())) { SPObject *server = SP_OBJECT_STYLE_STROKE_SERVER(item); if (SP_IS_GRADIENT (server)) { SPGradient *gradient = sp_gradient_convert_to_userspace (SP_GRADIENT (server), item, "stroke"); @@ -1072,7 +1189,7 @@ sp_item_adjust_stroke (SPItem *item, gdouble ex) { SPStyle *style = SP_OBJECT_STYLE (item); - if (style && style->stroke.type != SP_PAINT_TYPE_NONE && !NR_DF_TEST_CLOSE (ex, 1.0, NR_EPSILON)) { + if (style && !style->stroke.isNone() && !NR_DF_TEST_CLOSE (ex, 1.0, NR_EPSILON)) { style->stroke_width.computed *= ex; style->stroke_width.set = TRUE; @@ -1116,6 +1233,10 @@ sp_item_adjust_stroke_width_recursive(SPItem *item, double expansion) { sp_item_adjust_stroke (item, expansion); +// A clone's child is the ghost of its original - we must not touch it, skip recursion + if (item && SP_IS_USE(item)) + return; + for (SPObject *o = SP_OBJECT(item)->children; o != NULL; o = o->next) { if (SP_IS_ITEM(o)) sp_item_adjust_stroke_width_recursive(SP_ITEM(o), expansion); @@ -1144,45 +1265,77 @@ sp_item_adjust_rects_recursive(SPItem *item, NR::Matrix advertized_transform) void sp_item_adjust_paint_recursive (SPItem *item, NR::Matrix advertized_transform, NR::Matrix t_ancestors, bool is_pattern) { -// A clone must not touch the style (it's that of its parent!) and has no children, so quit now - if (item && SP_IS_USE(item)) - return; - // _Before_ full pattern/gradient transform: t_paint * t_item * t_ancestors // _After_ full pattern/gradient transform: t_paint_new * t_item * t_ancestors * advertised_transform // By equating these two expressions we get t_paint_new = t_paint * paint_delta, where: NR::Matrix t_item = sp_item_transform_repr (item); NR::Matrix paint_delta = t_item * t_ancestors * advertized_transform * t_ancestors.inverse() * t_item.inverse(); +// Within text, we do not fork gradients, and so must not recurse to avoid double compensation; +// also we do not recurse into clones, because a clone's child is the ghost of its original - +// we must not touch it + if (!(item && (SP_IS_TEXT(item) || SP_IS_USE(item)))) { + for (SPObject *o = SP_OBJECT(item)->children; o != NULL; o = o->next) { + if (SP_IS_ITEM(o)) { +// At the level of the transformed item, t_ancestors is identity; +// below it, it is the accmmulated chain of transforms from this level to the top level + sp_item_adjust_paint_recursive (SP_ITEM(o), advertized_transform, t_item * t_ancestors, is_pattern); + } + } + } + +// We recursed into children first, and are now adjusting this object second; +// this is so that adjustments in a tree are done from leaves up to the root, +// and paintservers on leaves inheriting their values from ancestors could adjust themselves properly +// before ancestors themselves are adjusted, probably differently (bug 1286535) + if (is_pattern) sp_item_adjust_pattern (item, paint_delta); else sp_item_adjust_gradient (item, paint_delta); -// Within text, we do not fork gradients, and so must not recurse to avoid double compensation - if (item && SP_IS_TEXT(item)) +} + +void +sp_item_adjust_livepatheffect (SPItem *item, NR::Matrix const &postmul, bool set) +{ + if ( !SP_IS_LPE_ITEM(item) ) return; - for (SPObject *o = SP_OBJECT(item)->children; o != NULL; o = o->next) { - if (SP_IS_ITEM(o)) { -// At the level of the transformed item, t_ancestors is identity; -// below it, it is the accmmulated chain of transforms from this level to the top level - sp_item_adjust_paint_recursive (SP_ITEM(o), advertized_transform, t_item * t_ancestors, is_pattern); + SPLPEItem *lpeitem = SP_LPE_ITEM (item); + if ( sp_lpe_item_has_path_effect(lpeitem) ) { + PathEffectList effect_list = sp_lpe_item_get_effect_list(lpeitem); + for (PathEffectList::iterator it = effect_list.begin(); it != effect_list.end(); it++) + { + // If the path effect is used by 2 or more items, fork it + // so that each object has its own independent copy of the effect + LivePathEffectObject *lpeobj = (*it)->lpeobject; + if (lpeobj) { + LivePathEffectObject *new_lpeobj = lpeobj->fork_private_if_necessary(); + if (new_lpeobj != lpeobj) { + sp_lpe_item_replace_path_effect(lpeitem, lpeobj, new_lpeobj); + } + + if (lpeobj->lpe) { + Inkscape::LivePathEffect::Effect * effect = lpeobj->lpe; + effect->transform_multiply(to_2geom(postmul), set); + } + } } } } /** - * A temporary wrapper for the next function accepting the NRMatrix + * A temporary wrapper for the next function accepting the NR::Matrix * instead of NR::Matrix */ void -sp_item_write_transform(SPItem *item, Inkscape::XML::Node *repr, NRMatrix const *transform, NR::Matrix const *adv) +sp_item_write_transform(SPItem *item, Inkscape::XML::Node *repr, NR::Matrix const *transform, NR::Matrix const *adv) { if (transform == NULL) sp_item_write_transform(item, repr, NR::identity(), adv); else - sp_item_write_transform(item, repr, NR::Matrix (transform), adv); + sp_item_write_transform(item, repr, *transform, adv); } /** @@ -1207,20 +1360,20 @@ sp_item_write_transform(SPItem *item, Inkscape::XML::Node *repr, NR::Matrix cons } else { advertized_transform = sp_item_transform_repr (item).inverse() * transform; } - + if (compensate) { - + // recursively compensate for stroke scaling, depending on user preference if (prefs_get_int_attribute("options.transform", "stroke", 1) == 0) { double const expansion = 1. / NR::expansion(advertized_transform); sp_item_adjust_stroke_width_recursive(item, expansion); } - + // recursively compensate rx/ry of a rect if requested if (prefs_get_int_attribute("options.transform", "rectcorners", 1) == 0) { sp_item_adjust_rects_recursive(item, advertized_transform); } - + // recursively compensate pattern fill if it's not to be transformed if (prefs_get_int_attribute("options.transform", "pattern", 1) == 0) { sp_item_adjust_paint_recursive (item, advertized_transform.inverse(), NR::identity(), true); @@ -1233,8 +1386,8 @@ sp_item_write_transform(SPItem *item, Inkscape::XML::Node *repr, NR::Matrix cons // this converts the gradient/pattern fill/stroke, if any, to userSpaceOnUse; we need to do // it here _before_ the new transform is set, so as to use the pre-transform bbox sp_item_adjust_paint_recursive (item, NR::identity(), NR::identity(), false); - } - + } + } // endif(compensate) gint preserve = prefs_get_int_attribute("options.preservetransform", "value", 0); @@ -1244,7 +1397,7 @@ sp_item_write_transform(SPItem *item, Inkscape::XML::Node *repr, NR::Matrix cons !preserve && // user did not chose to preserve all transforms !item->clip_ref->getObject() && // the object does not have a clippath !item->mask_ref->getObject() && // the object does not have a mask - !(!transform.is_translation() && SP_OBJECT_STYLE(item) && SP_OBJECT_STYLE(item)->filter.filter) + !(!transform.is_translation() && SP_OBJECT_STYLE(item) && SP_OBJECT_STYLE(item)->getFilter()) // the object does not have a filter, or the transform is translation (which is supposed to not affect filters) ) { transform_attr = ((SPItemClass *) G_OBJECT_GET_CLASS(item))->set_transform(item, transform); @@ -1293,43 +1446,59 @@ sp_item_set_item_transform(SPItem *item, NR::Matrix const &transform) } } +void +sp_item_convert_item_to_guides(SPItem *item) { + g_return_if_fail(item != NULL); + g_return_if_fail(SP_IS_ITEM(item)); + + /* Use derived method if present ... */ + if (((SPItemClass *) G_OBJECT_GET_CLASS(item))->convert_to_guides) { + (*((SPItemClass *) G_OBJECT_GET_CLASS(item))->convert_to_guides)(item); + return; + } + + /* .. otherwise simply place the guides around the item's bounding box */ + + sp_item_convert_to_guides(item); +} + /** * \pre \a ancestor really is an ancestor (\>=) of \a object, or NULL. * ("Ancestor (\>=)" here includes as far as \a object itself.) */ -NR::Matrix +Geom::Matrix i2anc_affine(SPObject const *object, SPObject const *const ancestor) { - NR::Matrix ret(NR::identity()); + Geom::Matrix ret(Geom::identity()); g_return_val_if_fail(object != NULL, ret); /* stop at first non-renderable ancestor */ while ( object != ancestor && SP_IS_ITEM(object) ) { if (SP_IS_ROOT(object)) { - ret *= SP_ROOT(object)->c2p; + ret *= to_2geom(SP_ROOT(object)->c2p); } - ret *= SP_ITEM(object)->transform; + ret *= to_2geom(SP_ITEM(object)->transform); object = SP_OBJECT_PARENT(object); } return ret; } -NR::Matrix +Geom::Matrix i2i_affine(SPObject const *src, SPObject const *dest) { - g_return_val_if_fail(src != NULL && dest != NULL, NR::identity()); + g_return_val_if_fail(src != NULL && dest != NULL, Geom::identity()); SPObject const *ancestor = src->nearestCommonAncestor(dest); - return i2anc_affine(src, ancestor) / i2anc_affine(dest, ancestor); + return to_2geom( from_2geom(i2anc_affine(src, ancestor)) / from_2geom(i2anc_affine(dest, ancestor)) ); } NR::Matrix SPItem::getRelativeTransform(SPObject const *dest) const { - return i2i_affine(this, dest); + return from_2geom(i2i_affine(this, dest)); } /** * Returns the accumulated transformation of the item and all its ancestors, including root's viewport. * \pre (item != NULL) and SP_IS_ITEM(item). */ -NR::Matrix sp_item_i2doc_affine(SPItem const *item) +Geom::Matrix sp_item_i2doc_affine(SPItem const *item) { return i2anc_affine(item, NULL); } @@ -1339,46 +1508,46 @@ NR::Matrix sp_item_i2doc_affine(SPItem const *item) * Used in path operations mostly. * \pre (item != NULL) and SP_IS_ITEM(item). */ -NR::Matrix sp_item_i2root_affine(SPItem const *item) +Geom::Matrix sp_item_i2root_affine(SPItem const *item) { g_assert(item != NULL); g_assert(SP_IS_ITEM(item)); - NR::Matrix ret(NR::identity()); - g_assert(ret.test_identity()); + Geom::Matrix ret(Geom::identity()); + g_assert(ret.isIdentity()); while ( NULL != SP_OBJECT_PARENT(item) ) { - ret *= item->transform; + ret *= to_2geom(item->transform); item = SP_ITEM(SP_OBJECT_PARENT(item)); } g_assert(SP_IS_ROOT(item)); - ret *= item->transform; + ret *= to_2geom(item->transform); return ret; } /* fixme: This is EVIL!!! */ - -NR::Matrix sp_item_i2d_affine(SPItem const *item) +// fix this note: why/what evil? :) +Geom::Matrix sp_item_i2d_affine(SPItem const *item) { g_assert(item != NULL); g_assert(SP_IS_ITEM(item)); - NR::Matrix const ret( sp_item_i2doc_affine(item) - * NR::scale(1, -1) - * NR::translate(0, sp_document_height(SP_OBJECT_DOCUMENT(item))) ); + Geom::Matrix const ret( sp_item_i2doc_affine(item) + * Geom::Scale(1, -1) + * Geom::Translate(0, sp_document_height(SP_OBJECT_DOCUMENT(item))) ); return ret; } // same as i2d but with i2root instead of i2doc -NR::Matrix sp_item_i2r_affine(SPItem const *item) +Geom::Matrix sp_item_i2r_affine(SPItem const *item) { g_assert(item != NULL); g_assert(SP_IS_ITEM(item)); - NR::Matrix const ret( sp_item_i2root_affine(item) - * NR::scale(1, -1) - * NR::translate(0, sp_document_height(SP_OBJECT_DOCUMENT(item))) ); + Geom::Matrix const ret( sp_item_i2root_affine(item) + * Geom::Scale(1, -1) + * Geom::Translate(0, sp_document_height(SP_OBJECT_DOCUMENT(item))) ); return ret; } @@ -1386,11 +1555,11 @@ NR::Matrix sp_item_i2r_affine(SPItem const *item) * Converts a matrix \a m into the desktop coords of the \a item. * Will become a noop when we eliminate the coordinate flipping. */ -NR::Matrix matrix_to_desktop(NR::Matrix const m, SPItem const *item) +Geom::Matrix matrix_to_desktop(Geom::Matrix const m, SPItem const *item) { - NR::Matrix const ret(m - * NR::translate(0, -sp_document_height(SP_OBJECT_DOCUMENT(item))) - * NR::scale(1, -1)); + Geom::Matrix const ret(m + * Geom::Translate(0, -sp_document_height(SP_OBJECT_DOCUMENT(item))) + * Geom::Scale(1, -1)); return ret; } @@ -1398,33 +1567,33 @@ NR::Matrix matrix_to_desktop(NR::Matrix const m, SPItem const *item) * Converts a matrix \a m from the desktop coords of the \a item. * Will become a noop when we eliminate the coordinate flipping. */ -NR::Matrix matrix_from_desktop(NR::Matrix const m, SPItem const *item) +Geom::Matrix matrix_from_desktop(Geom::Matrix const m, SPItem const *item) { - NR::Matrix const ret(NR::scale(1, -1) - * NR::translate(0, sp_document_height(SP_OBJECT_DOCUMENT(item))) + Geom::Matrix const ret(Geom::Scale(1, -1) + * Geom::Translate(0, sp_document_height(SP_OBJECT_DOCUMENT(item))) * m); return ret; } -void sp_item_set_i2d_affine(SPItem *item, NR::Matrix const &i2dt) +void sp_item_set_i2d_affine(SPItem *item, Geom::Matrix const &i2dt) { g_return_if_fail( item != NULL ); g_return_if_fail( SP_IS_ITEM(item) ); - NR::Matrix dt2p; /* desktop to item parent transform */ + Geom::Matrix dt2p; /* desktop to item parent transform */ if (SP_OBJECT_PARENT(item)) { dt2p = sp_item_i2d_affine((SPItem *) SP_OBJECT_PARENT(item)).inverse(); } else { - dt2p = ( NR::translate(0, -sp_document_height(SP_OBJECT_DOCUMENT(item))) - * NR::scale(1, -1) ); + dt2p = ( Geom::Translate(0, -sp_document_height(SP_OBJECT_DOCUMENT(item))) + * Geom::Scale(1, -1) ); } - NR::Matrix const i2p( i2dt * dt2p ); - sp_item_set_item_transform(item, i2p); + Geom::Matrix const i2p( i2dt * dt2p ); + sp_item_set_item_transform(item, from_2geom(i2p)); } -NR::Matrix +Geom::Matrix sp_item_dt2i_affine(SPItem const *item) { /* fixme: Implement the right way (Lauris) */ @@ -1504,6 +1673,36 @@ sp_item_first_item_child (SPObject *obj) return NULL; } +void +sp_item_convert_to_guides(SPItem *item) { + SPDesktop *dt = inkscape_active_desktop(); + SPNamedView *nv = sp_desktop_namedview(dt); + (void)nv; + + int prefs_bbox = prefs_get_int_attribute("tools", "bounding_box", 0); + SPItem::BBoxType bbox_type = (prefs_bbox ==0)? + SPItem::APPROXIMATE_BBOX : SPItem::GEOMETRIC_BBOX; + + NR::Maybe bbox = sp_item_bbox_desktop(item, bbox_type); + if (!bbox) { + g_warning ("Cannot determine item's bounding box during conversion to guides.\n"); + return; + } + + std::list > pts; + + NR::Point A((*bbox).min()); + NR::Point C((*bbox).max()); + NR::Point B(A[NR::X], C[NR::Y]); + NR::Point D(C[NR::X], A[NR::Y]); + + pts.push_back(std::make_pair(A.to_2geom(), B.to_2geom())); + pts.push_back(std::make_pair(B.to_2geom(), C.to_2geom())); + pts.push_back(std::make_pair(C.to_2geom(), D.to_2geom())); + pts.push_back(std::make_pair(D.to_2geom(), A.to_2geom())); + + sp_guide_pt_pairs_to_guides(SP_OBJECT_DOCUMENT(item), pts); +} /* Local Variables: