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, NR::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, NR::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 NR::Matrix const ct( child->transform
279 * NR::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 nr_arena_item_unref(ac);
348 }
349 NR::translate t(use->x.computed,
350 use->y.computed);
351 nr_arena_group_set_child_transform(NR_ARENA_GROUP(ai), NR::Matrix(t));
352 }
354 return ai;
355 }
357 static void
358 sp_use_hide(SPItem *item, unsigned key)
359 {
360 SPUse *use = SP_USE(item);
362 if (use->child) {
363 sp_item_invoke_hide(SP_ITEM(use->child), key);
364 }
366 if (((SPItemClass *) parent_class)->hide) {
367 ((SPItemClass *) parent_class)->hide(item, key);
368 }
369 }
371 /**
372 * Returns the ultimate original of a SPUse (i.e. the first object in the chain of its originals
373 * which is not an SPUse). If no original is found, NULL is returned (it is the responsibility
374 * of the caller to make sure that this is handled correctly).
375 *
376 * Note that the returned is the clone object, i.e. the child of an SPUse (of the argument one for
377 * the trivial case) and not the "true original".
378 */
379 SPItem *
380 sp_use_root(SPUse *use)
381 {
382 SPObject *orig = use->child;
383 while (SP_IS_USE(orig)) {
384 orig = SP_USE(orig)->child;
385 }
386 g_return_val_if_fail(SP_IS_ITEM(orig), NULL);
387 return SP_ITEM(orig);
388 }
390 /**
391 * Returns the effective transform that goes from the ultimate original to given SPUse, both ends
392 * included.
393 */
394 NR::Matrix
395 sp_use_get_root_transform(SPUse *use)
396 {
397 //track the ultimate source of a chain of uses
398 SPObject *orig = use->child;
399 GSList *chain = NULL;
400 chain = g_slist_prepend(chain, use);
401 while (SP_IS_USE(orig)) {
402 chain = g_slist_prepend(chain, orig);
403 orig = SP_USE(orig)->child;
404 }
405 chain = g_slist_prepend(chain, orig);
408 //calculate the accummulated transform, starting from the original
409 NR::Matrix t(NR::identity());
410 for (GSList *i = chain; i != NULL; i = i->next) {
411 SPItem *i_tem = SP_ITEM(i->data);
413 // "An additional transformation translate(x,y) is appended to the end (i.e.,
414 // right-side) of the transform attribute on the generated 'g', where x and y
415 // represent the values of the x and y attributes on the 'use' element." - http://www.w3.org/TR/SVG11/struct.html#UseElement
416 if (SP_IS_USE(i_tem)) {
417 SPUse *i_use = SP_USE(i_tem);
418 if ((i_use->x._set && i_use->x.computed != 0) || (i_use->y._set && i_use->y.computed != 0)) {
419 t = t * NR::translate(i_use->x._set ? i_use->x.computed : 0, i_use->y._set ? i_use->y.computed : 0);
420 }
421 }
423 t *= i_tem->transform;
424 }
426 g_slist_free(chain);
427 return t;
428 }
430 /**
431 * Returns the transform that leads to the use from its immediate original.
432 * Does not inlcude the original's transform if any.
433 */
434 NR::Matrix
435 sp_use_get_parent_transform(SPUse *use)
436 {
437 NR::Matrix t(NR::identity());
438 if ((use->x._set && use->x.computed != 0) || (use->y._set && use->y.computed != 0)) {
439 t *= NR::translate(use->x._set ? use->x.computed : 0,
440 use->y._set ? use->y.computed : 0);
441 }
443 t *= SP_ITEM(use)->transform;
444 return t;
445 }
447 /**
448 * Sensing a movement of the original, this function attempts to compensate for it in such a way
449 * that the clone stays unmoved or moves in parallel (depending on user setting) regardless of the
450 * clone's transform.
451 */
452 static void
453 sp_use_move_compensate(NR::Matrix const *mp, SPItem */*original*/, SPUse *self)
454 {
455 // the clone is orphaned; or this is not a real use, but a clone of another use;
456 // we skip it, otherwise duplicate compensation will occur
457 if (SP_OBJECT_IS_CLONED(self)) {
458 return;
459 }
461 // never compensate uses which are used in flowtext
462 if (SP_OBJECT_PARENT(self) && SP_IS_FLOWREGION(SP_OBJECT_PARENT(self))) {
463 return;
464 }
466 guint mode = prefs_get_int_attribute("options.clonecompensation", "value", SP_CLONE_COMPENSATION_PARALLEL);
467 // user wants no compensation
468 if (mode == SP_CLONE_COMPENSATION_NONE)
469 return;
471 NR::Matrix m(*mp);
473 // this is not a simple move, do not try to compensate
474 if (!(m.is_translation()))
475 return;
477 // restore item->transform field from the repr, in case it was changed by seltrans
478 sp_object_read_attr (SP_OBJECT (self), "transform");
480 NR::Matrix t = sp_use_get_parent_transform(self);
481 NR::Matrix clone_move = t.inverse() * m * t;
483 // calculate the compensation matrix and the advertized movement matrix
484 NR::Matrix advertized_move;
485 if (mode == SP_CLONE_COMPENSATION_PARALLEL) {
486 clone_move = clone_move.inverse() * m;
487 advertized_move = m;
488 } else if (mode == SP_CLONE_COMPENSATION_UNMOVED) {
489 clone_move = clone_move.inverse();
490 advertized_move.set_identity();
491 } else {
492 g_assert_not_reached();
493 }
495 // commit the compensation
496 SPItem *item = SP_ITEM(self);
497 item->transform *= clone_move;
498 sp_item_write_transform(item, SP_OBJECT_REPR(item), item->transform, &advertized_move);
499 SP_OBJECT(item)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
500 }
502 static void
503 sp_use_href_changed(SPObject */*old_ref*/, SPObject */*ref*/, SPUse *use)
504 {
505 SPItem *item = SP_ITEM(use);
507 use->_delete_connection.disconnect();
508 use->_transformed_connection.disconnect();
510 if (use->child) {
511 sp_object_detach(SP_OBJECT(use), use->child);
512 use->child = NULL;
513 }
515 if (use->href) {
516 SPItem *refobj = use->ref->getObject();
517 if (refobj) {
518 Inkscape::XML::Node *childrepr = SP_OBJECT_REPR(refobj);
519 GType type = sp_repr_type_lookup(childrepr);
520 g_return_if_fail(type > G_TYPE_NONE);
521 if (g_type_is_a(type, SP_TYPE_ITEM)) {
522 use->child = (SPObject*) g_object_new(type, 0);
523 sp_object_attach(SP_OBJECT(use), use->child, use->lastChild());
524 sp_object_unref(use->child, SP_OBJECT(use));
525 sp_object_invoke_build(use->child, SP_OBJECT(use)->document, childrepr, TRUE);
527 for (SPItemView *v = item->display; v != NULL; v = v->next) {
528 NRArenaItem *ai;
529 ai = sp_item_invoke_show(SP_ITEM(use->child), NR_ARENA_ITEM_ARENA(v->arenaitem), v->key, v->flags);
530 if (ai) {
531 nr_arena_item_add_child(v->arenaitem, ai, NULL);
532 nr_arena_item_unref(ai);
533 }
534 }
536 }
537 use->_delete_connection = SP_OBJECT(refobj)->connectDelete(sigc::bind(sigc::ptr_fun(&sp_use_delete_self), use));
538 use->_transformed_connection = SP_ITEM(refobj)->connectTransformed(sigc::bind(sigc::ptr_fun(&sp_use_move_compensate), use));
539 }
540 }
541 }
543 static void
544 sp_use_delete_self(SPObject */*deleted*/, SPUse *self)
545 {
546 // always delete uses which are used in flowtext
547 if (SP_OBJECT_PARENT(self) && SP_IS_FLOWREGION(SP_OBJECT_PARENT(self))) {
548 SP_OBJECT(self)->deleteObject();
549 return;
550 }
552 guint const mode = prefs_get_int_attribute("options.cloneorphans", "value",
553 SP_CLONE_ORPHANS_UNLINK);
555 if (mode == SP_CLONE_ORPHANS_UNLINK) {
556 sp_use_unlink(self);
557 } else if (mode == SP_CLONE_ORPHANS_DELETE) {
558 SP_OBJECT(self)->deleteObject();
559 }
560 }
562 static void
563 sp_use_update(SPObject *object, SPCtx *ctx, unsigned flags)
564 {
565 SPItem *item = SP_ITEM(object);
566 SPUse *use = SP_USE(object);
567 SPItemCtx *ictx = (SPItemCtx *) ctx;
568 SPItemCtx cctx = *ictx;
570 if (((SPObjectClass *) (parent_class))->update)
571 ((SPObjectClass *) (parent_class))->update(object, ctx, flags);
573 if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
574 flags &= SP_OBJECT_MODIFIED_CASCADE;
576 if (flags & SP_OBJECT_STYLE_MODIFIED_FLAG) {
577 for (SPItemView *v = SP_ITEM(object)->display; v != NULL; v = v->next) {
578 nr_arena_group_set_style(NR_ARENA_GROUP(v->arenaitem), SP_OBJECT_STYLE(object));
579 }
580 }
582 /* Set up child viewport */
583 if (use->x.unit == SVGLength::PERCENT) {
584 use->x.computed = use->x.value * (ictx->vp.x1 - ictx->vp.x0);
585 }
586 if (use->y.unit == SVGLength::PERCENT) {
587 use->y.computed = use->y.value * (ictx->vp.y1 - ictx->vp.y0);
588 }
589 if (use->width.unit == SVGLength::PERCENT) {
590 use->width.computed = use->width.value * (ictx->vp.x1 - ictx->vp.x0);
591 }
592 if (use->height.unit == SVGLength::PERCENT) {
593 use->height.computed = use->height.value * (ictx->vp.y1 - ictx->vp.y0);
594 }
595 cctx.vp.x0 = 0.0;
596 cctx.vp.y0 = 0.0;
597 cctx.vp.x1 = use->width.computed;
598 cctx.vp.y1 = use->height.computed;
599 cctx.i2vp = NR::identity();
600 flags&=~SP_OBJECT_USER_MODIFIED_FLAG_B;
602 if (use->child) {
603 g_object_ref(G_OBJECT(use->child));
604 if (flags || (use->child->uflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
605 if (SP_IS_ITEM(use->child)) {
606 SPItem const &chi = *SP_ITEM(use->child);
607 cctx.i2doc = chi.transform * ictx->i2doc;
608 cctx.i2vp = chi.transform * ictx->i2vp;
609 use->child->updateDisplay((SPCtx *)&cctx, flags);
610 } else {
611 use->child->updateDisplay(ctx, flags);
612 }
613 }
614 g_object_unref(G_OBJECT(use->child));
615 }
617 /* As last step set additional transform of arena group */
618 for (SPItemView *v = item->display; v != NULL; v = v->next) {
619 NR::Matrix t(NR::translate(use->x.computed, use->y.computed));
620 nr_arena_group_set_child_transform(NR_ARENA_GROUP(v->arenaitem), t);
621 }
622 }
624 static void
625 sp_use_modified(SPObject *object, guint flags)
626 {
627 SPUse *use_obj = SP_USE(object);
629 if (flags & SP_OBJECT_MODIFIED_FLAG) {
630 flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
631 }
632 flags &= SP_OBJECT_MODIFIED_CASCADE;
634 if (flags & SP_OBJECT_STYLE_MODIFIED_FLAG) {
635 for (SPItemView *v = SP_ITEM(object)->display; v != NULL; v = v->next) {
636 nr_arena_group_set_style(NR_ARENA_GROUP(v->arenaitem), SP_OBJECT_STYLE(object));
637 }
638 }
640 SPObject *child = use_obj->child;
641 if (child) {
642 g_object_ref(G_OBJECT(child));
643 if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
644 child->emitModified(flags);
645 }
646 g_object_unref(G_OBJECT(child));
647 }
648 }
650 SPItem *
651 sp_use_unlink(SPUse *use)
652 {
653 if (!use) return NULL;
655 Inkscape::XML::Node *repr = SP_OBJECT_REPR(use);
656 if (!repr) return NULL;
658 Inkscape::XML::Node *parent = sp_repr_parent(repr);
659 SPDocument *document = SP_OBJECT(use)->document;
660 Inkscape::XML::Document *xml_doc = sp_document_repr_doc(document);
662 // Track the ultimate source of a chain of uses.
663 SPItem *orig = sp_use_root(use);
664 g_return_val_if_fail(orig, NULL);
666 // Calculate the accumulated transform, starting from the original.
667 NR::Matrix t = sp_use_get_root_transform(use);
669 Inkscape::XML::Node *copy = NULL;
670 if (SP_IS_SYMBOL(orig)) { // make a group, copy children
671 copy = xml_doc->createElement("svg:g");
672 for (Inkscape::XML::Node *child = SP_OBJECT_REPR(orig)->firstChild() ; child != NULL; child = child->next()) {
673 Inkscape::XML::Node *newchild = child->duplicate(xml_doc);
674 copy->appendChild(newchild);
675 }
676 } else { // just copy
677 copy = SP_OBJECT_REPR(orig)->duplicate(xml_doc);
678 }
680 // Add the duplicate repr just after the existing one.
681 parent->addChild(copy, repr);
683 // Retrieve the SPItem of the resulting repr.
684 SPObject *unlinked = document->getObjectByRepr(copy);
686 // Merge style from the use.
687 SPStyle *unli_sty = SP_OBJECT_STYLE(unlinked);
688 SPStyle const *use_sty = SP_OBJECT_STYLE(use);
689 sp_style_merge_from_dying_parent(unli_sty, use_sty);
690 sp_style_merge_from_parent(unli_sty, unlinked->parent->style);
692 SP_OBJECT(unlinked)->updateRepr();
694 // Hold onto our SPObject and repr for now.
695 sp_object_ref(SP_OBJECT(use), NULL);
696 Inkscape::GC::anchor(repr);
698 // Remove ourselves, not propagating delete events to avoid a
699 // chain-reaction with other elements that might reference us.
700 SP_OBJECT(use)->deleteObject(false);
702 // Give the copy our old id and let go of our old repr.
703 copy->setAttribute("id", repr->attribute("id"));
704 Inkscape::GC::release(repr);
706 // Remove tiled clone attrs.
707 copy->setAttribute("inkscape:tiled-clone-of", NULL);
708 copy->setAttribute("inkscape:tile-w", NULL);
709 copy->setAttribute("inkscape:tile-h", NULL);
710 copy->setAttribute("inkscape:tile-cx", NULL);
711 copy->setAttribute("inkscape:tile-cy", NULL);
713 // Establish the succession and let go of our object.
714 SP_OBJECT(use)->setSuccessor(unlinked);
715 sp_object_unref(SP_OBJECT(use), NULL);
717 SPItem *item = SP_ITEM(unlinked);
718 // Set the accummulated transform.
719 {
720 NR::Matrix nomove(NR::identity());
721 // Advertise ourselves as not moving.
722 sp_item_write_transform(item, SP_OBJECT_REPR(item), t, &nomove);
723 }
724 return item;
725 }
727 SPItem *
728 sp_use_get_original(SPUse *use)
729 {
730 SPItem *ref = use->ref->getObject();
731 return ref;
732 }
734 static void
735 sp_use_snappoints(SPItem const *item, SnapPointsIter p)
736 {
737 g_assert (item != NULL);
738 g_assert (SP_IS_ITEM(item));
739 g_assert (SP_IS_USE(item));
741 SPUse *use = SP_USE(item);
742 SPItem *root = sp_use_root(use);
743 g_return_if_fail(root);
745 SPItemClass const &item_class = *(SPItemClass const *) G_OBJECT_GET_CLASS(root);
746 if (item_class.snappoints) {
747 item_class.snappoints(root, p);
748 }
749 }
752 /*
753 Local Variables:
754 mode:c++
755 c-file-style:"stroustrup"
756 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
757 indent-tabs-mode:nil
758 fill-column:99
759 End:
760 */
761 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :