static void sp_canvas_bpath_update(SPCanvasItem *item, Geom::Affine const &affine, unsigned int flags)
{
SPCanvasBPath *cbp = SP_CANVAS_BPATH(item);
item->canvas->requestRedraw((int)item->x1, (int)item->y1, (int)item->x2, (int)item->y2);
if (reinterpret_cast<SPCanvasItemClass *>(sp_canvas_bpath_parent_class)->update) {
reinterpret_cast<SPCanvasItemClass *>(sp_canvas_bpath_parent_class)->update(item, affine, flags);
}
sp_canvas_item_reset_bounds (item);
if (!cbp->curve) return;
cbp->affine = affine;
Geom::OptRect bbox = bounds_exact_transformed(cbp->curve->get_pathvector(), affine);
if (bbox) {
item->x1 = (int)bbox->min()[Geom::X] - 1;
item->y1 = (int)bbox->min()[Geom::Y] - 1;
item->x2 = (int)bbox->max()[Geom::X] + 1;
item->y2 = (int)bbox->max()[Geom::Y] + 1;
} else {
item->x1 = 0;
item->y1 = 0;
item->x2 = 0;
item->y2 = 0;
}
item->canvas->requestRedraw((int)item->x1, (int)item->y1, (int)item->x2, (int)item->y2);
}
static void
sp_selection_layout_widget_update(SPWidget *spw, Inkscape::Selection *sel)
{
if (g_object_get_data(G_OBJECT(spw), "update")) {
return;
}
g_object_set_data(G_OBJECT(spw), "update", GINT_TO_POINTER(TRUE));
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
using Geom::X;
using Geom::Y;
if ( sel && !sel->isEmpty() ) {
int prefs_bbox = prefs->getInt("/tools/bounding_box", 0);
SPItem::BBoxType bbox_type = (prefs_bbox ==0)?
SPItem::VISUAL_BBOX : SPItem::GEOMETRIC_BBOX;
Geom::OptRect const bbox(sel->bounds(bbox_type));
if ( bbox ) {
UnitTracker *tracker = reinterpret_cast<UnitTracker*>(g_object_get_data(G_OBJECT(spw), "tracker"));
Unit const *unit = tracker->getActiveUnit();
g_return_if_fail(unit != NULL);
struct { char const *key; double val; } const keyval[] = {
{ "X", bbox->min()[X] },
{ "Y", bbox->min()[Y] },
{ "width", bbox->dimensions()[X] },
{ "height", bbox->dimensions()[Y] }
};
if (unit->type == Inkscape::Util::UNIT_TYPE_DIMENSIONLESS) {
double const val = unit->factor * 100;
for (unsigned i = 0; i < G_N_ELEMENTS(keyval); ++i) {
GtkAdjustment *a = GTK_ADJUSTMENT(g_object_get_data(G_OBJECT(spw), keyval[i].key));
gtk_adjustment_set_value(a, val);
tracker->setFullVal( a, keyval[i].val );
}
} else {
for (unsigned i = 0; i < G_N_ELEMENTS(keyval); ++i) {
GtkAdjustment *a = GTK_ADJUSTMENT(g_object_get_data(G_OBJECT(spw), keyval[i].key));
gtk_adjustment_set_value(a, Quantity::convert(keyval[i].val, "px", unit));
}
}
}
}
g_object_set_data(G_OBJECT(spw), "update", GINT_TO_POINTER(FALSE));
}
/** Feeds path-creating calls to the cairo context translating them from the Path, with the given transform and shift */
static void
feed_path_to_cairo (cairo_t *ct, Geom::Path const &path, Geom::Affine trans, Geom::OptRect area, bool optimize_stroke, double stroke_width)
{
if (!area)
return;
if (path.empty())
return;
// Transform all coordinates to coords within "area"
Geom::Point shift = area->min();
Geom::Rect view = *area;
view.expandBy (stroke_width);
view = view * (Geom::Affine)Geom::Translate(-shift);
// Pass transformation to feed_curve, so that we don't need to create a whole new path.
Geom::Affine transshift(trans * Geom::Translate(-shift));
Geom::Point initial = path.initialPoint() * transshift;
cairo_move_to(ct, initial[0], initial[1] );
for(Geom::Path::const_iterator cit = path.begin(); cit != path.end_open(); ++cit) {
feed_curve_to_cairo(ct, *cit, transshift, view, optimize_stroke);
}
if (path.closed()) {
if (!optimize_stroke) {
cairo_close_path(ct);
} else {
cairo_line_to(ct, initial[0], initial[1]);
/* We cannot use cairo_close_path(ct) here because some parts of the path may have been
clipped and not drawn (maybe the before last segment was outside view area), which
would result in closing the "subpath" after the last interruption, not the entire path.
However, according to cairo documentation:
The behavior of cairo_close_path() is distinct from simply calling cairo_line_to() with the equivalent coordinate
in the case of stroking. When a closed sub-path is stroked, there are no caps on the ends of the sub-path. Instead,
there is a line join connecting the final and initial segments of the sub-path.
The correct fix will be possible when cairo introduces methods for moving without
ending/starting subpaths, which we will use for skipping invisible segments; then we
will be able to use cairo_close_path here. This issue also affects ps/eps/pdf export,
see bug 168129
*/
}
}
}
void sp_textpath_to_text(SPObject *tp)
{
SPObject *text = tp->parent;
Geom::OptRect bbox = SP_ITEM(text)->geometricBounds(SP_ITEM(text)->i2doc_affine());
if (!bbox) {
return;
}
Geom::Point xy = bbox->min();
xy *= tp->document->getDocumentScale().inverse(); // Convert to user-units.
// make a list of textpath children
GSList *tp_reprs = NULL;
for (SPObject *o = tp->firstChild() ; o != NULL; o = o->next) {
tp_reprs = g_slist_prepend(tp_reprs, o->getRepr());
}
for ( GSList *i = tp_reprs ; i ; i = i->next ) {
// make a copy of each textpath child
Inkscape::XML::Node *copy = ((Inkscape::XML::Node *) i->data)->duplicate(text->getRepr()->document());
// remove the old repr from under textpath
tp->getRepr()->removeChild((Inkscape::XML::Node *) i->data);
// put its copy under text
text->getRepr()->addChild(copy, NULL); // fixme: copy id
}
//remove textpath
tp->deleteObject();
g_slist_free(tp_reprs);
// set x/y on text (to be near where it was when on path)
/* fixme: Yuck, is this really the right test? */
if (xy[Geom::X] != 1e18 && xy[Geom::Y] != 1e18) {
sp_repr_set_svg_double(text->getRepr(), "x", xy[Geom::X]);
sp_repr_set_svg_double(text->getRepr(), "y", xy[Geom::Y]);
}
}
/**
* Takes a list of inkscape items, extracts the graph defined by
* connectors between them, and uses graph layout techniques to find
* a nice layout
*/
void graphlayout(std::vector<SPItem*> const &items) {
if(items.empty()) {
return;
}
list<SPItem *> selected;
filterConnectors(items,selected);
if (selected.empty()) return;
const unsigned n=selected.size();
//Check 2 or more selected objects
if (n < 2) return;
// add the connector spacing to the size of node bounding boxes
// so that connectors can always be routed between shapes
SPDesktop* desktop = SP_ACTIVE_DESKTOP;
double spacing = 0;
if(desktop) spacing = desktop->namedview->connector_spacing+0.1;
map<string,unsigned> nodelookup;
vector<Rectangle*> rs;
vector<Edge> es;
for (list<SPItem *>::iterator i(selected.begin());
i != selected.end();
++i)
{
SPItem *u=*i;
Geom::OptRect const item_box = u->desktopVisualBounds();
if(item_box) {
Geom::Point ll(item_box->min());
Geom::Point ur(item_box->max());
nodelookup[u->getId()]=rs.size();
rs.push_back(new Rectangle(ll[0]-spacing,ur[0]+spacing,
ll[1]-spacing,ur[1]+spacing));
} else {
// I'm not actually sure if it's possible for something with a
// NULL item-box to be attached to a connector in which case we
// should never get to here... but if such a null box can occur it's
// probably pretty safe to simply ignore
//fprintf(stderr,"NULL item_box found in graphlayout, ignoring!\n");
}
}
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
SimpleConstraints scx,scy;
double ideal_connector_length = prefs->getDouble("/tools/connector/length", 100.0);
double directed_edge_height_modifier = 1.0;
bool directed = prefs->getBool("/tools/connector/directedlayout");
bool avoid_overlaps = prefs->getBool("/tools/connector/avoidoverlaplayout");
for (list<SPItem *>::iterator i(selected.begin());
i != selected.end();
++i)
{
SPItem *iu=*i;
map<string,unsigned>::iterator i_iter=nodelookup.find(iu->getId());
map<string,unsigned>::iterator i_iter_end=nodelookup.end();
if(i_iter==i_iter_end) {
continue;
}
unsigned u=i_iter->second;
std::vector<SPItem *> nlist=iu->avoidRef->getAttachedConnectors(Avoid::runningFrom);
list<SPItem *> connectors;
connectors.insert(connectors.end(), nlist.begin(), nlist.end());
for (list<SPItem *>::iterator j(connectors.begin());
j != connectors.end();
++j) {
SPItem *conn=*j;
SPItem *iv;
SPItem *items[2];
assert(isConnector(conn));
SP_PATH(conn)->connEndPair.getAttachedItems(items);
if(items[0]==iu) {
iv=items[1];
} else {
iv=items[0];
}
if (iv == NULL) {
// The connector is not attached to anything at the
// other end so we should just ignore it.
continue;
}
// If iv not in nodelookup we again treat the connector
// as disconnected and continue
map<string,unsigned>::iterator v_pair=nodelookup.find(iv->getId());
if(v_pair!=nodelookup.end()) {
unsigned v=v_pair->second;
//cout << "Edge: (" << u <<","<<v<<")"<<endl;
es.push_back(make_pair(u,v));
if(conn->style->marker_end.set) {
if(directed && strcmp(conn->style->marker_end.value,"none")) {
scy.push_back(new SimpleConstraint(v, u,
(ideal_connector_length * directed_edge_height_modifier)));
}
}
}
}
}
const unsigned E = es.size();
double eweights[E];
fill(eweights,eweights+E,1);
vector<Component*> cs;
connectedComponents(rs,es,scx,scy,cs);
for(unsigned i=0;i<cs.size();i++) {
Component* c=cs[i];
if(c->edges.size()<2) continue;
CheckProgress test(0.0001,100,selected,rs,nodelookup);
ConstrainedMajorizationLayout alg(c->rects,c->edges,eweights,ideal_connector_length,test);
alg.setupConstraints(NULL,NULL,avoid_overlaps,
NULL,NULL,&c->scx,&c->scy,NULL,NULL);
alg.run();
}
separateComponents(cs);
for (list<SPItem *>::iterator it(selected.begin());
it != selected.end();
++it)
{
SPItem *u=*it;
if(!isConnector(u)) {
map<string,unsigned>::iterator i=nodelookup.find(u->getId());
if(i!=nodelookup.end()) {
Rectangle* r=rs[i->second];
Geom::OptRect item_box = u->desktopVisualBounds();
if (item_box) {
Geom::Point const curr(item_box->midpoint());
Geom::Point const dest(r->getCentreX(),r->getCentreY());
sp_item_move_rel(u, Geom::Translate(dest - curr));
}
}
}
}
for(unsigned i=0;i<scx.size();i++) {
delete scx[i];
}
for(unsigned i=0;i<scy.size();i++) {
delete scy[i];
}
for(unsigned i=0;i<rs.size();i++) {
delete rs[i];
}
}
