Code

remove many unnecessary to_2geom and from_2geom calls
[inkscape.git] / src / splivarot.cpp
index 3035cb1a7ae022a5c633b425f664be203d87949f..47051be2be132a954340c3d8ee223dccc8e1b068 100644 (file)
 # 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 "libnr/nr-path.h"
 #include "xml/repr.h"
 #include "xml/repr-sorting.h"
-
+#include <2geom/pathvector.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 <libnr/n-art-bpath-2geom.h>
+#include "helper/geom.h"
 
 #include "livarot/Path.h"
 #include "livarot/Shape.h"
@@ -66,6 +73,12 @@ sp_selected_path_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()
 {
@@ -78,6 +91,12 @@ sp_selected_path_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()
 {
@@ -178,7 +197,7 @@ sp_selected_path_boolop(bool_op bop, const unsigned int verb, const Glib::ustrin
     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);
@@ -442,10 +461,11 @@ sp_selected_path_boolop(bool_op bop, const unsigned int verb, const Glib::ustrin
     // 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 = sp_item_i2root_affine(item_source);
-    sp_item_adjust_stroke(item_source, i2root.expansion());
+    NR::Matrix i2root(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);
 
@@ -473,8 +493,8 @@ sp_selected_path_boolop(bool_op bop, const unsigned int verb, const Glib::ustrin
 
     // premultiply by the inverse of parent's repr
     SPItem *parent_item = SP_ITEM(sp_desktop_document(desktop)->getObjectByRepr(parent));
-    NR::Matrix local = sp_item_i2doc_affine(parent_item);
-    gchar *transform = sp_svg_transform_write(local);
+    NR::Matrix local (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 ) {
@@ -573,11 +593,36 @@ sp_selected_path_boolop(bool_op bop, const unsigned int verb, const Glib::ustrin
 
     g_free(transform);
 
-    sp_document_done(sp_desktop_document(desktop), verb, description);
+    if (verb != SP_VERB_NONE) {
+        sp_document_done(sp_desktop_document(desktop), verb, description);
+    }
 
     delete res;
 }
 
+static
+void sp_selected_path_outline_add_marker( SPObject *marker_object, Geom::Matrix marker_transform, NR::scale stroke_scale, NR::Matrix transform,
+                                       Inkscape::XML::Node *g_repr, Inkscape::XML::Document *xml_doc, SPDocument * doc )
+{
+    SPMarker* marker = SP_MARKER (marker_object);
+    SPItem* marker_item = sp_item_first_item_child (SP_OBJECT (marker_object));
+
+    NR::Matrix tr(marker_transform);
+
+    if (marker->markerUnits == SP_MARKER_UNITS_STROKEWIDTH) {
+        tr = stroke_scale * 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 *) doc->getObjectByRepr(m_repr);
+        sp_item_write_transform(marker_item, m_repr, tr);
+    }
+}
 
 void
 sp_selected_path_outline()
@@ -614,30 +659,25 @@ sp_selected_path_outline()
                 continue;
         }
 
-        {   // pas de stroke pas de chocolat
-            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);
-                continue;
-            }
+        // pas de stroke pas de chocolat
+        if (!SP_OBJECT_STYLE(item) || SP_OBJECT_STYLE(item)->stroke.noneSet) {
+            curve->unref();
+            continue;
         }
 
         // remember old stroke style, to be set on fill
+        SPStyle *i_style = SP_OBJECT_STYLE(item);
         SPCSSAttr *ncss;
         {
-            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);
-
-            ncss = sp_repr_css_attr_new();
+            ncss = sp_css_attr_from_style(i_style, SP_STYLE_FLAG_ALWAYS);
+            gchar const *s_val = sp_repr_css_property(ncss, "stroke", NULL);
+            gchar const *s_opac = sp_repr_css_property(ncss, "stroke-opacity", NULL);
 
             sp_repr_css_set_property(ncss, "stroke", "none");
             sp_repr_css_set_property(ncss, "stroke-opacity", "1.0");
-            sp_repr_css_set_property(ncss, "fill", val);
-            if ( opac ) {
-                sp_repr_css_set_property(ncss, "fill-opacity", opac);
+            sp_repr_css_set_property(ncss, "fill", s_val);
+            if ( s_opac ) {
+                sp_repr_css_set_property(ncss, "fill-opacity", s_opac);
             } else {
                 sp_repr_css_set_property(ncss, "fill-opacity", "1.0");
             }
@@ -647,9 +687,7 @@ sp_selected_path_outline()
         }
 
         NR::Matrix const transform(item->transform);
-        float const scale = transform.expansion();
-        gchar *style = g_strdup(SP_OBJECT_REPR(item)->attribute("style"));
-        SPStyle *i_style = SP_OBJECT(item)->style;
+        float const scale = NR::expansion(transform);
         gchar const *mask = SP_OBJECT_REPR(item)->attribute("mask");
         gchar const *clip_path = SP_OBJECT_REPR(item)->attribute("clip-path");
 
@@ -693,12 +731,17 @@ sp_selected_path_outline()
             o_miter = i_style->stroke_miterlimit.value * o_width;
         }
 
-        Path *orig = Path_for_item(item, false);
-        if (orig == NULL) {
-            g_free(style);
-            sp_curve_unref(curve);
+        SPCurve *curvetemp = curve_for_item(item);
+        if (curvetemp == NULL) {
+            curve->unref();
             continue;
         }
+        // Livarots outline of arcs is broken. So convert the path to linear and cubics only, for which the outline is created correctly.
+        Geom::PathVector pathv = pathv_to_linear_and_cubic_beziers( curvetemp->get_pathvector() );
+        curvetemp->unref();
+
+        Path *orig = new Path;
+        orig->LoadPathVector(pathv);
 
         Path *res = new Path;
         res->SetBackData(false);
@@ -754,7 +797,6 @@ sp_selected_path_outline()
             // ca a merd\8e, ou bien le resultat est vide
             delete res;
             delete orig;
-            g_free(style);
             continue;
         }
 
@@ -769,13 +811,11 @@ sp_selected_path_outline()
 
         if (res->descr_cmd.size() > 1) { // if there's 0 or 1 node left, drop this path altogether
 
-            Inkscape::XML::Document *xml_doc = sp_document_repr_doc(desktop->doc());
+            SPDocument * doc = sp_desktop_document(desktop);
+            Inkscape::XML::Document *xml_doc = sp_document_repr_doc(doc);
             Inkscape::XML::Node *repr = xml_doc->createElement("svg:path");
 
-            // restore old style
-            repr->setAttribute("style", style);
-
-            // set old stroke style on fill
+            // restore old style, but set old stroke style on fill
             sp_repr_css_change(repr, ncss, "style");
 
             sp_repr_css_attr_unref(ncss);
@@ -791,7 +831,7 @@ sp_selected_path_outline()
 
             if (SP_IS_SHAPE(item) && sp_shape_has_markers (SP_SHAPE(item))) {
 
-                Inkscape::XML::Document *xml_doc = sp_document_repr_doc(desktop->doc());
+                Inkscape::XML::Document *xml_doc = sp_document_repr_doc(doc);
                 Inkscape::XML::Node *g_repr = xml_doc->createElement("svg:g");
 
                 // add the group to the parent
@@ -801,37 +841,46 @@ sp_selected_path_outline()
 
                 g_repr->appendChild(repr);
                 repr->setAttribute("id", id);
-                SPItem *newitem = (SPItem *) sp_desktop_document(desktop)->getObjectByRepr(repr);
+                SPItem *newitem = (SPItem *) doc->getObjectByRepr(repr);
                 sp_item_write_transform(newitem, repr, transform);
 
                 SPShape *shape = SP_SHAPE(item);
 
-                for (NArtBpath* 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;
+                Geom::PathVector const & pathv = curve->get_pathvector();
+                for(Geom::PathVector::const_iterator path_it = pathv.begin(); path_it != pathv.end(); ++path_it) {
+                    if ( SPObject *marker_obj = shape->marker[SP_MARKER_LOC_START] ) {
+                        Geom::Matrix const m (sp_shape_marker_get_transform_at_start(path_it->front()));
+                        sp_selected_path_outline_add_marker( marker_obj, m,
+                                                             NR::scale(i_style->stroke_width.computed), transform,
+                                                             g_repr, xml_doc, doc );
+                    }
 
-                            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);
-                            }
+                    if ( SPObject *marker_obj = shape->marker[SP_MARKER_LOC_MID] ) {
+                        Geom::Path::const_iterator curve_it1 = path_it->begin();      // incoming curve
+                        Geom::Path::const_iterator curve_it2 = ++(path_it->begin());  // outgoing curve
+                        while (curve_it2 != path_it->end_default())
+                        {
+                            /* Put marker between curve_it1 and curve_it2.
+                             * Loop to end_default (so including closing segment), because when a path is closed,
+                             * there should be a midpoint marker between last segment and closing straight line segment
+                             */
+                            Geom::Matrix const m (sp_shape_marker_get_transform(*curve_it1, *curve_it2));
+                            sp_selected_path_outline_add_marker( marker_obj, m,
+                                                                 NR::scale(i_style->stroke_width.computed), transform,
+                                                                 g_repr, xml_doc, doc );
+
+                            ++curve_it1;
+                            ++curve_it2;
                         }
                     }
-                }
 
+                    if ( SPObject *marker_obj = shape->marker[SP_MARKER_LOC_END] ) {
+                        Geom::Matrix const m (sp_shape_marker_get_transform_at_end(path_it->back_default()));
+                        sp_selected_path_outline_add_marker( marker_obj, m,
+                                                             NR::scale(i_style->stroke_width.computed), transform,
+                                                             g_repr, xml_doc, doc );
+                    }
+                }
 
                 selection->add(g_repr);
 
@@ -857,7 +906,7 @@ sp_selected_path_outline()
 
             Inkscape::GC::release(repr);
 
-            sp_curve_unref(curve);
+            curve->unref();
             selection->remove(item);
             SP_OBJECT(item)->deleteObject(false);
 
@@ -865,8 +914,6 @@ sp_selected_path_outline()
 
         delete res;
         delete orig;
-        g_free(style);
-
     }
 
     if (did) {
@@ -1032,7 +1079,7 @@ sp_selected_path_create_offset_object(int expand, bool updating)
     if (orig == NULL)
     {
         g_free(style);
-        sp_curve_unref(curve);
+        curve->unref();
         return;
     }
 
@@ -1069,7 +1116,7 @@ sp_selected_path_create_offset_object(int expand, bool updating)
         delete theRes;
     }
 
-    sp_curve_unref(curve);
+    curve->unref();
 
     if (res->descr_cmd.size() <= 1)
     {
@@ -1254,7 +1301,7 @@ sp_selected_path_do_offset(bool expand, double prefOffset)
         Path *orig = Path_for_item(item, false);
         if (orig == NULL) {
             g_free(style);
-            sp_curve_unref(curve);
+            curve->unref();
             continue;
         }
 
@@ -1342,7 +1389,7 @@ sp_selected_path_do_offset(bool expand, double prefOffset)
 
         did = true;
 
-        sp_curve_unref(curve);
+        curve->unref();
         // remember the position of the item
         gint pos = SP_OBJECT_REPR(item)->position();
         // remember parent
@@ -1462,17 +1509,19 @@ sp_selected_path_simplify_item(SPDesktop *desktop,
     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)
@@ -1506,7 +1555,10 @@ sp_selected_path_simplify_item(SPDesktop *desktop,
 
     // 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
@@ -1523,6 +1575,9 @@ sp_selected_path_simplify_item(SPDesktop *desktop,
     // 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);
@@ -1555,7 +1610,7 @@ sp_selected_path_simplify_items(SPDesktop *desktop,
 
   bool didSomething = false;
 
-  NR::Maybe<NR::Rect> selectionBbox = selection->bounds();
+  boost::optional<NR::Rect> selectionBbox = selection->bounds();
   if (!selectionBbox) {
     return false;
   }
@@ -1576,7 +1631,7 @@ sp_selected_path_simplify_items(SPDesktop *desktop,
           continue;
 
       if (simplifyIndividualPaths) {
-          NR::Maybe<NR::Rect> itemBbox = item->getBounds(sp_item_i2d_affine(item));        
+          boost::optional<NR::Rect> itemBbox = item->getBounds(sp_item_i2d_affine(item));
           if (itemBbox) {
               simplifySize      = L2(itemBbox->dimensions());
           } else {
@@ -1692,52 +1747,74 @@ Ancetre(Inkscape::XML::Node *a, Inkscape::XML::Node *who)
 Path *
 Path_for_item(SPItem *item, bool doTransformation, bool transformFull)
 {
-    SPCurve *curve;
+    SPCurve *curve = curve_for_item(item);
 
-    if (!item)
+    if (curve == NULL)
         return NULL;
+    
+    Geom::PathVector *pathv = pathvector_for_curve(item, curve, doTransformation, transformFull, Geom::identity(), Geom::identity());
+    curve->unref();
+    
+    Path *dest = new Path;
+    dest->LoadPathVector(*pathv);    
+    delete pathv;
+    
+    return dest;
+}
 
-    if (SP_IS_SHAPE(item))
-    {
-        curve = sp_shape_get_curve(SP_SHAPE(item));
-    }
-    else if (SP_IS_TEXT(item))
-    {
-        curve = SP_TEXT(item)->getNormalizedBpath();
-    }
-    else
-    {
-        curve = NULL;
-    }
-
-    if (!curve)
-        return NULL;
-    NArtBpath *bpath = SP_CURVE_BPATH(curve);
-    if (bpath == NULL)
+/* 
+ * NOTE: Returns empty pathvector if curve == NULL
+ * TODO: see if calling this method can be optimized. All the pathvector copying might be slow.
+ */
+Geom::PathVector*
+pathvector_for_curve(SPItem *item, SPCurve *curve, bool doTransformation, bool transformFull, Geom::Matrix extraPreAffine, Geom::Matrix extraPostAffine)
+{
+    if (curve == NULL)
         return NULL;
 
-    if ( doTransformation ) {
-        if (transformFull)
-            bpath = nr_artpath_affine(SP_CURVE_BPATH(curve), sp_item_i2doc_affine(item));
-        else
-            bpath = nr_artpath_affine(SP_CURVE_BPATH(curve), item->transform);
-        sp_curve_unref(curve);
-        curve=NULL;
+    Geom::PathVector *dest = new Geom::PathVector;    
+    *dest = curve->get_pathvector(); // Make a copy; must be freed by the caller!
+    
+    if (doTransformation) {
+        if (transformFull) {
+            *dest *= extraPreAffine * sp_item_i2doc_affine(item) * extraPostAffine;
+        } else {
+            *dest *= extraPreAffine * (Geom::Matrix)item->transform * extraPostAffine;
+        }
     } else {
-        bpath=SP_CURVE_BPATH(curve);
+        *dest *= extraPreAffine * extraPostAffine;
     }
+    
+    return dest;
+}
 
-    Path *dest = bpath_to_Path(bpath);
-
-    if ( doTransformation ) {
-        if ( bpath ) g_free(bpath);
-    } else {
-        sp_curve_unref(curve);
+SPCurve* curve_for_item(SPItem *item)
+{
+    if (!item) 
+        return NULL;
+    
+    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));
+        }
     }
-    return dest;
+    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 *bpath_to_Path(NArtBpath const *bpath) 
+{
     Path *dest = new Path;
     dest->SetBackData(false);
     {
@@ -1794,10 +1871,10 @@ Path *bpath_to_Path(NArtBpath const *bpath) {
     return dest;
 }
 
-NR::Maybe<Path::cut_position> get_nearest_position_on_Path(Path *path, NR::Point p)
+boost::optional<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;
 }