49486476d2ef13a5e11bcee16e1cb15d67de6064
1 #define __MARKER_C__
3 /*
4 * SVG <marker> implementation
5 *
6 * Authors:
7 * Lauris Kaplinski <lauris@kaplinski.com>
8 * Bryce Harrington <bryce@bryceharrington.org>
9 *
10 * Copyright (C) 1999-2003 Lauris Kaplinski
11 * 2004-2006 Bryce Harrington
12 * 2008 Johan Engelen
13 *
14 * Released under GNU GPL, read the file 'COPYING' for more information
15 */
17 #include <cstring>
18 #include <string>
19 #include "config.h"
22 #include "libnr/nr-matrix-fns.h"
23 #include "libnr/nr-matrix-ops.h"
24 #include "libnr/nr-matrix-translate-ops.h"
25 #include "libnr/nr-scale-matrix-ops.h"
26 #include "libnr/nr-translate-matrix-ops.h"
27 #include "libnr/nr-convert2geom.h"
28 #include <2geom/matrix.h>
29 #include "svg/svg.h"
30 #include "display/nr-arena-group.h"
31 #include "xml/repr.h"
32 #include "attributes.h"
33 #include "marker.h"
34 #include "document.h"
35 #include "document-private.h"
37 struct SPMarkerView {
38 SPMarkerView *next;
39 unsigned int key;
40 unsigned int size;
41 NRArenaItem *items[1];
42 };
44 static void sp_marker_class_init (SPMarkerClass *klass);
45 static void sp_marker_init (SPMarker *marker);
47 static void sp_marker_build (SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
48 static void sp_marker_release (SPObject *object);
49 static void sp_marker_set (SPObject *object, unsigned int key, const gchar *value);
50 static void sp_marker_update (SPObject *object, SPCtx *ctx, guint flags);
51 static Inkscape::XML::Node *sp_marker_write (SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags);
53 static NRArenaItem *sp_marker_private_show (SPItem *item, NRArena *arena, unsigned int key, unsigned int flags);
54 static void sp_marker_private_hide (SPItem *item, unsigned int key);
55 static void sp_marker_bbox(SPItem const *item, NRRect *bbox, Geom::Matrix const &transform, unsigned const flags);
56 static void sp_marker_print (SPItem *item, SPPrintContext *ctx);
58 static void sp_marker_view_remove (SPMarker *marker, SPMarkerView *view, unsigned int destroyitems);
60 static SPGroupClass *parent_class;
62 /**
63 * Registers the SPMarker class with Gdk and returns its type number.
64 */
65 GType
66 sp_marker_get_type (void)
67 {
68 static GType type = 0;
69 if (!type) {
70 GTypeInfo info = {
71 sizeof (SPMarkerClass),
72 NULL, NULL,
73 (GClassInitFunc) sp_marker_class_init,
74 NULL, NULL,
75 sizeof (SPMarker),
76 16,
77 (GInstanceInitFunc) sp_marker_init,
78 NULL, /* value_table */
79 };
80 type = g_type_register_static (SP_TYPE_GROUP, "SPMarker", &info, (GTypeFlags)0);
81 }
82 return type;
83 }
85 /**
86 * Initializes a SPMarkerClass object. Establishes the function pointers to the class'
87 * member routines in the class vtable, and sets pointers to parent classes.
88 */
89 static void
90 sp_marker_class_init (SPMarkerClass *klass)
91 {
92 GObjectClass *object_class;
93 SPObjectClass *sp_object_class;
94 SPItemClass *sp_item_class;
96 object_class = G_OBJECT_CLASS (klass);
97 sp_object_class = (SPObjectClass *) klass;
98 sp_item_class = (SPItemClass *) klass;
100 parent_class = (SPGroupClass *)g_type_class_ref (SP_TYPE_GROUP);
102 sp_object_class->build = sp_marker_build;
103 sp_object_class->release = sp_marker_release;
104 sp_object_class->set = sp_marker_set;
105 sp_object_class->update = sp_marker_update;
106 sp_object_class->write = sp_marker_write;
108 sp_item_class->show = sp_marker_private_show;
109 sp_item_class->hide = sp_marker_private_hide;
110 sp_item_class->bbox = sp_marker_bbox;
111 sp_item_class->print = sp_marker_print;
112 }
114 /**
115 * Initializes an SPMarker object. This notes the marker's viewBox is
116 * not set and initializes the marker's c2p identity matrix.
117 */
118 static void
119 sp_marker_init (SPMarker *marker)
120 {
121 marker->viewBox_set = FALSE;
123 marker->c2p.setIdentity();
124 }
126 /**
127 * Virtual build callback for SPMarker.
128 *
129 * This is to be invoked immediately after creation of an SPMarker. This
130 * method fills an SPMarker object with its SVG attributes, and calls the
131 * parent class' build routine to attach the object to its document and
132 * repr. The result will be creation of the whole document tree.
133 *
134 * \see sp_object_build()
135 */
136 static void
137 sp_marker_build (SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
138 {
139 SPGroup *group;
140 SPMarker *marker;
142 group = (SPGroup *) object;
143 marker = (SPMarker *) object;
145 sp_object_read_attr (object, "markerUnits");
146 sp_object_read_attr (object, "refX");
147 sp_object_read_attr (object, "refY");
148 sp_object_read_attr (object, "markerWidth");
149 sp_object_read_attr (object, "markerHeight");
150 sp_object_read_attr (object, "orient");
151 sp_object_read_attr (object, "viewBox");
152 sp_object_read_attr (object, "preserveAspectRatio");
154 if (((SPObjectClass *) parent_class)->build)
155 ((SPObjectClass *) parent_class)->build (object, document, repr);
156 }
158 /**
159 * Removes, releases and unrefs all children of object
160 *
161 * This is the inverse of sp_marker_build(). It must be invoked as soon
162 * as the marker is removed from the tree, even if it is still referenced
163 * by other objects. It hides and removes any views of the marker, then
164 * calls the parent classes' release function to deregister the object
165 * and release its SPRepr bindings. The result will be the destruction
166 * of the entire document tree.
167 *
168 * \see sp_object_release()
169 */
170 static void
171 sp_marker_release (SPObject *object)
172 {
173 SPMarker *marker;
175 marker = (SPMarker *) object;
177 while (marker->views) {
178 /* Destroy all NRArenaitems etc. */
179 /* Parent class ::hide method */
180 ((SPItemClass *) parent_class)->hide ((SPItem *) marker, marker->views->key);
181 sp_marker_view_remove (marker, marker->views, TRUE);
182 }
184 if (((SPObjectClass *) parent_class)->release)
185 ((SPObjectClass *) parent_class)->release (object);
186 }
188 /**
189 * Sets an attribute, 'key', of a marker object to 'value'. Supported
190 * attributes that can be set with this routine include:
191 *
192 * SP_ATTR_MARKERUNITS
193 * SP_ATTR_REFX
194 * SP_ATTR_REFY
195 * SP_ATTR_MARKERWIDTH
196 * SP_ATTR_MARKERHEIGHT
197 * SP_ATTR_ORIENT
198 * SP_ATTR_VIEWBOX
199 * SP_ATTR_PRESERVEASPECTRATIO
200 */
201 static void
202 sp_marker_set (SPObject *object, unsigned int key, const gchar *value)
203 {
204 SPItem *item;
205 SPMarker *marker;
207 item = SP_ITEM (object);
208 marker = SP_MARKER (object);
210 switch (key) {
211 case SP_ATTR_MARKERUNITS:
212 marker->markerUnits_set = FALSE;
213 marker->markerUnits = SP_MARKER_UNITS_STROKEWIDTH;
214 if (value) {
215 if (!strcmp (value, "strokeWidth")) {
216 marker->markerUnits_set = TRUE;
217 } else if (!strcmp (value, "userSpaceOnUse")) {
218 marker->markerUnits = SP_MARKER_UNITS_USERSPACEONUSE;
219 marker->markerUnits_set = TRUE;
220 }
221 }
222 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_VIEWPORT_MODIFIED_FLAG);
223 break;
224 case SP_ATTR_REFX:
225 marker->refX.readOrUnset(value);
226 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
227 break;
228 case SP_ATTR_REFY:
229 marker->refY.readOrUnset(value);
230 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
231 break;
232 case SP_ATTR_MARKERWIDTH:
233 marker->markerWidth.readOrUnset(value, SVGLength::NONE, 3.0, 3.0);
234 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
235 break;
236 case SP_ATTR_MARKERHEIGHT:
237 marker->markerHeight.readOrUnset(value, SVGLength::NONE, 3.0, 3.0);
238 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
239 break;
240 case SP_ATTR_ORIENT:
241 marker->orient_set = FALSE;
242 marker->orient_auto = FALSE;
243 marker->orient = 0.0;
244 if (value) {
245 if (!strcmp (value, "auto")) {
246 marker->orient_auto = TRUE;
247 marker->orient_set = TRUE;
248 } else if (sp_svg_number_read_f (value, &marker->orient)) {
249 marker->orient_set = TRUE;
250 }
251 }
252 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
253 break;
254 case SP_ATTR_VIEWBOX:
255 marker->viewBox_set = FALSE;
256 if (value) {
257 double x, y, width, height;
258 char *eptr;
259 /* fixme: We have to take original item affine into account */
260 /* fixme: Think (Lauris) */
261 eptr = (gchar *) value;
262 x = g_ascii_strtod (eptr, &eptr);
263 while (*eptr && ((*eptr == ',') || (*eptr == ' '))) eptr++;
264 y = g_ascii_strtod (eptr, &eptr);
265 while (*eptr && ((*eptr == ',') || (*eptr == ' '))) eptr++;
266 width = g_ascii_strtod (eptr, &eptr);
267 while (*eptr && ((*eptr == ',') || (*eptr == ' '))) eptr++;
268 height = g_ascii_strtod (eptr, &eptr);
269 while (*eptr && ((*eptr == ',') || (*eptr == ' '))) eptr++;
270 if ((width > 0) && (height > 0)) {
271 /* Set viewbox */
272 marker->viewBox.x0 = x;
273 marker->viewBox.y0 = y;
274 marker->viewBox.x1 = x + width;
275 marker->viewBox.y1 = y + height;
276 marker->viewBox_set = TRUE;
277 }
278 }
279 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_VIEWPORT_MODIFIED_FLAG);
280 break;
281 case SP_ATTR_PRESERVEASPECTRATIO:
282 /* Do setup before, so we can use break to escape */
283 marker->aspect_set = FALSE;
284 marker->aspect_align = SP_ASPECT_NONE;
285 marker->aspect_clip = SP_ASPECT_MEET;
286 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_VIEWPORT_MODIFIED_FLAG);
287 if (value) {
288 int len;
289 gchar c[256];
290 const gchar *p, *e;
291 unsigned int align, clip;
292 p = value;
293 while (*p && *p == 32) p += 1;
294 if (!*p) break;
295 e = p;
296 while (*e && *e != 32) e += 1;
297 len = e - p;
298 if (len > 8) break;
299 memcpy (c, value, len);
300 c[len] = 0;
301 /* Now the actual part */
302 if (!strcmp (c, "none")) {
303 align = SP_ASPECT_NONE;
304 } else if (!strcmp (c, "xMinYMin")) {
305 align = SP_ASPECT_XMIN_YMIN;
306 } else if (!strcmp (c, "xMidYMin")) {
307 align = SP_ASPECT_XMID_YMIN;
308 } else if (!strcmp (c, "xMaxYMin")) {
309 align = SP_ASPECT_XMAX_YMIN;
310 } else if (!strcmp (c, "xMinYMid")) {
311 align = SP_ASPECT_XMIN_YMID;
312 } else if (!strcmp (c, "xMidYMid")) {
313 align = SP_ASPECT_XMID_YMID;
314 } else if (!strcmp (c, "xMaxYMin")) {
315 align = SP_ASPECT_XMAX_YMID;
316 } else if (!strcmp (c, "xMinYMax")) {
317 align = SP_ASPECT_XMIN_YMAX;
318 } else if (!strcmp (c, "xMidYMax")) {
319 align = SP_ASPECT_XMID_YMAX;
320 } else if (!strcmp (c, "xMaxYMax")) {
321 align = SP_ASPECT_XMAX_YMAX;
322 } else {
323 break;
324 }
325 clip = SP_ASPECT_MEET;
326 while (*e && *e == 32) e += 1;
327 if (e) {
328 if (!strcmp (e, "meet")) {
329 clip = SP_ASPECT_MEET;
330 } else if (!strcmp (e, "slice")) {
331 clip = SP_ASPECT_SLICE;
332 } else {
333 break;
334 }
335 }
336 marker->aspect_set = TRUE;
337 marker->aspect_align = align;
338 marker->aspect_clip = clip;
339 }
340 break;
341 default:
342 if (((SPObjectClass *) parent_class)->set)
343 ((SPObjectClass *) parent_class)->set (object, key, value);
344 break;
345 }
346 }
348 /**
349 * Updates <marker> when its attributes have changed. Takes care of setting up
350 * transformations and viewBoxes.
351 */
352 static void
353 sp_marker_update (SPObject *object, SPCtx *ctx, guint flags)
354 {
355 SPItem *item;
356 SPMarker *marker;
357 SPItemCtx rctx;
358 NRRect *vb;
359 double x, y, width, height;
360 SPMarkerView *v;
362 item = SP_ITEM (object);
363 marker = SP_MARKER (object);
365 /* fixme: We have to set up clip here too */
367 /* Copy parent context */
368 rctx.ctx = *ctx;
369 /* Initialize tranformations */
370 rctx.i2doc = NR::identity();
371 rctx.i2vp = NR::identity();
372 /* Set up viewport */
373 rctx.vp.x0 = 0.0;
374 rctx.vp.y0 = 0.0;
375 rctx.vp.x1 = marker->markerWidth.computed;
376 rctx.vp.y1 = marker->markerHeight.computed;
378 /* Start with identity transform */
379 marker->c2p.setIdentity();
381 /* Viewbox is always present, either implicitly or explicitly */
382 if (marker->viewBox_set) {
383 vb = &marker->viewBox;
384 } else {
385 vb = &rctx.vp;
386 }
387 /* Now set up viewbox transformation */
388 /* Determine actual viewbox in viewport coordinates */
389 if (marker->aspect_align == SP_ASPECT_NONE) {
390 x = 0.0;
391 y = 0.0;
392 width = rctx.vp.x1 - rctx.vp.x0;
393 height = rctx.vp.y1 - rctx.vp.y0;
394 } else {
395 double scalex, scaley, scale;
396 /* Things are getting interesting */
397 scalex = (rctx.vp.x1 - rctx.vp.x0) / (vb->x1 - vb->x0);
398 scaley = (rctx.vp.y1 - rctx.vp.y0) / (vb->y1 - vb->y0);
399 scale = (marker->aspect_clip == SP_ASPECT_MEET) ? MIN (scalex, scaley) : MAX (scalex, scaley);
400 width = (vb->x1 - vb->x0) * scale;
401 height = (vb->y1 - vb->y0) * scale;
402 /* Now place viewbox to requested position */
403 switch (marker->aspect_align) {
404 case SP_ASPECT_XMIN_YMIN:
405 x = 0.0;
406 y = 0.0;
407 break;
408 case SP_ASPECT_XMID_YMIN:
409 x = 0.5 * ((rctx.vp.x1 - rctx.vp.x0) - width);
410 y = 0.0;
411 break;
412 case SP_ASPECT_XMAX_YMIN:
413 x = 1.0 * ((rctx.vp.x1 - rctx.vp.x0) - width);
414 y = 0.0;
415 break;
416 case SP_ASPECT_XMIN_YMID:
417 x = 0.0;
418 y = 0.5 * ((rctx.vp.y1 - rctx.vp.y0) - height);
419 break;
420 case SP_ASPECT_XMID_YMID:
421 x = 0.5 * ((rctx.vp.x1 - rctx.vp.x0) - width);
422 y = 0.5 * ((rctx.vp.y1 - rctx.vp.y0) - height);
423 break;
424 case SP_ASPECT_XMAX_YMID:
425 x = 1.0 * ((rctx.vp.x1 - rctx.vp.x0) - width);
426 y = 0.5 * ((rctx.vp.y1 - rctx.vp.y0) - height);
427 break;
428 case SP_ASPECT_XMIN_YMAX:
429 x = 0.0;
430 y = 1.0 * ((rctx.vp.y1 - rctx.vp.y0) - height);
431 break;
432 case SP_ASPECT_XMID_YMAX:
433 x = 0.5 * ((rctx.vp.x1 - rctx.vp.x0) - width);
434 y = 1.0 * ((rctx.vp.y1 - rctx.vp.y0) - height);
435 break;
436 case SP_ASPECT_XMAX_YMAX:
437 x = 1.0 * ((rctx.vp.x1 - rctx.vp.x0) - width);
438 y = 1.0 * ((rctx.vp.y1 - rctx.vp.y0) - height);
439 break;
440 default:
441 x = 0.0;
442 y = 0.0;
443 break;
444 }
445 }
447 {
448 Geom::Matrix q;
449 /* Compose additional transformation from scale and position */
450 q[0] = width / (vb->x1 - vb->x0);
451 q[1] = 0.0;
452 q[2] = 0.0;
453 q[3] = height / (vb->y1 - vb->y0);
454 q[4] = -vb->x0 * q[0] + x;
455 q[5] = -vb->y0 * q[3] + y;
456 /* Append viewbox transformation */
457 marker->c2p = q * marker->c2p;
458 }
460 /* Append reference translation */
461 /* fixme: lala (Lauris) */
462 marker->c2p = Geom::Translate(-marker->refX.computed, -marker->refY.computed) * marker->c2p;
464 rctx.i2doc = marker->c2p * rctx.i2doc;
466 /* If viewBox is set reinitialize child viewport */
467 /* Otherwise it already correct */
468 if (marker->viewBox_set) {
469 rctx.vp.x0 = marker->viewBox.x0;
470 rctx.vp.y0 = marker->viewBox.y0;
471 rctx.vp.x1 = marker->viewBox.x1;
472 rctx.vp.y1 = marker->viewBox.y1;
473 rctx.i2vp = Geom::identity();
474 }
476 /* And invoke parent method */
477 if (((SPObjectClass *) (parent_class))->update)
478 ((SPObjectClass *) (parent_class))->update (object, (SPCtx *) &rctx, flags);
480 /* As last step set additional transform of arena group */
481 for (v = marker->views; v != NULL; v = v->next) {
482 for (unsigned i = 0 ; i < v->size ; i++) {
483 if (v->items[i]) {
484 NR::Matrix tmp = from_2geom(marker->c2p);
485 nr_arena_group_set_child_transform(NR_ARENA_GROUP(v->items[i]), &tmp);
486 }
487 }
488 }
489 }
491 /**
492 * Writes the object's properties into its repr object.
493 */
494 static Inkscape::XML::Node *
495 sp_marker_write (SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
496 {
497 SPMarker *marker;
499 marker = SP_MARKER (object);
501 if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
502 repr = xml_doc->createElement("svg:marker");
503 }
505 if (marker->markerUnits_set) {
506 if (marker->markerUnits == SP_MARKER_UNITS_STROKEWIDTH) {
507 repr->setAttribute("markerUnits", "strokeWidth");
508 } else {
509 repr->setAttribute("markerUnits", "userSpaceOnUse");
510 }
511 } else {
512 repr->setAttribute("markerUnits", NULL);
513 }
514 if (marker->refX._set) {
515 sp_repr_set_svg_double(repr, "refX", marker->refX.computed);
516 } else {
517 repr->setAttribute("refX", NULL);
518 }
519 if (marker->refY._set) {
520 sp_repr_set_svg_double (repr, "refY", marker->refY.computed);
521 } else {
522 repr->setAttribute("refY", NULL);
523 }
524 if (marker->markerWidth._set) {
525 sp_repr_set_svg_double (repr, "markerWidth", marker->markerWidth.computed);
526 } else {
527 repr->setAttribute("markerWidth", NULL);
528 }
529 if (marker->markerHeight._set) {
530 sp_repr_set_svg_double (repr, "markerHeight", marker->markerHeight.computed);
531 } else {
532 repr->setAttribute("markerHeight", NULL);
533 }
534 if (marker->orient_set) {
535 if (marker->orient_auto) {
536 repr->setAttribute("orient", "auto");
537 } else {
538 sp_repr_set_css_double(repr, "orient", marker->orient);
539 }
540 } else {
541 repr->setAttribute("orient", NULL);
542 }
543 /* fixme: */
544 repr->setAttribute("viewBox", object->repr->attribute("viewBox"));
545 repr->setAttribute("preserveAspectRatio", object->repr->attribute("preserveAspectRatio"));
547 if (((SPObjectClass *) (parent_class))->write)
548 ((SPObjectClass *) (parent_class))->write (object, xml_doc, repr, flags);
550 return repr;
551 }
553 /**
554 * This routine is disabled to break propagation.
555 */
556 static NRArenaItem *
557 sp_marker_private_show (SPItem */*item*/, NRArena */*arena*/, unsigned int /*key*/, unsigned int /*flags*/)
558 {
559 /* Break propagation */
560 return NULL;
561 }
563 /**
564 * This routine is disabled to break propagation.
565 */
566 static void
567 sp_marker_private_hide (SPItem */*item*/, unsigned int /*key*/)
568 {
569 /* Break propagation */
570 }
572 /**
573 * This routine is disabled to break propagation.
574 */
575 static void
576 sp_marker_bbox(SPItem const *, NRRect *, Geom::Matrix const &, unsigned const)
577 {
578 /* Break propagation */
579 }
581 /**
582 * This routine is disabled to break propagation.
583 */
584 static void
585 sp_marker_print (SPItem */*item*/, SPPrintContext */*ctx*/)
586 {
587 /* Break propagation */
588 }
590 /* fixme: Remove link if zero-sized (Lauris) */
592 /**
593 * Removes any SPMarkerViews that a marker has with a specific key.
594 * Set up the NRArenaItem array's size in the specified SPMarker's SPMarkerView.
595 * This is called from sp_shape_update() for shapes that have markers. It
596 * removes the old view of the marker and establishes a new one, registering
597 * it with the marker's list of views for future updates.
598 *
599 * \param marker Marker to create views in.
600 * \param key Key to give each SPMarkerView.
601 * \param size Number of NRArenaItems to put in the SPMarkerView.
602 */
603 void
604 sp_marker_show_dimension (SPMarker *marker, unsigned int key, unsigned int size)
605 {
606 SPMarkerView *view;
607 unsigned int i;
609 for (view = marker->views; view != NULL; view = view->next) {
610 if (view->key == key) break;
611 }
612 if (view && (view->size != size)) {
613 /* Free old view and allocate new */
614 /* Parent class ::hide method */
615 ((SPItemClass *) parent_class)->hide ((SPItem *) marker, key);
616 sp_marker_view_remove (marker, view, TRUE);
617 view = NULL;
618 }
619 if (!view) {
620 view = (SPMarkerView *)g_malloc (sizeof (SPMarkerView) + (size) * sizeof (NRArenaItem *));
621 for (i = 0; i < size; i++) view->items[i] = NULL;
622 view->next = marker->views;
623 marker->views = view;
624 view->key = key;
625 view->size = size;
626 }
627 }
629 /**
630 * Shows an instance of a marker. This is called during sp_shape_update_marker_view()
631 * show and transform a child item in the arena for all views with the given key.
632 */
633 NRArenaItem *
634 sp_marker_show_instance ( SPMarker *marker, NRArenaItem *parent,
635 unsigned int key, unsigned int pos,
636 Geom::Matrix const &base, float linewidth)
637 {
638 for (SPMarkerView *v = marker->views; v != NULL; v = v->next) {
639 if (v->key == key) {
640 if (pos >= v->size) {
641 return NULL;
642 }
643 if (!v->items[pos]) {
644 /* Parent class ::show method */
645 v->items[pos] = ((SPItemClass *) parent_class)->show ((SPItem *) marker,
646 parent->arena, key,
647 SP_ITEM_REFERENCE_FLAGS);
648 if (v->items[pos]) {
649 /* fixme: Position (Lauris) */
650 nr_arena_item_add_child (parent, v->items[pos], NULL);
651 /* nr_arena_item_unref (v->items[pos]); */
652 NR::Matrix tmp = from_2geom(marker->c2p);
653 nr_arena_group_set_child_transform((NRArenaGroup *) v->items[pos], &tmp);
654 }
655 }
656 if (v->items[pos]) {
657 Geom::Matrix m;
658 if (marker->orient_auto) {
659 m = base;
660 } else {
661 /* fixme: Orient units (Lauris) */
662 m = Geom::Matrix(Geom::Rotate::from_degrees(marker->orient));
663 m *= Geom::Translate(base[4], base[5]); // TODO: this was NR::get_translation() originally; should it be extracted into a new 2geom function?
664 }
665 if (marker->markerUnits == SP_MARKER_UNITS_STROKEWIDTH) {
666 m = Geom::Scale(linewidth) * m;
667 }
669 nr_arena_item_set_transform(v->items[pos], m);
670 }
671 return v->items[pos];
672 }
673 }
675 return NULL;
676 }
678 /**
679 * Hides/removes all views of the given marker that have key 'key'.
680 * This replaces SPItem implementation because we have our own views
681 * \param key SPMarkerView key to hide.
682 */
683 void
684 sp_marker_hide (SPMarker *marker, unsigned int key)
685 {
686 SPMarkerView *v;
688 v = marker->views;
689 while (v != NULL) {
690 SPMarkerView *next;
691 next = v->next;
692 if (v->key == key) {
693 /* Parent class ::hide method */
694 ((SPItemClass *) parent_class)->hide ((SPItem *) marker, key);
695 sp_marker_view_remove (marker, v, TRUE);
696 return;
697 }
698 v = next;
699 }
700 }
702 /**
703 * Removes a given view. Also will destroy sub-items in the view if destroyitems
704 * is set to a non-zero value.
705 */
706 static void
707 sp_marker_view_remove (SPMarker *marker, SPMarkerView *view, unsigned int destroyitems)
708 {
709 unsigned int i;
710 if (view == marker->views) {
711 marker->views = view->next;
712 } else {
713 SPMarkerView *v;
714 for (v = marker->views; v->next != view; v = v->next) if (!v->next) return;
715 v->next = view->next;
716 }
717 if (destroyitems) {
718 for (i = 0; i < view->size; i++) {
719 /* We have to walk through the whole array because there may be hidden items */
720 if (view->items[i]) nr_arena_item_unref (view->items[i]);
721 }
722 }
723 g_free (view);
724 }
726 const gchar *
727 generate_marker (GSList *reprs, NR::Rect bounds, SPDocument *document, Geom::Matrix /*transform*/, Geom::Matrix move)
728 {
729 Inkscape::XML::Document *xml_doc = sp_document_repr_doc(document);
730 Inkscape::XML::Node *defsrepr = SP_OBJECT_REPR (SP_DOCUMENT_DEFS (document));
732 Inkscape::XML::Node *repr = xml_doc->createElement("svg:marker");
734 // Uncommenting this will make the marker fixed-size independent of stroke width.
735 // Commented out for consistency with standard markers which scale when you change
736 // stroke width:
737 //repr->setAttribute("markerUnits", "userSpaceOnUse");
739 sp_repr_set_svg_double(repr, "markerWidth", bounds.extent(NR::X));
740 sp_repr_set_svg_double(repr, "markerHeight", bounds.extent(NR::Y));
742 repr->setAttribute("orient", "auto");
744 defsrepr->appendChild(repr);
745 const gchar *mark_id = repr->attribute("id");
746 SPObject *mark_object = document->getObjectById(mark_id);
748 for (GSList *i = reprs; i != NULL; i = i->next) {
749 Inkscape::XML::Node *node = (Inkscape::XML::Node *)(i->data);
750 SPItem *copy = SP_ITEM(mark_object->appendChildRepr(node));
752 Geom::Matrix dup_transform;
753 if (!sp_svg_transform_read (node->attribute("transform"), &dup_transform))
754 dup_transform = Geom::identity();
755 dup_transform *= move;
757 sp_item_write_transform(copy, SP_OBJECT_REPR(copy), dup_transform);
758 }
760 Inkscape::GC::release(repr);
761 return mark_id;
762 }
764 /*
765 Local Variables:
766 mode:c++
767 c-file-style:"stroustrup"
768 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
769 indent-tabs-mode:nil
770 fill-column:99
771 End:
772 */
773 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :