X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fconn-avoid-ref.cpp;h=43c9c0b66cb652c5fa906f50d7d1f5e1c5ca20b2;hb=43be2ed2178db96177d31205e4b9692535612136;hp=0dbd8c730156e51648bd7843e484ed5caaea7ac0;hpb=6b15695578f07a3f72c4c9475c1a261a3021472a;p=inkscape.git diff --git a/src/conn-avoid-ref.cpp b/src/conn-avoid-ref.cpp index 0dbd8c730..43c9c0b66 100644 --- a/src/conn-avoid-ref.cpp +++ b/src/conn-avoid-ref.cpp @@ -10,18 +10,25 @@ */ +#include +#include #include "sp-item.h" #include "conn-avoid-ref.h" -#include "libnr/nr-rect-ops.h" #include "libavoid/polyutil.h" -#include "libavoid/incremental.h" -#include "xml/simple-node.cpp" +#include "libavoid/router.h" +#include "libavoid/connector.h" +#include "xml/node.h" #include "document.h" +#include "desktop.h" +#include "desktop-handles.h" +#include "sp-namedview.h" +#include "inkscape.h" +using Avoid::Router; + static Avoid::Polygn avoid_item_poly(SPItem const *item); -static void avoid_item_move(NR::Matrix const *mp, SPItem *moved_item); SPAvoidRef::SPAvoidRef(SPItem *spitem) @@ -38,9 +45,10 @@ SPAvoidRef::~SPAvoidRef() { _transformed_connection.disconnect(); if (shapeRef) { + Router *router = shapeRef->router(); // shapeRef is finalised by delShape, // so no memory is lost here. - Avoid::delShape(shapeRef); + router->delShape(shapeRef); shapeRef = NULL; } } @@ -61,28 +69,45 @@ void SPAvoidRef::setAvoid(char const *value) void SPAvoidRef::handleSettingChange(void) { + SPDesktop *desktop = inkscape_active_desktop(); + if (desktop == NULL) { + return; + } + if (sp_desktop_document(desktop) != item->document) { + // We don't want to go any further if the active desktop's document + // isn't the same as the document that this item is part of. This + // case can happen if a new document is loaded from the file chooser + // or via the recent file menu. In this case, we can end up here + // as a rersult of a sp_document_ensure_up_to_date performed on a + // document not yet attached to the active desktop. + return; + } + if (new_setting == setting) { // Don't need to make any changes return; } + setting = new_setting; + Router *router = item->document->router; + _transformed_connection.disconnect(); if (new_setting) { - _transformed_connection = item->connectTransformed( - sigc::ptr_fun(&avoid_item_move)); - Avoid::Polygn poly = avoid_item_poly(item); if (poly.pn > 0) { + _transformed_connection = item->connectTransformed( + sigc::ptr_fun(&avoid_item_move)); + const char *id = SP_OBJECT_REPR(item)->attribute("id"); g_assert(id != NULL); // Get a unique ID for the item. GQuark itemID = g_quark_from_string(id); - shapeRef = new Avoid::ShapeRef(itemID, poly); + shapeRef = new Avoid::ShapeRef(router, itemID, poly); Avoid::freePoly(poly); - Avoid::addShape(shapeRef); + router->addShape(shapeRef); } } else @@ -91,15 +116,65 @@ void SPAvoidRef::handleSettingChange(void) // shapeRef is finalised by delShape, // so no memory is lost here. - Avoid::delShape(shapeRef); + router->delShape(shapeRef); shapeRef = NULL; } - setting = new_setting; +} + + +GSList *SPAvoidRef::getAttachedShapes(const unsigned int type) +{ + GSList *list = NULL; + + Avoid::IntList shapes; + GQuark shapeId = g_quark_from_string(item->id); + item->document->router->attachedShapes(shapes, shapeId, type); + + Avoid::IntList::iterator finish = shapes.end(); + for (Avoid::IntList::iterator i = shapes.begin(); i != finish; ++i) { + const gchar *connId = g_quark_to_string(*i); + SPObject *obj = item->document->getObjectById(connId); + if (obj == NULL) { + g_warning("getAttachedShapes: Object with id=\"%s\" is not " + "found. Skipping.", connId); + continue; + } + SPItem *shapeItem = SP_ITEM(obj); + list = g_slist_prepend(list, shapeItem); + } + return list; +} + + +GSList *SPAvoidRef::getAttachedConnectors(const unsigned int type) +{ + GSList *list = NULL; + + Avoid::IntList conns; + GQuark shapeId = g_quark_from_string(item->id); + item->document->router->attachedConns(conns, shapeId, type); + + Avoid::IntList::iterator finish = conns.end(); + for (Avoid::IntList::iterator i = conns.begin(); i != finish; ++i) { + const gchar *connId = g_quark_to_string(*i); + SPObject *obj = item->document->getObjectById(connId); + if (obj == NULL) { + g_warning("getAttachedConnectors: Object with id=\"%s\" is not " + "found. Skipping.", connId); + continue; + } + SPItem *connItem = SP_ITEM(obj); + list = g_slist_prepend(list, connItem); + } + return list; } static Avoid::Polygn avoid_item_poly(SPItem const *item) { + SPDesktop *desktop = inkscape_active_desktop(); + g_assert(desktop != NULL); + Avoid::Polygn poly; // TODO: The right way to do this is to return the convex hull of @@ -110,60 +185,95 @@ static Avoid::Polygn avoid_item_poly(SPItem const *item) // some convex hull code, though not NR::ConvexHull as this // only keeps the bounding box of the convex hull currently. - // TODO: SPItem::invokeBbox gives the wrong result for some objects + // 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(item->document); - NR::Rect rHull = item->invokeBbox(sp_item_i2doc_affine(item)); - + Geom::OptRect rHull = item->getBounds(sp_item_i2doc_affine(item)); + if (!rHull) { + return Avoid::newPoly(0); + } + + double spacing = desktop->namedview->connector_spacing; + // Add a little buffer around the edge of each object. - NR::Rect rExpandedHull = NR::expand(rHull, -10.0); + Geom::Rect rExpandedHull = *rHull; + rExpandedHull.expandBy(spacing); poly = Avoid::newPoly(4); for (unsigned n = 0; n < 4; ++n) { - // TODO: I think the winding order in libavoid or inkscape might - // be backwards, probably due to the inverse y co-ordinates - // used for the screen. The '3 - n' reverses the order. - /* On "correct" winding order: Winding order of NR::Rect::corner is in a positive - * direction, like libart. "Positive direction" means the same as in most of Inkscape and - * SVG: if you visualize y as increasing upwards, as is the convention in mathematics, then - * positive angle is visualized as anticlockwise, as in mathematics; so if you visualize y - * as increasing downwards, as is common outside of mathematics, then positive angle - * direction is visualized as clockwise, as is common outside of mathematics. This - * convention makes it easier mix pure mathematics code with graphics code: the important - * thing when mixing code is that the number values stored in variables (representing y - * coordinate, angle) match up; variables store numbers, not visualized positions, and the - * programmer is free to switch between visualizations when thinking about a given piece of - * code. - * - * MathWorld, libart and NR::Rect::corner all seem to take positive winding (i.e. winding - * that yields +1 winding number inside a simple closed shape) to mean winding in a - * positive angle. This, together with the observation that variables store numbers rather - * than positions, suggests that NR::Rect::corner uses the right direction. - */ - NR::Point hullPoint = rExpandedHull.corner(3 - n); - poly.ps[n].x = hullPoint[NR::X]; - poly.ps[n].y = hullPoint[NR::Y]; + Geom::Point hullPoint = rExpandedHull.corner(n); + poly.ps[n].x = hullPoint[Geom::X]; + poly.ps[n].y = hullPoint[Geom::Y]; } return poly; } -static void avoid_item_move(NR::Matrix const *mp, SPItem *moved_item) +GSList *get_avoided_items(GSList *list, SPObject *from, SPDesktop *desktop, + bool initialised) +{ + for (SPObject *child = sp_object_first_child(SP_OBJECT(from)) ; + child != NULL; child = SP_OBJECT_NEXT(child) ) { + if (SP_IS_ITEM(child) && + !desktop->isLayer(SP_ITEM(child)) && + !SP_ITEM(child)->isLocked() && + !desktop->itemIsHidden(SP_ITEM(child)) && + (!initialised || SP_ITEM(child)->avoidRef->shapeRef) + ) + { + list = g_slist_prepend (list, SP_ITEM(child)); + } + + if (SP_IS_ITEM(child) && desktop->isLayer(SP_ITEM(child))) { + list = get_avoided_items(list, child, desktop, initialised); + } + } + + return list; +} + + +void avoid_item_move(Geom::Matrix const */*mp*/, SPItem *moved_item) { Avoid::ShapeRef *shapeRef = moved_item->avoidRef->shapeRef; g_assert(shapeRef); + Router *router = moved_item->document->router; Avoid::Polygn poly = avoid_item_poly(moved_item); if (poly.pn > 0) { - // moveShape actually destroys the old shapeRef and returns a new one. - moved_item->avoidRef->shapeRef = Avoid::moveShape(shapeRef, &poly); + router->moveShape(shapeRef, &poly); Avoid::freePoly(poly); } } - + + +void init_avoided_shape_geometry(SPDesktop *desktop) +{ + // Don't count this as changes to the document, + // it is basically just late initialisation. + SPDocument *document = sp_desktop_document(desktop); + bool saved = sp_document_get_undo_sensitive(document); + sp_document_set_undo_sensitive(document, false); + + bool initialised = false; + GSList *items = get_avoided_items(NULL, desktop->currentRoot(), desktop, + initialised); + + for ( GSList const *iter = items ; iter != NULL ; iter = iter->next ) { + SPItem *item = reinterpret_cast(iter->data); + item->avoidRef->handleSettingChange(); + } + + if (items) { + g_slist_free(items); + } + sp_document_set_undo_sensitive(document, saved); +} + + /* Local Variables: mode:c++