diff --git a/src/sp-conn-end.cpp b/src/sp-conn-end.cpp
index 7a8a60dd088dde3f5fdb94c16f48b1b3db13905b..224442eb852370a877a160070d957f0ad09e6b13 100644 (file)
--- a/src/sp-conn-end.cpp
+++ b/src/sp-conn-end.cpp
+#include <cstring>
+#include <string>
+#include <limits>
+
#include "display/curve.h"
-#include "libnr/nr-matrix-div.h"
#include "libnr/nr-matrix-fns.h"
#include "xml/repr.h"
#include "sp-conn-end.h"
#include "sp-path.h"
#include "uri.h"
#include "document.h"
+#include "sp-item-group.h"
+#include "2geom/path.h"
+#include "2geom/pathvector.h"
+#include "2geom/path-intersection.h"
-static void change_endpts(SPCurve *const curve, NR::Point const h2endPt[2]);
-static NR::Point calc_bbox_conn_pt(NR::Rect const &bbox, NR::Point const &p);
-static double signed_one(double const x);
+static void change_endpts(SPCurve *const curve, double const endPos[2]);
SPConnEnd::SPConnEnd(SPObject *const owner) :
ref(owner),
@@ -33,197 +38,188 @@ get_nearest_common_ancestor(SPObject const *const obj, SPItem const *const objs[
return anc_sofar;
}
-static void
-sp_conn_end_move_compensate(NR::Matrix const *mp, SPItem *moved_item,
- SPPath *const path,
- bool const updatePathRepr = true)
-{
- // TODO: SPItem::getBounds gives the wrong result for some objects
- // that have internal representations that are updated later
- // by the sp_*_update functions, e.g., text.
- sp_document_ensure_up_to_date(path->document);
- // Get the new route around obstacles.
- path->connEndPair.reroutePath();
+static bool try_get_intersect_point_with_item_recursive(Geom::PathVector& conn_pv, SPItem* item,
+ const Geom::Matrix& item_transform, double& intersect_pos) {
- SPItem *h2attItem[2];
- path->connEndPair.getAttachedItems(h2attItem);
- if ( !h2attItem[0] && !h2attItem[1] ) {
- if (updatePathRepr) {
- path->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
- path->updateRepr();
+ double initial_pos = intersect_pos;
+ // if this is a group...
+ if (SP_IS_GROUP(item)) {
+ SPGroup* group = SP_GROUP(item);
+
+ // consider all first-order children
+ double child_pos = 0.0;
+ for (GSList const* i = sp_item_group_item_list(group); i != NULL; i = i->next) {
+ SPItem* child_item = SP_ITEM(i->data);
+ try_get_intersect_point_with_item_recursive(conn_pv, child_item,
+ item_transform * child_item->transform, child_pos);
+ if (intersect_pos < child_pos)
+ intersect_pos = child_pos;
}
- return;
+ return intersect_pos != initial_pos;
}
- SPItem const *const path_item = SP_ITEM(path);
- SPObject const *const ancestor = get_nearest_common_ancestor(path_item, h2attItem);
- NR::Matrix const path2anc(i2anc_affine(path_item, ancestor));
-
- if (h2attItem[0] != NULL && h2attItem[1] != NULL) {
- /* Initial end-points: centre of attached object. */
- NR::Point h2endPt_icoordsys[2];
- NR::Matrix h2i2anc[2];
- NR::Rect h2bbox_icoordsys[2];
- NR::Point last_seg_endPt[2] = {
- sp_curve_second_point(path->curve),
- sp_curve_penultimate_point(path->curve)
- };
- for (unsigned h = 0; h < 2; ++h) {
- NR::Maybe<NR::Rect> bbox = h2attItem[h]->getBounds(NR::identity());
- if (bbox) {
- h2bbox_icoordsys[h] = *bbox;
- } else {
- // FIXME
- h2bbox_icoordsys[h] = NR::Rect(NR::Point(0, 0), NR::Point(0, 0));
- }
- h2i2anc[h] = i2anc_affine(h2attItem[h], ancestor);
- h2endPt_icoordsys[h] = h2bbox_icoordsys[h].midpoint();
- }
+ // if this is not a shape, nothing to be done
+ if (!SP_IS_SHAPE(item)) return false;
- // For each attached object, change the corresponding point to be
- // on the edge of the bbox.
- NR::Point h2endPt_pcoordsys[2];
- for (unsigned h = 0; h < 2; ++h) {
- h2endPt_icoordsys[h] = calc_bbox_conn_pt(h2bbox_icoordsys[h],
- ( last_seg_endPt[h] / h2i2anc[h] ));
- h2endPt_pcoordsys[h] = h2endPt_icoordsys[h] * h2i2anc[h] / path2anc;
- }
- change_endpts(path->curve, h2endPt_pcoordsys);
- } else {
- // We leave the unattached endpoint where it is, and adjust the
- // position of the attached endpoint to be on the edge of the bbox.
- unsigned ind;
- NR::Point other_endpt;
- NR::Point last_seg_pt;
- if (h2attItem[0] != NULL) {
- other_endpt = sp_curve_last_point(path->curve);
- last_seg_pt = sp_curve_second_point(path->curve);
- ind = 0;
- }
- else {
- other_endpt = sp_curve_first_point(path->curve);
- last_seg_pt = sp_curve_penultimate_point(path->curve);
- ind = 1;
- }
- NR::Point h2endPt_icoordsys[2];
- NR::Matrix h2i2anc;
-
- NR::Rect otherpt_rect = NR::Rect(other_endpt, other_endpt);
- NR::Rect h2bbox_icoordsys[2] = { otherpt_rect, otherpt_rect };
- NR::Maybe<NR::Rect> bbox = h2attItem[ind]->getBounds(NR::identity());
- if (bbox) {
- h2bbox_icoordsys[ind] = *bbox;
- } else {
- // FIXME
- h2bbox_icoordsys[ind] = NR::Rect(NR::Point(0, 0), NR::Point(0, 0));
+ // make sure it has an associated curve
+ SPCurve* item_curve = sp_shape_get_curve(SP_SHAPE(item));
+ if (!item_curve) return false;
+
+ // apply transformations (up to common ancestor)
+ item_curve->transform(item_transform);
+
+ const Geom::PathVector& curve_pv = item_curve->get_pathvector();
+ Geom::CrossingSet cross = crossings(conn_pv, curve_pv);
+ // iterate over all Crossings
+ for (Geom::CrossingSet::const_iterator i = cross.begin(); i != cross.end(); i++) {
+ const Geom::Crossings& cr = *i;
+
+ for (Geom::Crossings::const_iterator i = cr.begin(); i != cr.end(); i++) {
+ const Geom::Crossing& cr_pt = *i;
+ if ( intersect_pos < cr_pt.ta)
+ intersect_pos = cr_pt.ta;
}
+ }
+
+ item_curve->unref();
+
+ return intersect_pos != initial_pos;
+}
+
+
+// This function returns the outermost intersection point between the path (a connector)
+// and the item given. If the item is a group, then the component items are considered.
+// The transforms given should be to a common ancestor of both the path and item.
+//
+static bool try_get_intersect_point_with_item(SPPath* conn, SPItem* item,
+ const Geom::Matrix& item_transform, const Geom::Matrix& conn_transform,
+ const bool at_start, double& intersect_pos) {
- h2i2anc = i2anc_affine(h2attItem[ind], ancestor);
- h2endPt_icoordsys[ind] = h2bbox_icoordsys[ind].midpoint();
+ // Copy the curve and apply transformations up to common ancestor.
+ SPCurve* conn_curve = conn->curve->copy();
+ conn_curve->transform(conn_transform);
+
+ Geom::PathVector conn_pv = conn_curve->get_pathvector();
+
+ // If this is not the starting point, use Geom::Path::reverse() to reverse the path
+ if (!at_start)
+ {
+ // connectors are actually a single path, so consider the first element from a Geom::PathVector
+ conn_pv[0] = conn_pv[0].reverse();
+ }
+
+ // We start with the intersection point at the beginning of the path
+ intersect_pos = 0.0;
+
+ // Find the intersection.
+ bool result = try_get_intersect_point_with_item_recursive(conn_pv, item, item_transform, intersect_pos);
+
+ if (!result)
+ // No intersection point has been found (why?)
+ // just default to connector end
+ intersect_pos = 0;
+ // If not at the starting point, recompute position with respect to original path
+ if (!at_start)
+ intersect_pos = conn_pv[0].size() - intersect_pos;
+ // Free the curve copy.
+ conn_curve->unref();
+
+ return result;
+}
- h2endPt_icoordsys[!ind] = other_endpt;
- // For the attached object, change the corresponding point to be
- // on the edge of the bbox.
- NR::Point h2endPt_pcoordsys[2];
- h2endPt_icoordsys[ind] = calc_bbox_conn_pt(h2bbox_icoordsys[ind],
- ( last_seg_pt / h2i2anc ));
- h2endPt_pcoordsys[ind] = h2endPt_icoordsys[ind] * h2i2anc / path2anc;
+static void
+sp_conn_get_route_and_redraw(SPPath *const path,
+ const bool updatePathRepr = true)
+{
+ // Get the new route around obstacles.
+ bool rerouted = path->connEndPair.reroutePathFromLibavoid();
+ if (!rerouted) {
+ return;
+ }
- // Leave the other where it is.
- h2endPt_pcoordsys[!ind] = other_endpt;
+ SPItem *h2attItem[2];
+ path->connEndPair.getAttachedItems(h2attItem);
- change_endpts(path->curve, h2endPt_pcoordsys);
+ SPItem const *const path_item = SP_ITEM(path);
+ SPObject const *const ancestor = get_nearest_common_ancestor(path_item, h2attItem);
+ Geom::Matrix const path2anc(i2anc_affine(path_item, ancestor));
+
+ // Set sensible values incase there the connector ends are not
+ // attached to any shapes.
+ Geom::PathVector conn_pv = path->curve->get_pathvector();
+ double endPos[2] = { 0, conn_pv[0].size() };
+
+ SPConnEnd** _connEnd = path->connEndPair.getConnEnds();
+ for (unsigned h = 0; h < 2; ++h) {
+ if (h2attItem[h] && _connEnd[h]->type == ConnPointDefault && _connEnd[h]->id == ConnPointPosCC) {
+ Geom::Matrix h2i2anc = i2anc_affine(h2attItem[h], ancestor);
+ try_get_intersect_point_with_item(path, h2attItem[h], h2i2anc, path2anc,
+ (h == 0), endPos[h]);
+ }
}
+ change_endpts(path->curve, endPos);
if (updatePathRepr) {
- path->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
path->updateRepr();
+ path->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
}
}
-// TODO: This triggering of makeInvalidPath could be cleaned up to be
-// another option passed to move_compensate.
+
static void
-sp_conn_end_shape_move_compensate(NR::Matrix const *mp, SPItem *moved_item,
+sp_conn_end_shape_move(Geom::Matrix const */*mp*/, SPItem */*moved_item*/,
SPPath *const path)
{
if (path->connEndPair.isAutoRoutingConn()) {
- path->connEndPair.makePathInvalid();
+ path->connEndPair.tellLibavoidNewEndpoints();
}
- sp_conn_end_move_compensate(mp, moved_item, path);
}
void
-sp_conn_adjust_invalid_path(SPPath *const path)
+sp_conn_reroute_path(SPPath *const path)
{
- sp_conn_end_move_compensate(NULL, NULL, path);
+ if (path->connEndPair.isAutoRoutingConn()) {
+ path->connEndPair.tellLibavoidNewEndpoints();
+ }
}
+
void
-sp_conn_adjust_path(SPPath *const path)
+sp_conn_reroute_path_immediate(SPPath *const path)
{
if (path->connEndPair.isAutoRoutingConn()) {
- path->connEndPair.makePathInvalid();
+ bool processTransaction = true;
+ path->connEndPair.tellLibavoidNewEndpoints(processTransaction);
}
// Don't update the path repr or else connector dragging is slowed by
// constant update of values to the xml editor, and each step is also
// needlessly remembered by undo/redo.
bool const updatePathRepr = false;
- sp_conn_end_move_compensate(NULL, NULL, path, updatePathRepr);
+ sp_conn_get_route_and_redraw(path, updatePathRepr);
}
-static NR::Point
-calc_bbox_conn_pt(NR::Rect const &bbox, NR::Point const &p)
+void sp_conn_redraw_path(SPPath *const path)
{
- using NR::X;
- using NR::Y;
- NR::Point const ctr(bbox.midpoint());
- NR::Point const lengths(bbox.dimensions());
- if ( ctr == p ) {
- /* Arbitrarily choose centre of right edge. */
- return NR::Point(ctr[X] + .5 * lengths[X],
- ctr[Y]);
- }
- NR::Point const cp( p - ctr );
- NR::Dim2 const edgeDim = ( ( fabs(lengths[Y] * cp[X]) <
- fabs(lengths[X] * cp[Y]) )
- ? Y
- : X );
- NR::Dim2 const otherDim = (NR::Dim2) !edgeDim;
- NR::Point offset;
- offset[edgeDim] = (signed_one(cp[edgeDim])
- * lengths[edgeDim]);
- offset[otherDim] = (lengths[edgeDim]
- * cp[otherDim]
- / fabs(cp[edgeDim]));
- g_assert((offset[otherDim] >= 0) == (cp[otherDim] >= 0));
-#ifndef NDEBUG
- for (unsigned d = 0; d < 2; ++d) {
- g_assert(fabs(offset[d]) <= lengths[d] + .125);
- }
-#endif
- return ctr + .5 * offset;
+ sp_conn_get_route_and_redraw(path);
}
-static double signed_one(double const x)
-{
- return (x < 0
- ? -1.
- : 1.);
-}
static void
-change_endpts(SPCurve *const curve, NR::Point const h2endPt[2])
+change_endpts(SPCurve *const curve, double const endPos[2])
{
-#if 0
- sp_curve_reset(curve);
- sp_curve_moveto(curve, h2endPt[0]);
- sp_curve_lineto(curve, h2endPt[1]);
-#else
- sp_curve_move_endpoints(curve, h2endPt[0], h2endPt[1]);
-#endif
+ // Use Geom::Path::portion to cut the curve at the end positions
+ if (endPos[0] > endPos[1])
+ {
+ // Path is "negative", reset the curve and return
+ curve->reset();
+ return;
+ }
+ const Geom::Path& old_path = curve->get_pathvector()[0];
+ Geom::PathVector new_path_vector;
+ new_path_vector.push_back(old_path.portion(endPos[0], endPos[1]));
+ curve->set_pathvector(new_path_vector);
}
static void
}
void
-SPConnEnd::setAttacherHref(gchar const *value)
+SPConnEnd::setAttacherHref(gchar const *value, SPPath* /*path*/)
{
if ( value && href && ( strcmp(value, href) == 0 ) ) {
/* No change, do nothing. */
} else {
- g_free(href);
- href = NULL;
- if (value) {
- // First, set the href field, because sp_conn_end_href_changed will need it.
- href = g_strdup(value);
-
- // Now do the attaching, which emits the changed signal.
- try {
- ref.attach(Inkscape::URI(value));
- } catch (Inkscape::BadURIException &e) {
- /* TODO: Proper error handling as per
- * http://www.w3.org/TR/SVG11/implnote.html#ErrorProcessing. (Also needed for
- * sp-use.) */
- g_warning("%s", e.what());
+ if (!value)
+ {
+ ref.detach();
+ g_free(href);
+ href = NULL;
+ }
+ else
+ {
+
+ /* References to the connection points have the following format
+ #svguri_t_id, where #svguri is the id of the item the
+ connector is attached to, t is the type of the point, which
+ can be either "d" for default or "u" for user-defined, and
+ id is the local (inside the item) id of the connection point.
+ In the case of default points id represents the position on the
+ item (i.e. Top-Left, Centre-Centre, etc.).
+ */
+
+ gchar ** href_strarray = NULL;
+ if (href)
+ href_strarray = g_strsplit(href, "_", 0);
+ gchar ** value_strarray = g_strsplit(value, "_", 0);
+
+ g_free(href);
+ href = NULL;
+
+ bool changed = false;
+ bool validRef = true;
+
+ if ( !href_strarray || g_strcmp0(href_strarray[0], value_strarray[0]) != 0 )
+ {
+ // The href has changed, so update it.
+ changed = true;
+ // Set the href field, because sp_conn_end_href_changed will need it.
+ href = g_strdup(value);
+ // Now do the attaching, which emits the changed signal.
+ try {
+ ref.attach(Inkscape::URI(value_strarray[0]));
+ } catch (Inkscape::BadURIException &e) {
+ /* TODO: Proper error handling as per
+ * http://www.w3.org/TR/SVG11/implnote.html#ErrorProcessing. (Also needed for
+ * sp-use.) */
+ g_warning("%s", e.what());
+ validRef = false;
+ }
+ }
+ // Check to see if the connection point changed and update it.
+ //
+
+ if ( !value_strarray[1] )
+ {
+ /* Treat the old references to connection points
+ as default points that connect to the centre
+ of the item.
+ */
+ if ( type != ConnPointDefault )
+ {
+ type = ConnPointDefault;
+ changed = true;
+ }
+ if ( id != ConnPointPosCC )
+ {
+ id = ConnPointPosCC;
+ changed = true;
+ }
+ }
+ else
+ {
+ switch (value_strarray[1][0])
+ {
+ case 'd':
+ if ( type != ConnPointDefault )
+ {
+ type = ConnPointDefault;
+ changed = true;
+ }
+ break;
+ case 'u':
+ if ( type != ConnPointUserDefined)
+ {
+ type = ConnPointUserDefined;
+ changed = true;
+ }
+ break;
+ default:
+ g_warning("Bad reference to a connection point.");
+ validRef = false;
+ }
+ if ( value_strarray[2] )
+ {
+ int newId = (int) g_ascii_strtod( value_strarray[2], 0 );
+ if ( id != newId )
+ {
+ id = newId;
+ changed = true;
+ }
+
+ }
+ else
+ {
+ // We have a malformed reference to a connection point,
+ // emit a warning, clear href and detach ref.
+ changed = true;
+ g_warning("Bad reference to a connection point.");\
+ validRef = false;
+ }
+ }
+
+ if ( changed )
+ {
+ // We still have to verify that the reference to the
+ // connection point is a valid one.
+
+ // Get the item the connector is attached to
+ SPItem* item = ref.getObject();
+ if ( item && !item->avoidRef->isValidConnPointId( type, id ) )
+ {
+ g_warning("Bad reference to a connection point.");
+ validRef = false;
+ }
+/* else
+ // Update the connector
+ if (path->connEndPair.isAutoRoutingConn()) {
+ path->connEndPair.tellLibavoidNewEndpoints();
+ }
+*/
+ }
+
+ if ( !validRef )
+ {
ref.detach();
+ g_free(href);
+ href = NULL;
}
- } else {
- ref.detach();
+ else
+ if (!href)
+ href = g_strdup(value);
+
+ g_strfreev(href_strarray);
+ g_strfreev(value_strarray);
}
}
}
void
-sp_conn_end_href_changed(SPObject *old_ref, SPObject *ref,
+sp_conn_end_href_changed(SPObject */*old_ref*/, SPObject */*ref*/,
SPConnEnd *connEndPtr, SPPath *const path, unsigned const handle_ix)
{
g_return_if_fail(connEndPtr != NULL);
= SP_OBJECT(refobj)->connectDelete(sigc::bind(sigc::ptr_fun(&sp_conn_end_deleted),
SP_OBJECT(path), handle_ix));
connEnd._transformed_connection
- = SP_ITEM(refobj)->connectTransformed(sigc::bind(sigc::ptr_fun(&sp_conn_end_shape_move_compensate),
+ = SP_ITEM(refobj)->connectTransformed(sigc::bind(sigc::ptr_fun(&sp_conn_end_shape_move),
path));
}
}