static void sp_arctb_open_state_changed( EgeSelectOneAction *act, GObject *tbl )
{
SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( tbl, "desktop" ));
if (DocumentUndo::getUndoSensitive(desktop->getDocument())) {
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
prefs->setBool("/tools/shapes/arc/open", ege_select_one_action_get_active(act) != 0);
}
// quit if run by the attr_changed listener
if (g_object_get_data( tbl, "freeze" )) {
return;
}
// in turn, prevent listener from responding
g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
bool modmade = false;
if ( ege_select_one_action_get_active(act) != 0 ) {
std::vector<SPItem*> itemlist=desktop->getSelection()->itemList();
for(std::vector<SPItem*>::const_iterator i=itemlist.begin();i!=itemlist.end();i++){
SPItem *item = *i;
if (SP_IS_GENERICELLIPSE(item)) {
Inkscape::XML::Node *repr = item->getRepr();
repr->setAttribute("sodipodi:open", "true");
item->updateRepr();
modmade = true;
}
}
} else {
std::vector<SPItem*> itemlist=desktop->getSelection()->itemList();
for(std::vector<SPItem*>::const_iterator i=itemlist.begin();i!=itemlist.end();i++){
SPItem *item = *i;
if (SP_IS_GENERICELLIPSE(item)) {
Inkscape::XML::Node *repr = item->getRepr();
repr->setAttribute("sodipodi:open", NULL);
item->updateRepr();
modmade = true;
}
}
}
if (modmade) {
DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_ARC,
_("Arc: Change open/closed"));
}
g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
}
// Create a mask element (using passed elements), add it to <defs>
const gchar *SPClipPath::create (GSList *reprs, SPDocument *document, Geom::Affine const* applyTransform)
{
Inkscape::XML::Node *defsrepr = document->getDefs()->getRepr();
Inkscape::XML::Document *xml_doc = document->getReprDoc();
Inkscape::XML::Node *repr = xml_doc->createElement("svg:clipPath");
repr->setAttribute("clipPathUnits", "userSpaceOnUse");
defsrepr->appendChild(repr);
const gchar *id = repr->attribute("id");
SPObject *clip_path_object = document->getObjectById(id);
for (GSList *it = reprs; it != NULL; it = it->next) {
Inkscape::XML::Node *node = (Inkscape::XML::Node *)(it->data);
SPItem *item = SP_ITEM(clip_path_object->appendChildRepr(node));
if (NULL != applyTransform) {
Geom::Affine transform (item->transform);
transform *= (*applyTransform);
item->doWriteTransform(item->getRepr(), transform);
}
}
Inkscape::GC::release(repr);
return id;
}
static void sp_spiral_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
{
int n_selected = 0;
Inkscape::XML::Node *repr = NULL;
purge_repr_listener( tbl, tbl );
std::vector<SPItem*> itemlist=selection->itemList();
for(std::vector<SPItem*>::const_iterator i=itemlist.begin();i!=itemlist.end(); ++i){
SPItem *item = *i;
if (SP_IS_SPIRAL(item)) {
n_selected++;
repr = item->getRepr();
}
}
EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) );
if (n_selected == 0) {
g_object_set( G_OBJECT(act), "label", _("<b>New:</b>"), NULL );
} else if (n_selected == 1) {
g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
if (repr) {
g_object_set_data( tbl, "repr", repr );
Inkscape::GC::anchor(repr);
sp_repr_add_listener(repr, &spiral_tb_repr_events, tbl);
sp_repr_synthesize_events(repr, &spiral_tb_repr_events, tbl);
}
} else {
// FIXME: implement averaging of all parameters for multiple selected
//gtk_label_set_markup(GTK_LABEL(l), _("<b>Average:</b>"));
g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
}
}
/**
* \param selection should not be NULL.
*/
static void sp_rect_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
{
int n_selected = 0;
Inkscape::XML::Node *repr = NULL;
SPItem *item = NULL;
if ( g_object_get_data( tbl, "repr" ) ) {
g_object_set_data( tbl, "item", NULL );
}
purge_repr_listener( tbl, tbl );
for (GSList const *items = selection->itemList();
items != NULL;
items = items->next) {
if (SP_IS_RECT(reinterpret_cast<SPItem *>(items->data))) {
n_selected++;
item = reinterpret_cast<SPItem *>(items->data);
repr = item->getRepr();
}
}
EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) );
g_object_set_data( tbl, "single", GINT_TO_POINTER(FALSE) );
if (n_selected == 0) {
g_object_set( G_OBJECT(act), "label", _("<b>New:</b>"), NULL );
GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "width_action" ) );
gtk_action_set_sensitive(w, FALSE);
GtkAction* h = GTK_ACTION( g_object_get_data( tbl, "height_action" ) );
gtk_action_set_sensitive(h, FALSE);
} else if (n_selected == 1) {
g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
g_object_set_data( tbl, "single", GINT_TO_POINTER(TRUE) );
GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "width_action" ) );
gtk_action_set_sensitive(w, TRUE);
GtkAction* h = GTK_ACTION( g_object_get_data( tbl, "height_action" ) );
gtk_action_set_sensitive(h, TRUE);
if (repr) {
g_object_set_data( tbl, "repr", repr );
g_object_set_data( tbl, "item", item );
Inkscape::GC::anchor(repr);
sp_repr_add_listener(repr, &rect_tb_repr_events, tbl);
sp_repr_synthesize_events(repr, &rect_tb_repr_events, tbl);
}
} else {
// FIXME: implement averaging of all parameters for multiple selected
//gtk_label_set_markup(GTK_LABEL(l), _("<b>Average:</b>"));
g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
sp_rtb_sensitivize( tbl );
}
}
void SPUse::href_changed() {
this->_delete_connection.disconnect();
this->_transformed_connection.disconnect();
if (this->child) {
this->detach(this->child);
this->child = NULL;
}
if (this->href) {
SPItem *refobj = this->ref->getObject();
if (refobj) {
Inkscape::XML::Node *childrepr = refobj->getRepr();
SPObject* obj = SPFactory::createObject(NodeTraits::get_type_string(*childrepr));
SPItem *item = dynamic_cast<SPItem *>(obj);
if (item) {
child = item;
this->attach(this->child, this->lastChild());
sp_object_unref(this->child, this);
this->child->invoke_build(this->document, childrepr, TRUE);
for (SPItemView *v = this->display; v != NULL; v = v->next) {
Inkscape::DrawingItem *ai = this->child->invoke_show(v->arenaitem->drawing(), v->key, v->flags);
if (ai) {
v->arenaitem->prependChild(ai);
}
}
} else {
delete obj;
g_warning("Tried to create svg:use from invalid object");
}
this->_delete_connection = refobj->connectDelete(
sigc::hide(sigc::mem_fun(this, &SPUse::delete_self))
);
this->_transformed_connection = refobj->connectTransformed(
sigc::hide(sigc::mem_fun(this, &SPUse::move_compensate))
);
}
}
}
static void
sp_usepath_move_compensate(Geom::Affine const *mp, SPItem *original, SPUsePath *self)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
guint mode = prefs->getInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_PARALLEL);
if (mode == SP_CLONE_COMPENSATION_NONE) {
return;
}
SPItem *item = SP_ITEM(self->owner);
// TODO kill naughty naughty #if 0
#if 0
Geom::Affine m(*mp);
if (!(m.is_translation())) {
return;
}
Geom::Affine const t(item->transform);
Geom::Affine clone_move = t.inverse() * m * t;
// Calculate the compensation matrix and the advertized movement matrix.
Geom::Affine advertized_move;
if (mode == SP_CLONE_COMPENSATION_PARALLEL) {
//clone_move = clone_move.inverse();
advertized_move.set_identity();
} else if (mode == SP_CLONE_COMPENSATION_UNMOVED) {
clone_move = clone_move.inverse() * m;
advertized_move = m;
} else {
g_assert_not_reached();
}
// Commit the compensation.
item->transform *= clone_move;
sp_item_write_transform(item, item->getRepr(), item->transform, &advertized_move);
#else
(void)mp;
(void)original;
#endif
self->sourceDirty = true;
item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
}
static void sp_spl_tb_value_changed(GtkAdjustment *adj, GObject *tbl, Glib::ustring const &value_name)
{
SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data( tbl, "desktop" ));
if (DocumentUndo::getUndoSensitive(desktop->getDocument())) {
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
prefs->setDouble("/tools/shapes/spiral/" + value_name,
gtk_adjustment_get_value(adj));
}
// quit if run by the attr_changed listener
if (g_object_get_data( tbl, "freeze" )) {
return;
}
// in turn, prevent listener from responding
g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
gchar* namespaced_name = g_strconcat("sodipodi:", value_name.data(), NULL);
bool modmade = false;
std::vector<SPItem*> itemlist=desktop->getSelection()->itemList();
for(std::vector<SPItem*>::const_iterator i=itemlist.begin();i!=itemlist.end(); ++i){
SPItem *item = *i;
if (SP_IS_SPIRAL(item)) {
Inkscape::XML::Node *repr = item->getRepr();
sp_repr_set_svg_double( repr, namespaced_name,
gtk_adjustment_get_value(adj) );
item->updateRepr();
modmade = true;
}
}
g_free(namespaced_name);
if (modmade) {
DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_SPIRAL,
_("Change spiral"));
}
g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
}
void
SPTagUse::href_changed(SPObject */*old_ref*/, SPObject */*ref*/)
{
if (href) {
SPItem *refobj = ref->getObject();
if (refobj) {
Inkscape::XML::Node *childrepr = refobj->getRepr();
const std::string typeString = NodeTraits::get_type_string(*childrepr);
SPObject* child_ = SPFactory::createObject(typeString);
if (child_) {
child = child_;
attach(child_, lastChild());
sp_object_unref(child_, 0);
child_->invoke_build(this->document, childrepr, TRUE);
}
}
}
}
void
sp_selected_path_break_apart(SPDesktop *desktop)
{
Inkscape::Selection *selection = sp_desktop_selection(desktop);
if (selection->isEmpty()) {
sp_desktop_message_stack(desktop)->flash(Inkscape::WARNING_MESSAGE, _("Select <b>path(s)</b> to break apart."));
return;
}
desktop->messageStack()->flash(Inkscape::IMMEDIATE_MESSAGE, _("Breaking apart paths..."));
// set "busy" cursor
desktop->setWaitingCursor();
bool did = false;
for (GSList *items = g_slist_copy((GSList *) selection->itemList());
items != NULL;
items = items->next) {
SPItem *item = (SPItem *) items->data;
if (!SP_IS_PATH(item)) {
continue;
}
SPPath *path = SP_PATH(item);
SPCurve *curve = path->get_curve_for_edit();
if (curve == NULL) {
continue;
}
did = true;
Inkscape::XML::Node *parent = item->getRepr()->parent();
gint pos = item->getRepr()->position();
char const *id = item->getRepr()->attribute("id");
// XML Tree being used directly here while it shouldn't be...
gchar *style = g_strdup(item->getRepr()->attribute("style"));
// XML Tree being used directly here while it shouldn't be...
gchar *path_effect = g_strdup(item->getRepr()->attribute("inkscape:path-effect"));
Geom::PathVector apv = curve->get_pathvector() * path->transform;
curve->unref();
// it's going to resurrect as one of the pieces, so we delete without advertisement
item->deleteObject(false);
curve = new SPCurve(apv);
g_assert(curve != NULL);
GSList *list = curve->split();
curve->unref();
GSList *reprs = NULL;
for (GSList *l = list; l != NULL; l = l->next) {
curve = (SPCurve *) l->data;
Inkscape::XML::Node *repr = parent->document()->createElement("svg:path");
repr->setAttribute("style", style);
repr->setAttribute("inkscape:path-effect", path_effect);
gchar *str = sp_svg_write_path(curve->get_pathvector());
if (path_effect)
repr->setAttribute("inkscape:original-d", str);
else
repr->setAttribute("d", str);
g_free(str);
// add the new repr to the parent
parent->appendChild(repr);
// move to the saved position
repr->setPosition(pos > 0 ? pos : 0);
// if it's the first one, restore id
if (l == list)
repr->setAttribute("id", id);
reprs = g_slist_prepend (reprs, repr);
Inkscape::GC::release(repr);
}
selection->setReprList(reprs);
g_slist_free(reprs);
g_slist_free(list);
g_free(style);
g_free(path_effect);
}
desktop->clearWaitingCursor();
if (did) {
DocumentUndo::done(sp_desktop_document(desktop), SP_VERB_SELECTION_BREAK_APART,
_("Break apart"));
} else {
sp_desktop_message_stack(desktop)->flash(Inkscape::ERROR_MESSAGE, _("<b>No path(s)</b> to break apart in the selection."));
}
}
SPItem *SPUse::unlink() {
Inkscape::XML::Node *repr = this->getRepr();
if (!repr) {
return NULL;
}
Inkscape::XML::Node *parent = repr->parent();
SPDocument *document = this->document;
Inkscape::XML::Document *xml_doc = document->getReprDoc();
// Track the ultimate source of a chain of uses.
SPItem *orig = this->root();
if (!orig) {
return NULL;
}
// Calculate the accumulated transform, starting from the original.
Geom::Affine t = this->get_root_transform();
Inkscape::XML::Node *copy = NULL;
if (dynamic_cast<SPSymbol *>(orig)) { // make a group, copy children
copy = xml_doc->createElement("svg:g");
for (Inkscape::XML::Node *child = orig->getRepr()->firstChild() ; child != NULL; child = child->next()) {
Inkscape::XML::Node *newchild = child->duplicate(xml_doc);
copy->appendChild(newchild);
}
} else { // just copy
copy = orig->getRepr()->duplicate(xml_doc);
}
// Add the duplicate repr just after the existing one.
parent->addChild(copy, repr);
// Retrieve the SPItem of the resulting repr.
SPObject *unlinked = document->getObjectByRepr(copy);
// Merge style from the use.
unlinked->style->merge( this->style );
unlinked->style->cascade( unlinked->parent->style );
unlinked->updateRepr();
// Hold onto our SPObject and repr for now.
sp_object_ref(this, NULL);
Inkscape::GC::anchor(repr);
// Remove ourselves, not propagating delete events to avoid a
// chain-reaction with other elements that might reference us.
this->deleteObject(false);
// Give the copy our old id and let go of our old repr.
copy->setAttribute("id", repr->attribute("id"));
Inkscape::GC::release(repr);
// Remove tiled clone attrs.
copy->setAttribute("inkscape:tiled-clone-of", NULL);
copy->setAttribute("inkscape:tile-w", NULL);
copy->setAttribute("inkscape:tile-h", NULL);
copy->setAttribute("inkscape:tile-cx", NULL);
copy->setAttribute("inkscape:tile-cy", NULL);
// Establish the succession and let go of our object.
this->setSuccessor(unlinked);
sp_object_unref(this, NULL);
SPItem *item = dynamic_cast<SPItem *>(unlinked);
g_assert(item != NULL);
// Set the accummulated transform.
{
Geom::Affine nomove(Geom::identity());
// Advertise ourselves as not moving.
item->doWriteTransform(item->getRepr(), t, &nomove);
}
return item;
}
void
sp_item_group_ungroup (SPGroup *group, GSList **children, bool do_done)
{
g_return_if_fail (group != NULL);
g_return_if_fail (SP_IS_GROUP (group));
SPDocument *doc = group->document;
SPRoot *root = doc->getRoot();
SPObject *defs = root->defs;
SPItem *gitem = group;
Inkscape::XML::Node *grepr = gitem->getRepr();
g_return_if_fail (!strcmp (grepr->name(), "svg:g") || !strcmp (grepr->name(), "svg:a") || !strcmp (grepr->name(), "svg:switch"));
// this converts the gradient/pattern fill/stroke on the group, if any, to userSpaceOnUse
gitem->adjust_paint_recursive (Geom::identity(), Geom::identity(), false);
SPItem *pitem = SP_ITEM(gitem->parent);
Inkscape::XML::Node *prepr = pitem->getRepr();
if (SP_IS_BOX3D(gitem)) {
group = box3d_convert_to_group(SP_BOX3D(gitem));
gitem = group;
}
sp_lpe_item_remove_all_path_effects(SP_LPE_ITEM(group), false);
/* Step 1 - generate lists of children objects */
GSList *items = NULL;
GSList *objects = NULL;
for (SPObject *child = group->firstChild() ; child; child = child->getNext() ) {
if (SP_IS_ITEM (child)) {
SPItem *citem = SP_ITEM (child);
/* Merging of style */
// this converts the gradient/pattern fill/stroke, if any, to userSpaceOnUse; we need to do
// it here _before_ the new transform is set, so as to use the pre-transform bbox
citem->adjust_paint_recursive (Geom::identity(), Geom::identity(), false);
sp_style_merge_from_dying_parent(child->style, gitem->style);
/*
* fixme: We currently make no allowance for the case where child is cloned
* and the group has any style settings.
*
* (This should never occur with documents created solely with the current
* version of inkscape without using the XML editor: we usually apply group
* style changes to children rather than to the group itself.)
*
* If the group has no style settings, then
* sp_style_merge_from_dying_parent should be a no-op. Otherwise (i.e. if
* we change the child's style to compensate for its parent going away)
* then those changes will typically be reflected in any clones of child,
* whereas we'd prefer for Ungroup not to affect the visual appearance.
*
* The only way of preserving styling appearance in general is for child to
* be put into a new group -- a somewhat surprising response to an Ungroup
* command. We could add a new groupmode:transparent that would mostly
* hide the existence of such groups from the user (i.e. editing behaves as
* if the transparent group's children weren't in a group), though that's
* extra complication & maintenance burden and this case is rare.
*/
child->updateRepr();
Inkscape::XML::Node *nrepr = child->getRepr()->duplicate(prepr->document());
// Merging transform
Geom::Affine ctrans;
Geom::Affine const g(gitem->transform);
if (SP_IS_USE(citem) && sp_use_get_original (SP_USE(citem)) &&
sp_use_get_original( SP_USE(citem) )->parent == SP_OBJECT(group)) {
// make sure a clone's effective transform is the same as was under group
ctrans = g.inverse() * citem->transform * g;
} else {
// We should not apply the group's transformation to both a linked offset AND to its source
if (SP_IS_OFFSET(citem)) { // Do we have an offset at hand (whether it's dynamic or linked)?
SPItem *source = sp_offset_get_source(SP_OFFSET(citem));
// When dealing with a chain of linked offsets, the transformation of an offset will be
// tied to the transformation of the top-most source, not to any of the intermediate
// offsets. So let's find the top-most source
while (source != NULL && SP_IS_OFFSET(source)) {
source = sp_offset_get_source(SP_OFFSET(source));
}
if (source != NULL && // If true then we must be dealing with a linked offset ...
group->isAncestorOf(source) == false) { // ... of which the source is not in the same group
ctrans = citem->transform * g; // then we should apply the transformation of the group to the offset
} else {
ctrans = citem->transform;
}
} else {
ctrans = citem->transform * g;
}
}
// FIXME: constructing a transform that would fully preserve the appearance of a
// textpath if it is ungrouped with its path seems to be impossible in general
// case. E.g. if the group was squeezed, to keep the ungrouped textpath squeezed
// as well, we'll need to relink it to some "virtual" path which is inversely
// stretched relative to the actual path, and then squeeze the textpath back so it
// would both fit the actual path _and_ be squeezed as before. It's a bummer.
// This is just a way to temporarily remember the transform in repr. When repr is
// reattached outside of the group, the transform will be written more properly
// (i.e. optimized into the object if the corresponding preference is set)
gchar *affinestr=sp_svg_transform_write(ctrans);
nrepr->setAttribute("transform", affinestr);
g_free(affinestr);
items = g_slist_prepend (items, nrepr);
} else {
Inkscape::XML::Node *nrepr = child->getRepr()->duplicate(prepr->document());
objects = g_slist_prepend (objects, nrepr);
}
}
/* Step 2 - clear group */
// remember the position of the group
gint pos = group->getRepr()->position();
// the group is leaving forever, no heir, clones should take note; its children however are going to reemerge
group->deleteObject(true, false);
/* Step 3 - add nonitems */
if (objects) {
Inkscape::XML::Node *last_def = defs->getRepr()->lastChild();
while (objects) {
Inkscape::XML::Node *repr = (Inkscape::XML::Node *) objects->data;
if (!sp_repr_is_meta_element(repr)) {
defs->getRepr()->addChild(repr, last_def);
}
Inkscape::GC::release(repr);
objects = g_slist_remove (objects, objects->data);
}
}
/* Step 4 - add items */
while (items) {
Inkscape::XML::Node *repr = (Inkscape::XML::Node *) items->data;
// add item
prepr->appendChild(repr);
// restore position; since the items list was prepended (i.e. reverse), we now add
// all children at the same pos, which inverts the order once again
repr->setPosition(pos > 0 ? pos : 0);
// fill in the children list if non-null
SPItem *item = static_cast<SPItem *>(doc->getObjectByRepr(repr));
item->doWriteTransform(repr, item->transform, NULL, false);
Inkscape::GC::release(repr);
if (children && SP_IS_ITEM (item))
*children = g_slist_prepend (*children, item);
items = g_slist_remove (items, items->data);
}
if (do_done) {
DocumentUndo::done(doc, SP_VERB_NONE, _("Ungroup"));
}
}
static void
refresh_offset_source(SPOffset* offset)
{
if ( offset == NULL ) {
return;
}
offset->sourceDirty=false;
// le mauvais cas: pas d'attribut d => il faut verifier que c'est une SPShape puis prendre le contour
// The bad case: no d attribute. Must check that it's an SPShape and then take the outline.
SPObject *refobj=offset->sourceObject;
if ( refobj == NULL ) {
return;
}
SPItem *item = SP_ITEM (refobj);
SPCurve *curve = NULL;
if (SP_IS_SHAPE (item)) {
curve = SP_SHAPE (item)->getCurve ();
}
else if (SP_IS_TEXT (item)) {
curve = SP_TEXT (item)->getNormalizedBpath ();
}
else {
return;
}
if (curve == NULL) {
return;
}
Path *orig = new Path;
orig->LoadPathVector(curve->get_pathvector());
curve->unref();
if (!item->transform.isIdentity()) {
gchar const *t_attr = item->getRepr()->attribute("transform");
if (t_attr) {
Geom::Affine t;
if (sp_svg_transform_read(t_attr, &t)) {
orig->Transform(t);
}
}
}
// Finish up.
{
SPCSSAttr *css;
const gchar *val;
Shape *theShape = new Shape;
Shape *theRes = new Shape;
orig->ConvertWithBackData (1.0);
orig->Fill (theShape, 0);
css = sp_repr_css_attr (offset->sourceRepr , "style");
val = sp_repr_css_property (css, "fill-rule", NULL);
if (val && strcmp (val, "nonzero") == 0)
{
theRes->ConvertToShape (theShape, fill_nonZero);
}
else if (val && strcmp (val, "evenodd") == 0)
{
theRes->ConvertToShape (theShape, fill_oddEven);
}
else
{
theRes->ConvertToShape (theShape, fill_nonZero);
}
Path *originaux[1];
originaux[0] = orig;
Path *res = new Path;
theRes->ConvertToForme (res, 1, originaux);
delete theShape;
delete theRes;
char *res_d = res->svg_dump_path ();
delete res;
delete orig;
// TODO fix:
//XML Tree being used diectly here while it shouldn't be.
offset->getRepr()->setAttribute("inkscape:original", res_d);
free (res_d);
}
}
void
sp_selected_path_combine(SPDesktop *desktop)
{
Inkscape::Selection *selection = desktop->getSelection();
SPDocument *doc = desktop->getDocument();
std::vector<SPItem*> items(selection->itemList());
if (items.size() < 1) {
desktop->getMessageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>object(s)</b> to combine."));
return;
}
desktop->messageStack()->flash(Inkscape::IMMEDIATE_MESSAGE, _("Combining paths..."));
// set "busy" cursor
desktop->setWaitingCursor();
items = sp_degroup_list (items); // descend into any groups in selection
std::vector<SPItem*> to_paths;
for (std::vector<SPItem*>::const_reverse_iterator i = items.rbegin(); i != items.rend(); ++i) {
if (!dynamic_cast<SPPath *>(*i) && !dynamic_cast<SPGroup *>(*i)) {
to_paths.push_back(*i);
}
}
std::vector<Inkscape::XML::Node*> converted;
bool did = sp_item_list_to_curves(to_paths, items, converted);
for (std::vector<Inkscape::XML::Node*>::const_iterator i = converted.begin(); i != converted.end(); ++i)
items.push_back((SPItem*)doc->getObjectByRepr(*i));
items = sp_degroup_list (items); // converting to path may have added more groups, descend again
sort(items.begin(),items.end(),less_than_items);
assert(!items.empty()); // cannot be NULL because of list length check at top of function
// remember the position, id, transform and style of the topmost path, they will be assigned to the combined one
gint position = 0;
char const *id = NULL;
char const *transform = NULL;
char const *style = NULL;
char const *path_effect = NULL;
SPCurve* curve = NULL;
SPItem *first = NULL;
Inkscape::XML::Node *parent = NULL;
if (did) {
selection->clear();
}
for (std::vector<SPItem*>::const_reverse_iterator i = items.rbegin(); i != items.rend(); ++i){
SPItem *item = *i;
SPPath *path = dynamic_cast<SPPath *>(item);
if (!path) {
continue;
}
if (!did) {
selection->clear();
did = true;
}
SPCurve *c = path->get_curve_for_edit();
if (first == NULL) { // this is the topmost path
first = item;
parent = first->getRepr()->parent();
position = first->getRepr()->position();
id = first->getRepr()->attribute("id");
transform = first->getRepr()->attribute("transform");
// FIXME: merge styles of combined objects instead of using the first one's style
style = first->getRepr()->attribute("style");
path_effect = first->getRepr()->attribute("inkscape:path-effect");
//c->transform(item->transform);
curve = c;
} else {
c->transform(item->getRelativeTransform(first));
curve->append(c, false);
c->unref();
// reduce position only if the same parent
if (item->getRepr()->parent() == parent) {
position--;
}
// delete the object for real, so that its clones can take appropriate action
item->deleteObject();
}
}
if (did) {
first->deleteObject(false);
// delete the topmost.
Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
Inkscape::XML::Node *repr = xml_doc->createElement("svg:path");
// restore id, transform, path effect, and style
repr->setAttribute("id", id);
if (transform) {
repr->setAttribute("transform", transform);
}
repr->setAttribute("style", style);
repr->setAttribute("inkscape:path-effect", path_effect);
// set path data corresponding to new curve
gchar *dstring = sp_svg_write_path(curve->get_pathvector());
curve->unref();
if (path_effect) {
repr->setAttribute("inkscape:original-d", dstring);
} else {
repr->setAttribute("d", dstring);
}
g_free(dstring);
// add the new group to the parent of the topmost
parent->appendChild(repr);
// move to the position of the topmost, reduced by the number of deleted items
repr->setPosition(position > 0 ? position : 0);
DocumentUndo::done(desktop->getDocument(), SP_VERB_SELECTION_COMBINE,
_("Combine"));
selection->set(repr);
Inkscape::GC::release(repr);
} else {
desktop->getMessageStack()->flash(Inkscape::ERROR_MESSAGE, _("<b>No path(s)</b> to combine in the selection."));
}
desktop->clearWaitingCursor();
}
bool
sp_item_list_to_curves(const std::vector<SPItem*> &items, std::vector<SPItem*>& selected, std::vector<Inkscape::XML::Node*> &to_select, bool skip_all_lpeitems)
{
bool did = false;
for (std::vector<SPItem*>::const_iterator i = items.begin(); i != items.end(); ++i){
SPItem *item = *i;
g_assert(item != NULL);
SPDocument *document = item->document;
SPGroup *group = dynamic_cast<SPGroup *>(item);
if ( skip_all_lpeitems &&
dynamic_cast<SPLPEItem *>(item) &&
!group ) // also convert objects in an SPGroup when skip_all_lpeitems is set.
{
continue;
}
SPPath *path = dynamic_cast<SPPath *>(item);
if (path && !path->_curve_before_lpe) {
// remove connector attributes
if (item->getAttribute("inkscape:connector-type") != NULL) {
item->removeAttribute("inkscape:connection-start");
item->removeAttribute("inkscape:connection-end");
item->removeAttribute("inkscape:connector-type");
item->removeAttribute("inkscape:connector-curvature");
did = true;
}
continue; // already a path, and no path effect
}
SPBox3D *box = dynamic_cast<SPBox3D *>(item);
if (box) {
// convert 3D box to ordinary group of paths; replace the old element in 'selected' with the new group
Inkscape::XML::Node *repr = box3d_convert_to_group(box)->getRepr();
if (repr) {
to_select.insert(to_select.begin(),repr);
did = true;
selected.erase(remove(selected.begin(), selected.end(), item), selected.end());
}
continue;
}
if (group) {
group->removeAllPathEffects(true);
std::vector<SPItem*> item_list = sp_item_group_item_list(group);
std::vector<Inkscape::XML::Node*> item_to_select;
std::vector<SPItem*> item_selected;
if (sp_item_list_to_curves(item_list, item_selected, item_to_select))
did = true;
continue;
}
Inkscape::XML::Node *repr = sp_selected_item_to_curved_repr(item, 0);
if (!repr)
continue;
did = true;
selected.erase(remove(selected.begin(), selected.end(), item), selected.end());
// remember the position of the item
gint pos = item->getRepr()->position();
// remember parent
Inkscape::XML::Node *parent = item->getRepr()->parent();
// remember id
char const *id = item->getRepr()->attribute("id");
// remember title
gchar *title = item->title();
// remember description
gchar *desc = item->desc();
// remember highlight color
guint32 highlight_color = 0;
if (item->isHighlightSet())
highlight_color = item->highlight_color();
// It's going to resurrect, so we delete without notifying listeners.
item->deleteObject(false);
// restore id
repr->setAttribute("id", id);
// add the new repr to the parent
parent->appendChild(repr);
SPObject* newObj = document->getObjectByRepr(repr);
if (title && newObj) {
newObj->setTitle(title);
g_free(title);
}
if (desc && newObj) {
newObj->setDesc(desc);
g_free(desc);
}
if (highlight_color && newObj) {
SP_ITEM(newObj)->setHighlightColor( highlight_color );
}
// move to the saved position
repr->setPosition(pos > 0 ? pos : 0);
/* Buglet: We don't re-add the (new version of the) object to the selection of any other
* desktops where it was previously selected. */
to_select.insert(to_select.begin(),repr);
Inkscape::GC::release(repr);
}
return did;
}
static void spdc_flush_white(FreehandBase *dc, SPCurve *gc)
{
SPCurve *c;
if (dc->white_curves) {
g_assert(dc->white_item);
c = SPCurve::concat(dc->white_curves);
g_slist_free(dc->white_curves);
dc->white_curves = NULL;
if (gc) {
c->append(gc, FALSE);
}
} else if (gc) {
c = gc;
c->ref();
} else {
return;
}
// Now we have to go back to item coordinates at last
c->transform( dc->white_item
? (dc->white_item)->dt2i_affine()
: dc->desktop->dt2doc() );
SPDesktop *desktop = dc->desktop;
SPDocument *doc = desktop->getDocument();
Inkscape::XML::Document *xml_doc = doc->getReprDoc();
if ( c && !c->is_empty() ) {
// We actually have something to write
bool has_lpe = false;
Inkscape::XML::Node *repr;
if (dc->white_item) {
repr = dc->white_item->getRepr();
has_lpe = SP_LPE_ITEM(dc->white_item)->hasPathEffectRecursive();
} else {
repr = xml_doc->createElement("svg:path");
// Set style
sp_desktop_apply_style_tool(desktop, repr, tool_name(dc).data(), false);
}
gchar *str = sp_svg_write_path( c->get_pathvector() );
g_assert( str != NULL );
if (has_lpe)
repr->setAttribute("inkscape:original-d", str);
else
repr->setAttribute("d", str);
g_free(str);
if (!dc->white_item) {
// Attach repr
SPItem *item = SP_ITEM(desktop->currentLayer()->appendChildRepr(repr));
spdc_check_for_and_apply_waiting_LPE(dc, item, c);
if(previous_shape_type != BEND_CLIPBOARD){
dc->selection->set(repr);
}
Inkscape::GC::release(repr);
item->transform = SP_ITEM(desktop->currentLayer())->i2doc_affine().inverse();
item->updateRepr();
item->doWriteTransform(item->getRepr(), item->transform, NULL, true);
if(previous_shape_type == BEND_CLIPBOARD){
repr->parent()->removeChild(repr);
}
}
DocumentUndo::done(doc, SP_IS_PEN_CONTEXT(dc)? SP_VERB_CONTEXT_PEN : SP_VERB_CONTEXT_PENCIL,
_("Draw path"));
// When quickly drawing several subpaths with Shift, the next subpath may be finished and
// flushed before the selection_modified signal is fired by the previous change, which
// results in the tool losing all of the selected path's curve except that last subpath. To
// fix this, we force the selection_modified callback now, to make sure the tool's curve is
// in sync immediately.
spdc_selection_modified(desktop->getSelection(), 0, dc);
}
c->unref();
// Flush pending updates
doc->ensureUpToDate();
}
bool
sp_item_list_to_curves(const GSList *items, GSList **selected, GSList **to_select, bool skip_all_lpeitems)
{
bool did = false;
for (;
items != NULL;
items = items->next) {
SPItem *item = SP_ITEM(items->data);
SPDocument *document = item->document;
if ( skip_all_lpeitems &&
SP_IS_LPE_ITEM(item) &&
!SP_IS_GROUP(item) ) // also convert objects in an SPGroup when skip_all_lpeitems is set.
{
continue;
}
if (SP_IS_PATH(item) && !SP_SHAPE(item)->_curve_before_lpe) {
// remove connector attributes
if (item->getAttribute("inkscape:connector-type") != NULL) {
item->removeAttribute("inkscape:connection-start");
item->removeAttribute("inkscape:connection-end");
item->removeAttribute("inkscape:connector-type");
item->removeAttribute("inkscape:connector-curvature");
did = true;
}
continue; // already a path, and no path effect
}
if (SP_IS_BOX3D(item)) {
// convert 3D box to ordinary group of paths; replace the old element in 'selected' with the new group
Inkscape::XML::Node *repr = box3d_convert_to_group(SP_BOX3D(item))->getRepr();
if (repr) {
*to_select = g_slist_prepend (*to_select, repr);
did = true;
*selected = g_slist_remove (*selected, item);
}
continue;
}
if (SP_IS_GROUP(item)) {
SP_LPE_ITEM(item)->removeAllPathEffects(true);
GSList *item_list = sp_item_group_item_list(SP_GROUP(item));
GSList *item_to_select = NULL;
GSList *item_selected = NULL;
if (sp_item_list_to_curves(item_list, &item_selected, &item_to_select))
did = true;
g_slist_free(item_list);
g_slist_free(item_to_select);
g_slist_free(item_selected);
continue;
}
Inkscape::XML::Node *repr = sp_selected_item_to_curved_repr(item, 0);
if (!repr)
continue;
did = true;
*selected = g_slist_remove (*selected, item);
// remember the position of the item
gint pos = item->getRepr()->position();
// remember parent
Inkscape::XML::Node *parent = item->getRepr()->parent();
// remember id
char const *id = item->getRepr()->attribute("id");
// remember title
gchar *title = item->title();
// remember description
gchar *desc = item->desc();
// It's going to resurrect, so we delete without notifying listeners.
item->deleteObject(false);
// restore id
repr->setAttribute("id", id);
// add the new repr to the parent
parent->appendChild(repr);
SPObject* newObj = document->getObjectByRepr(repr);
if (title && newObj) {
newObj->setTitle(title);
g_free(title);
}
if (desc && newObj) {
newObj->setDesc(desc);
g_free(desc);
}
// move to the saved position
repr->setPosition(pos > 0 ? pos : 0);
/* Buglet: We don't re-add the (new version of the) object to the selection of any other
* desktops where it was previously selected. */
*to_select = g_slist_prepend (*to_select, repr);
Inkscape::GC::release(repr);
}
return did;
}
void
sp_selected_path_break_apart(SPDesktop *desktop, bool skip_undo)
{
Inkscape::Selection *selection = desktop->getSelection();
if (selection->isEmpty()) {
desktop->getMessageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>path(s)</b> to break apart."));
return;
}
desktop->messageStack()->flash(Inkscape::IMMEDIATE_MESSAGE, _("Breaking apart paths..."));
// set "busy" cursor
desktop->setWaitingCursor();
bool did = false;
std::vector<SPItem*> itemlist(selection->itemList());
for (std::vector<SPItem*>::const_iterator i = itemlist.begin(); i != itemlist.end(); ++i){
SPItem *item = *i;
SPPath *path = dynamic_cast<SPPath *>(item);
if (!path) {
continue;
}
SPCurve *curve = path->get_curve_for_edit();
if (curve == NULL) {
continue;
}
did = true;
Inkscape::XML::Node *parent = item->getRepr()->parent();
gint pos = item->getRepr()->position();
char const *id = item->getRepr()->attribute("id");
// XML Tree being used directly here while it shouldn't be...
gchar *style = g_strdup(item->getRepr()->attribute("style"));
// XML Tree being used directly here while it shouldn't be...
gchar *path_effect = g_strdup(item->getRepr()->attribute("inkscape:path-effect"));
Geom::Affine transform = path->transform;
// it's going to resurrect as one of the pieces, so we delete without advertisement
item->deleteObject(false);
GSList *list = curve->split();
curve->unref();
std::vector<Inkscape::XML::Node*> reprs;
for (GSList *l = list; l != NULL; l = l->next) {
curve = (SPCurve *) l->data;
Inkscape::XML::Node *repr = parent->document()->createElement("svg:path");
repr->setAttribute("style", style);
repr->setAttribute("inkscape:path-effect", path_effect);
gchar *str = sp_svg_write_path(curve->get_pathvector());
if (path_effect)
repr->setAttribute("inkscape:original-d", str);
else
repr->setAttribute("d", str);
g_free(str);
repr->setAttribute("transform", sp_svg_transform_write(transform));
// add the new repr to the parent
parent->appendChild(repr);
// move to the saved position
repr->setPosition(pos > 0 ? pos : 0);
// if it's the first one, restore id
if (l == list)
repr->setAttribute("id", id);
reprs.push_back(repr);
Inkscape::GC::release(repr);
}
selection->setReprList(reprs);
g_slist_free(list);
g_free(style);
g_free(path_effect);
}
desktop->clearWaitingCursor();
if (did) {
if ( !skip_undo ) {
DocumentUndo::done(desktop->getDocument(), SP_VERB_SELECTION_BREAK_APART,
_("Break apart"));
}
} else {
desktop->getMessageStack()->flash(Inkscape::ERROR_MESSAGE, _("<b>No path(s)</b> to break apart in the selection."));
}
}
void
sp_selected_path_combine(SPDesktop *desktop)
{
Inkscape::Selection *selection = sp_desktop_selection(desktop);
SPDocument *doc = sp_desktop_document(desktop);
if (g_slist_length((GSList *) selection->itemList()) < 1) {
sp_desktop_message_stack(desktop)->flash(Inkscape::WARNING_MESSAGE, _("Select <b>object(s)</b> to combine."));
return;
}
desktop->messageStack()->flash(Inkscape::IMMEDIATE_MESSAGE, _("Combining paths..."));
// set "busy" cursor
desktop->setWaitingCursor();
GSList *items = g_slist_copy((GSList *) selection->itemList());
items = sp_degroup_list (items); // descend into any groups in selection
GSList *to_paths = NULL;
for (GSList *i = items; i != NULL; i = i->next) {
SPItem *item = (SPItem *) i->data;
if (!SP_IS_PATH(item) && !SP_IS_GROUP(item))
to_paths = g_slist_prepend(to_paths, item);
}
GSList *converted = NULL;
bool did = sp_item_list_to_curves(to_paths, &items, &converted);
g_slist_free(to_paths);
for (GSList *i = converted; i != NULL; i = i->next)
items = g_slist_prepend(items, doc->getObjectByRepr((Inkscape::XML::Node*)(i->data)));
items = sp_degroup_list (items); // converting to path may have added more groups, descend again
items = g_slist_sort(items, (GCompareFunc) sp_item_repr_compare_position);
items = g_slist_reverse(items);
// remember the position, id, transform and style of the topmost path, they will be assigned to the combined one
gint position = 0;
char const *id = NULL;
char const *transform = NULL;
char const *style = NULL;
char const *path_effect = NULL;
SPCurve* curve = NULL;
SPItem *first = NULL;
Inkscape::XML::Node *parent = NULL;
if (did) {
selection->clear();
}
for (GSList *i = items; i != NULL; i = i->next) { // going from top to bottom
SPItem *item = (SPItem *) i->data;
if (!SP_IS_PATH(item)) {
continue;
}
if (!did) {
selection->clear();
did = true;
}
SPCurve *c = SP_PATH(item)->get_curve_for_edit();
if (first == NULL) { // this is the topmost path
first = item;
parent = first->getRepr()->parent();
position = first->getRepr()->position();
id = first->getRepr()->attribute("id");
transform = first->getRepr()->attribute("transform");
// FIXME: merge styles of combined objects instead of using the first one's style
style = first->getRepr()->attribute("style");
path_effect = first->getRepr()->attribute("inkscape:path-effect");
//c->transform(item->transform);
curve = c;
} else {
c->transform(item->getRelativeTransform(first));
curve->append(c, false);
c->unref();
// reduce position only if the same parent
if (item->getRepr()->parent() == parent) {
position--;
}
// delete the object for real, so that its clones can take appropriate action
item->deleteObject();
}
}
g_slist_free(items);
if (did) {
first->deleteObject(false);
// delete the topmost.
Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
Inkscape::XML::Node *repr = xml_doc->createElement("svg:path");
// restore id, transform, path effect, and style
repr->setAttribute("id", id);
if (transform) {
repr->setAttribute("transform", transform);
}
repr->setAttribute("style", style);
repr->setAttribute("inkscape:path-effect", path_effect);
// set path data corresponding to new curve
gchar *dstring = sp_svg_write_path(curve->get_pathvector());
curve->unref();
if (path_effect) {
repr->setAttribute("inkscape:original-d", dstring);
} else {
repr->setAttribute("d", dstring);
}
g_free(dstring);
// add the new group to the parent of the topmost
parent->appendChild(repr);
// move to the position of the topmost, reduced by the number of deleted items
repr->setPosition(position > 0 ? position : 0);
DocumentUndo::done(sp_desktop_document(desktop), SP_VERB_SELECTION_COMBINE,
_("Combine"));
selection->set(repr);
Inkscape::GC::release(repr);
} else {
sp_desktop_message_stack(desktop)->flash(Inkscape::ERROR_MESSAGE, _("<b>No path(s)</b> to combine in the selection."));
}
desktop->clearWaitingCursor();
}
static bool sp_spray_recursive(SPDesktop *desktop,
Inkscape::Selection *selection,
SPItem *item,
Geom::Point p,
Geom::Point /*vector*/,
gint mode,
double radius,
double /*force*/,
double population,
double &scale,
double scale_variation,
bool /*reverse*/,
double mean,
double standard_deviation,
double ratio,
double tilt,
double rotation_variation,
gint _distrib)
{
bool did = false;
if (SP_IS_BOX3D(item) ) {
// convert 3D boxes to ordinary groups before spraying their shapes
item = box3d_convert_to_group(SP_BOX3D(item));
selection->add(item);
}
double _fid = g_random_double_range(0, 1);
double angle = g_random_double_range( - rotation_variation / 100.0 * M_PI , rotation_variation / 100.0 * M_PI );
double _scale = g_random_double_range( 1.0 - scale_variation / 100.0, 1.0 + scale_variation / 100.0 );
double dr; double dp;
random_position( dr, dp, mean, standard_deviation, _distrib );
dr=dr*radius;
if (mode == SPRAY_MODE_COPY) {
Geom::OptRect a = item->documentVisualBounds();
if (a) {
SPItem *item_copied;
if(_fid <= population)
{
// duplicate
SPDocument *doc = item->document;
Inkscape::XML::Document* xml_doc = doc->getReprDoc();
Inkscape::XML::Node *old_repr = item->getRepr();
Inkscape::XML::Node *parent = old_repr->parent();
Inkscape::XML::Node *copy = old_repr->duplicate(xml_doc);
parent->appendChild(copy);
SPObject *new_obj = doc->getObjectByRepr(copy);
item_copied = (SPItem *) new_obj; //convertion object->item
Geom::Point center=item->getCenter();
sp_spray_scale_rel(center,desktop, item_copied, Geom::Scale(_scale,_scale));
sp_spray_scale_rel(center,desktop, item_copied, Geom::Scale(scale,scale));
sp_spray_rotate_rel(center,desktop,item_copied, Geom::Rotate(angle));
//Move the cursor p
Geom::Point move = (Geom::Point(cos(tilt)*cos(dp)*dr/(1-ratio)+sin(tilt)*sin(dp)*dr/(1+ratio), -sin(tilt)*cos(dp)*dr/(1-ratio)+cos(tilt)*sin(dp)*dr/(1+ratio)))+(p-a->midpoint());
sp_item_move_rel(item_copied, Geom::Translate(move[Geom::X], -move[Geom::Y]));
did = true;
}
}
} else if (mode == SPRAY_MODE_SINGLE_PATH) {
SPItem *father = NULL; //initial Object
SPItem *item_copied = NULL; //Projected Object
SPItem *unionResult = NULL; //previous union
SPItem *son = NULL; //father copy
int i=1;
for (GSList *items = g_slist_copy((GSList *) selection->itemList());
items != NULL;
items = items->next) {
SPItem *item1 = (SPItem *) items->data;
if (i == 1) {
father = item1;
}
if (i == 2) {
unionResult = item1;
}
i++;
}
SPDocument *doc = father->document;
Inkscape::XML::Document* xml_doc = doc->getReprDoc();
Inkscape::XML::Node *old_repr = father->getRepr();
Inkscape::XML::Node *parent = old_repr->parent();
Geom::OptRect a = father->documentVisualBounds();
if (a) {
if (i == 2) {
Inkscape::XML::Node *copy1 = old_repr->duplicate(xml_doc);
parent->appendChild(copy1);
SPObject *new_obj1 = doc->getObjectByRepr(copy1);
son = (SPItem *) new_obj1; // conversion object->item
unionResult = son;
Inkscape::GC::release(copy1);
}
if (_fid <= population) { // Rules the population of objects sprayed
// duplicates the father
Inkscape::XML::Node *copy2 = old_repr->duplicate(xml_doc);
parent->appendChild(copy2);
SPObject *new_obj2 = doc->getObjectByRepr(copy2);
item_copied = (SPItem *) new_obj2;
// Move around the cursor
Geom::Point move = (Geom::Point(cos(tilt)*cos(dp)*dr/(1-ratio)+sin(tilt)*sin(dp)*dr/(1+ratio), -sin(tilt)*cos(dp)*dr/(1-ratio)+cos(tilt)*sin(dp)*dr/(1+ratio)))+(p-a->midpoint());
Geom::Point center=father->getCenter();
sp_spray_scale_rel(center, desktop, item_copied, Geom::Scale(_scale, _scale));
sp_spray_scale_rel(center, desktop, item_copied, Geom::Scale(scale, scale));
sp_spray_rotate_rel(center, desktop, item_copied, Geom::Rotate(angle));
sp_item_move_rel(item_copied, Geom::Translate(move[Geom::X], -move[Geom::Y]));
// union and duplication
selection->clear();
selection->add(item_copied);
selection->add(unionResult);
sp_selected_path_union_skip_undo(selection->desktop());
selection->add(father);
Inkscape::GC::release(copy2);
did = true;
}
}
} else if (mode == SPRAY_MODE_CLONE) {
Geom::OptRect a = item->documentVisualBounds();
if (a) {
if(_fid <= population) {
SPItem *item_copied;
SPDocument *doc = item->document;
Inkscape::XML::Document* xml_doc = doc->getReprDoc();
Inkscape::XML::Node *old_repr = item->getRepr();
Inkscape::XML::Node *parent = old_repr->parent();
// Creation of the clone
Inkscape::XML::Node *clone = xml_doc->createElement("svg:use");
// Ad the clone to the list of the father's sons
parent->appendChild(clone);
// Generates the link between father and son attributes
clone->setAttribute("xlink:href", g_strdup_printf("#%s", old_repr->attribute("id")), false);
SPObject *clone_object = doc->getObjectByRepr(clone);
// conversion object->item
item_copied = (SPItem *) clone_object;
Geom::Point center = item->getCenter();
sp_spray_scale_rel(center, desktop, item_copied, Geom::Scale(_scale, _scale));
sp_spray_scale_rel(center, desktop, item_copied, Geom::Scale(scale, scale));
sp_spray_rotate_rel(center, desktop, item_copied, Geom::Rotate(angle));
Geom::Point move = (Geom::Point(cos(tilt)*cos(dp)*dr/(1-ratio)+sin(tilt)*sin(dp)*dr/(1+ratio), -sin(tilt)*cos(dp)*dr/(1-ratio)+cos(tilt)*sin(dp)*dr/(1+ratio)))+(p-a->midpoint());
sp_item_move_rel(item_copied, Geom::Translate(move[Geom::X], -move[Geom::Y]));
Inkscape::GC::release(clone);
did = true;
}
}
}
return did;
}
