src/sp-pattern.cpp

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