1 #define __SP_PATTERN_C__
3 /*
4 * SVG <pattern> implementation
5 *
6 * Author:
7 * Lauris Kaplinski <lauris@kaplinski.com>
8 * bulia byak <buliabyak@users.sf.net>
9 *
10 * Copyright (C) 2002 Lauris Kaplinski
11 *
12 * Released under GNU GPL, read the file 'COPYING' for more information
13 */
15 #ifdef HAVE_CONFIG_H
16 # include "config.h"
17 #endif
19 #include <cstring>
20 #include <string>
21 #include <libnr/nr-matrix-ops.h>
22 #include "libnr/nr-matrix-fns.h"
23 #include <2geom/transforms.h>
24 #include "macros.h"
25 #include "svg/svg.h"
26 #include "display/nr-arena.h"
27 #include "display/nr-arena-group.h"
28 #include "attributes.h"
29 #include "document-private.h"
30 #include "uri.h"
31 #include "sp-pattern.h"
32 #include "xml/repr.h"
34 #include <sigc++/functors/ptr_fun.h>
35 #include <sigc++/adaptors/bind.h>
37 /*
38 * Pattern
39 */
41 class SPPatPainter;
43 struct SPPatPainter {
44 SPPainter painter;
45 SPPattern *pat;
47 Geom::Matrix ps2px;
48 Geom::Matrix px2ps;
49 Geom::Matrix pcs2px;
51 NRArena *arena;
52 unsigned int dkey;
53 NRArenaItem *root;
55 bool use_cached_tile;
56 Geom::Matrix ca2pa;
57 Geom::Matrix pa2ca;
58 NRRectL cached_bbox;
59 NRPixBlock cached_tile;
61 std::map<SPObject *, sigc::connection> *_release_connections;
62 };
64 static void sp_pattern_class_init (SPPatternClass *klass);
65 static void sp_pattern_init (SPPattern *gr);
67 static void sp_pattern_build (SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
68 static void sp_pattern_release (SPObject *object);
69 static void sp_pattern_set (SPObject *object, unsigned int key, const gchar *value);
70 static void sp_pattern_child_added (SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref);
71 static void sp_pattern_update (SPObject *object, SPCtx *ctx, unsigned int flags);
72 static void sp_pattern_modified (SPObject *object, unsigned int flags);
74 static void pattern_ref_changed(SPObject *old_ref, SPObject *ref, SPPattern *pat);
75 static void pattern_ref_modified (SPObject *ref, guint flags, SPPattern *pattern);
77 static SPPainter *sp_pattern_painter_new (SPPaintServer *ps, Geom::Matrix const &full_transform, Geom::Matrix const &parent_transform, const NRRect *bbox);
78 static void sp_pattern_painter_free (SPPaintServer *ps, SPPainter *painter);
80 static SPPaintServerClass * pattern_parent_class;
82 GType
83 sp_pattern_get_type (void)
84 {
85 static GType pattern_type = 0;
86 if (!pattern_type) {
87 GTypeInfo pattern_info = {
88 sizeof (SPPatternClass),
89 NULL, /* base_init */
90 NULL, /* base_finalize */
91 (GClassInitFunc) sp_pattern_class_init,
92 NULL, /* class_finalize */
93 NULL, /* class_data */
94 sizeof (SPPattern),
95 16, /* n_preallocs */
96 (GInstanceInitFunc) sp_pattern_init,
97 NULL, /* value_table */
98 };
99 pattern_type = g_type_register_static (SP_TYPE_PAINT_SERVER, "SPPattern", &pattern_info, (GTypeFlags)0);
100 }
101 return pattern_type;
102 }
104 static void
105 sp_pattern_class_init (SPPatternClass *klass)
106 {
107 SPObjectClass *sp_object_class;
108 SPPaintServerClass *ps_class;
110 sp_object_class = (SPObjectClass *) klass;
111 ps_class = (SPPaintServerClass *) klass;
113 pattern_parent_class = (SPPaintServerClass*)g_type_class_ref (SP_TYPE_PAINT_SERVER);
115 sp_object_class->build = sp_pattern_build;
116 sp_object_class->release = sp_pattern_release;
117 sp_object_class->set = sp_pattern_set;
118 sp_object_class->child_added = sp_pattern_child_added;
119 sp_object_class->update = sp_pattern_update;
120 sp_object_class->modified = sp_pattern_modified;
122 // do we need _write? seems to work without it
124 ps_class->painter_new = sp_pattern_painter_new;
125 ps_class->painter_free = sp_pattern_painter_free;
126 }
128 static void
129 sp_pattern_init (SPPattern *pat)
130 {
131 pat->ref = new SPPatternReference(SP_OBJECT(pat));
132 pat->ref->changedSignal().connect(sigc::bind(sigc::ptr_fun(pattern_ref_changed), pat));
134 pat->patternUnits = SP_PATTERN_UNITS_OBJECTBOUNDINGBOX;
135 pat->patternUnits_set = FALSE;
137 pat->patternContentUnits = SP_PATTERN_UNITS_USERSPACEONUSE;
138 pat->patternContentUnits_set = FALSE;
140 pat->patternTransform = NR::identity();
141 pat->patternTransform_set = FALSE;
143 pat->x.unset();
144 pat->y.unset();
145 pat->width.unset();
146 pat->height.unset();
148 pat->viewBox_set = FALSE;
150 new (&pat->modified_connection) sigc::connection();
151 }
153 static void
154 sp_pattern_build (SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
155 {
156 if (((SPObjectClass *) pattern_parent_class)->build)
157 (* ((SPObjectClass *) pattern_parent_class)->build) (object, document, repr);
159 sp_object_read_attr (object, "patternUnits");
160 sp_object_read_attr (object, "patternContentUnits");
161 sp_object_read_attr (object, "patternTransform");
162 sp_object_read_attr (object, "x");
163 sp_object_read_attr (object, "y");
164 sp_object_read_attr (object, "width");
165 sp_object_read_attr (object, "height");
166 sp_object_read_attr (object, "viewBox");
167 sp_object_read_attr (object, "xlink:href");
169 /* Register ourselves */
170 sp_document_add_resource (document, "pattern", object);
171 }
173 static void
174 sp_pattern_release (SPObject *object)
175 {
176 SPPattern *pat;
178 pat = (SPPattern *) object;
180 if (SP_OBJECT_DOCUMENT (object)) {
181 /* Unregister ourselves */
182 sp_document_remove_resource (SP_OBJECT_DOCUMENT (object), "pattern", SP_OBJECT (object));
183 }
185 if (pat->ref) {
186 pat->modified_connection.disconnect();
187 pat->ref->detach();
188 delete pat->ref;
189 pat->ref = NULL;
190 }
192 pat->modified_connection.~connection();
194 if (((SPObjectClass *) pattern_parent_class)->release)
195 ((SPObjectClass *) pattern_parent_class)->release (object);
196 }
198 static void
199 sp_pattern_set (SPObject *object, unsigned int key, const gchar *value)
200 {
201 SPPattern *pat = SP_PATTERN (object);
203 switch (key) {
204 case SP_ATTR_PATTERNUNITS:
205 if (value) {
206 if (!strcmp (value, "userSpaceOnUse")) {
207 pat->patternUnits = SP_PATTERN_UNITS_USERSPACEONUSE;
208 } else {
209 pat->patternUnits = SP_PATTERN_UNITS_OBJECTBOUNDINGBOX;
210 }
211 pat->patternUnits_set = TRUE;
212 } else {
213 pat->patternUnits_set = FALSE;
214 }
215 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
216 break;
217 case SP_ATTR_PATTERNCONTENTUNITS:
218 if (value) {
219 if (!strcmp (value, "userSpaceOnUse")) {
220 pat->patternContentUnits = SP_PATTERN_UNITS_USERSPACEONUSE;
221 } else {
222 pat->patternContentUnits = SP_PATTERN_UNITS_OBJECTBOUNDINGBOX;
223 }
224 pat->patternContentUnits_set = TRUE;
225 } else {
226 pat->patternContentUnits_set = FALSE;
227 }
228 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
229 break;
230 case SP_ATTR_PATTERNTRANSFORM: {
231 Geom::Matrix t;
232 if (value && sp_svg_transform_read (value, &t)) {
233 pat->patternTransform = t;
234 pat->patternTransform_set = TRUE;
235 } else {
236 pat->patternTransform = NR::identity();
237 pat->patternTransform_set = FALSE;
238 }
239 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
240 break;
241 }
242 case SP_ATTR_X:
243 pat->x.readOrUnset(value);
244 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
245 break;
246 case SP_ATTR_Y:
247 pat->y.readOrUnset(value);
248 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
249 break;
250 case SP_ATTR_WIDTH:
251 pat->width.readOrUnset(value);
252 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
253 break;
254 case SP_ATTR_HEIGHT:
255 pat->height.readOrUnset(value);
256 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
257 break;
258 case SP_ATTR_VIEWBOX: {
259 /* fixme: Think (Lauris) */
260 double x, y, width, height;
261 char *eptr;
263 if (value) {
264 eptr = (gchar *) value;
265 x = g_ascii_strtod (eptr, &eptr);
266 while (*eptr && ((*eptr == ',') || (*eptr == ' '))) eptr++;
267 y = g_ascii_strtod (eptr, &eptr);
268 while (*eptr && ((*eptr == ',') || (*eptr == ' '))) eptr++;
269 width = g_ascii_strtod (eptr, &eptr);
270 while (*eptr && ((*eptr == ',') || (*eptr == ' '))) eptr++;
271 height = g_ascii_strtod (eptr, &eptr);
272 while (*eptr && ((*eptr == ',') || (*eptr == ' '))) eptr++;
273 if ((width > 0) && (height > 0)) {
274 pat->viewBox.x0 = x;
275 pat->viewBox.y0 = y;
276 pat->viewBox.x1 = x + width;
277 pat->viewBox.y1 = y + height;
278 pat->viewBox_set = TRUE;
279 } else {
280 pat->viewBox_set = FALSE;
281 }
282 } else {
283 pat->viewBox_set = FALSE;
284 }
285 object->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_VIEWPORT_MODIFIED_FLAG);
286 break;
287 }
288 case SP_ATTR_XLINK_HREF:
289 if ( value && pat->href && ( strcmp(value, pat->href) == 0 ) ) {
290 /* Href unchanged, do nothing. */
291 } else {
292 g_free(pat->href);
293 pat->href = NULL;
294 if (value) {
295 // First, set the href field; it's only used in the "unchanged" check above.
296 pat->href = g_strdup(value);
297 // Now do the attaching, which emits the changed signal.
298 if (value) {
299 try {
300 pat->ref->attach(Inkscape::URI(value));
301 } catch (Inkscape::BadURIException &e) {
302 g_warning("%s", e.what());
303 pat->ref->detach();
304 }
305 } else {
306 pat->ref->detach();
307 }
308 }
309 }
310 break;
311 default:
312 if (((SPObjectClass *) pattern_parent_class)->set)
313 ((SPObjectClass *) pattern_parent_class)->set (object, key, value);
314 break;
315 }
316 }
318 static void
319 sp_pattern_child_added (SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
320 {
321 SPPattern *pat = SP_PATTERN (object);
323 if (((SPObjectClass *) (pattern_parent_class))->child_added)
324 (* ((SPObjectClass *) (pattern_parent_class))->child_added) (object, child, ref);
326 SPObject *ochild = sp_object_get_child_by_repr(object, child);
327 if (SP_IS_ITEM (ochild)) {
329 SPPaintServer *ps = SP_PAINT_SERVER (pat);
330 unsigned position = sp_item_pos_in_parent(SP_ITEM(ochild));
332 for (SPPainter *p = ps->painters; p != NULL; p = p->next) {
334 SPPatPainter *pp = (SPPatPainter *) p;
335 NRArenaItem *ai = sp_item_invoke_show (SP_ITEM (ochild), pp->arena, pp->dkey, SP_ITEM_REFERENCE_FLAGS);
337 if (ai) {
338 nr_arena_item_add_child (pp->root, ai, NULL);
339 nr_arena_item_set_order (ai, position);
340 nr_arena_item_unref (ai);
341 }
342 }
343 }
344 }
346 /* TODO: do we need a ::remove_child handler? */
348 /* fixme: We need ::order_changed handler too (Lauris) */
350 GSList *
351 pattern_getchildren (SPPattern *pat)
352 {
353 GSList *l = NULL;
355 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
356 if (sp_object_first_child(SP_OBJECT(pat_i))) { // find the first one with children
357 for (SPObject *child = sp_object_first_child(SP_OBJECT (pat)) ; child != NULL ; child = SP_OBJECT_NEXT(child) ) {
358 l = g_slist_prepend (l, child);
359 }
360 break; // do not go further up the chain if children are found
361 }
362 }
364 return l;
365 }
367 static void
368 sp_pattern_update (SPObject *object, SPCtx *ctx, unsigned int flags)
369 {
370 SPPattern *pat = SP_PATTERN (object);
372 if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
373 flags &= SP_OBJECT_MODIFIED_CASCADE;
375 GSList *l = pattern_getchildren (pat);
376 l = g_slist_reverse (l);
378 while (l) {
379 SPObject *child = SP_OBJECT (l->data);
380 sp_object_ref (child, NULL);
381 l = g_slist_remove (l, child);
382 if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
383 child->updateDisplay(ctx, flags);
384 }
385 sp_object_unref (child, NULL);
386 }
387 }
389 static void
390 sp_pattern_modified (SPObject *object, guint flags)
391 {
392 SPPattern *pat = SP_PATTERN (object);
394 if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
395 flags &= SP_OBJECT_MODIFIED_CASCADE;
397 GSList *l = pattern_getchildren (pat);
398 l = g_slist_reverse (l);
400 while (l) {
401 SPObject *child = SP_OBJECT (l->data);
402 sp_object_ref (child, NULL);
403 l = g_slist_remove (l, child);
404 if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
405 child->emitModified(flags);
406 }
407 sp_object_unref (child, NULL);
408 }
409 }
411 /**
412 Gets called when the pattern is reattached to another <pattern>
413 */
414 static void
415 pattern_ref_changed(SPObject *old_ref, SPObject *ref, SPPattern *pat)
416 {
417 if (old_ref) {
418 pat->modified_connection.disconnect();
419 }
420 if (SP_IS_PATTERN (ref)) {
421 pat->modified_connection = ref->connectModified(sigc::bind<2>(sigc::ptr_fun(&pattern_ref_modified), pat));
422 }
424 pattern_ref_modified (ref, 0, pat);
425 }
427 /**
428 Gets called when the referenced <pattern> is changed
429 */
430 static void
431 pattern_ref_modified (SPObject */*ref*/, guint /*flags*/, SPPattern *pattern)
432 {
433 if (SP_IS_OBJECT (pattern))
434 SP_OBJECT (pattern)->requestModified(SP_OBJECT_MODIFIED_FLAG);
435 /* Conditional to avoid causing infinite loop if there's a cycle in the href chain. */
436 }
439 /**
440 Count how many times pat is used by the styles of o and its descendants
441 */
442 guint
443 count_pattern_hrefs(SPObject *o, SPPattern *pat)
444 {
445 if (!o)
446 return 1;
448 guint i = 0;
450 SPStyle *style = SP_OBJECT_STYLE(o);
451 if (style
452 && style->fill.isPaintserver()
453 && SP_IS_PATTERN(SP_STYLE_FILL_SERVER(style))
454 && SP_PATTERN(SP_STYLE_FILL_SERVER(style)) == pat)
455 {
456 i ++;
457 }
458 if (style
459 && style->stroke.isPaintserver()
460 && SP_IS_PATTERN(SP_STYLE_STROKE_SERVER(style))
461 && SP_PATTERN(SP_STYLE_STROKE_SERVER(style)) == pat)
462 {
463 i ++;
464 }
466 for (SPObject *child = sp_object_first_child(o);
467 child != NULL; child = SP_OBJECT_NEXT(child)) {
468 i += count_pattern_hrefs(child, pat);
469 }
471 return i;
472 }
474 SPPattern *
475 pattern_chain (SPPattern *pattern)
476 {
477 SPDocument *document = SP_OBJECT_DOCUMENT (pattern);
478 Inkscape::XML::Document *xml_doc = sp_document_repr_doc(document);
479 Inkscape::XML::Node *defsrepr = SP_OBJECT_REPR (SP_DOCUMENT_DEFS (document));
481 Inkscape::XML::Node *repr = xml_doc->createElement("svg:pattern");
482 repr->setAttribute("inkscape:collect", "always");
483 gchar *parent_ref = g_strconcat ("#", SP_OBJECT_REPR(pattern)->attribute("id"), NULL);
484 repr->setAttribute("xlink:href", parent_ref);
485 g_free (parent_ref);
487 defsrepr->addChild(repr, NULL);
488 const gchar *child_id = repr->attribute("id");
489 SPObject *child = document->getObjectById(child_id);
490 g_assert (SP_IS_PATTERN (child));
492 return SP_PATTERN (child);
493 }
495 SPPattern *
496 sp_pattern_clone_if_necessary (SPItem *item, SPPattern *pattern, const gchar *property)
497 {
498 if (!pattern->href || SP_OBJECT_HREFCOUNT(pattern) > count_pattern_hrefs(item, pattern)) {
499 pattern = pattern_chain (pattern);
500 gchar *href = g_strconcat ("url(#", SP_OBJECT_REPR (pattern)->attribute("id"), ")", NULL);
502 SPCSSAttr *css = sp_repr_css_attr_new ();
503 sp_repr_css_set_property (css, property, href);
504 sp_repr_css_change_recursive (SP_OBJECT_REPR (item), css, "style");
505 }
506 return pattern;
507 }
509 void
510 sp_pattern_transform_multiply (SPPattern *pattern, Geom::Matrix postmul, bool set)
511 {
512 // this formula is for a different interpretation of pattern transforms as described in (*) in sp-pattern.cpp
513 // for it to work, we also need sp_object_read_attr (SP_OBJECT (item), "transform");
514 //pattern->patternTransform = premul * item->transform * pattern->patternTransform * item->transform.inverse() * postmul;
516 // otherwise the formula is much simpler
517 if (set) {
518 pattern->patternTransform = postmul;
519 } else {
520 pattern->patternTransform = pattern_patternTransform(pattern) * postmul;
521 }
522 pattern->patternTransform_set = TRUE;
524 gchar *c=sp_svg_transform_write(pattern->patternTransform);
525 SP_OBJECT_REPR(pattern)->setAttribute("patternTransform", c);
526 g_free(c);
527 }
529 const gchar *
530 pattern_tile (GSList *reprs, Geom::Rect bounds, SPDocument *document, Geom::Matrix transform, Geom::Matrix move)
531 {
532 Inkscape::XML::Document *xml_doc = sp_document_repr_doc(document);
533 Inkscape::XML::Node *defsrepr = SP_OBJECT_REPR (SP_DOCUMENT_DEFS (document));
535 Inkscape::XML::Node *repr = xml_doc->createElement("svg:pattern");
536 repr->setAttribute("patternUnits", "userSpaceOnUse");
537 sp_repr_set_svg_double(repr, "width", bounds.dimensions()[Geom::X]);
538 sp_repr_set_svg_double(repr, "height", bounds.dimensions()[Geom::Y]);
540 gchar *t=sp_svg_transform_write(transform);
541 repr->setAttribute("patternTransform", t);
542 g_free(t);
544 defsrepr->appendChild(repr);
545 const gchar *pat_id = repr->attribute("id");
546 SPObject *pat_object = document->getObjectById(pat_id);
548 for (GSList *i = reprs; i != NULL; i = i->next) {
549 Inkscape::XML::Node *node = (Inkscape::XML::Node *)(i->data);
550 SPItem *copy = SP_ITEM(pat_object->appendChildRepr(node));
552 Geom::Matrix dup_transform;
553 if (!sp_svg_transform_read (node->attribute("transform"), &dup_transform))
554 dup_transform = Geom::identity();
555 dup_transform *= move;
557 sp_item_write_transform(copy, SP_OBJECT_REPR(copy), dup_transform, NULL, false);
558 }
560 Inkscape::GC::release(repr);
561 return pat_id;
562 }
564 SPPattern *
565 pattern_getroot (SPPattern *pat)
566 {
567 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
568 if (sp_object_first_child(SP_OBJECT(pat_i))) { // find the first one with children
569 return pat_i;
570 }
571 }
572 return pat; // document is broken, we can't get to root; but at least we can return pat which is supposedly a valid pattern
573 }
577 // Access functions that look up fields up the chain of referenced patterns and return the first one which is set
578 // FIXME: all of them must use chase_hrefs the same as in SPGradient, to avoid lockup on circular refs
580 guint pattern_patternUnits (SPPattern *pat)
581 {
582 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
583 if (pat_i->patternUnits_set)
584 return pat_i->patternUnits;
585 }
586 return pat->patternUnits;
587 }
589 guint pattern_patternContentUnits (SPPattern *pat)
590 {
591 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
592 if (pat_i->patternContentUnits_set)
593 return pat_i->patternContentUnits;
594 }
595 return pat->patternContentUnits;
596 }
598 Geom::Matrix const &pattern_patternTransform(SPPattern const *pat)
599 {
600 for (SPPattern const *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
601 if (pat_i->patternTransform_set)
602 return pat_i->patternTransform;
603 }
604 return pat->patternTransform;
605 }
607 gdouble pattern_x (SPPattern *pat)
608 {
609 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
610 if (pat_i->x._set)
611 return pat_i->x.computed;
612 }
613 return 0;
614 }
616 gdouble pattern_y (SPPattern *pat)
617 {
618 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
619 if (pat_i->y._set)
620 return pat_i->y.computed;
621 }
622 return 0;
623 }
625 gdouble pattern_width (SPPattern *pat)
626 {
627 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
628 if (pat_i->width._set)
629 return pat_i->width.computed;
630 }
631 return 0;
632 }
634 gdouble pattern_height (SPPattern *pat)
635 {
636 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
637 if (pat_i->height._set)
638 return pat_i->height.computed;
639 }
640 return 0;
641 }
643 NRRect *pattern_viewBox (SPPattern *pat)
644 {
645 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
646 if (pat_i->viewBox_set)
647 return &(pat_i->viewBox);
648 }
649 return &(pat->viewBox);
650 }
652 bool pattern_hasItemChildren (SPPattern *pat)
653 {
654 for (SPObject *child = sp_object_first_child(SP_OBJECT(pat)) ; child != NULL; child = SP_OBJECT_NEXT(child) ) {
655 if (SP_IS_ITEM (child)) {
656 return true;
657 }
658 }
659 return false;
660 }
664 /* Painter */
666 static void sp_pat_fill (SPPainter *painter, NRPixBlock *pb);
668 // item in this pattern is about to be deleted, hide it on our arena and disconnect
669 void
670 sp_pattern_painter_release (SPObject *obj, SPPatPainter *painter)
671 {
672 std::map<SPObject *, sigc::connection>::iterator iter = painter->_release_connections->find(obj);
673 if (iter != painter->_release_connections->end()) {
674 iter->second.disconnect();
675 painter->_release_connections->erase(obj);
676 }
678 sp_item_invoke_hide(SP_ITEM(obj), painter->dkey);
679 }
681 /**
682 Creates a painter (i.e. the thing that does actual filling at the given zoom).
683 See (*) below for why the parent_transform may be necessary.
684 */
685 static SPPainter *
686 sp_pattern_painter_new (SPPaintServer *ps, Geom::Matrix const &full_transform, Geom::Matrix const &/*parent_transform*/, const NRRect *bbox)
687 {
688 SPPattern *pat = SP_PATTERN (ps);
689 SPPatPainter *pp = g_new (SPPatPainter, 1);
691 pp->painter.type = SP_PAINTER_IND;
692 pp->painter.fill = sp_pat_fill;
694 pp->pat = pat;
696 if (pattern_patternUnits (pat) == SP_PATTERN_UNITS_OBJECTBOUNDINGBOX) {
697 /* BBox to user coordinate system */
698 Geom::Matrix bbox2user (bbox->x1 - bbox->x0, 0.0, 0.0, bbox->y1 - bbox->y0, bbox->x0, bbox->y0);
700 // the final patternTransform, taking into account bbox
701 Geom::Matrix const ps2user(pattern_patternTransform(pat) * bbox2user);
703 // see (*) comment below
704 pp->ps2px = ps2user * full_transform;
705 } else {
706 /* Problem: What to do, if we have mixed lengths and percentages? */
707 /* Currently we do ignore percentages at all, but that is not good (lauris) */
709 /* fixme: We may try to normalize here too, look at linearGradient (Lauris) */
711 // (*) The spec says, "This additional transformation matrix [patternTransform] is
712 // post-multiplied to (i.e., inserted to the right of) any previously defined
713 // transformations, including the implicit transformation necessary to convert from
714 // object bounding box units to user space." To me, this means that the order should be:
715 // item_transform * patternTransform * parent_transform
716 // However both Batik and Adobe plugin use:
717 // patternTransform * item_transform * parent_transform
718 // So here I comply with the majority opinion, but leave my interpretation commented out below.
719 // (To get item_transform, I subtract parent from full.)
721 //pp->ps2px = (full_transform / parent_transform) * pattern_patternTransform(pat) * parent_transform;
722 pp->ps2px = pattern_patternTransform(pat) * full_transform;
723 }
725 pp->px2ps = pp->ps2px.inverse();
727 if (pat->viewBox_set) {
728 gdouble tmp_x = pattern_width (pat) / (pattern_viewBox(pat)->x1 - pattern_viewBox(pat)->x0);
729 gdouble tmp_y = pattern_height (pat) / (pattern_viewBox(pat)->y1 - pattern_viewBox(pat)->y0);
731 // FIXME: preserveAspectRatio must be taken into account here too!
732 Geom::Matrix vb2ps (tmp_x, 0.0, 0.0, tmp_y, pattern_x(pat) - pattern_viewBox(pat)->x0 * tmp_x, pattern_y(pat) - pattern_viewBox(pat)->y0 * tmp_y);
734 Geom::Matrix vb2us = vb2ps * pattern_patternTransform(pat);
736 // see (*)
737 pp->pcs2px = vb2us * full_transform;
738 } else {
739 /* No viewbox, have to parse units */
740 if (pattern_patternContentUnits (pat) == SP_PATTERN_UNITS_OBJECTBOUNDINGBOX) {
741 /* BBox to user coordinate system */
742 Geom::Matrix bbox2user (bbox->x1 - bbox->x0, 0.0, 0.0, bbox->y1 - bbox->y0, bbox->x0, bbox->y0);
744 Geom::Matrix pcs2user = pattern_patternTransform(pat) * bbox2user;
746 // see (*)
747 pp->pcs2px = pcs2user * full_transform;
748 } else {
749 // see (*)
750 //pcs2px = (full_transform / parent_transform) * pattern_patternTransform(pat) * parent_transform;
751 pp->pcs2px = pattern_patternTransform(pat) * full_transform;
752 }
754 pp->pcs2px = Geom::Translate (pattern_x (pat), pattern_y (pat)) * pp->pcs2px;
755 }
757 /* Create arena */
758 pp->arena = NRArena::create();
760 pp->dkey = sp_item_display_key_new (1);
762 /* Create group */
763 pp->root = NRArenaGroup::create(pp->arena);
765 /* Show items */
766 pp->_release_connections = new std::map<SPObject *, sigc::connection>;
767 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
768 if (pat_i && SP_IS_OBJECT (pat_i) && pattern_hasItemChildren(pat_i)) { // find the first one with item children
769 for (SPObject *child = sp_object_first_child(SP_OBJECT(pat_i)) ; child != NULL; child = SP_OBJECT_NEXT(child) ) {
770 if (SP_IS_ITEM (child)) {
771 // for each item in pattern,
772 NRArenaItem *cai;
773 // show it on our arena,
774 cai = sp_item_invoke_show (SP_ITEM (child), pp->arena, pp->dkey, SP_ITEM_REFERENCE_FLAGS);
775 // add to the group,
776 nr_arena_item_append_child (pp->root, cai);
777 // and connect to the release signal in case the item gets deleted
778 pp->_release_connections->insert(std::make_pair(child, child->connectRelease(sigc::bind<1>(sigc::ptr_fun(&sp_pattern_painter_release), pp))));
779 }
780 }
781 break; // do not go further up the chain if children are found
782 }
783 }
785 {
786 NRRect one_tile,tr_tile;
787 one_tile.x0=pattern_x(pp->pat);
788 one_tile.y0=pattern_y(pp->pat);
789 one_tile.x1=one_tile.x0+pattern_width (pp->pat);
790 one_tile.y1=one_tile.y0+pattern_height (pp->pat);
791 // TODO: remove ps2px_nr after converting to 2geom
792 NR::Matrix ps2px_nr = from_2geom(pp->ps2px);
793 nr_rect_d_matrix_transform (&tr_tile, &one_tile, &ps2px_nr);
794 int tr_width=(int)ceil(1.3*(tr_tile.x1-tr_tile.x0));
795 int tr_height=(int)ceil(1.3*(tr_tile.y1-tr_tile.y0));
796 // if ( tr_width < 10000 && tr_height < 10000 && tr_width*tr_height < 1000000 ) {
797 pp->use_cached_tile=false;//true;
798 if ( tr_width > 1000 ) tr_width=1000;
799 if ( tr_height > 1000 ) tr_height=1000;
800 pp->cached_bbox.x0=0;
801 pp->cached_bbox.y0=0;
802 pp->cached_bbox.x1=tr_width;
803 pp->cached_bbox.y1=tr_height;
805 if (pp->use_cached_tile) {
806 nr_pixblock_setup (&pp->cached_tile,NR_PIXBLOCK_MODE_R8G8B8A8N, pp->cached_bbox.x0, pp->cached_bbox.y0, pp->cached_bbox.x1, pp->cached_bbox.y1,TRUE);
807 }
809 pp->pa2ca[0]=((double)tr_width)/(one_tile.x1-one_tile.x0);
810 pp->pa2ca[1]=0;
811 pp->pa2ca[2]=0;
812 pp->pa2ca[3]=((double)tr_height)/(one_tile.y1-one_tile.y0);
813 pp->pa2ca[4]=-one_tile.x0*pp->pa2ca[0];
814 pp->pa2ca[5]=-one_tile.y0*pp->pa2ca[1];
815 pp->ca2pa[0]=(one_tile.x1-one_tile.x0)/((double)tr_width);
816 pp->ca2pa[1]=0;
817 pp->ca2pa[2]=0;
818 pp->ca2pa[3]=(one_tile.y1-one_tile.y0)/((double)tr_height);
819 pp->ca2pa[4]=one_tile.x0;
820 pp->ca2pa[5]=one_tile.y0;
821 // } else {
822 // pp->use_cached_tile=false;
823 // }
824 }
826 NRGC gc(NULL);
827 if ( pp->use_cached_tile ) {
828 gc.transform=pp->pa2ca;
829 } else {
830 gc.transform = pp->pcs2px;
831 }
832 nr_arena_item_invoke_update (pp->root, NULL, &gc, NR_ARENA_ITEM_STATE_ALL, NR_ARENA_ITEM_STATE_ALL);
833 if ( pp->use_cached_tile ) {
834 nr_arena_item_invoke_render (NULL, pp->root, &pp->cached_bbox, &pp->cached_tile, 0);
835 } else {
836 // nothing to do now
837 }
839 return (SPPainter *) pp;
840 }
843 static void
844 sp_pattern_painter_free (SPPaintServer */*ps*/, SPPainter *painter)
845 {
846 SPPatPainter *pp = (SPPatPainter *) painter;
847 // free our arena
848 if (pp->arena) {
849 ((NRObject *) pp->arena)->unreference();
850 pp->arena = NULL;
851 }
853 // disconnect all connections
854 std::map<SPObject *, sigc::connection>::iterator iter;
855 for (iter = pp->_release_connections->begin() ; iter!=pp->_release_connections->end() ; iter++) {
856 iter->second.disconnect();
857 }
858 pp->_release_connections->clear();
859 delete pp->_release_connections;
861 if ( pp->use_cached_tile ) nr_pixblock_release(&pp->cached_tile);
862 g_free (pp);
863 }
865 void
866 get_cached_tile_pixel(SPPatPainter* pp,double x,double y,unsigned char &r,unsigned char &g,unsigned char &b,unsigned char &a)
867 {
868 int ca_h=(int)floor(x);
869 int ca_v=(int)floor(y);
870 int r_x=(int)floor(16*(x-floor(x)));
871 int r_y=(int)floor(16*(y-floor(y)));
872 unsigned int tl_m=(16-r_x)*(16-r_y);
873 unsigned int bl_m=(16-r_x)*r_y;
874 unsigned int tr_m=r_x*(16-r_y);
875 unsigned int br_m=r_x*r_y;
876 int cb_h=ca_h+1;
877 int cb_v=ca_v+1;
878 if ( cb_h >= pp->cached_bbox.x1 ) cb_h=0;
879 if ( cb_v >= pp->cached_bbox.y1 ) cb_v=0;
881 unsigned char* tlx=NR_PIXBLOCK_PX(&pp->cached_tile)+(ca_v*pp->cached_tile.rs)+4*ca_h;
882 unsigned char* trx=NR_PIXBLOCK_PX(&pp->cached_tile)+(ca_v*pp->cached_tile.rs)+4*cb_h;
883 unsigned char* blx=NR_PIXBLOCK_PX(&pp->cached_tile)+(cb_v*pp->cached_tile.rs)+4*ca_h;
884 unsigned char* brx=NR_PIXBLOCK_PX(&pp->cached_tile)+(cb_v*pp->cached_tile.rs)+4*cb_h;
886 unsigned int tl_c=tlx[0];
887 unsigned int tr_c=trx[0];
888 unsigned int bl_c=blx[0];
889 unsigned int br_c=brx[0];
890 unsigned int f_c=(tl_m*tl_c+tr_m*tr_c+bl_m*bl_c+br_m*br_c)>>8;
891 r=f_c;
892 tl_c=tlx[1];
893 tr_c=trx[1];
894 bl_c=blx[1];
895 br_c=brx[1];
896 f_c=(tl_m*tl_c+tr_m*tr_c+bl_m*bl_c+br_m*br_c)>>8;
897 g=f_c;
898 tl_c=tlx[2];
899 tr_c=trx[2];
900 bl_c=blx[2];
901 br_c=brx[2];
902 f_c=(tl_m*tl_c+tr_m*tr_c+bl_m*bl_c+br_m*br_c)>>8;
903 b=f_c;
904 tl_c=tlx[3];
905 tr_c=trx[3];
906 bl_c=blx[3];
907 br_c=brx[3];
908 f_c=(tl_m*tl_c+tr_m*tr_c+bl_m*bl_c+br_m*br_c)>>8;
909 a=f_c;
910 }
912 static void
913 sp_pat_fill (SPPainter *painter, NRPixBlock *pb)
914 {
915 SPPatPainter *pp;
916 NRRect ba, psa;
917 NRRectL area;
918 double x, y;
920 pp = (SPPatPainter *) painter;
922 if (pattern_width (pp->pat) < NR_EPSILON) return;
923 if (pattern_height (pp->pat) < NR_EPSILON) return;
925 /* Find buffer area in gradient space */
926 /* fixme: This is suboptimal (Lauris) */
928 if ( pp->use_cached_tile ) {
929 double pat_w=pattern_width (pp->pat);
930 double pat_h=pattern_height (pp->pat);
931 if ( pb->mode == NR_PIXBLOCK_MODE_R8G8B8A8N || pb->mode == NR_PIXBLOCK_MODE_R8G8B8A8P ) { // same thing because it's filling an empty pixblock
932 unsigned char* lpx=NR_PIXBLOCK_PX(pb);
933 double px_y=pb->area.y0;
934 for (int j=pb->area.y0;j<pb->area.y1;j++) {
935 unsigned char* cpx=lpx;
936 double px_x = pb->area.x0;
938 double ps_x=pp->px2ps[0]*px_x+pp->px2ps[2]*px_y+pp->px2ps[4];
939 double ps_y=pp->px2ps[1]*px_x+pp->px2ps[3]*px_y+pp->px2ps[5];
940 for (int i=pb->area.x0;i<pb->area.x1;i++) {
941 while ( ps_x > pat_w ) ps_x-=pat_w;
942 while ( ps_x < 0 ) ps_x+=pat_w;
943 while ( ps_y > pat_h ) ps_y-=pat_h;
944 while ( ps_y < 0 ) ps_y+=pat_h;
945 double ca_x=pp->pa2ca[0]*ps_x+pp->pa2ca[2]*ps_y+pp->pa2ca[4];
946 double ca_y=pp->pa2ca[1]*ps_x+pp->pa2ca[3]*ps_y+pp->pa2ca[5];
947 unsigned char n_a,n_r,n_g,n_b;
948 get_cached_tile_pixel(pp,ca_x,ca_y,n_r,n_g,n_b,n_a);
949 cpx[0]=n_r;
950 cpx[1]=n_g;
951 cpx[2]=n_b;
952 cpx[3]=n_a;
954 px_x+=1.0;
955 ps_x+=pp->px2ps[0];
956 ps_y+=pp->px2ps[1];
957 cpx+=4;
958 }
959 px_y+=1.0;
960 lpx+=pb->rs;
961 }
962 } else if ( pb->mode == NR_PIXBLOCK_MODE_R8G8B8 ) {
963 unsigned char* lpx=NR_PIXBLOCK_PX(pb);
964 double px_y=pb->area.y0;
965 for (int j=pb->area.y0;j<pb->area.y1;j++) {
966 unsigned char* cpx=lpx;
967 double px_x = pb->area.x0;
969 double ps_x=pp->px2ps[0]*px_x+pp->px2ps[2]*px_y+pp->px2ps[4];
970 double ps_y=pp->px2ps[1]*px_x+pp->px2ps[3]*px_y+pp->px2ps[5];
971 for (int i=pb->area.x0;i<pb->area.x1;i++) {
972 while ( ps_x > pat_w ) ps_x-=pat_w;
973 while ( ps_x < 0 ) ps_x+=pat_w;
974 while ( ps_y > pat_h ) ps_y-=pat_h;
975 while ( ps_y < 0 ) ps_y+=pat_h;
976 double ca_x=pp->pa2ca[0]*ps_x+pp->pa2ca[2]*ps_y+pp->pa2ca[4];
977 double ca_y=pp->pa2ca[1]*ps_x+pp->pa2ca[3]*ps_y+pp->pa2ca[5];
978 unsigned char n_a,n_r,n_g,n_b;
979 get_cached_tile_pixel(pp,ca_x,ca_y,n_r,n_g,n_b,n_a);
980 cpx[0]=n_r;
981 cpx[1]=n_g;
982 cpx[2]=n_b;
984 px_x+=1.0;
985 ps_x+=pp->px2ps[0];
986 ps_y+=pp->px2ps[1];
987 cpx+=4;
988 }
989 px_y+=1.0;
990 lpx+=pb->rs;
991 }
992 }
993 } else {
994 ba.x0 = pb->area.x0;
995 ba.y0 = pb->area.y0;
996 ba.x1 = pb->area.x1;
997 ba.y1 = pb->area.y1;
999 // Trying to solve this bug: https://bugs.launchpad.net/inkscape/+bug/167416
1000 // Bail out if the transformation matrix has extreme values. If we bail out
1001 // however, then something (which was meaningless anyway) won't be rendered,
1002 // which is better than getting stuck in a virtually infinite loop
1003 if (fabs(pp->px2ps[0]) < 1e6 &&
1004 fabs(pp->px2ps[3]) < 1e6 &&
1005 fabs(pp->px2ps[4]) < 1e6 &&
1006 fabs(pp->px2ps[5]) < 1e6)
1007 {
1008 // TODO: remove px2ps_nr after converting to 2geom
1009 NR::Matrix px2ps_nr = from_2geom(pp->px2ps);
1010 nr_rect_d_matrix_transform (&psa, &ba, &px2ps_nr);
1012 psa.x0 = floor ((psa.x0 - pattern_x (pp->pat)) / pattern_width (pp->pat)) -1;
1013 psa.y0 = floor ((psa.y0 - pattern_y (pp->pat)) / pattern_height (pp->pat)) -1;
1014 psa.x1 = ceil ((psa.x1 - pattern_x (pp->pat)) / pattern_width (pp->pat)) +1;
1015 psa.y1 = ceil ((psa.y1 - pattern_y (pp->pat)) / pattern_height (pp->pat)) +1;
1017 // If psa is too wide or tall, then something must be wrong! This is due to
1018 // nr_rect_d_matrix_transform (&psa, &ba, &pp->px2ps) using a weird transformation matrix pp->px2ps.
1019 g_assert(std::abs(psa.x1 - psa.x0) < 1e6);
1020 g_assert(std::abs(psa.y1 - psa.y0) < 1e6);
1022 for (y = psa.y0; y < psa.y1; y++) {
1023 for (x = psa.x0; x < psa.x1; x++) {
1024 NRPixBlock ppb;
1025 double psx, psy;
1027 psx = x * pattern_width (pp->pat);
1028 psy = y * pattern_height (pp->pat);
1030 area.x0 = (gint32)(pb->area.x0 - (pp->ps2px[0] * psx + pp->ps2px[2] * psy));
1031 area.y0 = (gint32)(pb->area.y0 - (pp->ps2px[1] * psx + pp->ps2px[3] * psy));
1032 area.x1 = area.x0 + pb->area.x1 - pb->area.x0;
1033 area.y1 = area.y0 + pb->area.y1 - pb->area.y0;
1035 // We do not update here anymore
1037 // Set up buffer
1038 // fixme: (Lauris)
1039 nr_pixblock_setup_extern (&ppb, pb->mode, area.x0, area.y0, area.x1, area.y1, NR_PIXBLOCK_PX (pb), pb->rs, FALSE, FALSE);
1041 nr_arena_item_invoke_render (NULL, pp->root, &area, &ppb, 0);
1043 nr_pixblock_release (&ppb);
1044 }
1045 }
1046 }
1047 }
1048 }