1 #define __SP_USE_C__
3 /*
4 * SVG <use> implementation
5 *
6 * Authors:
7 * Lauris Kaplinski <lauris@kaplinski.com>
8 * bulia byak <buliabyak@users.sf.net>
9 *
10 * Copyright (C) 1999-2005 authors
11 * Copyright (C) 2000-2001 Ximian, Inc.
12 *
13 * Released under GNU GPL, read the file 'COPYING' for more information
14 */
16 #ifdef HAVE_CONFIG_H
17 # include <config.h>
18 #endif
20 #include <cstring>
21 #include <string>
23 #include <libnr/nr-matrix-ops.h>
24 #include <libnr/nr-matrix-fns.h>
25 #include "libnr/nr-matrix-translate-ops.h"
26 #include <glibmm/i18n.h>
27 #include "display/nr-arena-group.h"
28 #include "attributes.h"
29 #include "document.h"
30 #include "sp-object-repr.h"
31 #include "sp-flowregion.h"
32 #include "uri.h"
33 #include "print.h"
34 #include "xml/repr.h"
35 #include "prefs-utils.h"
36 #include "style.h"
37 #include "sp-symbol.h"
38 #include "sp-use.h"
39 #include "sp-use-reference.h"
41 /* fixme: */
43 static void sp_use_class_init(SPUseClass *classname);
44 static void sp_use_init(SPUse *use);
45 static void sp_use_finalize(GObject *obj);
47 static void sp_use_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
48 static void sp_use_release(SPObject *object);
49 static void sp_use_set(SPObject *object, unsigned key, gchar const *value);
50 static Inkscape::XML::Node *sp_use_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags);
51 static void sp_use_update(SPObject *object, SPCtx *ctx, guint flags);
52 static void sp_use_modified(SPObject *object, guint flags);
54 static void sp_use_bbox(SPItem const *item, NRRect *bbox, Geom::Matrix const &transform, unsigned const flags);
55 static void sp_use_snappoints(SPItem const *item, SnapPointsIter p);
56 static void sp_use_print(SPItem *item, SPPrintContext *ctx);
57 static gchar *sp_use_description(SPItem *item);
58 static NRArenaItem *sp_use_show(SPItem *item, NRArena *arena, unsigned key, unsigned flags);
59 static void sp_use_hide(SPItem *item, unsigned key);
61 static void sp_use_href_changed(SPObject *old_ref, SPObject *ref, SPUse *use);
63 static void sp_use_delete_self(SPObject *deleted, SPUse *self);
65 static SPItemClass *parent_class;
67 //void m_print(gchar *say, NR::Matrix m)
68 //{ g_print("%s %g %g %g %g %g %g\n", say, m[0], m[1], m[2], m[3], m[4], m[5]); }
70 GType
71 sp_use_get_type(void)
72 {
73 static GType use_type = 0;
74 if (!use_type) {
75 GTypeInfo use_info = {
76 sizeof(SPUseClass),
77 NULL, /* base_init */
78 NULL, /* base_finalize */
79 (GClassInitFunc) sp_use_class_init,
80 NULL, /* class_finalize */
81 NULL, /* class_data */
82 sizeof(SPUse),
83 16, /* n_preallocs */
84 (GInstanceInitFunc) sp_use_init,
85 NULL, /* value_table */
86 };
87 use_type = g_type_register_static(SP_TYPE_ITEM, "SPUse", &use_info, (GTypeFlags)0);
88 }
89 return use_type;
90 }
92 static void
93 sp_use_class_init(SPUseClass *classname)
94 {
95 GObjectClass *gobject_class = (GObjectClass *) classname;
96 SPObjectClass *sp_object_class = (SPObjectClass *) classname;
97 SPItemClass *item_class = (SPItemClass *) classname;
99 parent_class = (SPItemClass*) g_type_class_ref(SP_TYPE_ITEM);
101 gobject_class->finalize = sp_use_finalize;
103 sp_object_class->build = sp_use_build;
104 sp_object_class->release = sp_use_release;
105 sp_object_class->set = sp_use_set;
106 sp_object_class->write = sp_use_write;
107 sp_object_class->update = sp_use_update;
108 sp_object_class->modified = sp_use_modified;
110 item_class->bbox = sp_use_bbox;
111 item_class->description = sp_use_description;
112 item_class->print = sp_use_print;
113 item_class->show = sp_use_show;
114 item_class->hide = sp_use_hide;
115 item_class->snappoints = sp_use_snappoints;
116 }
118 static void
119 sp_use_init(SPUse *use)
120 {
121 use->x.unset();
122 use->y.unset();
123 use->width.unset(SVGLength::PERCENT, 1.0, 1.0);
124 use->height.unset(SVGLength::PERCENT, 1.0, 1.0);
125 use->href = NULL;
127 new (&use->_delete_connection) sigc::connection();
128 new (&use->_changed_connection) sigc::connection();
130 new (&use->_transformed_connection) sigc::connection();
132 use->ref = new SPUseReference(SP_OBJECT(use));
134 use->_changed_connection = use->ref->changedSignal().connect(sigc::bind(sigc::ptr_fun(sp_use_href_changed), use));
135 }
137 static void
138 sp_use_finalize(GObject *obj)
139 {
140 SPUse *use = (SPUse *) obj;
142 delete use->ref;
144 use->_delete_connection.~connection();
145 use->_changed_connection.~connection();
147 use->_transformed_connection.~connection();
148 }
150 static void
151 sp_use_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
152 {
153 if (((SPObjectClass *) parent_class)->build) {
154 (* ((SPObjectClass *) parent_class)->build)(object, document, repr);
155 }
157 sp_object_read_attr(object, "x");
158 sp_object_read_attr(object, "y");
159 sp_object_read_attr(object, "width");
160 sp_object_read_attr(object, "height");
161 sp_object_read_attr(object, "xlink:href");
163 // We don't need to create child here:
164 // reading xlink:href will attach ref, and that will cause the changed signal to be emitted,
165 // which will call sp_use_href_changed, and that will take care of the child
166 }
168 static void
169 sp_use_release(SPObject *object)
170 {
171 SPUse *use = SP_USE(object);
173 use->child = NULL;
175 use->_delete_connection.disconnect();
176 use->_changed_connection.disconnect();
177 use->_transformed_connection.disconnect();
179 g_free(use->href);
180 use->href = NULL;
182 use->ref->detach();
184 if (((SPObjectClass *) parent_class)->release) {
185 ((SPObjectClass *) parent_class)->release(object);
186 }
187 }
189 static void
190 sp_use_set(SPObject *object, unsigned key, gchar const *value)
191 {
192 SPUse *use = SP_USE(object);
194 switch (key) {
195 case SP_ATTR_X:
196 use->x.readOrUnset(value);
197 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
198 break;
199 case SP_ATTR_Y:
200 use->y.readOrUnset(value);
201 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
202 break;
203 case SP_ATTR_WIDTH:
204 use->width.readOrUnset(value, SVGLength::PERCENT, 1.0, 1.0);
205 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
206 break;
207 case SP_ATTR_HEIGHT:
208 use->height.readOrUnset(value, SVGLength::PERCENT, 1.0, 1.0);
209 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
210 break;
212 case SP_ATTR_XLINK_HREF: {
213 if ( value && use->href && ( strcmp(value, use->href) == 0 ) ) {
214 /* No change, do nothing. */
215 } else {
216 g_free(use->href);
217 use->href = NULL;
218 if (value) {
219 // First, set the href field, because sp_use_href_changed will need it.
220 use->href = g_strdup(value);
222 // Now do the attaching, which emits the changed signal.
223 try {
224 use->ref->attach(Inkscape::URI(value));
225 } catch (Inkscape::BadURIException &e) {
226 g_warning("%s", e.what());
227 use->ref->detach();
228 }
229 } else {
230 use->ref->detach();
231 }
232 }
233 break;
234 }
236 default:
237 if (((SPObjectClass *) parent_class)->set) {
238 ((SPObjectClass *) parent_class)->set(object, key, value);
239 }
240 break;
241 }
242 }
244 static Inkscape::XML::Node *
245 sp_use_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
246 {
247 SPUse *use = SP_USE(object);
249 if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
250 repr = xml_doc->createElement("svg:use");
251 }
253 if (((SPObjectClass *) (parent_class))->write) {
254 ((SPObjectClass *) (parent_class))->write(object, xml_doc, repr, flags);
255 }
257 sp_repr_set_svg_double(repr, "x", use->x.computed);
258 sp_repr_set_svg_double(repr, "y", use->y.computed);
259 sp_repr_set_svg_double(repr, "width", use->width.computed);
260 sp_repr_set_svg_double(repr, "height", use->height.computed);
262 if (use->ref->getURI()) {
263 gchar *uri_string = use->ref->getURI()->toString();
264 repr->setAttribute("xlink:href", uri_string);
265 g_free(uri_string);
266 }
268 return repr;
269 }
271 static void
272 sp_use_bbox(SPItem const *item, NRRect *bbox, Geom::Matrix const &transform, unsigned const flags)
273 {
274 SPUse const *use = SP_USE(item);
276 if (use->child && SP_IS_ITEM(use->child)) {
277 SPItem *child = SP_ITEM(use->child);
278 Geom::Matrix const ct( child->transform
279 * Geom::Translate(use->x.computed,
280 use->y.computed)
281 * transform );
282 sp_item_invoke_bbox_full(child, bbox, ct, flags, FALSE);
283 }
284 }
286 static void
287 sp_use_print(SPItem *item, SPPrintContext *ctx)
288 {
289 bool translated = false;
290 SPUse *use = SP_USE(item);
292 if ((use->x._set && use->x.computed != 0) || (use->y._set && use->y.computed != 0)) {
293 NR::Matrix tp(NR::translate(use->x.computed, use->y.computed));
294 sp_print_bind(ctx, tp, 1.0);
295 translated = true;
296 }
298 if (use->child && SP_IS_ITEM(use->child)) {
299 sp_item_invoke_print(SP_ITEM(use->child), ctx);
300 }
302 if (translated) {
303 sp_print_release(ctx);
304 }
305 }
307 static gchar *
308 sp_use_description(SPItem *item)
309 {
310 SPUse *use = SP_USE(item);
312 char *ret;
313 if (use->child) {
314 static unsigned recursion_depth = 0;
315 if (recursion_depth >= 4) {
316 /* TRANSLATORS: Used for statusbar description for long <use> chains:
317 * "Clone of: Clone of: ... in Layer 1". */
318 return g_strdup(_("..."));
319 /* We could do better, e.g. chasing the href chain until we reach something other than
320 * a <use>, and giving its description. */
321 }
322 ++recursion_depth;
323 char *child_desc = sp_item_description(SP_ITEM(use->child));
324 --recursion_depth;
326 ret = g_strdup_printf(_("<b>Clone</b> of: %s"), child_desc);
327 g_free(child_desc);
328 return ret;
329 } else {
330 return g_strdup(_("<b>Orphaned clone</b>"));
331 }
332 }
334 static NRArenaItem *
335 sp_use_show(SPItem *item, NRArena *arena, unsigned key, unsigned flags)
336 {
337 SPUse *use = SP_USE(item);
339 NRArenaItem *ai = NRArenaGroup::create(arena);
340 nr_arena_group_set_transparent(NR_ARENA_GROUP(ai), FALSE);
341 nr_arena_group_set_style(NR_ARENA_GROUP(ai), SP_OBJECT_STYLE(item));
343 if (use->child) {
344 NRArenaItem *ac = sp_item_invoke_show(SP_ITEM(use->child), arena, key, flags);
345 if (ac) {
346 nr_arena_item_add_child(ai, ac, NULL);
347 }
348 NR::translate t(use->x.computed,
349 use->y.computed);
350 nr_arena_group_set_child_transform(NR_ARENA_GROUP(ai), NR::Matrix(t));
351 }
353 return ai;
354 }
356 static void
357 sp_use_hide(SPItem *item, unsigned key)
358 {
359 SPUse *use = SP_USE(item);
361 if (use->child) {
362 sp_item_invoke_hide(SP_ITEM(use->child), key);
363 }
365 if (((SPItemClass *) parent_class)->hide) {
366 ((SPItemClass *) parent_class)->hide(item, key);
367 }
368 }
370 /**
371 * Returns the ultimate original of a SPUse (i.e. the first object in the chain of its originals
372 * which is not an SPUse). If no original is found, NULL is returned (it is the responsibility
373 * of the caller to make sure that this is handled correctly).
374 *
375 * Note that the returned is the clone object, i.e. the child of an SPUse (of the argument one for
376 * the trivial case) and not the "true original".
377 */
378 SPItem *
379 sp_use_root(SPUse *use)
380 {
381 SPObject *orig = use->child;
382 while (SP_IS_USE(orig)) {
383 orig = SP_USE(orig)->child;
384 }
385 g_return_val_if_fail(SP_IS_ITEM(orig), NULL);
386 return SP_ITEM(orig);
387 }
389 /**
390 * Returns the effective transform that goes from the ultimate original to given SPUse, both ends
391 * included.
392 */
393 NR::Matrix
394 sp_use_get_root_transform(SPUse *use)
395 {
396 //track the ultimate source of a chain of uses
397 SPObject *orig = use->child;
398 GSList *chain = NULL;
399 chain = g_slist_prepend(chain, use);
400 while (SP_IS_USE(orig)) {
401 chain = g_slist_prepend(chain, orig);
402 orig = SP_USE(orig)->child;
403 }
404 chain = g_slist_prepend(chain, orig);
407 //calculate the accummulated transform, starting from the original
408 NR::Matrix t(NR::identity());
409 for (GSList *i = chain; i != NULL; i = i->next) {
410 SPItem *i_tem = SP_ITEM(i->data);
412 // "An additional transformation translate(x,y) is appended to the end (i.e.,
413 // right-side) of the transform attribute on the generated 'g', where x and y
414 // represent the values of the x and y attributes on the 'use' element." - http://www.w3.org/TR/SVG11/struct.html#UseElement
415 if (SP_IS_USE(i_tem)) {
416 SPUse *i_use = SP_USE(i_tem);
417 if ((i_use->x._set && i_use->x.computed != 0) || (i_use->y._set && i_use->y.computed != 0)) {
418 t = t * NR::translate(i_use->x._set ? i_use->x.computed : 0, i_use->y._set ? i_use->y.computed : 0);
419 }
420 }
422 t *= i_tem->transform;
423 }
425 g_slist_free(chain);
426 return t;
427 }
429 /**
430 * Returns the transform that leads to the use from its immediate original.
431 * Does not inlcude the original's transform if any.
432 */
433 NR::Matrix
434 sp_use_get_parent_transform(SPUse *use)
435 {
436 NR::Matrix t(NR::identity());
437 if ((use->x._set && use->x.computed != 0) || (use->y._set && use->y.computed != 0)) {
438 t *= NR::translate(use->x._set ? use->x.computed : 0,
439 use->y._set ? use->y.computed : 0);
440 }
442 t *= SP_ITEM(use)->transform;
443 return t;
444 }
446 /**
447 * Sensing a movement of the original, this function attempts to compensate for it in such a way
448 * that the clone stays unmoved or moves in parallel (depending on user setting) regardless of the
449 * clone's transform.
450 */
451 static void
452 sp_use_move_compensate(NR::Matrix const *mp, SPItem */*original*/, SPUse *self)
453 {
454 // the clone is orphaned; or this is not a real use, but a clone of another use;
455 // we skip it, otherwise duplicate compensation will occur
456 if (SP_OBJECT_IS_CLONED(self)) {
457 return;
458 }
460 // never compensate uses which are used in flowtext
461 if (SP_OBJECT_PARENT(self) && SP_IS_FLOWREGION(SP_OBJECT_PARENT(self))) {
462 return;
463 }
465 guint mode = prefs_get_int_attribute("options.clonecompensation", "value", SP_CLONE_COMPENSATION_PARALLEL);
466 // user wants no compensation
467 if (mode == SP_CLONE_COMPENSATION_NONE)
468 return;
470 NR::Matrix m(*mp);
472 // this is not a simple move, do not try to compensate
473 if (!(m.is_translation()))
474 return;
476 // restore item->transform field from the repr, in case it was changed by seltrans
477 sp_object_read_attr (SP_OBJECT (self), "transform");
479 NR::Matrix t = sp_use_get_parent_transform(self);
480 NR::Matrix clone_move = t.inverse() * m * t;
482 // calculate the compensation matrix and the advertized movement matrix
483 NR::Matrix advertized_move;
484 if (mode == SP_CLONE_COMPENSATION_PARALLEL) {
485 clone_move = clone_move.inverse() * m;
486 advertized_move = m;
487 } else if (mode == SP_CLONE_COMPENSATION_UNMOVED) {
488 clone_move = clone_move.inverse();
489 advertized_move.set_identity();
490 } else {
491 g_assert_not_reached();
492 }
494 // commit the compensation
495 SPItem *item = SP_ITEM(self);
496 item->transform *= clone_move;
497 sp_item_write_transform(item, SP_OBJECT_REPR(item), item->transform, &advertized_move);
498 SP_OBJECT(item)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
499 }
501 static void
502 sp_use_href_changed(SPObject */*old_ref*/, SPObject */*ref*/, SPUse *use)
503 {
504 SPItem *item = SP_ITEM(use);
506 use->_delete_connection.disconnect();
507 use->_transformed_connection.disconnect();
509 if (use->child) {
510 sp_object_detach(SP_OBJECT(use), use->child);
511 use->child = NULL;
512 }
514 if (use->href) {
515 SPItem *refobj = use->ref->getObject();
516 if (refobj) {
517 Inkscape::XML::Node *childrepr = SP_OBJECT_REPR(refobj);
518 GType type = sp_repr_type_lookup(childrepr);
519 g_return_if_fail(type > G_TYPE_NONE);
520 if (g_type_is_a(type, SP_TYPE_ITEM)) {
521 use->child = (SPObject*) g_object_new(type, 0);
522 sp_object_attach(SP_OBJECT(use), use->child, use->lastChild());
523 sp_object_unref(use->child, SP_OBJECT(use));
524 sp_object_invoke_build(use->child, SP_OBJECT(use)->document, childrepr, TRUE);
526 for (SPItemView *v = item->display; v != NULL; v = v->next) {
527 NRArenaItem *ai;
528 ai = sp_item_invoke_show(SP_ITEM(use->child), NR_ARENA_ITEM_ARENA(v->arenaitem), v->key, v->flags);
529 if (ai) {
530 nr_arena_item_add_child(v->arenaitem, ai, NULL);
531 }
532 }
534 }
535 use->_delete_connection = SP_OBJECT(refobj)->connectDelete(sigc::bind(sigc::ptr_fun(&sp_use_delete_self), use));
536 use->_transformed_connection = SP_ITEM(refobj)->connectTransformed(sigc::bind(sigc::ptr_fun(&sp_use_move_compensate), use));
537 }
538 }
539 }
541 static void
542 sp_use_delete_self(SPObject */*deleted*/, SPUse *self)
543 {
544 // always delete uses which are used in flowtext
545 if (SP_OBJECT_PARENT(self) && SP_IS_FLOWREGION(SP_OBJECT_PARENT(self))) {
546 SP_OBJECT(self)->deleteObject();
547 return;
548 }
550 guint const mode = prefs_get_int_attribute("options.cloneorphans", "value",
551 SP_CLONE_ORPHANS_UNLINK);
553 if (mode == SP_CLONE_ORPHANS_UNLINK) {
554 sp_use_unlink(self);
555 } else if (mode == SP_CLONE_ORPHANS_DELETE) {
556 SP_OBJECT(self)->deleteObject();
557 }
558 }
560 static void
561 sp_use_update(SPObject *object, SPCtx *ctx, unsigned flags)
562 {
563 SPItem *item = SP_ITEM(object);
564 SPUse *use = SP_USE(object);
565 SPItemCtx *ictx = (SPItemCtx *) ctx;
566 SPItemCtx cctx = *ictx;
568 if (((SPObjectClass *) (parent_class))->update)
569 ((SPObjectClass *) (parent_class))->update(object, ctx, flags);
571 if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
572 flags &= SP_OBJECT_MODIFIED_CASCADE;
574 if (flags & SP_OBJECT_STYLE_MODIFIED_FLAG) {
575 for (SPItemView *v = SP_ITEM(object)->display; v != NULL; v = v->next) {
576 nr_arena_group_set_style(NR_ARENA_GROUP(v->arenaitem), SP_OBJECT_STYLE(object));
577 }
578 }
580 /* Set up child viewport */
581 if (use->x.unit == SVGLength::PERCENT) {
582 use->x.computed = use->x.value * (ictx->vp.x1 - ictx->vp.x0);
583 }
584 if (use->y.unit == SVGLength::PERCENT) {
585 use->y.computed = use->y.value * (ictx->vp.y1 - ictx->vp.y0);
586 }
587 if (use->width.unit == SVGLength::PERCENT) {
588 use->width.computed = use->width.value * (ictx->vp.x1 - ictx->vp.x0);
589 }
590 if (use->height.unit == SVGLength::PERCENT) {
591 use->height.computed = use->height.value * (ictx->vp.y1 - ictx->vp.y0);
592 }
593 cctx.vp.x0 = 0.0;
594 cctx.vp.y0 = 0.0;
595 cctx.vp.x1 = use->width.computed;
596 cctx.vp.y1 = use->height.computed;
597 cctx.i2vp = NR::identity();
598 flags&=~SP_OBJECT_USER_MODIFIED_FLAG_B;
600 if (use->child) {
601 g_object_ref(G_OBJECT(use->child));
602 if (flags || (use->child->uflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
603 if (SP_IS_ITEM(use->child)) {
604 SPItem const &chi = *SP_ITEM(use->child);
605 cctx.i2doc = chi.transform * ictx->i2doc;
606 cctx.i2vp = chi.transform * ictx->i2vp;
607 use->child->updateDisplay((SPCtx *)&cctx, flags);
608 } else {
609 use->child->updateDisplay(ctx, flags);
610 }
611 }
612 g_object_unref(G_OBJECT(use->child));
613 }
615 /* As last step set additional transform of arena group */
616 for (SPItemView *v = item->display; v != NULL; v = v->next) {
617 NR::Matrix t(NR::translate(use->x.computed, use->y.computed));
618 nr_arena_group_set_child_transform(NR_ARENA_GROUP(v->arenaitem), t);
619 }
620 }
622 static void
623 sp_use_modified(SPObject *object, guint flags)
624 {
625 SPUse *use_obj = SP_USE(object);
627 if (flags & SP_OBJECT_MODIFIED_FLAG) {
628 flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
629 }
630 flags &= SP_OBJECT_MODIFIED_CASCADE;
632 if (flags & SP_OBJECT_STYLE_MODIFIED_FLAG) {
633 for (SPItemView *v = SP_ITEM(object)->display; v != NULL; v = v->next) {
634 nr_arena_group_set_style(NR_ARENA_GROUP(v->arenaitem), SP_OBJECT_STYLE(object));
635 }
636 }
638 SPObject *child = use_obj->child;
639 if (child) {
640 g_object_ref(G_OBJECT(child));
641 if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
642 child->emitModified(flags);
643 }
644 g_object_unref(G_OBJECT(child));
645 }
646 }
648 SPItem *
649 sp_use_unlink(SPUse *use)
650 {
651 if (!use) return NULL;
653 Inkscape::XML::Node *repr = SP_OBJECT_REPR(use);
654 if (!repr) return NULL;
656 Inkscape::XML::Node *parent = sp_repr_parent(repr);
657 SPDocument *document = SP_OBJECT(use)->document;
658 Inkscape::XML::Document *xml_doc = sp_document_repr_doc(document);
660 // Track the ultimate source of a chain of uses.
661 SPItem *orig = sp_use_root(use);
662 g_return_val_if_fail(orig, NULL);
664 // Calculate the accumulated transform, starting from the original.
665 NR::Matrix t = sp_use_get_root_transform(use);
667 Inkscape::XML::Node *copy = NULL;
668 if (SP_IS_SYMBOL(orig)) { // make a group, copy children
669 copy = xml_doc->createElement("svg:g");
670 for (Inkscape::XML::Node *child = SP_OBJECT_REPR(orig)->firstChild() ; child != NULL; child = child->next()) {
671 Inkscape::XML::Node *newchild = child->duplicate(xml_doc);
672 copy->appendChild(newchild);
673 }
674 } else { // just copy
675 copy = SP_OBJECT_REPR(orig)->duplicate(xml_doc);
676 }
678 // Add the duplicate repr just after the existing one.
679 parent->addChild(copy, repr);
681 // Retrieve the SPItem of the resulting repr.
682 SPObject *unlinked = document->getObjectByRepr(copy);
684 // Merge style from the use.
685 SPStyle *unli_sty = SP_OBJECT_STYLE(unlinked);
686 SPStyle const *use_sty = SP_OBJECT_STYLE(use);
687 sp_style_merge_from_dying_parent(unli_sty, use_sty);
688 sp_style_merge_from_parent(unli_sty, unlinked->parent->style);
690 SP_OBJECT(unlinked)->updateRepr();
692 // Hold onto our SPObject and repr for now.
693 sp_object_ref(SP_OBJECT(use), NULL);
694 Inkscape::GC::anchor(repr);
696 // Remove ourselves, not propagating delete events to avoid a
697 // chain-reaction with other elements that might reference us.
698 SP_OBJECT(use)->deleteObject(false);
700 // Give the copy our old id and let go of our old repr.
701 copy->setAttribute("id", repr->attribute("id"));
702 Inkscape::GC::release(repr);
704 // Remove tiled clone attrs.
705 copy->setAttribute("inkscape:tiled-clone-of", NULL);
706 copy->setAttribute("inkscape:tile-w", NULL);
707 copy->setAttribute("inkscape:tile-h", NULL);
708 copy->setAttribute("inkscape:tile-cx", NULL);
709 copy->setAttribute("inkscape:tile-cy", NULL);
711 // Establish the succession and let go of our object.
712 SP_OBJECT(use)->setSuccessor(unlinked);
713 sp_object_unref(SP_OBJECT(use), NULL);
715 SPItem *item = SP_ITEM(unlinked);
716 // Set the accummulated transform.
717 {
718 NR::Matrix nomove(NR::identity());
719 // Advertise ourselves as not moving.
720 sp_item_write_transform(item, SP_OBJECT_REPR(item), t, &nomove);
721 }
722 return item;
723 }
725 SPItem *
726 sp_use_get_original(SPUse *use)
727 {
728 SPItem *ref = use->ref->getObject();
729 return ref;
730 }
732 static void
733 sp_use_snappoints(SPItem const *item, SnapPointsIter p)
734 {
735 g_assert (item != NULL);
736 g_assert (SP_IS_ITEM(item));
737 g_assert (SP_IS_USE(item));
739 SPUse *use = SP_USE(item);
740 SPItem *root = sp_use_root(use);
741 g_return_if_fail(root);
743 SPItemClass const &item_class = *(SPItemClass const *) G_OBJECT_GET_CLASS(root);
744 if (item_class.snappoints) {
745 item_class.snappoints(root, p);
746 }
747 }
750 /*
751 Local Variables:
752 mode:c++
753 c-file-style:"stroustrup"
754 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
755 indent-tabs-mode:nil
756 fill-column:99
757 End:
758 */
759 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :