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();
}
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."));
}
}
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
Effect::merge_menu (Inkscape::XML::Node * base,
Inkscape::XML::Node * start,
Inkscape::XML::Node * patern,
Inkscape::XML::Node * mergee) {
Glib::ustring mergename;
Inkscape::XML::Node * tomerge = NULL;
Inkscape::XML::Node * submenu = NULL;
/* printf("Merge menu with '%s' '%s' '%s'\n",
base != NULL ? base->name() : "NULL",
patern != NULL ? patern->name() : "NULL",
mergee != NULL ? mergee->name() : "NULL"); */
if (patern == NULL) {
// Merge the verb name
tomerge = mergee;
mergename = _(this->get_name());
} else {
gchar const * menuname = patern->attribute("name");
if (menuname == NULL) menuname = patern->attribute("_name");
if (menuname == NULL) return;
Inkscape::XML::Document *xml_doc;
xml_doc = base->document();
tomerge = xml_doc->createElement("submenu");
tomerge->setAttribute("name", menuname, false);
mergename = _(menuname);
}
int position = -1;
if (start != NULL) {
Inkscape::XML::Node * menupass;
for (menupass = start; menupass != NULL && strcmp(menupass->name(), "separator"); menupass = menupass->next()) {
gchar const * compare_char = NULL;
if (!strcmp(menupass->name(), "verb")) {
gchar const * verbid = menupass->attribute("verb-id");
Inkscape::Verb * verb = Inkscape::Verb::getbyid(verbid);
if (verb == NULL) {
g_warning("Unable to find verb '%s' which is referred to in the menus.", verbid);
continue;
}
compare_char = verb->get_name();
} else if (!strcmp(menupass->name(), "submenu")) {
compare_char = menupass->attribute("name");
if (compare_char == NULL)
compare_char = menupass->attribute("_name");
}
position = menupass->position() + 1;
/* This will cause us to skip tags we don't understand */
if (compare_char == NULL) {
continue;
}
Glib::ustring compare(_(compare_char));
if (mergename == compare) {
Inkscape::GC::release(tomerge);
tomerge = NULL;
submenu = menupass;
break;
}
if (mergename < compare) {
position = menupass->position();
break;
}
} // for menu items
} // start != NULL
if (tomerge != NULL) {
base->appendChild(tomerge);
Inkscape::GC::release(tomerge);
if (position != -1)
tomerge->setPosition(position);
}
if (patern != NULL) {
if (submenu == NULL)
submenu = tomerge;
merge_menu(submenu, submenu->firstChild(), patern->firstChild(), mergee);
}
return;
}
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;
}
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_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"));
}
}