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 #include "config.h"
17 #include <libnr/nr-matrix-ops.h>
18 #include "libnr/nr-matrix-fns.h"
19 #include <libnr/nr-translate-matrix-ops.h>
20 #include "macros.h"
21 #include "svg/svg.h"
22 #include "display/nr-arena.h"
23 #include "display/nr-arena-group.h"
24 #include "attributes.h"
25 #include "document-private.h"
26 #include "uri.h"
27 #include "sp-pattern.h"
28 #include "xml/repr.h"
30 #include <sigc++/functors/ptr_fun.h>
31 #include <sigc++/adaptors/bind.h>
33 /*
34 * Pattern
35 */
37 class SPPatPainter;
39 struct SPPatPainter {
40 SPPainter painter;
41 SPPattern *pat;
43 NRMatrix ps2px;
44 NRMatrix px2ps;
45 NRMatrix pcs2px;
47 NRArena *arena;
48 unsigned int dkey;
49 NRArenaItem *root;
51 bool use_cached_tile;
52 NRMatrix ca2pa;
53 NRMatrix pa2ca;
54 NRRectL cached_bbox;
55 NRPixBlock cached_tile;
56 };
58 static void sp_pattern_class_init (SPPatternClass *klass);
59 static void sp_pattern_init (SPPattern *gr);
61 static void sp_pattern_build (SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
62 static void sp_pattern_release (SPObject *object);
63 static void sp_pattern_set (SPObject *object, unsigned int key, const gchar *value);
64 static void sp_pattern_child_added (SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref);
65 static void sp_pattern_update (SPObject *object, SPCtx *ctx, unsigned int flags);
66 static void sp_pattern_modified (SPObject *object, unsigned int flags);
68 static void pattern_ref_changed(SPObject *old_ref, SPObject *ref, SPPattern *pat);
69 static void pattern_ref_modified (SPObject *ref, guint flags, SPPattern *pattern);
71 static SPPainter *sp_pattern_painter_new (SPPaintServer *ps, NR::Matrix const &full_transform, NR::Matrix const &parent_transform, const NRRect *bbox);
72 static void sp_pattern_painter_free (SPPaintServer *ps, SPPainter *painter);
74 static SPPaintServerClass * pattern_parent_class;
76 GType
77 sp_pattern_get_type (void)
78 {
79 static GType pattern_type = 0;
80 if (!pattern_type) {
81 GTypeInfo pattern_info = {
82 sizeof (SPPatternClass),
83 NULL, /* base_init */
84 NULL, /* base_finalize */
85 (GClassInitFunc) sp_pattern_class_init,
86 NULL, /* class_finalize */
87 NULL, /* class_data */
88 sizeof (SPPattern),
89 16, /* n_preallocs */
90 (GInstanceInitFunc) sp_pattern_init,
91 NULL, /* value_table */
92 };
93 pattern_type = g_type_register_static (SP_TYPE_PAINT_SERVER, "SPPattern", &pattern_info, (GTypeFlags)0);
94 }
95 return pattern_type;
96 }
98 static void
99 sp_pattern_class_init (SPPatternClass *klass)
100 {
101 SPObjectClass *sp_object_class;
102 SPPaintServerClass *ps_class;
104 sp_object_class = (SPObjectClass *) klass;
105 ps_class = (SPPaintServerClass *) klass;
107 pattern_parent_class = (SPPaintServerClass*)g_type_class_ref (SP_TYPE_PAINT_SERVER);
109 sp_object_class->build = sp_pattern_build;
110 sp_object_class->release = sp_pattern_release;
111 sp_object_class->set = sp_pattern_set;
112 sp_object_class->child_added = sp_pattern_child_added;
113 sp_object_class->update = sp_pattern_update;
114 sp_object_class->modified = sp_pattern_modified;
116 // do we need _write? seems to work without it
118 ps_class->painter_new = sp_pattern_painter_new;
119 ps_class->painter_free = sp_pattern_painter_free;
120 }
122 static void
123 sp_pattern_init (SPPattern *pat)
124 {
125 pat->ref = new SPPatternReference(SP_OBJECT(pat));
126 pat->ref->changedSignal().connect(sigc::bind(sigc::ptr_fun(pattern_ref_changed), pat));
128 pat->patternUnits = SP_PATTERN_UNITS_OBJECTBOUNDINGBOX;
129 pat->patternUnits_set = FALSE;
131 pat->patternContentUnits = SP_PATTERN_UNITS_USERSPACEONUSE;
132 pat->patternContentUnits_set = FALSE;
134 pat->patternTransform = NR::identity();
135 pat->patternTransform_set = FALSE;
137 pat->x.unset();
138 pat->y.unset();
139 pat->width.unset();
140 pat->height.unset();
142 pat->viewBox_set = FALSE;
144 new (&pat->modified_connection) sigc::connection();
145 }
147 static void
148 sp_pattern_build (SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
149 {
150 if (((SPObjectClass *) pattern_parent_class)->build)
151 (* ((SPObjectClass *) pattern_parent_class)->build) (object, document, repr);
153 sp_object_read_attr (object, "patternUnits");
154 sp_object_read_attr (object, "patternContentUnits");
155 sp_object_read_attr (object, "patternTransform");
156 sp_object_read_attr (object, "x");
157 sp_object_read_attr (object, "y");
158 sp_object_read_attr (object, "width");
159 sp_object_read_attr (object, "height");
160 sp_object_read_attr (object, "viewBox");
161 sp_object_read_attr (object, "xlink:href");
163 /* Register ourselves */
164 sp_document_add_resource (document, "pattern", object);
165 }
167 static void
168 sp_pattern_release (SPObject *object)
169 {
170 SPPattern *pat;
172 pat = (SPPattern *) object;
174 if (SP_OBJECT_DOCUMENT (object)) {
175 /* Unregister ourselves */
176 sp_document_remove_resource (SP_OBJECT_DOCUMENT (object), "pattern", SP_OBJECT (object));
177 }
179 if (pat->ref) {
180 pat->modified_connection.disconnect();
181 pat->ref->detach();
182 delete pat->ref;
183 pat->ref = NULL;
184 }
186 pat->modified_connection.~connection();
188 if (((SPObjectClass *) pattern_parent_class)->release)
189 ((SPObjectClass *) pattern_parent_class)->release (object);
190 }
192 static void
193 sp_pattern_set (SPObject *object, unsigned int key, const gchar *value)
194 {
195 SPPattern *pat = SP_PATTERN (object);
197 switch (key) {
198 case SP_ATTR_PATTERNUNITS:
199 if (value) {
200 if (!strcmp (value, "userSpaceOnUse")) {
201 pat->patternUnits = SP_PATTERN_UNITS_USERSPACEONUSE;
202 } else {
203 pat->patternUnits = SP_PATTERN_UNITS_OBJECTBOUNDINGBOX;
204 }
205 pat->patternUnits_set = TRUE;
206 } else {
207 pat->patternUnits_set = FALSE;
208 }
209 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
210 break;
211 case SP_ATTR_PATTERNCONTENTUNITS:
212 if (value) {
213 if (!strcmp (value, "userSpaceOnUse")) {
214 pat->patternContentUnits = SP_PATTERN_UNITS_USERSPACEONUSE;
215 } else {
216 pat->patternContentUnits = SP_PATTERN_UNITS_OBJECTBOUNDINGBOX;
217 }
218 pat->patternContentUnits_set = TRUE;
219 } else {
220 pat->patternContentUnits_set = FALSE;
221 }
222 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
223 break;
224 case SP_ATTR_PATTERNTRANSFORM: {
225 NR::Matrix t;
226 if (value && sp_svg_transform_read (value, &t)) {
227 pat->patternTransform = t;
228 pat->patternTransform_set = TRUE;
229 } else {
230 pat->patternTransform = NR::identity();
231 pat->patternTransform_set = FALSE;
232 }
233 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
234 break;
235 }
236 case SP_ATTR_X:
237 pat->x.readOrUnset(value);
238 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
239 break;
240 case SP_ATTR_Y:
241 pat->y.readOrUnset(value);
242 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
243 break;
244 case SP_ATTR_WIDTH:
245 pat->width.readOrUnset(value);
246 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
247 break;
248 case SP_ATTR_HEIGHT:
249 pat->height.readOrUnset(value);
250 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
251 break;
252 case SP_ATTR_VIEWBOX: {
253 /* fixme: Think (Lauris) */
254 double x, y, width, height;
255 char *eptr;
257 if (value) {
258 eptr = (gchar *) value;
259 x = g_ascii_strtod (eptr, &eptr);
260 while (*eptr && ((*eptr == ',') || (*eptr == ' '))) eptr++;
261 y = g_ascii_strtod (eptr, &eptr);
262 while (*eptr && ((*eptr == ',') || (*eptr == ' '))) eptr++;
263 width = g_ascii_strtod (eptr, &eptr);
264 while (*eptr && ((*eptr == ',') || (*eptr == ' '))) eptr++;
265 height = g_ascii_strtod (eptr, &eptr);
266 while (*eptr && ((*eptr == ',') || (*eptr == ' '))) eptr++;
267 if ((width > 0) && (height > 0)) {
268 pat->viewBox.x0 = x;
269 pat->viewBox.y0 = y;
270 pat->viewBox.x1 = x + width;
271 pat->viewBox.y1 = y + height;
272 pat->viewBox_set = TRUE;
273 } else {
274 pat->viewBox_set = FALSE;
275 }
276 } else {
277 pat->viewBox_set = FALSE;
278 }
279 object->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_VIEWPORT_MODIFIED_FLAG);
280 break;
281 }
282 case SP_ATTR_XLINK_HREF:
283 if ( value && pat->href && ( strcmp(value, pat->href) == 0 ) ) {
284 /* Href unchanged, do nothing. */
285 } else {
286 g_free(pat->href);
287 pat->href = NULL;
288 if (value) {
289 // First, set the href field; it's only used in the "unchanged" check above.
290 pat->href = g_strdup(value);
291 // Now do the attaching, which emits the changed signal.
292 if (value) {
293 try {
294 pat->ref->attach(Inkscape::URI(value));
295 } catch (Inkscape::BadURIException &e) {
296 g_warning("%s", e.what());
297 pat->ref->detach();
298 }
299 } else {
300 pat->ref->detach();
301 }
302 }
303 }
304 break;
305 default:
306 if (((SPObjectClass *) pattern_parent_class)->set)
307 ((SPObjectClass *) pattern_parent_class)->set (object, key, value);
308 break;
309 }
310 }
312 static void
313 sp_pattern_child_added (SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
314 {
315 SPPattern *pat = SP_PATTERN (object);
317 if (((SPObjectClass *) (pattern_parent_class))->child_added)
318 (* ((SPObjectClass *) (pattern_parent_class))->child_added) (object, child, ref);
320 SPObject *ochild = sp_object_get_child_by_repr(object, child);
321 if (SP_IS_ITEM (ochild)) {
323 SPPaintServer *ps = SP_PAINT_SERVER (pat);
324 unsigned position = sp_item_pos_in_parent(SP_ITEM(ochild));
326 for (SPPainter *p = ps->painters; p != NULL; p = p->next) {
328 SPPatPainter *pp = (SPPatPainter *) p;
329 NRArenaItem *ai = sp_item_invoke_show (SP_ITEM (ochild), pp->arena, pp->dkey, SP_ITEM_REFERENCE_FLAGS);
331 if (ai) {
332 nr_arena_item_add_child (pp->root, ai, NULL);
333 nr_arena_item_set_order (ai, position);
334 nr_arena_item_unref (ai);
335 }
336 }
337 }
338 }
340 /* TODO: do we need a ::remove_child handler? */
342 /* fixme: We need ::order_changed handler too (Lauris) */
344 GSList *
345 pattern_getchildren (SPPattern *pat)
346 {
347 GSList *l = NULL;
349 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
350 if (sp_object_first_child(SP_OBJECT(pat_i))) { // find the first one with children
351 for (SPObject *child = sp_object_first_child(SP_OBJECT (pat)) ; child != NULL ; child = SP_OBJECT_NEXT(child) ) {
352 l = g_slist_prepend (l, child);
353 }
354 break; // do not go further up the chain if children are found
355 }
356 }
358 return l;
359 }
361 static void
362 sp_pattern_update (SPObject *object, SPCtx *ctx, unsigned int flags)
363 {
364 SPPattern *pat = SP_PATTERN (object);
366 if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
367 flags &= SP_OBJECT_MODIFIED_CASCADE;
369 GSList *l = pattern_getchildren (pat);
370 l = g_slist_reverse (l);
372 while (l) {
373 SPObject *child = SP_OBJECT (l->data);
374 sp_object_ref (child, NULL);
375 l = g_slist_remove (l, child);
376 if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
377 child->updateDisplay(ctx, flags);
378 }
379 sp_object_unref (child, NULL);
380 }
381 }
383 static void
384 sp_pattern_modified (SPObject *object, guint flags)
385 {
386 SPPattern *pat = SP_PATTERN (object);
388 if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
389 flags &= SP_OBJECT_MODIFIED_CASCADE;
391 GSList *l = pattern_getchildren (pat);
392 l = g_slist_reverse (l);
394 while (l) {
395 SPObject *child = SP_OBJECT (l->data);
396 sp_object_ref (child, NULL);
397 l = g_slist_remove (l, child);
398 if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
399 child->emitModified(flags);
400 }
401 sp_object_unref (child, NULL);
402 }
403 }
405 /**
406 Gets called when the pattern is reattached to another <pattern>
407 */
408 static void
409 pattern_ref_changed(SPObject *old_ref, SPObject *ref, SPPattern *pat)
410 {
411 if (old_ref) {
412 pat->modified_connection.disconnect();
413 }
414 if (SP_IS_PATTERN (ref)) {
415 pat->modified_connection = ref->connectModified(sigc::bind<2>(sigc::ptr_fun(&pattern_ref_modified), pat));
416 }
418 pattern_ref_modified (ref, 0, pat);
419 }
421 /**
422 Gets called when the referenced <pattern> is changed
423 */
424 static void
425 pattern_ref_modified (SPObject *ref, guint flags, SPPattern *pattern)
426 {
427 if (SP_IS_OBJECT (pattern))
428 SP_OBJECT (pattern)->requestModified(SP_OBJECT_MODIFIED_FLAG);
429 }
431 guint
432 pattern_users (SPPattern *pattern)
433 {
434 return SP_OBJECT (pattern)->hrefcount;
435 }
437 SPPattern *
438 pattern_chain (SPPattern *pattern)
439 {
440 SPDocument *document = SP_OBJECT_DOCUMENT (pattern);
441 Inkscape::XML::Document *xml_doc = sp_document_repr_doc(document);
442 Inkscape::XML::Node *defsrepr = SP_OBJECT_REPR (SP_DOCUMENT_DEFS (document));
444 Inkscape::XML::Node *repr = xml_doc->createElement("svg:pattern");
445 repr->setAttribute("inkscape:collect", "always");
446 gchar *parent_ref = g_strconcat ("#", SP_OBJECT_REPR(pattern)->attribute("id"), NULL);
447 repr->setAttribute("xlink:href", parent_ref);
448 g_free (parent_ref);
450 defsrepr->addChild(repr, NULL);
451 const gchar *child_id = repr->attribute("id");
452 SPObject *child = document->getObjectById(child_id);
453 g_assert (SP_IS_PATTERN (child));
455 return SP_PATTERN (child);
456 }
458 SPPattern *
459 sp_pattern_clone_if_necessary (SPItem *item, SPPattern *pattern, const gchar *property)
460 {
461 if (pattern_users(pattern) > 1) {
462 pattern = pattern_chain (pattern);
463 gchar *href = g_strconcat ("url(#", SP_OBJECT_REPR (pattern)->attribute("id"), ")", NULL);
465 SPCSSAttr *css = sp_repr_css_attr_new ();
466 sp_repr_css_set_property (css, property, href);
467 sp_repr_css_change_recursive (SP_OBJECT_REPR (item), css, "style");
468 }
469 return pattern;
470 }
472 void
473 sp_pattern_transform_multiply (SPPattern *pattern, NR::Matrix postmul, bool set)
474 {
475 // this formula is for a different interpretation of pattern transforms as described in (*) in sp-pattern.cpp
476 // for it to work, we also need sp_object_read_attr (SP_OBJECT (item), "transform");
477 //pattern->patternTransform = premul * item->transform * pattern->patternTransform * item->transform.inverse() * postmul;
479 // otherwise the formula is much simpler
480 if (set) {
481 pattern->patternTransform = postmul;
482 } else {
483 pattern->patternTransform = pattern_patternTransform(pattern) * postmul;
484 }
485 pattern->patternTransform_set = TRUE;
487 gchar c[256];
488 if (sp_svg_transform_write(c, 256, pattern->patternTransform)) {
489 SP_OBJECT_REPR(pattern)->setAttribute("patternTransform", c);
490 } else {
491 SP_OBJECT_REPR(pattern)->setAttribute("patternTransform", NULL);
492 }
493 }
495 const gchar *
496 pattern_tile (GSList *reprs, NR::Rect bounds, SPDocument *document, NR::Matrix transform, NR::Matrix move)
497 {
498 Inkscape::XML::Document *xml_doc = sp_document_repr_doc(document);
499 Inkscape::XML::Node *defsrepr = SP_OBJECT_REPR (SP_DOCUMENT_DEFS (document));
501 Inkscape::XML::Node *repr = xml_doc->createElement("svg:pattern");
502 repr->setAttribute("patternUnits", "userSpaceOnUse");
503 sp_repr_set_svg_double(repr, "width", bounds.extent(NR::X));
504 sp_repr_set_svg_double(repr, "height", bounds.extent(NR::Y));
506 gchar t[256];
507 if (sp_svg_transform_write(t, 256, transform)) {
508 repr->setAttribute("patternTransform", t);
509 } else {
510 repr->setAttribute("patternTransform", NULL);
511 }
514 defsrepr->appendChild(repr);
515 const gchar *pat_id = repr->attribute("id");
516 SPObject *pat_object = document->getObjectById(pat_id);
518 for (GSList *i = reprs; i != NULL; i = i->next) {
519 Inkscape::XML::Node *node = (Inkscape::XML::Node *)(i->data);
520 SPItem *copy = SP_ITEM(pat_object->appendChildRepr(node));
522 NR::Matrix dup_transform;
523 if (!sp_svg_transform_read (node->attribute("transform"), &dup_transform))
524 dup_transform = NR::identity();
525 dup_transform *= move;
527 sp_item_write_transform(copy, SP_OBJECT_REPR(copy), dup_transform);
528 }
530 Inkscape::GC::release(repr);
531 return pat_id;
532 }
534 SPPattern *
535 pattern_getroot (SPPattern *pat)
536 {
537 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
538 if (sp_object_first_child(SP_OBJECT(pat_i))) { // find the first one with children
539 return pat_i;
540 }
541 }
542 return pat; // document is broken, we can't get to root; but at least we can return pat which is supposedly a valid pattern
543 }
547 // Access functions that look up fields up the chain of referenced patterns and return the first one which is set
549 guint pattern_patternUnits (SPPattern *pat)
550 {
551 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
552 if (pat_i->patternUnits_set)
553 return pat_i->patternUnits;
554 }
555 return pat->patternUnits;
556 }
558 guint pattern_patternContentUnits (SPPattern *pat)
559 {
560 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
561 if (pat_i->patternContentUnits_set)
562 return pat_i->patternContentUnits;
563 }
564 return pat->patternContentUnits;
565 }
567 NR::Matrix const &pattern_patternTransform(SPPattern const *pat)
568 {
569 for (SPPattern const *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
570 if (pat_i->patternTransform_set)
571 return pat_i->patternTransform;
572 }
573 return pat->patternTransform;
574 }
576 gdouble pattern_x (SPPattern *pat)
577 {
578 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
579 if (pat_i->x._set)
580 return pat_i->x.computed;
581 }
582 return 0;
583 }
585 gdouble pattern_y (SPPattern *pat)
586 {
587 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
588 if (pat_i->y._set)
589 return pat_i->y.computed;
590 }
591 return 0;
592 }
594 gdouble pattern_width (SPPattern *pat)
595 {
596 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
597 if (pat_i->width._set)
598 return pat_i->width.computed;
599 }
600 return 0;
601 }
603 gdouble pattern_height (SPPattern *pat)
604 {
605 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
606 if (pat_i->height._set)
607 return pat_i->height.computed;
608 }
609 return 0;
610 }
612 NRRect *pattern_viewBox (SPPattern *pat)
613 {
614 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
615 if (pat_i->viewBox_set)
616 return &(pat_i->viewBox);
617 }
618 return &(pat->viewBox);
619 }
621 bool pattern_hasItemChildren (SPPattern *pat)
622 {
623 for (SPObject *child = sp_object_first_child(SP_OBJECT(pat)) ; child != NULL; child = SP_OBJECT_NEXT(child) ) {
624 if (SP_IS_ITEM (child)) {
625 return true;
626 }
627 }
628 return false;
629 }
633 /* Painter */
635 static void sp_pat_fill (SPPainter *painter, NRPixBlock *pb);
637 /**
638 Creates a painter (i.e. the thing that does actual filling at the given zoom).
639 See (*) below for why the parent_transform may be necessary.
640 */
641 static SPPainter *
642 sp_pattern_painter_new (SPPaintServer *ps, NR::Matrix const &full_transform, NR::Matrix const &parent_transform, const NRRect *bbox)
643 {
644 SPPattern *pat = SP_PATTERN (ps);
645 SPPatPainter *pp = g_new (SPPatPainter, 1);
647 pp->painter.type = SP_PAINTER_IND;
648 pp->painter.fill = sp_pat_fill;
650 pp->pat = pat;
652 if (pattern_patternUnits (pat) == SP_PATTERN_UNITS_OBJECTBOUNDINGBOX) {
653 /* BBox to user coordinate system */
654 NR::Matrix bbox2user (bbox->x1 - bbox->x0, 0.0, 0.0, bbox->y1 - bbox->y0, bbox->x0, bbox->y0);
656 // the final patternTransform, taking into account bbox
657 NR::Matrix const ps2user(pattern_patternTransform(pat) * bbox2user);
659 // see (*) comment below
660 NR::Matrix ps2px = ps2user * full_transform;
662 ps2px.copyto (&pp->ps2px);
664 } else {
665 /* Problem: What to do, if we have mixed lengths and percentages? */
666 /* Currently we do ignore percentages at all, but that is not good (lauris) */
668 /* fixme: We may try to normalize here too, look at linearGradient (Lauris) */
670 // (*) The spec says, "This additional transformation matrix [patternTransform] is
671 // post-multiplied to (i.e., inserted to the right of) any previously defined
672 // transformations, including the implicit transformation necessary to convert from
673 // object bounding box units to user space." To me, this means that the order should be:
674 // item_transform * patternTransform * parent_transform
675 // However both Batik and Adobe plugin use:
676 // patternTransform * item_transform * parent_transform
677 // So here I comply with the majority opinion, but leave my interpretation commented out below.
678 // (To get item_transform, I subtract parent from full.)
680 //NR::Matrix ps2px = (full_transform / parent_transform) * pattern_patternTransform(pat) * parent_transform;
681 NR::Matrix ps2px = pattern_patternTransform(pat) * full_transform;
683 ps2px.copyto (&pp->ps2px);
684 }
686 nr_matrix_invert (&pp->px2ps, &pp->ps2px);
688 if (pat->viewBox_set) {
689 gdouble tmp_x = (pattern_viewBox(pat)->x1 - pattern_viewBox(pat)->x0) / pattern_width (pat);
690 gdouble tmp_y = (pattern_viewBox(pat)->y1 - pattern_viewBox(pat)->y0) / pattern_height (pat);
692 // FIXME: preserveAspectRatio must be taken into account here too!
693 NR::Matrix vb2ps (tmp_x, 0.0, 0.0, tmp_y, pattern_x(pat) - pattern_viewBox(pat)->x0, pattern_y(pat) - pattern_viewBox(pat)->y0);
695 NR::Matrix vb2us = vb2ps * pattern_patternTransform(pat);
697 // see (*)
698 NR::Matrix pcs2px = vb2us * full_transform;
700 pcs2px.copyto (&pp->pcs2px);
701 } else {
702 NR::Matrix pcs2px;
704 /* No viewbox, have to parse units */
705 if (pattern_patternContentUnits (pat) == SP_PATTERN_UNITS_OBJECTBOUNDINGBOX) {
706 /* BBox to user coordinate system */
707 NR::Matrix bbox2user (bbox->x1 - bbox->x0, 0.0, 0.0, bbox->y1 - bbox->y0, bbox->x0, bbox->y0);
709 NR::Matrix pcs2user = pattern_patternTransform(pat) * bbox2user;
711 // see (*)
712 pcs2px = pcs2user * full_transform;
713 } else {
714 // see (*)
715 //pcs2px = (full_transform / parent_transform) * pattern_patternTransform(pat) * parent_transform;
716 pcs2px = pattern_patternTransform(pat) * full_transform;
717 }
719 pcs2px = NR::translate (pattern_x (pat), pattern_y (pat)) * pcs2px;
721 pcs2px.copyto (&pp->pcs2px);
722 }
724 /* Create arena */
725 pp->arena = NRArena::create();
727 pp->dkey = sp_item_display_key_new (1);
729 /* Create group */
730 pp->root = NRArenaGroup::create(pp->arena);
732 /* Show items */
733 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
734 if (pat_i && SP_IS_OBJECT (pat_i) && pattern_hasItemChildren(pat_i)) { // find the first one with item children
735 for (SPObject *child = sp_object_first_child(SP_OBJECT(pat_i)) ; child != NULL; child = SP_OBJECT_NEXT(child) ) {
736 if (SP_IS_ITEM (child)) {
737 NRArenaItem *cai;
738 cai = sp_item_invoke_show (SP_ITEM (child), pp->arena, pp->dkey, SP_ITEM_REFERENCE_FLAGS);
739 nr_arena_item_append_child (pp->root, cai);
740 nr_arena_item_unref (cai);
741 }
742 }
743 break; // do not go further up the chain if children are found
744 }
745 }
747 {
748 NRRect one_tile,tr_tile;
749 one_tile.x0=pattern_x(pp->pat);
750 one_tile.y0=pattern_y(pp->pat);
751 one_tile.x1=one_tile.x0+pattern_width (pp->pat);
752 one_tile.y1=one_tile.y0+pattern_height (pp->pat);
753 nr_rect_d_matrix_transform (&tr_tile, &one_tile, &pp->ps2px);
754 int tr_width=(int)ceil(1.3*(tr_tile.x1-tr_tile.x0));
755 int tr_height=(int)ceil(1.3*(tr_tile.y1-tr_tile.y0));
756 // if ( tr_width < 10000 && tr_height < 10000 && tr_width*tr_height < 1000000 ) {
757 pp->use_cached_tile=false;//true;
758 if ( tr_width > 1000 ) tr_width=1000;
759 if ( tr_height > 1000 ) tr_height=1000;
760 pp->cached_bbox.x0=0;
761 pp->cached_bbox.y0=0;
762 pp->cached_bbox.x1=tr_width;
763 pp->cached_bbox.y1=tr_height;
765 if (pp->use_cached_tile) {
766 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);
767 }
769 pp->pa2ca.c[0]=((double)tr_width)/(one_tile.x1-one_tile.x0);
770 pp->pa2ca.c[1]=0;
771 pp->pa2ca.c[2]=0;
772 pp->pa2ca.c[3]=((double)tr_height)/(one_tile.y1-one_tile.y0);
773 pp->pa2ca.c[4]=-one_tile.x0*pp->pa2ca.c[0];
774 pp->pa2ca.c[5]=-one_tile.y0*pp->pa2ca.c[1];
775 pp->ca2pa.c[0]=(one_tile.x1-one_tile.x0)/((double)tr_width);
776 pp->ca2pa.c[1]=0;
777 pp->ca2pa.c[2]=0;
778 pp->ca2pa.c[3]=(one_tile.y1-one_tile.y0)/((double)tr_height);
779 pp->ca2pa.c[4]=one_tile.x0;
780 pp->ca2pa.c[5]=one_tile.y0;
781 // } else {
782 // pp->use_cached_tile=false;
783 // }
784 }
786 NRGC gc(NULL);
787 if ( pp->use_cached_tile ) {
788 gc.transform=pp->pa2ca;
789 } else {
790 gc.transform = pp->pcs2px;
791 }
792 nr_arena_item_invoke_update (pp->root, NULL, &gc, NR_ARENA_ITEM_STATE_ALL, NR_ARENA_ITEM_STATE_ALL);
793 if ( pp->use_cached_tile ) {
794 nr_arena_item_invoke_render (pp->root, &pp->cached_bbox, &pp->cached_tile, 0);
795 } else {
796 // nothing to do now
797 }
799 return (SPPainter *) pp;
800 }
802 static void
803 sp_pattern_painter_free (SPPaintServer *ps, SPPainter *painter)
804 {
805 SPPatPainter *pp = (SPPatPainter *) painter;
806 SPPattern *pat = pp->pat;
808 for (SPPattern *pat_i = pat; pat_i != NULL; pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
809 if (pat_i && SP_IS_OBJECT (pat_i) && pattern_hasItemChildren(pat_i)) { // find the first one with item children
810 for (SPObject *child = sp_object_first_child(SP_OBJECT(pat_i)) ; child != NULL; child = SP_OBJECT_NEXT(child) ) {
811 if (SP_IS_ITEM (child)) {
812 sp_item_invoke_hide (SP_ITEM (child), pp->dkey);
813 }
814 }
815 break; // do not go further up the chain if children are found
816 }
817 }
818 if ( pp->use_cached_tile ) nr_pixblock_release(&pp->cached_tile);
819 g_free (pp);
820 }
822 void
823 get_cached_tile_pixel(SPPatPainter* pp,double x,double y,unsigned char &r,unsigned char &g,unsigned char &b,unsigned char &a)
824 {
825 int ca_h=(int)floor(x);
826 int ca_v=(int)floor(y);
827 int r_x=(int)floor(16*(x-floor(x)));
828 int r_y=(int)floor(16*(y-floor(y)));
829 unsigned int tl_m=(16-r_x)*(16-r_y);
830 unsigned int bl_m=(16-r_x)*r_y;
831 unsigned int tr_m=r_x*(16-r_y);
832 unsigned int br_m=r_x*r_y;
833 int cb_h=ca_h+1;
834 int cb_v=ca_v+1;
835 if ( cb_h >= pp->cached_bbox.x1 ) cb_h=0;
836 if ( cb_v >= pp->cached_bbox.y1 ) cb_v=0;
838 unsigned char* tlx=NR_PIXBLOCK_PX(&pp->cached_tile)+(ca_v*pp->cached_tile.rs)+4*ca_h;
839 unsigned char* trx=NR_PIXBLOCK_PX(&pp->cached_tile)+(ca_v*pp->cached_tile.rs)+4*cb_h;
840 unsigned char* blx=NR_PIXBLOCK_PX(&pp->cached_tile)+(cb_v*pp->cached_tile.rs)+4*ca_h;
841 unsigned char* brx=NR_PIXBLOCK_PX(&pp->cached_tile)+(cb_v*pp->cached_tile.rs)+4*cb_h;
843 unsigned int tl_c=tlx[0];
844 unsigned int tr_c=trx[0];
845 unsigned int bl_c=blx[0];
846 unsigned int br_c=brx[0];
847 unsigned int f_c=(tl_m*tl_c+tr_m*tr_c+bl_m*bl_c+br_m*br_c)>>8;
848 r=f_c;
849 tl_c=tlx[1];
850 tr_c=trx[1];
851 bl_c=blx[1];
852 br_c=brx[1];
853 f_c=(tl_m*tl_c+tr_m*tr_c+bl_m*bl_c+br_m*br_c)>>8;
854 g=f_c;
855 tl_c=tlx[2];
856 tr_c=trx[2];
857 bl_c=blx[2];
858 br_c=brx[2];
859 f_c=(tl_m*tl_c+tr_m*tr_c+bl_m*bl_c+br_m*br_c)>>8;
860 b=f_c;
861 tl_c=tlx[3];
862 tr_c=trx[3];
863 bl_c=blx[3];
864 br_c=brx[3];
865 f_c=(tl_m*tl_c+tr_m*tr_c+bl_m*bl_c+br_m*br_c)>>8;
866 a=f_c;
867 }
869 static void
870 sp_pat_fill (SPPainter *painter, NRPixBlock *pb)
871 {
872 SPPatPainter *pp;
873 NRRect ba, psa;
874 NRRectL area;
875 double x, y;
877 pp = (SPPatPainter *) painter;
879 if (pattern_width (pp->pat) < NR_EPSILON) return;
880 if (pattern_height (pp->pat) < NR_EPSILON) return;
882 /* Find buffer area in gradient space */
883 /* fixme: This is suboptimal (Lauris) */
885 if ( pp->use_cached_tile ) {
886 double pat_w=pattern_width (pp->pat);
887 double pat_h=pattern_height (pp->pat);
888 if ( pb->mode == NR_PIXBLOCK_MODE_R8G8B8A8N || pb->mode == NR_PIXBLOCK_MODE_R8G8B8A8P ) { // same thing because it's filling an empty pixblock
889 unsigned char* lpx=NR_PIXBLOCK_PX(pb);
890 double px_y=pb->area.y0;
891 for (int j=pb->area.y0;j<pb->area.y1;j++) {
892 unsigned char* cpx=lpx;
893 double px_x = pb->area.x0;
895 double ps_x=pp->px2ps.c[0]*px_x+pp->px2ps.c[2]*px_y+pp->px2ps.c[4];
896 double ps_y=pp->px2ps.c[1]*px_x+pp->px2ps.c[3]*px_y+pp->px2ps.c[5];
897 for (int i=pb->area.x0;i<pb->area.x1;i++) {
898 while ( ps_x > pat_w ) ps_x-=pat_w;
899 while ( ps_x < 0 ) ps_x+=pat_w;
900 while ( ps_y > pat_h ) ps_y-=pat_h;
901 while ( ps_y < 0 ) ps_y+=pat_h;
902 double ca_x=pp->pa2ca.c[0]*ps_x+pp->pa2ca.c[2]*ps_y+pp->pa2ca.c[4];
903 double ca_y=pp->pa2ca.c[1]*ps_x+pp->pa2ca.c[3]*ps_y+pp->pa2ca.c[5];
904 unsigned char n_a,n_r,n_g,n_b;
905 get_cached_tile_pixel(pp,ca_x,ca_y,n_r,n_g,n_b,n_a);
906 cpx[0]=n_r;
907 cpx[1]=n_g;
908 cpx[2]=n_b;
909 cpx[3]=n_a;
911 px_x+=1.0;
912 ps_x+=pp->px2ps.c[0];
913 ps_y+=pp->px2ps.c[1];
914 cpx+=4;
915 }
916 px_y+=1.0;
917 lpx+=pb->rs;
918 }
919 } else if ( pb->mode == NR_PIXBLOCK_MODE_R8G8B8 ) {
920 unsigned char* lpx=NR_PIXBLOCK_PX(pb);
921 double px_y=pb->area.y0;
922 for (int j=pb->area.y0;j<pb->area.y1;j++) {
923 unsigned char* cpx=lpx;
924 double px_x = pb->area.x0;
926 double ps_x=pp->px2ps.c[0]*px_x+pp->px2ps.c[2]*px_y+pp->px2ps.c[4];
927 double ps_y=pp->px2ps.c[1]*px_x+pp->px2ps.c[3]*px_y+pp->px2ps.c[5];
928 for (int i=pb->area.x0;i<pb->area.x1;i++) {
929 while ( ps_x > pat_w ) ps_x-=pat_w;
930 while ( ps_x < 0 ) ps_x+=pat_w;
931 while ( ps_y > pat_h ) ps_y-=pat_h;
932 while ( ps_y < 0 ) ps_y+=pat_h;
933 double ca_x=pp->pa2ca.c[0]*ps_x+pp->pa2ca.c[2]*ps_y+pp->pa2ca.c[4];
934 double ca_y=pp->pa2ca.c[1]*ps_x+pp->pa2ca.c[3]*ps_y+pp->pa2ca.c[5];
935 unsigned char n_a,n_r,n_g,n_b;
936 get_cached_tile_pixel(pp,ca_x,ca_y,n_r,n_g,n_b,n_a);
937 cpx[0]=n_r;
938 cpx[1]=n_g;
939 cpx[2]=n_b;
941 px_x+=1.0;
942 ps_x+=pp->px2ps.c[0];
943 ps_y+=pp->px2ps.c[1];
944 cpx+=4;
945 }
946 px_y+=1.0;
947 lpx+=pb->rs;
948 }
949 }
950 } else {
951 ba.x0 = pb->area.x0;
952 ba.y0 = pb->area.y0;
953 ba.x1 = pb->area.x1;
954 ba.y1 = pb->area.y1;
955 nr_rect_d_matrix_transform (&psa, &ba, &pp->px2ps);
957 psa.x0 = floor ((psa.x0 - pattern_x (pp->pat)) / pattern_width (pp->pat)) -1;
958 psa.y0 = floor ((psa.y0 - pattern_y (pp->pat)) / pattern_height (pp->pat)) -1;
959 psa.x1 = ceil ((psa.x1 - pattern_x (pp->pat)) / pattern_width (pp->pat)) +1;
960 psa.y1 = ceil ((psa.y1 - pattern_y (pp->pat)) / pattern_height (pp->pat)) +1;
962 for (y = psa.y0; y < psa.y1; y++) {
963 for (x = psa.x0; x < psa.x1; x++) {
964 NRPixBlock ppb;
965 double psx, psy;
967 psx = x * pattern_width (pp->pat);
968 psy = y * pattern_height (pp->pat);
970 area.x0 = (gint32)(pb->area.x0 - (pp->ps2px.c[0] * psx + pp->ps2px.c[2] * psy));
971 area.y0 = (gint32)(pb->area.y0 - (pp->ps2px.c[1] * psx + pp->ps2px.c[3] * psy));
972 area.x1 = area.x0 + pb->area.x1 - pb->area.x0;
973 area.y1 = area.y0 + pb->area.y1 - pb->area.y0;
975 // We do not update here anymore
977 // Set up buffer
978 // fixme: (Lauris)
979 nr_pixblock_setup_extern (&ppb, pb->mode, area.x0, area.y0, area.x1, area.y1, NR_PIXBLOCK_PX (pb), pb->rs, FALSE, FALSE);
981 nr_arena_item_invoke_render (pp->root, &area, &ppb, 0);
983 nr_pixblock_release (&ppb);
984 }
985 }
986 }
987 }