![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
diff --git a/src/splivarot.cpp b/src/splivarot.cpp
index 065533f71395a5be9635ad8c43bce94f66b638d6..5868140a6d25b101fe677b514e1c2cd51b84da8b 100644 (file)
--- a/src/splivarot.cpp
+++ b/src/splivarot.cpp
# include <config.h>
#endif
+#include <cstring>
+#include <string>
+#include <vector>
+#include <glib/gmem.h>
#include "xml/repr.h"
#include "svg/svg.h"
#include "sp-path.h"
+#include "sp-shape.h"
+#include "sp-image.h"
+#include "marker.h"
+#include "enums.h"
#include "sp-text.h"
+#include "sp-flowtext.h"
+#include "text-editing.h"
#include "sp-item-group.h"
#include "style.h"
#include "inkscape.h"
#include "xml/repr.h"
#include "xml/repr-sorting.h"
+#include <libnr/nr-matrix-fns.h>
+#include <libnr/nr-matrix-ops.h>
+#include <libnr/nr-matrix-translate-ops.h>
+#include <libnr/nr-scale-matrix-ops.h>
+
#include "livarot/Path.h"
#include "livarot/Shape.h"
bool Ancetre(Inkscape::XML::Node *a, Inkscape::XML::Node *who);
-void sp_selected_path_boolop(bool_op bop);
+void sp_selected_path_boolop(bool_op bop, const unsigned int verb=SP_VERB_NONE, const Glib::ustring description="");
void sp_selected_path_do_offset(bool expand, double prefOffset);
void sp_selected_path_create_offset_object(int expand, bool updating);
void
sp_selected_path_union()
{
- sp_selected_path_boolop(bool_op_union);
+ sp_selected_path_boolop(bool_op_union, SP_VERB_SELECTION_UNION, _("Union"));
+}
+
+void
+sp_selected_path_union_skip_undo()
+{
+ sp_selected_path_boolop(bool_op_union, SP_VERB_NONE, _("Union"));
}
void
sp_selected_path_intersect()
{
- sp_selected_path_boolop(bool_op_inters);
+ sp_selected_path_boolop(bool_op_inters, SP_VERB_SELECTION_INTERSECT, _("Intersection"));
}
void
sp_selected_path_diff()
{
- sp_selected_path_boolop(bool_op_diff);
+ sp_selected_path_boolop(bool_op_diff, SP_VERB_SELECTION_DIFF, _("Difference"));
+}
+
+void
+sp_selected_path_diff_skip_undo()
+{
+ sp_selected_path_boolop(bool_op_diff, SP_VERB_NONE, _("Difference"));
}
void
sp_selected_path_symdiff()
{
- sp_selected_path_boolop(bool_op_symdiff);
+ sp_selected_path_boolop(bool_op_symdiff, SP_VERB_SELECTION_SYMDIFF, _("Exclusion"));
}
void
sp_selected_path_cut()
{
- sp_selected_path_boolop(bool_op_cut);
+ sp_selected_path_boolop(bool_op_cut, SP_VERB_SELECTION_CUT, _("Division"));
}
void
sp_selected_path_slice()
{
- sp_selected_path_boolop(bool_op_slice);
+ sp_selected_path_boolop(bool_op_slice, SP_VERB_SELECTION_SLICE, _("Cut path"));
}
// boolean operations
// take the source paths from the file, do the operation, delete the originals and add the results
void
-sp_selected_path_boolop(bool_op bop)
+sp_selected_path_boolop(bool_op bop, const unsigned int verb, const Glib::ustring description)
{
SPDesktop *desktop = SP_ACTIVE_DESKTOP;
- Inkscape::Selection *selection = SP_DT_SELECTION(desktop);
-
+ Inkscape::Selection *selection = sp_desktop_selection(desktop);
+
GSList *il = (GSList *) selection->itemList();
-
- if (g_slist_length(il) < 2) {
+
+ // allow union on a single object for the purpose of removing self overlapse (svn log, revision 13334)
+ if ( (g_slist_length(il) < 2) && (bop != bool_op_union)) {
desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("Select <b>at least 2 paths</b> to perform a boolean operation."));
return;
}
+ else if ( g_slist_length(il) < 1 ) {
+ desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("Select <b>at least 1 path</b> to perform a boolean union."));
+ return;
+ }
if (g_slist_length(il) > 2) {
if (bop == bool_op_diff || bop == bool_op_symdiff || bop == bool_op_cut || bop == bool_op_slice ) {
for (GSList *l = il; l != NULL; l = l->next)
{
SPItem *item = SP_ITEM(l->data);
- if (!SP_IS_SHAPE(item) && !SP_IS_TEXT(item))
+ if (!SP_IS_SHAPE(item) && !SP_IS_TEXT(item) && !SP_IS_FLOWTEXT(item))
{
desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("One of the objects is <b>not a path</b>, cannot perform boolean operation."));
g_slist_free(il);
// extract the livarot Paths from the source objects
// also get the winding rule specified in the style
int nbOriginaux = g_slist_length(il);
- Path *originaux[nbOriginaux];
- FillRule origWind[nbOriginaux];
+ std::vector<Path *> originaux(nbOriginaux);
+ std::vector<FillRule> origWind(nbOriginaux);
int curOrig;
{
curOrig = 0;
if ( bop == bool_op_inters || bop == bool_op_union || bop == bool_op_diff || bop == bool_op_symdiff ) {
// true boolean op
// get the polygons of each path, with the winding rule specified, and apply the operation iteratively
- originaux[0]->ConvertWithBackData(0.03);
+ originaux[0]->ConvertWithBackData(0.1);
originaux[0]->Fill(theShape, 0);
curOrig = 1;
for (GSList *l = il->next; l != NULL; l = l->next) {
- originaux[curOrig]->ConvertWithBackData(0.03);
+ originaux[curOrig]->ConvertWithBackData(0.1);
originaux[curOrig]->Fill(theShape, curOrig);
// function needs it.
// this function uses the point_data to get the winding number of each path (ie: is a hole or not)
// for later reconstruction in objects, you also need to extract which path is parent of holes (nesting info)
- theShape->ConvertToFormeNested(res, nbOriginaux, originaux, 1, nbNest, nesting, conts);
+ theShape->ConvertToFormeNested(res, nbOriginaux, &originaux[0], 1, nbNest, nesting, conts);
} else {
- theShape->ConvertToForme(res, nbOriginaux, originaux);
+ theShape->ConvertToForme(res, nbOriginaux, &originaux[0]);
}
delete theShape;
{
SP_OBJECT(l->data)->deleteObject();
}
- sp_document_done(SP_DT_DOCUMENT(desktop));
+ sp_document_done(sp_desktop_document(desktop), SP_VERB_NONE,
+ description);
selection->clear();
delete res;
return;
}
- // remember important aspects of the source path, to be restored
- Inkscape::XML::Node *repr_source;
+ // get the source path object
+ SPObject *source;
if ( bop == bool_op_diff || bop == bool_op_symdiff || bop == bool_op_cut || bop == bool_op_slice ) {
if (reverseOrderForOp) {
- repr_source = SP_OBJECT_REPR(il->data);
+ source = SP_OBJECT(il->data);
} else {
- repr_source = SP_OBJECT_REPR(il->next->data);
+ source = SP_OBJECT(il->next->data);
}
} else {
// find out the bottom object
GSList *sorted = g_slist_copy((GSList *) selection->reprList());
sorted = g_slist_sort(sorted, (GCompareFunc) sp_repr_compare_position);
- repr_source = ((Inkscape::XML::Node *) sorted->data);
+
+ source = sp_desktop_document(desktop)->
+ getObjectByRepr((Inkscape::XML::Node *)sorted->data);
+
g_slist_free(sorted);
}
+
+ // adjust style properties that depend on a possible transform in the source object in order
+ // to get a correct style attribute for the new path
+ SPItem* item_source = SP_ITEM(source);
+ NR::Matrix i2root = from_2geom(sp_item_i2root_affine(item_source));
+ sp_item_adjust_stroke(item_source, NR::expansion(i2root));
+ sp_item_adjust_pattern(item_source, i2root);
+ sp_item_adjust_gradient(item_source, i2root);
+ sp_item_adjust_livepatheffect(item_source, i2root);
+
+ Inkscape::XML::Node *repr_source = SP_OBJECT_REPR(source);
+
+ // remember important aspects of the source path, to be restored
gint pos = repr_source->position();
Inkscape::XML::Node *parent = sp_repr_parent(repr_source);
- char const *id = repr_source->attribute("id");
- char const *style = repr_source->attribute("style");
-
+ gchar const *id = repr_source->attribute("id");
+ gchar const *style = repr_source->attribute("style");
+ gchar const *mask = repr_source->attribute("mask");
+ gchar const *clip_path = repr_source->attribute("clip-path");
// remove source paths
selection->clear();
g_slist_free(il);
// premultiply by the inverse of parent's repr
- SPItem *parent_item = SP_ITEM(SP_DT_DOCUMENT(desktop)->getObjectByRepr(parent));
- NR::Matrix local = sp_item_i2doc_affine(parent_item);
- gchar affinestr[80];
- gchar *transform = NULL;
- if (!local.test_identity() && sp_svg_transform_write(affinestr, 79, local.inverse())) {
- transform = affinestr;
- }
+ SPItem *parent_item = SP_ITEM(sp_desktop_document(desktop)->getObjectByRepr(parent));
+ NR::Matrix local = from_2geom(sp_item_i2doc_affine(parent_item));
+ gchar *transform = sp_svg_transform_write(local.inverse());
// now that we have the result, add it on the canvas
if ( bop == bool_op_cut || bop == bool_op_slice ) {
for (int i=0;i<nbRP;i++) {
gchar *d = resPath[i]->svg_dump_path();
- Inkscape::XML::Node *repr = sp_repr_new("svg:path");
+ Inkscape::XML::Document *xml_doc = sp_document_repr_doc(desktop->doc());
+ Inkscape::XML::Node *repr = xml_doc->createElement("svg:path");
repr->setAttribute("style", style);
+ if (mask)
+ repr->setAttribute("mask", mask);
+ if (clip_path)
+ repr->setAttribute("clip-path", clip_path);
+
repr->setAttribute("d", d);
g_free(d);
} else {
gchar *d = res->svg_dump_path();
- Inkscape::XML::Node *repr = sp_repr_new("svg:path");
+ Inkscape::XML::Document *xml_doc = sp_document_repr_doc(desktop->doc());
+ Inkscape::XML::Node *repr = xml_doc->createElement("svg:path");
repr->setAttribute("style", style);
+ if ( mask )
+ repr->setAttribute("mask", mask);
+
+ if ( clip_path )
+ repr->setAttribute("clip-path", clip_path);
+
repr->setAttribute("d", d);
g_free(d);
Inkscape::GC::release(repr);
}
- sp_document_done(SP_DT_DOCUMENT(desktop));
+ g_free(transform);
+
+ if (verb != SP_VERB_NONE) {
+ sp_document_done(sp_desktop_document(desktop), verb, description);
+ }
delete res;
}
{
SPDesktop *desktop = SP_ACTIVE_DESKTOP;
- Inkscape::Selection *selection = SP_DT_SELECTION(desktop);
+ Inkscape::Selection *selection = sp_desktop_selection(desktop);
if (selection->isEmpty()) {
- // TRANSLATORS: "to outline" means "to convert stroke to path"
- desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>path(s)</b> to outline."));
+ desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>stroked path(s)</b> to convert stroke to path."));
return;
}
}
{ // pas de stroke pas de chocolat
- SPCSSAttr *css = sp_repr_css_attr(SP_OBJECT_REPR(item), "style");
+ SPCSSAttr *css = sp_repr_css_attr_inherited(SP_OBJECT_REPR(item), "style");
gchar const *val = sp_repr_css_property(css, "stroke", NULL);
if (val == NULL || strcmp(val, "none") == 0) {
- sp_curve_unref(curve);
+ curve->unref();
continue;
}
}
// remember old stroke style, to be set on fill
SPCSSAttr *ncss;
{
- SPCSSAttr *ocss = sp_repr_css_attr(SP_OBJECT_REPR(item), "style");
+ SPCSSAttr *ocss = sp_repr_css_attr_inherited(SP_OBJECT_REPR(item), "style");
gchar const *val = sp_repr_css_property(ocss, "stroke", NULL);
gchar const *opac = sp_repr_css_property(ocss, "stroke-opacity", NULL);
} else {
sp_repr_css_set_property(ncss, "fill-opacity", "1.0");
}
+ sp_repr_css_unset_property(ncss, "marker-start");
+ sp_repr_css_unset_property(ncss, "marker-mid");
+ sp_repr_css_unset_property(ncss, "marker-end");
}
NR::Matrix const transform(item->transform);
+ float const scale = NR::expansion(transform);
gchar *style = g_strdup(SP_OBJECT_REPR(item)->attribute("style"));
+ SPStyle *i_style = SP_OBJECT(item)->style;
+ gchar const *mask = SP_OBJECT_REPR(item)->attribute("mask");
+ gchar const *clip_path = SP_OBJECT_REPR(item)->attribute("clip-path");
float o_width, o_miter;
JoinType o_join;
ButtType o_butt;
{
- SPStyle *i_style = SP_OBJECT(item)->style;
int jointype, captype;
jointype = i_style->stroke_linejoin.computed;
Path *orig = Path_for_item(item, false);
if (orig == NULL) {
g_free(style);
- sp_curve_unref(curve);
+ curve->unref();
continue;
}
Path *res = new Path;
res->SetBackData(false);
+ if (i_style->stroke_dash.n_dash) {
+ // For dashed strokes, use Stroke method, because Outline can't do dashes
+ // However Stroke adds lots of extra nodes _or_ makes the path crooked, so consider this a temporary workaround
+
+ orig->ConvertWithBackData(0.1);
+
+ orig->DashPolylineFromStyle(i_style, scale, 0);
+
+ Shape* theShape = new Shape;
+ orig->Stroke(theShape, false, 0.5*o_width, o_join, o_butt,
+ 0.5 * o_miter);
+ orig->Outline(res, 0.5 * o_width, o_join, o_butt, 0.5 * o_miter);
+
+ Shape *theRes = new Shape;
+
+ theRes->ConvertToShape(theShape, fill_positive);
+
+ Path *originaux[1];
+ originaux[0] = res;
+ theRes->ConvertToForme(orig, 1, originaux);
+
+ res->Coalesce(5.0);
+
+ delete theShape;
+ delete theRes;
+
+ } else {
- {
orig->Outline(res, 0.5 * o_width, o_join, o_butt, 0.5 * o_miter);
orig->Coalesce(0.5 * o_width);
did = true;
- sp_curve_unref(curve);
// remember the position of the item
gint pos = SP_OBJECT_REPR(item)->position();
// remember parent
// remember id
char const *id = SP_OBJECT_REPR(item)->attribute("id");
- selection->remove(item);
- SP_OBJECT(item)->deleteObject(false);
-
if (res->descr_cmd.size() > 1) { // if there's 0 or 1 node left, drop this path altogether
- Inkscape::XML::Node *repr = sp_repr_new("svg:path");
+ Inkscape::XML::Document *xml_doc = sp_document_repr_doc(desktop->doc());
+ Inkscape::XML::Node *repr = xml_doc->createElement("svg:path");
// restore old style
repr->setAttribute("style", style);
repr->setAttribute("d", str);
g_free(str);
- // add the new repr to the parent
- parent->appendChild(repr);
+ if (mask)
+ repr->setAttribute("mask", mask);
+ if (clip_path)
+ repr->setAttribute("clip-path", clip_path);
- // move to the saved position
- repr->setPosition(pos > 0 ? pos : 0);
+ if (SP_IS_SHAPE(item) && sp_shape_has_markers (SP_SHAPE(item))) {
- repr->setAttribute("id", id);
+ Inkscape::XML::Document *xml_doc = sp_document_repr_doc(desktop->doc());
+ Inkscape::XML::Node *g_repr = xml_doc->createElement("svg:g");
- SPItem *newitem = (SPItem *) SP_DT_DOCUMENT(desktop)->getObjectByRepr(repr);
- sp_item_write_transform(newitem, repr, transform);
+ // add the group to the parent
+ parent->appendChild(g_repr);
+ // move to the saved position
+ g_repr->setPosition(pos > 0 ? pos : 0);
- selection->add(repr);
+ g_repr->appendChild(repr);
+ repr->setAttribute("id", id);
+ SPItem *newitem = (SPItem *) sp_desktop_document(desktop)->getObjectByRepr(repr);
+ sp_item_write_transform(newitem, repr, transform);
+
+ SPShape *shape = SP_SHAPE(item);
+
+ for (NArtBpath const* bp = SP_CURVE_BPATH(shape->curve); bp->code != NR_END; bp++) {
+ for (int m = SP_MARKER_LOC_START; m < SP_MARKER_LOC_QTY; m++) {
+ if (sp_shape_marker_required (shape, m, bp)) {
+
+ SPMarker* marker = SP_MARKER (shape->marker[m]);
+ SPItem* marker_item = sp_item_first_item_child (SP_OBJECT (shape->marker[m]));
+
+ NR::Matrix tr(sp_shape_marker_get_transform(shape, bp));
+
+ if (marker->markerUnits == SP_MARKER_UNITS_STROKEWIDTH) {
+ tr = NR::scale(i_style->stroke_width.computed) * tr;
+ }
+
+ // total marker transform
+ tr = marker_item->transform * marker->c2p * tr * transform;
+
+ if (SP_OBJECT_REPR(marker_item)) {
+ Inkscape::XML::Node *m_repr = SP_OBJECT_REPR(marker_item)->duplicate(xml_doc);
+ g_repr->appendChild(m_repr);
+ SPItem *marker_item = (SPItem *) sp_desktop_document(desktop)->getObjectByRepr(m_repr);
+ sp_item_write_transform(marker_item, m_repr, tr);
+ }
+ }
+ }
+ }
+
+
+ selection->add(g_repr);
+
+ Inkscape::GC::release(g_repr);
+
+
+ } else {
+
+ // add the new repr to the parent
+ parent->appendChild(repr);
+
+ // move to the saved position
+ repr->setPosition(pos > 0 ? pos : 0);
+
+ repr->setAttribute("id", id);
+
+ SPItem *newitem = (SPItem *) sp_desktop_document(desktop)->getObjectByRepr(repr);
+ sp_item_write_transform(newitem, repr, transform);
+
+ selection->add(repr);
+
+ }
Inkscape::GC::release(repr);
+
+ curve->unref();
+ selection->remove(item);
+ SP_OBJECT(item)->deleteObject(false);
+
}
delete res;
}
if (did) {
- sp_document_done(SP_DT_DOCUMENT(desktop));
+ sp_document_done(sp_desktop_document(desktop), SP_VERB_SELECTION_OUTLINE,
+ _("Convert stroke to path"));
} else {
// TRANSLATORS: "to outline" means "to convert stroke to path"
- desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("<b>No stroked paths</b> to outline in the selection."));
+ desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("<b>No stroked paths</b> in the selection."));
return;
}
}
desktop = SP_ACTIVE_DESKTOP;
- selection = SP_DT_SELECTION(desktop);
+ selection = sp_desktop_selection(desktop);
item = selection->singleItem();
if (orig == NULL)
{
g_free(style);
- sp_curve_unref(curve);
+ curve->unref();
return;
}
delete theRes;
}
- sp_curve_unref(curve);
+ curve->unref();
if (res->descr_cmd.size() <= 1)
{
// pas vraiment de points sur le resultat
// donc il ne reste rien
- sp_document_done(SP_DT_DOCUMENT(desktop));
+ sp_document_done(sp_desktop_document(desktop),
+ (updating ? SP_VERB_SELECTION_LINKED_OFFSET
+ : SP_VERB_SELECTION_DYNAMIC_OFFSET),
+ (updating ? _("Create linked offset")
+ : _("Create dynamic offset")));
selection->clear();
delete res;
tstr[79] = '\0';
- repr = sp_repr_new("svg:path");
+ Inkscape::XML::Document *xml_doc = sp_document_repr_doc(desktop->doc());
+ repr = xml_doc->createElement("svg:path");
repr->setAttribute("sodipodi:type", "inkscape:offset");
sp_repr_set_svg_double(repr, "inkscape:radius", ( expand > 0
? o_width
// move to the saved position
repr->setPosition(pos > 0 ? pos : 0);
- SPItem *nitem = (SPItem *) SP_DT_DOCUMENT(desktop)->getObjectByRepr(repr);
+ SPItem *nitem = (SPItem *) sp_desktop_document(desktop)->getObjectByRepr(repr);
if ( updating ) {
// on conserve l'original
selection->set(nitem);
}
- sp_document_done(SP_DT_DOCUMENT(desktop));
+ sp_document_done(sp_desktop_document(desktop),
+ (updating ? SP_VERB_SELECTION_LINKED_OFFSET
+ : SP_VERB_SELECTION_DYNAMIC_OFFSET),
+ (updating ? _("Create linked offset")
+ : _("Create dynamic offset")));
delete res;
delete orig;
{
SPDesktop *desktop = SP_ACTIVE_DESKTOP;
- Inkscape::Selection *selection = SP_DT_SELECTION(desktop);
+ Inkscape::Selection *selection = sp_desktop_selection(desktop);
if (selection->isEmpty()) {
desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>path(s)</b> to inset/outset."));
Path *orig = Path_for_item(item, false);
if (orig == NULL) {
g_free(style);
- sp_curve_unref(curve);
+ curve->unref();
continue;
}
did = true;
- sp_curve_unref(curve);
+ curve->unref();
// remember the position of the item
gint pos = SP_OBJECT_REPR(item)->position();
// remember parent
tstr[79] = '\0';
- Inkscape::XML::Node *repr = sp_repr_new("svg:path");
+ Inkscape::XML::Document *xml_doc = sp_document_repr_doc(desktop->doc());
+ Inkscape::XML::Node *repr = xml_doc->createElement("svg:path");
repr->setAttribute("style", style);
// move to the saved position
repr->setPosition(pos > 0 ? pos : 0);
- SPItem *newitem = (SPItem *) SP_DT_DOCUMENT(desktop)->getObjectByRepr(repr);
+ SPItem *newitem = (SPItem *) sp_desktop_document(desktop)->getObjectByRepr(repr);
// reapply the transform
sp_item_write_transform(newitem, repr, transform);
}
if (did) {
- sp_document_done(SP_DT_DOCUMENT(desktop));
+ sp_document_done(sp_desktop_document(desktop),
+ (expand ? SP_VERB_SELECTION_OFFSET : SP_VERB_SELECTION_INSET),
+ (expand ? _("Outset path") : _("Inset path")));
} else {
desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("<b>No paths</b> to inset/outset in the selection."));
return;
}
+static bool
+sp_selected_path_simplify_items(SPDesktop *desktop,
+ Inkscape::Selection *selection, GSList *items,
+ float threshold, bool justCoalesce,
+ float angleLimit, bool breakableAngles,
+ bool modifySelection);
+
//return true if we changed something, else false
bool
-sp_selected_path_simplify_item(SPDesktop *desktop, Inkscape::Selection *selection, SPItem *item,
+sp_selected_path_simplify_item(SPDesktop *desktop,
+ Inkscape::Selection *selection, SPItem *item,
float threshold, bool justCoalesce,
float angleLimit, bool breakableAngles,
gdouble size, bool modifySelection)
@@ -1267,18 +1442,12 @@ sp_selected_path_simplify_item(SPDesktop *desktop, Inkscape::Selection *selectio
//If this is a group, do the children instead
if (SP_IS_GROUP(item)) {
-
- bool didSomething = false;
-
- for ( GSList *children = sp_item_group_item_list(SP_GROUP(item));
- children ; children = children->next) {
-
- SPItem *child = (SPItem *) children->data;
- didSomething |= sp_selected_path_simplify_item(desktop, selection, child, threshold, justCoalesce,
- angleLimit, breakableAngles, size, false);
- }
-
- return didSomething;
+ GSList *items = sp_item_group_item_list(SP_GROUP(item));
+
+ return sp_selected_path_simplify_items(desktop, selection, items,
+ threshold, justCoalesce,
+ angleLimit, breakableAngles,
+ false);
}
@@ -1307,21 +1476,25 @@ sp_selected_path_simplify_item(SPDesktop *desktop, Inkscape::Selection *selectio
sp_item_write_transform(item, SP_OBJECT_REPR(item), NR::identity());
gchar *style = g_strdup(SP_OBJECT_REPR(item)->attribute("style"));
+ gchar *mask = g_strdup(SP_OBJECT_REPR(item)->attribute("mask"));
+ gchar *clip_path = g_strdup(SP_OBJECT_REPR(item)->attribute("clip-path"));
Path *orig = Path_for_item(item, false);
if (orig == NULL) {
g_free(style);
- sp_curve_unref(curve);
+ curve->unref();
return false;
}
- sp_curve_unref(curve);
+ curve->unref();
// remember the position of the item
gint pos = SP_OBJECT_REPR(item)->position();
// remember parent
Inkscape::XML::Node *parent = SP_OBJECT_REPR(item)->parent();
// remember id
char const *id = SP_OBJECT_REPR(item)->attribute("id");
+ // remember path effect
+ char const *patheffect = SP_OBJECT_REPR(item)->attribute("inkscape:path-effect");
//If a group was selected, to not change the selection list
if (modifySelection)
@@ -1336,12 +1509,29 @@ sp_selected_path_simplify_item(SPDesktop *desktop, Inkscape::Selection *selectio
orig->Simplify(threshold * size);
}
- Inkscape::XML::Node *repr = sp_repr_new("svg:path");
+ Inkscape::XML::Document *xml_doc = sp_document_repr_doc(desktop->doc());
+ Inkscape::XML::Node *repr = xml_doc->createElement("svg:path");
+ // restore style, mask and clip-path
repr->setAttribute("style", style);
+ g_free(style);
+
+ if ( mask ) {
+ repr->setAttribute("mask", mask);
+ g_free(mask);
+ }
+
+ if ( clip_path ) {
+ repr->setAttribute("clip-path", clip_path);
+ g_free(clip_path);
+ }
+ // path
gchar *str = orig->svg_dump_path();
- repr->setAttribute("d", str);
+ if (patheffect)
+ repr->setAttribute("inkscape:original-d", str);
+ else
+ repr->setAttribute("d", str);
g_free(str);
// restore id
@@ -1353,11 +1543,14 @@ sp_selected_path_simplify_item(SPDesktop *desktop, Inkscape::Selection *selectio
// move to the saved position
repr->setPosition(pos > 0 ? pos : 0);
- SPItem *newitem = (SPItem *) SP_DT_DOCUMENT(desktop)->getObjectByRepr(repr);
+ SPItem *newitem = (SPItem *) sp_desktop_document(desktop)->getObjectByRepr(repr);
// reapply the transform
sp_item_write_transform(newitem, repr, transform);
+ // restore path effect
+ repr->setAttribute("inkscape:path-effect", patheffect);
+
//If we are not in a selected group
if (modifySelection)
selection->add(repr);
@@ -1371,13 +1564,81 @@ sp_selected_path_simplify_item(SPDesktop *desktop, Inkscape::Selection *selectio
}
+bool
+sp_selected_path_simplify_items(SPDesktop *desktop,
+ Inkscape::Selection *selection, GSList *items,
+ float threshold, bool justCoalesce,
+ float angleLimit, bool breakableAngles,
+ bool modifySelection)
+{
+ bool simplifyIndividualPaths =
+ (bool) prefs_get_int_attribute("options.simplifyindividualpaths", "value", 0);
+
+ gchar *simplificationType;
+ if (simplifyIndividualPaths) {
+ simplificationType = _("Simplifying paths (separately):");
+ } else {
+ simplificationType = _("Simplifying paths:");
+ }
+
+ bool didSomething = false;
+
+ NR::Maybe<NR::Rect> selectionBbox = selection->bounds();
+ if (!selectionBbox) {
+ return false;
+ }
+ gdouble selectionSize = L2(selectionBbox->dimensions());
+
+ gdouble simplifySize = selectionSize;
+
+ int pathsSimplified = 0;
+ int totalPathCount = g_slist_length(items);
+
+ // set "busy" cursor
+ desktop->setWaitingCursor();
+
+ for (; items != NULL; items = items->next) {
+ SPItem *item = (SPItem *) items->data;
+
+ if (!(SP_IS_GROUP(item) || SP_IS_SHAPE(item) || SP_IS_TEXT(item)))
+ continue;
+
+ if (simplifyIndividualPaths) {
+ NR::Maybe<NR::Rect> itemBbox = item->getBounds(from_2geom(sp_item_i2d_affine(item)));
+ if (itemBbox) {
+ simplifySize = L2(itemBbox->dimensions());
+ } else {
+ simplifySize = 0;
+ }
+ }
+
+ pathsSimplified++;
+
+ if (pathsSimplified % 20 == 0) {
+ gchar *message = g_strdup_printf(_("%s <b>%d</b> of <b>%d</b> paths simplified..."), simplificationType, pathsSimplified, totalPathCount);
+ desktop->messageStack()->flash(Inkscape::IMMEDIATE_MESSAGE, message);
+ }
+
+ didSomething |= sp_selected_path_simplify_item(desktop, selection, item,
+ threshold, justCoalesce, angleLimit, breakableAngles, simplifySize, modifySelection);
+ }
+
+ desktop->clearWaitingCursor();
+
+ if (pathsSimplified > 20) {
+ desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, g_strdup_printf(_("<b>%d</b> paths simplified."), pathsSimplified));
+ }
+
+ return didSomething;
+}
+
void
sp_selected_path_simplify_selection(float threshold, bool justCoalesce,
float angleLimit, bool breakableAngles)
{
SPDesktop *desktop = SP_ACTIVE_DESKTOP;
- Inkscape::Selection *selection = SP_DT_SELECTION(desktop);
+ Inkscape::Selection *selection = sp_desktop_selection(desktop);
if (selection->isEmpty()) {
desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE,
return;
}
- // remember selection size
- NR::Rect bbox = selection->bounds();
- gdouble size = L2(bbox.dimensions());
-
- bool didSomething = false;
-
- //Loop through all of the items in the selection
- for (GSList *items = g_slist_copy((GSList *) selection->itemList());
- items != NULL; items = items->next) {
-
- SPItem *item = (SPItem *) items->data;
-
- if (!(SP_IS_GROUP(item) || SP_IS_SHAPE(item) || SP_IS_TEXT(item)))
- continue;
-
- didSomething |= sp_selected_path_simplify_item(desktop, selection, item,
- threshold, justCoalesce, angleLimit, breakableAngles, size, true);
- }
+ GSList *items = g_slist_copy((GSList *) selection->itemList());
+ bool didSomething = sp_selected_path_simplify_items(desktop, selection,
+ items, threshold,
+ justCoalesce,
+ angleLimit,
+ breakableAngles, true);
if (didSomething)
- sp_document_done(SP_DT_DOCUMENT(desktop));
+ sp_document_done(sp_desktop_document(desktop), SP_VERB_SELECTION_SIMPLIFY,
+ _("Simplify"));
else
desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("<b>No paths</b> to simplify in the selection."));
Path *
Path_for_item(SPItem *item, bool doTransformation, bool transformFull)
{
- SPCurve *curve;
+ SPCurve *curve = curve_for_item(item);
+ NArtBpath *bpath = bpath_for_curve(item, curve, doTransformation, transformFull);
+
+ if (bpath == NULL) {
+ return NULL;
+ }
+
+ Path *dest = bpath_to_Path(bpath);
- if (!item)
+ g_free(bpath);
+
+ curve->unref();
+
+ return dest;
+}
+
+/*
+ * This function always returns a new NArtBpath, the caller must g_free the returned path!
+*/
+NArtBpath *
+bpath_for_curve(SPItem *item, SPCurve *curve, bool doTransformation, bool transformFull)
+{
+ if (curve == NULL)
return NULL;
- if (SP_IS_SHAPE(item))
- {
- curve = sp_shape_get_curve(SP_SHAPE(item));
- }
- else if (SP_IS_TEXT(item))
- {
- curve = SP_TEXT(item)->getNormalizedBpath();
+ NArtBpath const *bpath = SP_CURVE_BPATH(curve);
+ if (bpath == NULL) {
+ return NULL;
}
- else
- {
- curve = NULL;
+
+ NArtBpath *new_bpath; // we will get a duplicate which has to be freed at some point!
+ if (doTransformation) {
+ if (transformFull) {
+ new_bpath = nr_artpath_affine(bpath, from_2geom(sp_item_i2doc_affine(item)));
+ } else {
+ new_bpath = nr_artpath_affine(bpath, item->transform);
+ }
+ } else {
+ new_bpath = nr_artpath_affine(bpath, NR::identity());
}
- if (!curve)
- return NULL;
- NArtBpath *bpath = curve->bpath;
- if (bpath == NULL)
+ return new_bpath;
+}
+
+SPCurve* curve_for_item(SPItem *item)
+{
+ if (!item)
return NULL;
- if ( doTransformation ) {
- if (transformFull)
- bpath = nr_artpath_affine(curve->bpath, sp_item_i2doc_affine(item));
- else
- bpath = nr_artpath_affine(curve->bpath, item->transform);
- sp_curve_unref(curve);
- curve=NULL;
- } else {
- bpath=curve->bpath;
+ SPCurve *curve = NULL;
+
+ if (SP_IS_SHAPE(item)) {
+ if (SP_IS_PATH(item)) {
+ curve = sp_path_get_curve_for_edit(SP_PATH(item));
+ } else {
+ curve = sp_shape_get_curve(SP_SHAPE(item));
+ }
+ }
+ else if (SP_IS_TEXT(item) || SP_IS_FLOWTEXT(item))
+ {
+ curve = te_get_layout(item)->convertToCurves();
+ }
+ else if (SP_IS_IMAGE(item))
+ {
+ curve = sp_image_get_curve(SP_IMAGE(item));
}
+
+ return curve; // do not forget to unref the curve at some point!
+}
+Path *bpath_to_Path(NArtBpath const *bpath) {
Path *dest = new Path;
dest->SetBackData(false);
{
if (closed)
dest->Close();
}
-
- if ( doTransformation ) {
- if ( bpath ) nr_free(bpath);
- } else {
- sp_curve_unref(curve);
- }
return dest;
}
-NR::Maybe<Path::cut_position> get_nearest_position_on_Path(Path *path, NR::Point p)
+NR::Maybe<Path::cut_position> get_nearest_position_on_Path(Path *path, NR::Point p, unsigned seg)
{
//get nearest position on path
- Path::cut_position pos = path->PointToCurvilignPosition(p);
+ Path::cut_position pos = path->PointToCurvilignPosition(p, seg);
return pos;
}