Code

updated POT and POs
[inkscape.git] / src / sp-shape.cpp
index e1fd13ffbc24ad7fd27ac87ca61e8daf619049a8..e7ded6303def093aa92ef19fde99c71245600482 100644 (file)
@@ -68,7 +68,7 @@ static void sp_shape_bbox(SPItem const *item, NRRect *bbox, Geom::Matrix const &
 void sp_shape_print (SPItem * item, SPPrintContext * ctx);
 static NRArenaItem *sp_shape_show (SPItem *item, NRArena *arena, unsigned int key, unsigned int flags);
 static void sp_shape_hide (SPItem *item, unsigned int key);
-static void sp_shape_snappoints (SPItem const *item, SnapPointsIter p, Inkscape::SnapPreferences const *snapprefs);
+static void sp_shape_snappoints (SPItem const *item, bool const target, SnapPointsWithType &p, Inkscape::SnapPreferences const *snapprefs);
 
 static void sp_shape_update_marker_view (SPShape *shape, NRArenaItem *ai);
 
@@ -300,7 +300,7 @@ sp_shape_update (SPObject *object, SPCtx *ctx, unsigned int flags)
             for (int i = 0 ; i < SP_MARKER_LOC_QTY ; i++) {
                 if (shape->marker[i]) {
                     sp_marker_show_dimension ((SPMarker *) shape->marker[i],
-                                              NR_ARENA_ITEM_GET_KEY (v->arenaitem) + i - SP_MARKER_LOC,
+                                              NR_ARENA_ITEM_GET_KEY (v->arenaitem) + i,
                                               sp_shape_number_of_markers (shape, i));
                 }
             }
@@ -525,84 +525,105 @@ static void sp_shape_bbox(SPItem const *item, NRRect *bbox, Geom::Matrix const &
                     /* TODO: make code prettier: lots of variables can be taken out of the loop! */
                     Geom::PathVector const & pathv = shape->curve->get_pathvector();
                     for(Geom::PathVector::const_iterator path_it = pathv.begin(); path_it != pathv.end(); ++path_it) {
-                        if ( shape->marker[SP_MARKER_LOC_START] ) {
-                            SPMarker* marker = SP_MARKER (shape->marker[SP_MARKER_LOC_START]);
-                            SPItem* marker_item = sp_item_first_item_child (SP_OBJECT (marker));
-
-                            Geom::Matrix tr(sp_shape_marker_get_transform_at_start(path_it->front()));
-
-                            if (marker->markerUnits == SP_MARKER_UNITS_STROKEWIDTH) {
-                                tr = Geom::Scale(style->stroke_width.computed) * tr;
-                            }
-
-                            // total marker transform
-                            tr = marker_item->transform * marker->c2p * tr * transform;
-
-                            // get bbox of the marker with that transform
-                            NRRect marker_bbox;
-                            sp_item_invoke_bbox (marker_item, &marker_bbox, from_2geom(tr), true);
-                            // union it with the shape bbox
-                            nr_rect_d_union (&cbbox, &cbbox, &marker_bbox);
-                        }
-
-                        if ( shape->marker[SP_MARKER_LOC_MID] && (path_it->size_default() > 1) ) {
-                            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 */
-
-                                SPMarker* marker = SP_MARKER (shape->marker[SP_MARKER_LOC_MID]);
+                        for (unsigned i = 0; i < 2; i++) { // SP_MARKER_LOC and SP_MARKER_LOC_START
+                            if ( shape->marker[i] ) {
+                                SPMarker* marker = SP_MARKER (shape->marker[i]);
                                 SPItem* marker_item = sp_item_first_item_child (SP_OBJECT (marker));
 
-                                Geom::Matrix tr(sp_shape_marker_get_transform(*curve_it1, *curve_it2));
-
-                                if (marker->markerUnits == SP_MARKER_UNITS_STROKEWIDTH) {
-                                    tr = Geom::Scale(style->stroke_width.computed) * tr;
+                                if (marker_item) {
+                                                                       Geom::Matrix tr(sp_shape_marker_get_transform_at_start(path_it->front()));
+                                                                       if (!marker->orient_auto) {
+                                                                               Geom::Point transl = tr.translation();
+                                                                               tr = Geom::Rotate::from_degrees(marker->orient) * Geom::Translate(transl);
+                                                                       }
+                                                                       if (marker->markerUnits == SP_MARKER_UNITS_STROKEWIDTH) {
+                                                                               tr = Geom::Scale(style->stroke_width.computed) * tr;
+                                                                       }
+
+                                                                       // total marker transform
+                                                                       tr = marker_item->transform * marker->c2p * tr * transform;
+
+                                                                       // get bbox of the marker with that transform
+                                                                       NRRect marker_bbox;
+                                                                       sp_item_invoke_bbox (marker_item, &marker_bbox, from_2geom(tr), true);
+                                                                       // union it with the shape bbox
+                                                                       nr_rect_d_union (&cbbox, &cbbox, &marker_bbox);
                                 }
-
-                                // total marker transform
-                                tr = marker_item->transform * marker->c2p * tr * transform;
-
-                                // get bbox of the marker with that transform
-                                NRRect marker_bbox;
-                                sp_item_invoke_bbox (marker_item, &marker_bbox, from_2geom(tr), true);
-                                // union it with the shape bbox
-                                nr_rect_d_union (&cbbox, &cbbox, &marker_bbox);
-
-                                ++curve_it1;
-                                ++curve_it2;
                             }
                         }
 
-                        if ( shape->marker[SP_MARKER_LOC_END] ) {
-                            SPMarker* marker = SP_MARKER (shape->marker[SP_MARKER_LOC_END]);
-                            SPItem* marker_item = sp_item_first_item_child (SP_OBJECT (marker));
-
-                            /* Get reference to last curve in the path.
-                             * For moveto-only path, this returns the "closing line segment". */
-                            unsigned int index = path_it->size_default();
-                            if (index > 0) {
-                                index--;
+                        for (unsigned i = 0; i < 3; i += 2) { // SP_MARKER_LOC and SP_MARKER_LOC_MID
+                            if ( shape->marker[i] && (path_it->size_default() > 1) ) {
+                                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 */
+
+                                    SPMarker* marker = SP_MARKER (shape->marker[i]);
+                                    SPItem* marker_item = sp_item_first_item_child (SP_OBJECT (marker));
+
+                                    if (marker_item) {
+                                       Geom::Matrix tr(sp_shape_marker_get_transform(*curve_it1, *curve_it2));
+                                                                               if (!marker->orient_auto) {
+                                                                                       Geom::Point transl = tr.translation();
+                                                                                       tr = Geom::Rotate::from_degrees(marker->orient) * Geom::Translate(transl);
+                                                                               }
+                                                                               if (marker->markerUnits == SP_MARKER_UNITS_STROKEWIDTH) {
+                                                                                       tr = Geom::Scale(style->stroke_width.computed) * tr;
+                                                                               }
+
+                                                                               // total marker transform
+                                                                               tr = marker_item->transform * marker->c2p * tr * transform;
+
+                                                                               // get bbox of the marker with that transform
+                                                                               NRRect marker_bbox;
+                                                                               sp_item_invoke_bbox (marker_item, &marker_bbox, from_2geom(tr), true);
+                                                                               // union it with the shape bbox
+                                                                               nr_rect_d_union (&cbbox, &cbbox, &marker_bbox);
+                                    }
+
+                                    ++curve_it1;
+                                    ++curve_it2;
+                                }
                             }
-                            Geom::Curve const &lastcurve = (*path_it)[index];
+                        }
 
-                            Geom::Matrix tr = sp_shape_marker_get_transform_at_end(lastcurve);
+                        for (unsigned i = 0; i < 4; i += 3) { // SP_MARKER_LOC and SP_MARKER_LOC_END
+                            if ( shape->marker[i] ) {
+                                SPMarker* marker = SP_MARKER (shape->marker[i]);
+                                SPItem* marker_item = sp_item_first_item_child (SP_OBJECT (marker));
 
-                            if (marker->markerUnits == SP_MARKER_UNITS_STROKEWIDTH) {
-                                tr = Geom::Scale(style->stroke_width.computed) * tr;
+                                if (marker_item) {
+                                                                       /* Get reference to last curve in the path.
+                                                                        * For moveto-only path, this returns the "closing line segment". */
+                                                                       unsigned int index = path_it->size_default();
+                                                                       if (index > 0) {
+                                                                               index--;
+                                                                       }
+                                                                       Geom::Curve const &lastcurve = (*path_it)[index];
+
+                                                                       Geom::Matrix tr = sp_shape_marker_get_transform_at_end(lastcurve);
+                                                                       if (!marker->orient_auto) {
+                                                                               Geom::Point transl = tr.translation();
+                                                                               tr = Geom::Rotate::from_degrees(marker->orient) * Geom::Translate(transl);
+                                                                       }
+                                                                       if (marker->markerUnits == SP_MARKER_UNITS_STROKEWIDTH) {
+                                                                               tr = Geom::Scale(style->stroke_width.computed) * tr;
+                                                                       }
+
+                                                                       // total marker transform
+                                                                       tr = marker_item->transform * marker->c2p * tr * transform;
+
+                                                                       // get bbox of the marker with that transform
+                                                                       NRRect marker_bbox;
+                                                                       sp_item_invoke_bbox (marker_item, &marker_bbox, tr, true);
+                                                                       // union it with the shape bbox
+                                                                       nr_rect_d_union (&cbbox, &cbbox, &marker_bbox);
+                                }
                             }
-
-                            // total marker transform
-                            tr = marker_item->transform * marker->c2p * tr * transform;
-
-                            // get bbox of the marker with that transform
-                            NRRect marker_bbox;
-                            sp_item_invoke_bbox (marker_item, &marker_bbox, tr, true);
-                            // union it with the shape bbox
-                            nr_rect_d_union (&cbbox, &cbbox, &marker_bbox);
                         }
                     }
                 }
@@ -772,7 +793,7 @@ sp_shape_show (SPItem *item, NRArena *arena, unsigned int /*key*/, unsigned int
         for (int i = 0; i < SP_MARKER_LOC_QTY; i++) {
             if (shape->marker[i]) {
                 sp_marker_show_dimension ((SPMarker *) shape->marker[i],
-                                          NR_ARENA_ITEM_GET_KEY (arenaitem) + i - SP_MARKER_LOC,
+                                          NR_ARENA_ITEM_GET_KEY (arenaitem) + i,
                                           sp_shape_number_of_markers (shape, i));
             }
         }
@@ -937,7 +958,7 @@ sp_shape_set_marker (SPObject *object, unsigned int key, const gchar *value)
     SPItem *item = (SPItem *) object;
     SPShape *shape = (SPShape *) object;
 
-    if (key < 0 || key > SP_MARKER_LOC_END) {
+    if (key > SP_MARKER_LOC_END) {
         return;
     }
 
@@ -1042,7 +1063,7 @@ sp_shape_set_curve_insync (SPShape *shape, SPCurve *curve, unsigned int owner)
 /**
  * Return all nodes in a path that are to be considered for snapping
  */
-static void sp_shape_snappoints(SPItem const *item, SnapPointsIter p, Inkscape::SnapPreferences const *snapprefs)
+static void sp_shape_snappoints(SPItem const *item, bool const target, SnapPointsWithType &p, Inkscape::SnapPreferences const *snapprefs)
 {
     g_assert(item != NULL);
     g_assert(SP_IS_SHAPE(item));
@@ -1052,14 +1073,32 @@ static void sp_shape_snappoints(SPItem const *item, SnapPointsIter p, Inkscape::
         return;
     }
 
+    // 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;
+    }
+
     Geom::PathVector const &pathv = shape->curve->get_pathvector();
     if (pathv.empty())
         return;
 
     Geom::Matrix const i2d (sp_item_i2d_affine (item));
 
+    int type;
+
+       if (snapprefs->getSnapObjectMidpoints()) {
+               Geom::OptRect bbox = item->getBounds(sp_item_i2d_affine(item));
+               if (bbox) {
+                       type = target ? int(Inkscape::SNAPTARGET_OBJECT_MIDPOINT) : int(Inkscape::SNAPSOURCE_OBJECT_MIDPOINT);
+                       p.push_back(std::make_pair(bbox->midpoint(), type));
+               }
+       }
+
     for(Geom::PathVector::const_iterator path_it = pathv.begin(); path_it != pathv.end(); ++path_it) {
-        *p = from_2geom(path_it->initialPoint() * i2d);
+        if (snapprefs->getSnapToItemNode()) {
+               type = target ? int(Inkscape::SNAPTARGET_NODE_CUSP) : int(Inkscape::SNAPSOURCE_NODE_CUSP);
+               p.push_back(std::make_pair(path_it->initialPoint() * i2d, type));
+        }
 
         Geom::Path::const_iterator curve_it1 = path_it->begin();      // incoming curve
         Geom::Path::const_iterator curve_it2 = ++(path_it->begin());  // outgoing curve
@@ -1073,37 +1112,41 @@ static void sp_shape_snappoints(SPItem const *item, SnapPointsIter p, Inkscape::
 
             Geom::NodeType nodetype = Geom::get_nodetype(*curve_it1, *curve_it2);
 
-            // Depending on the snapping preferences, either add only cusp nodes, or add add both cusp and smooth nodes
-            if (snapprefs->getSnapSmoothNodes() || nodetype == Geom::NODE_NONE || nodetype == Geom::NODE_CUSP) {
-                *p = from_2geom(curve_it1->finalPoint() * i2d);
-            }
+            bool c1 = snapprefs->getSnapToItemNode() && (nodetype == Geom::NODE_CUSP || nodetype == Geom::NODE_NONE);
+            bool c2 = snapprefs->getSnapSmoothNodes() && (nodetype == Geom::NODE_SMOOTH || nodetype == Geom::NODE_SYMM);
 
-            // Consider midpoints of line segments for snapping
-            if (snapprefs->getSnapMidpoints()) {
-                if (Geom::LineSegment const* line_segment = dynamic_cast<Geom::LineSegment const*>(&(*curve_it1))) {
-                    *p = from_2geom(Geom::middle_point(*line_segment) * i2d);
-                }
+            if (c1 || c2) {
+               type = target ? int(Inkscape::SNAPTARGET_NODE_CUSP) : int(Inkscape::SNAPSOURCE_NODE_CUSP);
+                               p.push_back(std::make_pair(curve_it1->finalPoint() * i2d, type));
             }
 
+                       // Consider midpoints of line segments for snapping
+                       if (snapprefs->getSnapLineMidpoints()) { // only do this when we're snapping nodes (enforce strict snapping)
+                               if (Geom::LineSegment const* line_segment = dynamic_cast<Geom::LineSegment const*>(&(*curve_it1))) {
+                                       type = target ? int(Inkscape::SNAPTARGET_LINE_MIDPOINT) : int(Inkscape::SNAPSOURCE_LINE_MIDPOINT);
+                                       p.push_back(std::make_pair(Geom::middle_point(*line_segment) * i2d, type));
+                               }
+                       }
+
             ++curve_it1;
             ++curve_it2;
         }
 
-        // Find the internal intersections of each path and consider these for snapping (using "Method 1" as desciribed in Inkscape::ObjectSnapper::_collectNodes())
+        // Find the internal intersections of each path and consider these for snapping
+        // (using "Method 1" as described in Inkscape::ObjectSnapper::_collectNodes())
         if (snapprefs->getSnapIntersectionCS()) {
             Geom::Crossings cs;
             cs = self_crossings(*path_it);
             if (cs.size() > 0) { // There might be multiple intersections...
                 for (Geom::Crossings::const_iterator i = cs.begin(); i != cs.end(); i++) {
                     Geom::Point p_ix = (*path_it).pointAt((*i).ta);
-                    *p = from_2geom(p_ix * i2d);
+                    type = target ? int(Inkscape::SNAPTARGET_PATH_INTERSECTION) : int(Inkscape::SNAPSOURCE_PATH_INTERSECTION);
+                    p.push_back(std::make_pair(p_ix * i2d, type));
                 }
             }
         }
     }
 
-
-
 }
 
 /*