src/sp-gradient.cpp

   1 #define __SP_GRADIENT_C__
   2
   3 /** \file
   4  * SPGradient, SPStop, SPLinearGradient, SPRadialGradient.
   5  */
   6 /*
   7  * Authors:
   8  *   Lauris Kaplinski <lauris@kaplinski.com>
   9  *   bulia byak <buliabyak@users.sf.net>
  10  *   Jasper van de Gronde <th.v.d.gronde@hccnet.nl>
  11  *
  12  * Copyright (C) 1999-2002 Lauris Kaplinski
  13  * Copyright (C) 2000-2001 Ximian, Inc.
  14  * Copyright (C) 2004 David Turner
  15  * Copyright (C) 2009 Jasper van de Gronde
  16  *
  17  * Released under GNU GPL, read the file 'COPYING' for more information
  18  *
  19  */
  20
  21 #define noSP_GRADIENT_VERBOSE
  22
  23 #include <cstring>
  24 #include <string>
  25
  26 #include <libnr/nr-matrix-fns.h>
  27 #include <libnr/nr-matrix-ops.h>
  28 #include <libnr/nr-matrix-scale-ops.h>
  29 #include <2geom/transforms.h>
  30
  31 #include <sigc++/functors/ptr_fun.h>
  32 #include <sigc++/adaptors/bind.h>
  33
  34 #include "libnr/nr-gradient.h"
  35 #include "libnr/nr-pixops.h"
  36 #include "svg/svg.h"
  37 #include "svg/svg-color.h"
  38 #include "svg/css-ostringstream.h"
  39 #include "attributes.h"
  40 #include "document-private.h"
  41 #include "gradient-chemistry.h"
  42 #include "sp-gradient-reference.h"
  43 #include "sp-linear-gradient.h"
  44 #include "sp-radial-gradient.h"
  45 #include "sp-stop.h"
  46 #include "streq.h"
  47 #include "uri.h"
  48 #include "xml/repr.h"
  49
  50 #define SP_MACROS_SILENT
  51 #include "macros.h"
  52
  53 /// Has to be power of 2
  54 #define NCOLORS NR_GRADIENT_VECTOR_LENGTH
  55
  56 static void sp_stop_class_init(SPStopClass *klass);
  57 static void sp_stop_init(SPStop *stop);
  58
  59 static void sp_stop_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
  60 static void sp_stop_set(SPObject *object, unsigned key, gchar const *value);
  61 static Inkscape::XML::Node *sp_stop_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags);
  62
  63 static SPObjectClass *stop_parent_class;
  64
  65 /**
  66  * Registers SPStop class and returns its type.
  67  */
  68 GType
  69 sp_stop_get_type()
  70 {
  71     static GType type = 0;
  72     if (!type) {
  73         GTypeInfo info = {
  74             sizeof(SPStopClass),
  75             NULL, NULL,
  76             (GClassInitFunc) sp_stop_class_init,
  77             NULL, NULL,
  78             sizeof(SPStop),
  79             16,
  80             (GInstanceInitFunc) sp_stop_init,
  81             NULL,   /* value_table */
  82         };
  83         type = g_type_register_static(SP_TYPE_OBJECT, "SPStop", &info, (GTypeFlags)0);
  84     }
  85     return type;
  86 }
  87
  88 /**
  89  * Callback to initialize SPStop vtable.
  90  */
  91 static void sp_stop_class_init(SPStopClass *klass)
  92 {
  93     SPObjectClass *sp_object_class = (SPObjectClass *) klass;
  94
  95     stop_parent_class = (SPObjectClass *) g_type_class_ref(SP_TYPE_OBJECT);
  96
  97     sp_object_class->build = sp_stop_build;
  98     sp_object_class->set = sp_stop_set;
  99     sp_object_class->write = sp_stop_write;
 100 }
 101
 102 /**
 103  * Callback to initialize SPStop object.
 104  */
 105 static void
 106 sp_stop_init(SPStop *stop)
 107 {
 108     stop->offset = 0.0;
 109     stop->currentColor = false;
 110     stop->specified_color.set( 0x000000ff );
 111     stop->opacity = 1.0;
 112 }
 113
 114 /**
 115  * Virtual build: set stop attributes from its associated XML node.
 116  */
 117 static void sp_stop_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
 118 {
 119     if (((SPObjectClass *) stop_parent_class)->build)
 120         (* ((SPObjectClass *) stop_parent_class)->build)(object, document, repr);
 121
 122     sp_object_read_attr(object, "offset");
 123     sp_object_read_attr(object, "stop-color");
 124     sp_object_read_attr(object, "stop-opacity");
 125     sp_object_read_attr(object, "style");
 126 }
 127
 128 /**
 129  * Virtual set: set attribute to value.
 130  */
 131 static void
 132 sp_stop_set(SPObject *object, unsigned key, gchar const *value)
 133 {
 134     SPStop *stop = SP_STOP(object);
 135
 136     switch (key) {
 137         case SP_ATTR_STYLE: {
 138         /** \todo
 139          * fixme: We are reading simple values 3 times during build (Lauris).
 140          * \par
 141          * We need presentation attributes etc.
 142          * \par
 143          * remove the hackish "style reading" from here: see comments in
 144          * sp_object_get_style_property about the bugs in our current
 145          * approach.  However, note that SPStyle doesn't currently have
 146          * stop-color and stop-opacity properties.
 147          */
 148             {
 149                 gchar const *p = sp_object_get_style_property(object, "stop-color", "black");
 150                 if (streq(p, "currentColor")) {
 151                     stop->currentColor = true;
 152                 } else {
 153                     guint32 const color = sp_svg_read_color(p, 0);
 154                     stop->specified_color.set( color );
 155                 }
 156             }
 157             {
 158                 gchar const *p = sp_object_get_style_property(object, "stop-opacity", "1");
 159                 gdouble opacity = sp_svg_read_percentage(p, stop->opacity);
 160                 stop->opacity = opacity;
 161             }
 162             object->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
 163             break;
 164         }
 165         case SP_PROP_STOP_COLOR: {
 166             {
 167                 gchar const *p = sp_object_get_style_property(object, "stop-color", "black");
 168                 if (streq(p, "currentColor")) {
 169                     stop->currentColor = true;
 170                 } else {
 171                     stop->currentColor = false;
 172                     guint32 const color = sp_svg_read_color(p, 0);
 173                     stop->specified_color.set( color );
 174                 }
 175             }
 176             object->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
 177             break;
 178         }
 179         case SP_PROP_STOP_OPACITY: {
 180             {
 181                 gchar const *p = sp_object_get_style_property(object, "stop-opacity", "1");
 182                 gdouble opacity = sp_svg_read_percentage(p, stop->opacity);
 183                 stop->opacity = opacity;
 184             }
 185             object->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
 186             break;
 187         }
 188         case SP_ATTR_OFFSET: {
 189             stop->offset = sp_svg_read_percentage(value, 0.0);
 190             object->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
 191             break;
 192         }
 193         default: {
 194             if (((SPObjectClass *) stop_parent_class)->set)
 195                 (* ((SPObjectClass *) stop_parent_class)->set)(object, key, value);
 196             break;
 197         }
 198     }
 199 }
 200
 201 /**
 202  * Virtual write: write object attributes to repr.
 203  */
 204 static Inkscape::XML::Node *
 205 sp_stop_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
 206 {
 207     SPStop *stop = SP_STOP(object);
 208
 209     if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
 210         repr = xml_doc->createElement("svg:stop");
 211     }
 212
 213     guint32 specifiedcolor = stop->specified_color.toRGBA32( 255 );
 214     gfloat opacity = stop->opacity;
 215
 216     if (((SPObjectClass *) stop_parent_class)->write)
 217         (* ((SPObjectClass *) stop_parent_class)->write)(object, xml_doc, repr, flags);
 218
 219     // Since we do a hackish style setting here (because SPStyle does not support stop-color and
 220     // stop-opacity), we must do it AFTER calling the parent write method; otherwise
 221     // sp_object_write would clear our style= attribute (bug 1695287)
 222
 223     Inkscape::CSSOStringStream os;
 224     os << "stop-color:";
 225     if (stop->currentColor) {
 226         os << "currentColor";
 227     } else {
 228         gchar c[64];
 229         sp_svg_write_color(c, sizeof(c), specifiedcolor);
 230         os << c;
 231     }
 232     os << ";stop-opacity:" << opacity;
 233     repr->setAttribute("style", os.str().c_str());
 234     repr->setAttribute("stop-color", NULL);
 235     repr->setAttribute("stop-opacity", NULL);
 236     sp_repr_set_css_double(repr, "offset", stop->offset);
 237     /* strictly speaking, offset an SVG <number> rather than a CSS one, but exponents make no sense
 238      * for offset proportions. */
 239
 240     return repr;
 241 }
 242
 243 /**
 244  * Return stop's color as 32bit value.
 245  */
 246 guint32
 247 sp_stop_get_rgba32(SPStop const *const stop)
 248 {
 249     guint32 rgb0 = 0;
 250     /* Default value: arbitrarily black.  (SVG1.1 and CSS2 both say that the initial
 251      * value depends on user agent, and don't give any further restrictions that I can
 252      * see.) */
 253     if (stop->currentColor) {
 254         char const *str = sp_object_get_style_property(stop, "color", NULL);
 255         if (str) {
 256             rgb0 = sp_svg_read_color(str, rgb0);
 257         }
 258         unsigned const alpha = static_cast<unsigned>(stop->opacity * 0xff + 0.5);
 259         g_return_val_if_fail((alpha & ~0xff) == 0,
 260                              rgb0 | 0xff);
 261         return rgb0 | alpha;
 262     } else {
 263         return stop->specified_color.toRGBA32( stop->opacity );
 264     }
 265 }
 266
 267 /**
 268  * Return stop's color as SPColor.
 269  */
 270 static SPColor
 271 sp_stop_get_color(SPStop const *const stop)
 272 {
 273     if (stop->currentColor) {
 274         char const *str = sp_object_get_style_property(stop, "color", NULL);
 275         guint32 const dfl = 0;
 276         /* Default value: arbitrarily black.  (SVG1.1 and CSS2 both say that the initial
 277          * value depends on user agent, and don't give any further restrictions that I can
 278          * see.) */
 279         guint32 color = dfl;
 280         if (str) {
 281             color = sp_svg_read_color(str, dfl);
 282         }
 283         SPColor ret( color );
 284         return ret;
 285     } else {
 286         return stop->specified_color;
 287     }
 288 }
 289
 290 /*
 291  * Gradient
 292  */
 293
 294 static void sp_gradient_class_init(SPGradientClass *klass);
 295 static void sp_gradient_init(SPGradient *gr);
 296
 297 static void sp_gradient_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
 298 static void sp_gradient_release(SPObject *object);
 299 static void sp_gradient_set(SPObject *object, unsigned key, gchar const *value);
 300 static void sp_gradient_child_added(SPObject *object,
 301                                     Inkscape::XML::Node *child,
 302                                     Inkscape::XML::Node *ref);
 303 static void sp_gradient_remove_child(SPObject *object, Inkscape::XML::Node *child);
 304 static void sp_gradient_modified(SPObject *object, guint flags);
 305 static Inkscape::XML::Node *sp_gradient_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr,
 306                                               guint flags);
 307
 308 static void gradient_ref_modified(SPObject *href, guint flags, SPGradient *gradient);
 309
 310 static bool sp_gradient_invalidate_vector(SPGradient *gr);
 311 static void sp_gradient_rebuild_vector(SPGradient *gr);
 312
 313 static void gradient_ref_changed(SPObject *old_ref, SPObject *ref, SPGradient *gradient);
 314
 315 SPGradientSpread sp_gradient_get_spread(SPGradient *gradient);
 316 SPGradientUnits sp_gradient_get_units(SPGradient *gradient);
 317
 318 static SPPaintServerClass *gradient_parent_class;
 319
 320 /**
 321  * Registers SPGradient class and returns its type.
 322  */
 323 GType
 324 sp_gradient_get_type()
 325 {
 326     static GType gradient_type = 0;
 327     if (!gradient_type) {
 328         GTypeInfo gradient_info = {
 329             sizeof(SPGradientClass),
 330             NULL, NULL,
 331             (GClassInitFunc) sp_gradient_class_init,
 332             NULL, NULL,
 333             sizeof(SPGradient),
 334             16,
 335             (GInstanceInitFunc) sp_gradient_init,
 336             NULL,   /* value_table */
 337         };
 338         gradient_type = g_type_register_static(SP_TYPE_PAINT_SERVER, "SPGradient",
 339                                                &gradient_info, (GTypeFlags)0);
 340     }
 341     return gradient_type;
 342 }
 343
 344 /**
 345  * SPGradient vtable initialization.
 346  */
 347 static void
 348 sp_gradient_class_init(SPGradientClass *klass)
 349 {
 350     SPObjectClass *sp_object_class = (SPObjectClass *) klass;
 351
 352     gradient_parent_class = (SPPaintServerClass *)g_type_class_ref(SP_TYPE_PAINT_SERVER);
 353
 354     sp_object_class->build = sp_gradient_build;
 355     sp_object_class->release = sp_gradient_release;
 356     sp_object_class->set = sp_gradient_set;
 357     sp_object_class->child_added = sp_gradient_child_added;
 358     sp_object_class->remove_child = sp_gradient_remove_child;
 359     sp_object_class->modified = sp_gradient_modified;
 360     sp_object_class->write = sp_gradient_write;
 361 }
 362
 363 /**
 364  * Callback for SPGradient object initialization.
 365  */
 366 static void
 367 sp_gradient_init(SPGradient *gr)
 368 {
 369     gr->ref = new SPGradientReference(SP_OBJECT(gr));
 370     gr->ref->changedSignal().connect(sigc::bind(sigc::ptr_fun(gradient_ref_changed), gr));
 371
 372     /** \todo
 373      * Fixme: reprs being rearranged (e.g. via the XML editor)
 374      * may require us to clear the state.
 375      */
 376     gr->state = SP_GRADIENT_STATE_UNKNOWN;
 377
 378     gr->units = SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX;
 379     gr->units_set = FALSE;
 380
 381     gr->gradientTransform = Geom::identity();
 382     gr->gradientTransform_set = FALSE;
 383
 384     gr->spread = SP_GRADIENT_SPREAD_PAD;
 385     gr->spread_set = FALSE;
 386
 387     gr->has_stops = FALSE;
 388
 389     gr->vector.built = false;
 390     gr->vector.stops.clear();
 391
 392     gr->color = NULL;
 393
 394     new (&gr->modified_connection) sigc::connection();
 395 }
 396
 397 /**
 398  * Virtual build: set gradient attributes from its associated repr.
 399  */
 400 static void
 401 sp_gradient_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
 402 {
 403     SPGradient *gradient = SP_GRADIENT(object);
 404
 405     if (((SPObjectClass *) gradient_parent_class)->build)
 406         (* ((SPObjectClass *) gradient_parent_class)->build)(object, document, repr);
 407
 408     SPObject *ochild;
 409     for ( ochild = sp_object_first_child(object) ; ochild ; ochild = SP_OBJECT_NEXT(ochild) ) {
 410         if (SP_IS_STOP(ochild)) {
 411             gradient->has_stops = TRUE;
 412             break;
 413         }
 414     }
 415
 416     sp_object_read_attr(object, "gradientUnits");
 417     sp_object_read_attr(object, "gradientTransform");
 418     sp_object_read_attr(object, "spreadMethod");
 419     sp_object_read_attr(object, "xlink:href");
 420
 421     /* Register ourselves */
 422     sp_document_add_resource(document, "gradient", object);
 423 }
 424
 425 /**
 426  * Virtual release of SPGradient members before destruction.
 427  */
 428 static void
 429 sp_gradient_release(SPObject *object)
 430 {
 431     SPGradient *gradient = (SPGradient *) object;
 432
 433 #ifdef SP_GRADIENT_VERBOSE
 434     g_print("Releasing gradient %s\n", SP_OBJECT_ID(object));
 435 #endif
 436
 437     if (SP_OBJECT_DOCUMENT(object)) {
 438         /* Unregister ourselves */
 439         sp_document_remove_resource(SP_OBJECT_DOCUMENT(object), "gradient", SP_OBJECT(object));
 440     }
 441
 442     if (gradient->ref) {
 443         gradient->modified_connection.disconnect();
 444         gradient->ref->detach();
 445         delete gradient->ref;
 446         gradient->ref = NULL;
 447     }
 448
 449     if (gradient->color) {
 450         g_free(gradient->color);
 451         gradient->color = NULL;
 452     }
 453
 454     gradient->modified_connection.~connection();
 455
 456     if (((SPObjectClass *) gradient_parent_class)->release)
 457         ((SPObjectClass *) gradient_parent_class)->release(object);
 458 }
 459
 460 /**
 461  * Set gradient attribute to value.
 462  */
 463 static void
 464 sp_gradient_set(SPObject *object, unsigned key, gchar const *value)
 465 {
 466     SPGradient *gr = SP_GRADIENT(object);
 467
 468     switch (key) {
 469         case SP_ATTR_GRADIENTUNITS:
 470             if (value) {
 471                 if (!strcmp(value, "userSpaceOnUse")) {
 472                     gr->units = SP_GRADIENT_UNITS_USERSPACEONUSE;
 473                 } else {
 474                     gr->units = SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX;
 475                 }
 476                 gr->units_set = TRUE;
 477             } else {
 478                 gr->units = SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX;
 479                 gr->units_set = FALSE;
 480             }
 481             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
 482             break;
 483         case SP_ATTR_GRADIENTTRANSFORM: {
 484             Geom::Matrix t;
 485             if (value && sp_svg_transform_read(value, &t)) {
 486                 gr->gradientTransform = t;
 487                 gr->gradientTransform_set = TRUE;
 488             } else {
 489                 gr->gradientTransform = Geom::identity();
 490                 gr->gradientTransform_set = FALSE;
 491             }
 492             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
 493             break;
 494         }
 495         case SP_ATTR_SPREADMETHOD:
 496             if (value) {
 497                 if (!strcmp(value, "reflect")) {
 498                     gr->spread = SP_GRADIENT_SPREAD_REFLECT;
 499                 } else if (!strcmp(value, "repeat")) {
 500                     gr->spread = SP_GRADIENT_SPREAD_REPEAT;
 501                 } else {
 502                     gr->spread = SP_GRADIENT_SPREAD_PAD;
 503                 }
 504                 gr->spread_set = TRUE;
 505             } else {
 506                 gr->spread_set = FALSE;
 507             }
 508             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
 509             break;
 510         case SP_ATTR_XLINK_HREF:
 511             if (value) {
 512                 try {
 513                     gr->ref->attach(Inkscape::URI(value));
 514                 } catch (Inkscape::BadURIException &e) {
 515                     g_warning("%s", e.what());
 516                     gr->ref->detach();
 517                 }
 518             } else {
 519                 gr->ref->detach();
 520             }
 521             break;
 522         default:
 523             if (((SPObjectClass *) gradient_parent_class)->set)
 524                 ((SPObjectClass *) gradient_parent_class)->set(object, key, value);
 525             break;
 526     }
 527 }
 528
 529 /**
 530  * Gets called when the gradient is (re)attached to another gradient.
 531  */
 532 static void
 533 gradient_ref_changed(SPObject *old_ref, SPObject *ref, SPGradient *gr)
 534 {
 535     if (old_ref) {
 536         gr->modified_connection.disconnect();
 537     }
 538     if ( SP_IS_GRADIENT(ref)
 539          && ref != gr )
 540     {
 541         gr->modified_connection = ref->connectModified(sigc::bind<2>(sigc::ptr_fun(&gradient_ref_modified), gr));
 542     }
 543
 544     // Per SVG, all unset attributes must be inherited from linked gradient.
 545     // So, as we're now (re)linked, we assign linkee's values to this gradient if they are not yet set -
 546     // but without setting the _set flags.
 547     // FIXME: do the same for gradientTransform too
 548     if (!gr->units_set)
 549         gr->units = sp_gradient_get_units (gr);
 550     if (!gr->spread_set)
 551         gr->spread = sp_gradient_get_spread (gr);
 552
 553     /// \todo Fixme: what should the flags (second) argument be? */
 554     gradient_ref_modified(ref, 0, gr);
 555 }
 556
 557 /**
 558  * Callback for child_added event.
 559  */
 560 static void
 561 sp_gradient_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
 562 {
 563     SPGradient *gr = SP_GRADIENT(object);
 564
 565     sp_gradient_invalidate_vector(gr);
 566
 567     if (((SPObjectClass *) gradient_parent_class)->child_added)
 568         (* ((SPObjectClass *) gradient_parent_class)->child_added)(object, child, ref);
 569
 570     SPObject *ochild = sp_object_get_child_by_repr(object, child);
 571     if ( ochild && SP_IS_STOP(ochild) ) {
 572         gr->has_stops = TRUE;
 573     }
 574
 575     /// \todo Fixme: should we schedule "modified" here?
 576     object->requestModified(SP_OBJECT_MODIFIED_FLAG);
 577 }
 578
 579 /**
 580  * Callback for remove_child event.
 581  */
 582 static void
 583 sp_gradient_remove_child(SPObject *object, Inkscape::XML::Node *child)
 584 {
 585     SPGradient *gr = SP_GRADIENT(object);
 586
 587     sp_gradient_invalidate_vector(gr);
 588
 589     if (((SPObjectClass *) gradient_parent_class)->remove_child)
 590         (* ((SPObjectClass *) gradient_parent_class)->remove_child)(object, child);
 591
 592     gr->has_stops = FALSE;
 593     SPObject *ochild;
 594     for ( ochild = sp_object_first_child(object) ; ochild ; ochild = SP_OBJECT_NEXT(ochild) ) {
 595         if (SP_IS_STOP(ochild)) {
 596             gr->has_stops = TRUE;
 597             break;
 598         }
 599     }
 600
 601     /* Fixme: should we schedule "modified" here? */
 602     object->requestModified(SP_OBJECT_MODIFIED_FLAG);
 603 }
 604
 605 /**
 606  * Callback for modified event.
 607  */
 608 static void
 609 sp_gradient_modified(SPObject *object, guint flags)
 610 {
 611     SPGradient *gr = SP_GRADIENT(object);
 612
 613     if (flags & SP_OBJECT_CHILD_MODIFIED_FLAG) {
 614         sp_gradient_invalidate_vector(gr);
 615     }
 616
 617     if (flags & SP_OBJECT_STYLE_MODIFIED_FLAG) {
 618         sp_gradient_ensure_colors(gr);
 619     }
 620
 621     if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
 622     flags &= SP_OBJECT_MODIFIED_CASCADE;
 623
 624     // FIXME: climb up the ladder of hrefs
 625     GSList *l = NULL;
 626     for (SPObject *child = sp_object_first_child(object) ; child != NULL; child = SP_OBJECT_NEXT(child) ) {
 627         g_object_ref(G_OBJECT(child));
 628         l = g_slist_prepend(l, child);
 629     }
 630     l = g_slist_reverse(l);
 631     while (l) {
 632         SPObject *child = SP_OBJECT(l->data);
 633         l = g_slist_remove(l, child);
 634         if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
 635             child->emitModified(flags);
 636         }
 637         g_object_unref(G_OBJECT(child));
 638     }
 639 }
 640
 641
 642 bool SPGradient::isSolid() const
 643 {
 644     bool solid = false;
 645     if ( SP_GRADIENT_HAS_STOPS(this) && (sp_number_of_stops(this) == 0) ) {
 646         gchar const * attr = repr->attribute("osb:paint");
 647         if (attr && !strcmp(attr, "solid")) {
 648             solid = true;
 649         }
 650     }
 651     return solid;
 652 }
 653
 654
 655 /**
 656  * Write gradient attributes to repr.
 657  */
 658 static Inkscape::XML::Node *
 659 sp_gradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
 660 {
 661     SPGradient *gr = SP_GRADIENT(object);
 662
 663     if (((SPObjectClass *) gradient_parent_class)->write)
 664         (* ((SPObjectClass *) gradient_parent_class)->write)(object, xml_doc, repr, flags);
 665
 666     if (flags & SP_OBJECT_WRITE_BUILD) {
 667         GSList *l = NULL;
 668         for (SPObject *child = sp_object_first_child(object); child; child = SP_OBJECT_NEXT(child)) {
 669             Inkscape::XML::Node *crepr;
 670             crepr = child->updateRepr(xml_doc, NULL, flags);
 671             if (crepr) l = g_slist_prepend(l, crepr);
 672         }
 673         while (l) {
 674             repr->addChild((Inkscape::XML::Node *) l->data, NULL);
 675             Inkscape::GC::release((Inkscape::XML::Node *) l->data);
 676             l = g_slist_remove(l, l->data);
 677         }
 678     }
 679
 680     if (gr->ref->getURI()) {
 681         gchar *uri_string = gr->ref->getURI()->toString();
 682         repr->setAttribute("xlink:href", uri_string);
 683         g_free(uri_string);
 684     }
 685
 686     if ((flags & SP_OBJECT_WRITE_ALL) || gr->units_set) {
 687         switch (gr->units) {
 688             case SP_GRADIENT_UNITS_USERSPACEONUSE:
 689                 repr->setAttribute("gradientUnits", "userSpaceOnUse");
 690                 break;
 691             default:
 692                 repr->setAttribute("gradientUnits", "objectBoundingBox");
 693                 break;
 694         }
 695     }
 696
 697     if ((flags & SP_OBJECT_WRITE_ALL) || gr->gradientTransform_set) {
 698         gchar *c=sp_svg_transform_write(gr->gradientTransform);
 699         repr->setAttribute("gradientTransform", c);
 700         g_free(c);
 701     }
 702
 703     if ((flags & SP_OBJECT_WRITE_ALL) || gr->spread_set) {
 704         /* FIXME: Ensure that gr->spread is the inherited value
 705          * if !gr->spread_set.  Not currently happening: see sp_gradient_modified.
 706          */
 707         switch (gr->spread) {
 708             case SP_GRADIENT_SPREAD_REFLECT:
 709                 repr->setAttribute("spreadMethod", "reflect");
 710                 break;
 711             case SP_GRADIENT_SPREAD_REPEAT:
 712                 repr->setAttribute("spreadMethod", "repeat");
 713                 break;
 714             default:
 715                 repr->setAttribute("spreadMethod", "pad");
 716                 break;
 717         }
 718     }
 719
 720     return repr;
 721 }
 722
 723 /**
 724  * Forces the vector to be built, if not present (i.e., changed).
 725  *
 726  * \pre SP_IS_GRADIENT(gradient).
 727  */
 728 void
 729 sp_gradient_ensure_vector(SPGradient *gradient)
 730 {
 731     g_return_if_fail(gradient != NULL);
 732     g_return_if_fail(SP_IS_GRADIENT(gradient));
 733
 734     if (!gradient->vector.built) {
 735         sp_gradient_rebuild_vector(gradient);
 736     }
 737 }
 738
 739 /**
 740  * Set units property of gradient and emit modified.
 741  */
 742 void
 743 sp_gradient_set_units(SPGradient *gr, SPGradientUnits units)
 744 {
 745     if (units != gr->units) {
 746         gr->units = units;
 747         gr->units_set = TRUE;
 748         SP_OBJECT(gr)->requestModified(SP_OBJECT_MODIFIED_FLAG);
 749     }
 750 }
 751
 752 /**
 753  * Set spread property of gradient and emit modified.
 754  */
 755 void
 756 sp_gradient_set_spread(SPGradient *gr, SPGradientSpread spread)
 757 {
 758     if (spread != gr->spread) {
 759         gr->spread = spread;
 760         gr->spread_set = TRUE;
 761         SP_OBJECT(gr)->requestModified(SP_OBJECT_MODIFIED_FLAG);
 762     }
 763 }
 764
 765 /**
 766  * Returns the first of {src, src-\>ref-\>getObject(),
 767  * src-\>ref-\>getObject()-\>ref-\>getObject(),...}
 768  * for which \a match is true, or NULL if none found.
 769  *
 770  * The raison d'être of this routine is that it correctly handles cycles in the href chain (e.g., if
 771  * a gradient gives itself as its href, or if each of two gradients gives the other as its href).
 772  *
 773  * \pre SP_IS_GRADIENT(src).
 774  */
 775 static SPGradient *
 776 chase_hrefs(SPGradient *const src, bool (*match)(SPGradient const *))
 777 {
 778     g_return_val_if_fail(SP_IS_GRADIENT(src), NULL);
 779
 780     /* Use a pair of pointers for detecting loops: p1 advances half as fast as p2.  If there is a
 781        loop, then once p1 has entered the loop, we'll detect it the next time the distance between
 782        p1 and p2 is a multiple of the loop size. */
 783     SPGradient *p1 = src, *p2 = src;
 784     bool do1 = false;
 785     for (;;) {
 786         if (match(p2)) {
 787             return p2;
 788         }
 789
 790         p2 = p2->ref->getObject();
 791         if (!p2) {
 792             return p2;
 793         }
 794         if (do1) {
 795             p1 = p1->ref->getObject();
 796         }
 797         do1 = !do1;
 798
 799         if ( p2 == p1 ) {
 800             /* We've been here before, so return NULL to indicate that no matching gradient found
 801              * in the chain. */
 802             return NULL;
 803         }
 804     }
 805 }
 806
 807 /**
 808  * True if gradient has stops.
 809  */
 810 static bool
 811 has_stops(SPGradient const *gr)
 812 {
 813     return SP_GRADIENT_HAS_STOPS(gr);
 814 }
 815
 816 /**
 817  * True if gradient has spread set.
 818  */
 819 static bool
 820 has_spread_set(SPGradient const *gr)
 821 {
 822     return gr->spread_set;
 823 }
 824
 825 /**
 826  * True if gradient has units set.
 827  */
 828 static bool
 829 has_units_set(SPGradient const *gr)
 830 {
 831     return gr->units_set;
 832 }
 833
 834
 835 /**
 836  * Returns private vector of given gradient (the gradient at the end of the href chain which has
 837  * stops), optionally normalizing it.
 838  *
 839  * \pre SP_IS_GRADIENT(gradient).
 840  * \pre There exists a gradient in the chain that has stops.
 841  */
 842 SPGradient *
 843 sp_gradient_get_vector(SPGradient *gradient, bool force_vector)
 844 {
 845     g_return_val_if_fail(gradient != NULL, NULL);
 846     g_return_val_if_fail(SP_IS_GRADIENT(gradient), NULL);
 847
 848     SPGradient *const src = chase_hrefs(gradient, has_stops);
 849     return ( force_vector
 850              ? sp_gradient_ensure_vector_normalized(src)
 851              : src );
 852 }
 853
 854 /**
 855  * Returns the effective spread of given gradient (climbing up the refs chain if needed).
 856  *
 857  * \pre SP_IS_GRADIENT(gradient).
 858  */
 859 SPGradientSpread
 860 sp_gradient_get_spread(SPGradient *gradient)
 861 {
 862     g_return_val_if_fail(SP_IS_GRADIENT(gradient), SP_GRADIENT_SPREAD_PAD);
 863
 864     SPGradient const *src = chase_hrefs(gradient, has_spread_set);
 865     return ( src
 866              ? src->spread
 867              : SP_GRADIENT_SPREAD_PAD ); // pad is the default
 868 }
 869
 870 /**
 871  * Returns the effective units of given gradient (climbing up the refs chain if needed).
 872  *
 873  * \pre SP_IS_GRADIENT(gradient).
 874  */
 875 SPGradientUnits
 876 sp_gradient_get_units(SPGradient *gradient)
 877 {
 878     g_return_val_if_fail(SP_IS_GRADIENT(gradient), SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX);
 879
 880     SPGradient const *src = chase_hrefs(gradient, has_units_set);
 881     return ( src
 882              ? src->units
 883              : SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX ); // bbox is the default
 884 }
 885
 886
 887 /**
 888  * Clears the gradient's svg:stop children from its repr.
 889  */
 890 void
 891 sp_gradient_repr_clear_vector(SPGradient *gr)
 892 {
 893     Inkscape::XML::Node *repr = SP_OBJECT_REPR(gr);
 894
 895     /* Collect stops from original repr */
 896     GSList *sl = NULL;
 897     for (Inkscape::XML::Node *child = repr->firstChild() ; child != NULL; child = child->next() ) {
 898         if (!strcmp(child->name(), "svg:stop")) {
 899             sl = g_slist_prepend(sl, child);
 900         }
 901     }
 902     /* Remove all stops */
 903     while (sl) {
 904         /** \todo
 905          * fixme: This should work, unless we make gradient
 906          * into generic group.
 907          */
 908         sp_repr_unparent((Inkscape::XML::Node *)sl->data);
 909         sl = g_slist_remove(sl, sl->data);
 910     }
 911 }
 912
 913 /**
 914  * Writes the gradient's internal vector (whether from its own stops, or
 915  * inherited from refs) into the gradient repr as svg:stop elements.
 916  */
 917 void
 918 sp_gradient_repr_write_vector(SPGradient *gr)
 919 {
 920     g_return_if_fail(gr != NULL);
 921     g_return_if_fail(SP_IS_GRADIENT(gr));
 922
 923     Inkscape::XML::Document *xml_doc = sp_document_repr_doc(SP_OBJECT_DOCUMENT(gr));
 924     Inkscape::XML::Node *repr = SP_OBJECT_REPR(gr);
 925
 926     /* We have to be careful, as vector may be our own, so construct repr list at first */
 927     GSList *cl = NULL;
 928
 929     for (guint i = 0; i < gr->vector.stops.size(); i++) {
 930         Inkscape::CSSOStringStream os;
 931         Inkscape::XML::Node *child = xml_doc->createElement("svg:stop");
 932         sp_repr_set_css_double(child, "offset", gr->vector.stops[i].offset);
 933         /* strictly speaking, offset an SVG <number> rather than a CSS one, but exponents make no
 934          * sense for offset proportions. */
 935         gchar c[64];
 936         sp_svg_write_color(c, sizeof(c), gr->vector.stops[i].color.toRGBA32( 0x00 ));
 937         os << "stop-color:" << c << ";stop-opacity:" << gr->vector.stops[i].opacity;
 938         child->setAttribute("style", os.str().c_str());
 939         /* Order will be reversed here */
 940         cl = g_slist_prepend(cl, child);
 941     }
 942
 943     sp_gradient_repr_clear_vector(gr);
 944
 945     /* And insert new children from list */
 946     while (cl) {
 947         Inkscape::XML::Node *child = static_cast<Inkscape::XML::Node *>(cl->data);
 948         repr->addChild(child, NULL);
 949         Inkscape::GC::release(child);
 950         cl = g_slist_remove(cl, child);
 951     }
 952 }
 953
 954
 955 static void
 956 gradient_ref_modified(SPObject */*href*/, guint /*flags*/, SPGradient *gradient)
 957 {
 958     if (sp_gradient_invalidate_vector(gradient)) {
 959         SP_OBJECT(gradient)->requestModified(SP_OBJECT_MODIFIED_FLAG);
 960         /* Conditional to avoid causing infinite loop if there's a cycle in the href chain. */
 961     }
 962 }
 963
 964 /** Return true iff change made. */
 965 static bool
 966 sp_gradient_invalidate_vector(SPGradient *gr)
 967 {
 968     bool ret = false;
 969
 970     if (gr->color != NULL) {
 971         g_free(gr->color);
 972         gr->color = NULL;
 973         ret = true;
 974     }
 975
 976     if (gr->vector.built) {
 977         gr->vector.built = false;
 978         gr->vector.stops.clear();
 979         ret = true;
 980     }
 981
 982     return ret;
 983 }
 984
 985 /** Creates normalized color vector */
 986 static void
 987 sp_gradient_rebuild_vector(SPGradient *gr)
 988 {
 989     gint len = 0;
 990     for ( SPObject *child = sp_object_first_child(SP_OBJECT(gr)) ;
 991           child != NULL ;
 992           child = SP_OBJECT_NEXT(child) ) {
 993         if (SP_IS_STOP(child)) {
 994             len ++;
 995         }
 996     }
 997
 998     gr->has_stops = (len != 0);
 999
1000     gr->vector.stops.clear();
1001
1002     SPGradient *ref = gr->ref->getObject();
1003     if ( !gr->has_stops && ref ) {
1004         /* Copy vector from referenced gradient */
1005         gr->vector.built = true;   // Prevent infinite recursion.
1006         sp_gradient_ensure_vector(ref);
1007         if (!ref->vector.stops.empty()) {
1008             gr->vector.built = ref->vector.built;
1009             gr->vector.stops.assign(ref->vector.stops.begin(), ref->vector.stops.end());
1010             return;
1011         }
1012     }
1013
1014     for (SPObject *child = sp_object_first_child(SP_OBJECT(gr)) ;
1015          child != NULL;
1016          child = SP_OBJECT_NEXT(child) ) {
1017         if (SP_IS_STOP(child)) {
1018             SPStop *stop = SP_STOP(child);
1019
1020             SPGradientStop gstop;
1021             if (gr->vector.stops.size() > 0) {
1022                 // "Each gradient offset value is required to be equal to or greater than the
1023                 // previous gradient stop's offset value. If a given gradient stop's offset
1024                 // value is not equal to or greater than all previous offset values, then the
1025                 // offset value is adjusted to be equal to the largest of all previous offset
1026                 // values."
1027                 gstop.offset = MAX(stop->offset, gr->vector.stops.back().offset);
1028             } else {
1029                 gstop.offset = stop->offset;
1030             }
1031
1032             // "Gradient offset values less than 0 (or less than 0%) are rounded up to
1033             // 0%. Gradient offset values greater than 1 (or greater than 100%) are rounded
1034             // down to 100%."
1035             gstop.offset = CLAMP(gstop.offset, 0, 1);
1036
1037             gstop.color = sp_stop_get_color(stop);
1038             gstop.opacity = stop->opacity;
1039
1040             gr->vector.stops.push_back(gstop);
1041         }
1042     }
1043
1044     // Normalize per section 13.2.4 of SVG 1.1.
1045     if (gr->vector.stops.size() == 0) {
1046         /* "If no stops are defined, then painting shall occur as if 'none' were specified as the
1047          * paint style."
1048          */
1049         {
1050             SPGradientStop gstop;
1051             gstop.offset = 0.0;
1052             gstop.color.set( 0x00000000 );
1053             gstop.opacity = 0.0;
1054             gr->vector.stops.push_back(gstop);
1055         }
1056         {
1057             SPGradientStop gstop;
1058             gstop.offset = 1.0;
1059             gstop.color.set( 0x00000000 );
1060             gstop.opacity = 0.0;
1061             gr->vector.stops.push_back(gstop);
1062         }
1063     } else {
1064         /* "If one stop is defined, then paint with the solid color fill using the color defined
1065          * for that gradient stop."
1066          */
1067         if (gr->vector.stops.front().offset > 0.0) {
1068             // If the first one is not at 0, then insert a copy of the first at 0.
1069             SPGradientStop gstop;
1070             gstop.offset = 0.0;
1071             gstop.color = gr->vector.stops.front().color;
1072             gstop.opacity = gr->vector.stops.front().opacity;
1073             gr->vector.stops.insert(gr->vector.stops.begin(), gstop);
1074         }
1075         if (gr->vector.stops.back().offset < 1.0) {
1076             // If the last one is not at 1, then insert a copy of the last at 1.
1077             SPGradientStop gstop;
1078             gstop.offset = 1.0;
1079             gstop.color = gr->vector.stops.back().color;
1080             gstop.opacity = gr->vector.stops.back().opacity;
1081             gr->vector.stops.push_back(gstop);
1082         }
1083     }
1084
1085     gr->vector.built = true;
1086 }
1087
1088 /**
1089  * The gradient's color array is newly created and set up from vector.
1090  */
1091 void
1092 sp_gradient_ensure_colors(SPGradient *gr)
1093 {
1094     if (!gr->vector.built) {
1095         sp_gradient_rebuild_vector(gr);
1096     }
1097     g_return_if_fail(!gr->vector.stops.empty());
1098
1099     /// \todo Where is the memory freed?
1100     if (!gr->color) {
1101         gr->color = g_new(guchar, 4 * NCOLORS);
1102     }
1103
1104     // This assumes that gr->vector is a zero-order B-spline (box function) approximation of the "true" gradient.
1105     // This means that the "true" gradient must be prefiltered using a zero order B-spline and then sampled.
1106     // Furthermore, the first element corresponds to offset="0" and the last element to offset="1".
1107
1108     double remainder[4] = {0,0,0,0};
1109     double remainder_for_end[4] = {0,0,0,0}; // Used at the end
1110     switch(gr->spread) {
1111     case SP_GRADIENT_SPREAD_PAD:
1112         remainder[0] = 0.5*gr->vector.stops[0].color.v.c[0]; // Half of the first cell uses the color of the first stop
1113         remainder[1] = 0.5*gr->vector.stops[0].color.v.c[1];
1114         remainder[2] = 0.5*gr->vector.stops[0].color.v.c[2];
1115         remainder[3] = 0.5*gr->vector.stops[0].opacity;
1116         remainder_for_end[0] = 0.5*gr->vector.stops[gr->vector.stops.size() - 1].color.v.c[0]; // Half of the first cell uses the color of the last stop
1117         remainder_for_end[1] = 0.5*gr->vector.stops[gr->vector.stops.size() - 1].color.v.c[1];
1118         remainder_for_end[2] = 0.5*gr->vector.stops[gr->vector.stops.size() - 1].color.v.c[2];
1119         remainder_for_end[3] = 0.5*gr->vector.stops[gr->vector.stops.size() - 1].opacity;
1120         break;
1121     case SP_GRADIENT_SPREAD_REFLECT:
1122     case SP_GRADIENT_SPREAD_REPEAT:
1123         // These two are handled differently, see below.
1124         break;
1125     default:
1126         g_error("Spread type not supported!");
1127     };
1128     for (unsigned int i = 0; i < gr->vector.stops.size() - 1; i++) {
1129         double r0 = gr->vector.stops[i].color.v.c[0];
1130         double g0 = gr->vector.stops[i].color.v.c[1];
1131         double b0 = gr->vector.stops[i].color.v.c[2];
1132         double a0 = gr->vector.stops[i].opacity;
1133         double r1 = gr->vector.stops[i+1].color.v.c[0];
1134         double g1 = gr->vector.stops[i+1].color.v.c[1];
1135         double b1 = gr->vector.stops[i+1].color.v.c[2];
1136         double a1 = gr->vector.stops[i+1].opacity;
1137         double o0 = gr->vector.stops[i].offset * (NCOLORS-1);
1138         double o1 = gr->vector.stops[i + 1].offset * (NCOLORS-1);
1139         unsigned int ob = (unsigned int) floor(o0+.5); // These are the first and last element that might be affected by this interval.
1140         unsigned int oe = (unsigned int) floor(o1+.5); // These need to be computed the same to ensure that ob will be covered by the next interval if oe==ob
1141
1142         if (oe == ob) {
1143             // Simple case, this interval starts and stops within one cell
1144             // The contribution of this interval is:
1145             //    (o1-o0)*(c(o0)+c(o1))/2
1146             //  = (o1-o0)*(c0+c1)/2
1147             double dt = 0.5*(o1-o0);
1148             remainder[0] += dt*(r0 + r1);
1149             remainder[1] += dt*(g0 + g1);
1150             remainder[2] += dt*(b0 + b1);
1151             remainder[3] += dt*(a0 + a1);
1152         } else {
1153             // First compute colors for the cells which are fully covered by the current interval.
1154             // The prefiltered values are equal to the midpoint of each cell here.
1155             //  f = (j-o0)/(o1-o0)
1156             //    = j*(1/(o1-o0)) - o0/(o1-o0)
1157             double f = (ob-o0) / (o1-o0);
1158             double df = 1. / (o1-o0);
1159             for (unsigned int j = ob+1; j < oe; j++) {
1160                 f += df;
1161                 gr->color[4 * j + 0] = (unsigned char) floor(255*(r0 + f*(r1-r0)) + .5);
1162                 gr->color[4 * j + 1] = (unsigned char) floor(255*(g0 + f*(g1-g0)) + .5);
1163                 gr->color[4 * j + 2] = (unsigned char) floor(255*(b0 + f*(b1-b0)) + .5);
1164                 gr->color[4 * j + 3] = (unsigned char) floor(255*(a0 + f*(a1-a0)) + .5);
1165             }
1166
1167             // Now handle the beginning
1168             // The contribution of the last point is already in remainder.
1169             // The contribution of this point is:
1170             //    (ob+.5-o0)*(c(o0)+c(ob+.5))/2
1171             //  = (ob+.5-o0)*c((o0+ob+.5)/2)
1172             //  = (ob+.5-o0)*(c0+((o0+ob+.5)/2-o0)*df*(c1-c0))
1173             //  = (ob+.5-o0)*(c0+(ob+.5-o0)*df*(c1-c0)/2)
1174             double dt = ob+.5-o0;
1175             f = 0.5*dt*df;
1176             if (ob==0 && gr->spread==SP_GRADIENT_SPREAD_REFLECT) {
1177                 // The first half of the first cell is just a mirror image of the second half, so simply multiply it by 2.
1178                 gr->color[4 * ob + 0] = (unsigned char) floor(2*255*(remainder[0] + dt*(r0 + f*(r1-r0))) + .5);
1179                 gr->color[4 * ob + 1] = (unsigned char) floor(2*255*(remainder[1] + dt*(g0 + f*(g1-g0))) + .5);
1180                 gr->color[4 * ob + 2] = (unsigned char) floor(2*255*(remainder[2] + dt*(b0 + f*(b1-b0))) + .5);
1181                 gr->color[4 * ob + 3] = (unsigned char) floor(2*255*(remainder[3] + dt*(a0 + f*(a1-a0))) + .5);
1182             } else if (ob==0 && gr->spread==SP_GRADIENT_SPREAD_REPEAT) {
1183                 // The first cell is the same as the last cell, so save whatever is in the second half here and deal with the rest later.
1184                 remainder_for_end[0] = remainder[0] + dt*(r0 + f*(r1-r0));
1185                 remainder_for_end[1] = remainder[1] + dt*(g0 + f*(g1-g0));
1186                 remainder_for_end[2] = remainder[2] + dt*(b0 + f*(b1-b0));
1187                 remainder_for_end[3] = remainder[3] + dt*(a0 + f*(a1-a0));
1188             } else {
1189                 // The first half of the cell was already in remainder.
1190                 gr->color[4 * ob + 0] = (unsigned char) floor(255*(remainder[0] + dt*(r0 + f*(r1-r0))) + .5);
1191                 gr->color[4 * ob + 1] = (unsigned char) floor(255*(remainder[1] + dt*(g0 + f*(g1-g0))) + .5);
1192                 gr->color[4 * ob + 2] = (unsigned char) floor(255*(remainder[2] + dt*(b0 + f*(b1-b0))) + .5);
1193                 gr->color[4 * ob + 3] = (unsigned char) floor(255*(remainder[3] + dt*(a0 + f*(a1-a0))) + .5);
1194             }
1195
1196             // Now handle the end, which should end up in remainder
1197             // The contribution of this point is:
1198             //    (o1-oe+.5)*(c(o1)+c(oe-.5))/2
1199             //  = (o1-oe+.5)*c((o1+oe-.5)/2)
1200             //  = (o1-oe+.5)*(c0+((o1+oe-.5)/2-o0)*df*(c1-c0))
1201             dt = o1-oe+.5;
1202             f = (0.5*(o1+oe-.5)-o0)*df;
1203             remainder[0] = dt*(r0 + f*(r1-r0));
1204             remainder[1] = dt*(g0 + f*(g1-g0));
1205             remainder[2] = dt*(b0 + f*(b1-b0));
1206             remainder[3] = dt*(a0 + f*(a1-a0));
1207         }
1208     }
1209     switch(gr->spread) {
1210     case SP_GRADIENT_SPREAD_PAD:
1211         gr->color[4 * (NCOLORS-1) + 0] = (unsigned char) floor(255*(remainder[0]+remainder_for_end[0]) + .5);
1212         gr->color[4 * (NCOLORS-1) + 1] = (unsigned char) floor(255*(remainder[1]+remainder_for_end[1]) + .5);
1213         gr->color[4 * (NCOLORS-1) + 2] = (unsigned char) floor(255*(remainder[2]+remainder_for_end[2]) + .5);
1214         gr->color[4 * (NCOLORS-1) + 3] = (unsigned char) floor(255*(remainder[3]+remainder_for_end[3]) + .5);
1215         break;
1216     case SP_GRADIENT_SPREAD_REFLECT:
1217         // The second half is the same as the first half, so multiply by 2.
1218         gr->color[4 * (NCOLORS-1) + 0] = (unsigned char) floor(2*255*remainder[0] + .5);
1219         gr->color[4 * (NCOLORS-1) + 1] = (unsigned char) floor(2*255*remainder[1] + .5);
1220         gr->color[4 * (NCOLORS-1) + 2] = (unsigned char) floor(2*255*remainder[2] + .5);
1221         gr->color[4 * (NCOLORS-1) + 3] = (unsigned char) floor(2*255*remainder[3] + .5);
1222         break;
1223     case SP_GRADIENT_SPREAD_REPEAT:
1224         // The second half is the same as the second half of the first cell (which was saved in remainder_for_end).
1225         gr->color[0] = gr->color[4 * (NCOLORS-1) + 0] = (unsigned char) floor(255*(remainder[0]+remainder_for_end[0]) + .5);
1226         gr->color[1] = gr->color[4 * (NCOLORS-1) + 1] = (unsigned char) floor(255*(remainder[1]+remainder_for_end[1]) + .5);
1227         gr->color[2] = gr->color[4 * (NCOLORS-1) + 2] = (unsigned char) floor(255*(remainder[2]+remainder_for_end[2]) + .5);
1228         gr->color[3] = gr->color[4 * (NCOLORS-1) + 3] = (unsigned char) floor(255*(remainder[3]+remainder_for_end[3]) + .5);
1229         break;
1230     }
1231 }
1232
1233 /**
1234  * Renders gradient vector to buffer as line.
1235  *
1236  * RGB buffer background should be set up beforehand.
1237  *
1238  * @param len,width,height,rowstride Buffer parameters (1 or 2 dimensional).
1239  * @param span Full integer width of requested gradient.
1240  * @param pos Buffer starting position in span.
1241  */
1242 static void
1243 sp_gradient_render_vector_line_rgba(SPGradient *const gradient, guchar *buf,
1244                                     gint const len, gint const pos, gint const span)
1245 {
1246     g_return_if_fail(gradient != NULL);
1247     g_return_if_fail(SP_IS_GRADIENT(gradient));
1248     g_return_if_fail(buf != NULL);
1249     g_return_if_fail(len > 0);
1250     g_return_if_fail(pos >= 0);
1251     g_return_if_fail(pos + len <= span);
1252     g_return_if_fail(span > 0);
1253
1254     if (!gradient->color) {
1255         sp_gradient_ensure_colors(gradient);
1256     }
1257
1258     gint idx = (pos * 1024 << 8) / span;
1259     gint didx = (1024 << 8) / span;
1260
1261     for (gint x = 0; x < len; x++) {
1262         /// \todo Can this be done with 4 byte copies?
1263         *buf++ = gradient->color[4 * (idx >> 8)];
1264         *buf++ = gradient->color[4 * (idx >> 8) + 1];
1265         *buf++ = gradient->color[4 * (idx >> 8) + 2];
1266         *buf++ = gradient->color[4 * (idx >> 8) + 3];
1267         idx += didx;
1268     }
1269 }
1270
1271 /**
1272  * Render rectangular RGBA area from gradient vector.
1273  */
1274 void
1275 sp_gradient_render_vector_block_rgba(SPGradient *const gradient, guchar *buf,
1276                                      gint const width, gint const height, gint const rowstride,
1277                                      gint const pos, gint const span, bool const horizontal)
1278 {
1279     g_return_if_fail(gradient != NULL);
1280     g_return_if_fail(SP_IS_GRADIENT(gradient));
1281     g_return_if_fail(buf != NULL);
1282     g_return_if_fail(width > 0);
1283     g_return_if_fail(height > 0);
1284     g_return_if_fail(pos >= 0);
1285     g_return_if_fail((horizontal && (pos + width <= span)) || (!horizontal && (pos + height <= span)));
1286     g_return_if_fail(span > 0);
1287
1288     if (horizontal) {
1289         sp_gradient_render_vector_line_rgba(gradient, buf, width, pos, span);
1290         for (gint y = 1; y < height; y++) {
1291             memcpy(buf + y * rowstride, buf, 4 * width);
1292         }
1293     } else {
1294         guchar *tmp = (guchar *)alloca(4 * height);
1295         sp_gradient_render_vector_line_rgba(gradient, tmp, height, pos, span);
1296         for (gint y = 0; y < height; y++) {
1297             guchar *b = buf + y * rowstride;
1298             for (gint x = 0; x < width; x++) {
1299                 *b++ = tmp[0];
1300                 *b++ = tmp[1];
1301                 *b++ = tmp[2];
1302                 *b++ = tmp[3];
1303             }
1304             tmp += 4;
1305         }
1306     }
1307 }
1308
1309 /**
1310  * Render rectangular RGB area from gradient vector.
1311  */
1312 void
1313 sp_gradient_render_vector_block_rgb(SPGradient *gradient, guchar *buf,
1314                                     gint const width, gint const height, gint const /*rowstride*/,
1315                                     gint const pos, gint const span, bool const horizontal)
1316 {
1317     g_return_if_fail(gradient != NULL);
1318     g_return_if_fail(SP_IS_GRADIENT(gradient));
1319     g_return_if_fail(buf != NULL);
1320     g_return_if_fail(width > 0);
1321     g_return_if_fail(height > 0);
1322     g_return_if_fail(pos >= 0);
1323     g_return_if_fail((horizontal && (pos + width <= span)) || (!horizontal && (pos + height <= span)));
1324     g_return_if_fail(span > 0);
1325
1326     if (horizontal) {
1327         guchar *tmp = (guchar*)alloca(4 * width);
1328         sp_gradient_render_vector_line_rgba(gradient, tmp, width, pos, span);
1329         for (gint y = 0; y < height; y++) {
1330             guchar *t = tmp;
1331             for (gint x = 0; x < width; x++) {
1332                 gint a = t[3];
1333                 gint fc = (t[0] - buf[0]) * a;
1334                 buf[0] = buf[0] + ((fc + (fc >> 8) + 0x80) >> 8);
1335                 fc = (t[1] - buf[1]) * a;
1336                 buf[1] = buf[1] + ((fc + (fc >> 8) + 0x80) >> 8);
1337                 fc = (t[2] - buf[2]) * a;
1338                 buf[2] = buf[2] + ((fc + (fc >> 8) + 0x80) >> 8);
1339                 buf += 3;
1340                 t += 4;
1341             }
1342         }
1343     } else {
1344         guchar *tmp = (guchar*)alloca(4 * height);
1345         sp_gradient_render_vector_line_rgba(gradient, tmp, height, pos, span);
1346         for (gint y = 0; y < height; y++) {
1347             guchar *t = tmp + 4 * y;
1348             for (gint x = 0; x < width; x++) {
1349                 gint a = t[3];
1350                 gint fc = (t[0] - buf[0]) * a;
1351                 buf[0] = buf[0] + ((fc + (fc >> 8) + 0x80) >> 8);
1352                 fc = (t[1] - buf[1]) * a;
1353                 buf[1] = buf[1] + ((fc + (fc >> 8) + 0x80) >> 8);
1354                 fc = (t[2] - buf[2]) * a;
1355                 buf[2] = buf[2] + ((fc + (fc >> 8) + 0x80) >> 8);
1356             }
1357         }
1358     }
1359 }
1360
1361 Geom::Matrix
1362 sp_gradient_get_g2d_matrix(SPGradient const *gr, Geom::Matrix const &ctm, Geom::Rect const &bbox)
1363 {
1364     if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
1365         return ( Geom::Scale(bbox.dimensions())
1366                  * Geom::Translate(bbox.min())
1367                  * Geom::Matrix(ctm) );
1368     } else {
1369         return ctm;
1370     }
1371 }
1372
1373 Geom::Matrix
1374 sp_gradient_get_gs2d_matrix(SPGradient const *gr, Geom::Matrix const &ctm, Geom::Rect const &bbox)
1375 {
1376     if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
1377         return ( gr->gradientTransform
1378                  * Geom::Scale(bbox.dimensions())
1379                  * Geom::Translate(bbox.min())
1380                  * Geom::Matrix(ctm) );
1381     } else {
1382         return gr->gradientTransform * ctm;
1383     }
1384 }
1385
1386 void
1387 sp_gradient_set_gs2d_matrix(SPGradient *gr, Geom::Matrix const &ctm,
1388                             Geom::Rect const &bbox, Geom::Matrix const &gs2d)
1389 {
1390     gr->gradientTransform = gs2d * ctm.inverse();
1391     if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX ) {
1392         gr->gradientTransform = ( gr->gradientTransform
1393                                   * Geom::Translate(-bbox.min())
1394                                   * Geom::Scale(bbox.dimensions()).inverse() );
1395     }
1396     gr->gradientTransform_set = TRUE;
1397
1398     SP_OBJECT(gr)->requestModified(SP_OBJECT_MODIFIED_FLAG);
1399 }
1400
1401 /*
1402  * Linear Gradient
1403  */
1404
1405 class SPLGPainter;
1406
1407 /// A context with linear gradient, painter, and gradient renderer.
1408 struct SPLGPainter {
1409     SPPainter painter;
1410     SPLinearGradient *lg;
1411
1412     NRLGradientRenderer lgr;
1413 };
1414
1415 static void sp_lineargradient_class_init(SPLinearGradientClass *klass);
1416 static void sp_lineargradient_init(SPLinearGradient *lg);
1417
1418 static void sp_lineargradient_build(SPObject *object,
1419                                     SPDocument *document,
1420                                     Inkscape::XML::Node *repr);
1421 static void sp_lineargradient_set(SPObject *object, unsigned key, gchar const *value);
1422 static Inkscape::XML::Node *sp_lineargradient_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr,
1423                                                     guint flags);
1424
1425 static SPPainter *sp_lineargradient_painter_new(SPPaintServer *ps,
1426                                                 Geom::Matrix const &full_transform,
1427                                                 Geom::Matrix const &parent_transform,
1428                                                 NRRect const *bbox);
1429 static void sp_lineargradient_painter_free(SPPaintServer *ps, SPPainter *painter);
1430
1431 static void sp_lg_fill(SPPainter *painter, NRPixBlock *pb);
1432
1433 static SPGradientClass *lg_parent_class;
1434
1435 /**
1436  * Register SPLinearGradient class and return its type.
1437  */
1438 GType
1439 sp_lineargradient_get_type()
1440 {
1441     static GType type = 0;
1442     if (!type) {
1443         GTypeInfo info = {
1444             sizeof(SPLinearGradientClass),
1445             NULL, NULL,
1446             (GClassInitFunc) sp_lineargradient_class_init,
1447             NULL, NULL,
1448             sizeof(SPLinearGradient),
1449             16,
1450             (GInstanceInitFunc) sp_lineargradient_init,
1451             NULL,   /* value_table */
1452         };
1453         type = g_type_register_static(SP_TYPE_GRADIENT, "SPLinearGradient", &info, (GTypeFlags)0);
1454     }
1455     return type;
1456 }
1457
1458 /**
1459  * SPLinearGradient vtable initialization.
1460  */
1461 static void sp_lineargradient_class_init(SPLinearGradientClass *klass)
1462 {
1463     SPObjectClass *sp_object_class = (SPObjectClass *) klass;
1464     SPPaintServerClass *ps_class = (SPPaintServerClass *) klass;
1465
1466     lg_parent_class = (SPGradientClass*)g_type_class_ref(SP_TYPE_GRADIENT);
1467
1468     sp_object_class->build = sp_lineargradient_build;
1469     sp_object_class->set = sp_lineargradient_set;
1470     sp_object_class->write = sp_lineargradient_write;
1471
1472     ps_class->painter_new = sp_lineargradient_painter_new;
1473     ps_class->painter_free = sp_lineargradient_painter_free;
1474 }
1475
1476 /**
1477  * Callback for SPLinearGradient object initialization.
1478  */
1479 static void sp_lineargradient_init(SPLinearGradient *lg)
1480 {
1481     lg->x1.unset(SVGLength::PERCENT, 0.0, 0.0);
1482     lg->y1.unset(SVGLength::PERCENT, 0.0, 0.0);
1483     lg->x2.unset(SVGLength::PERCENT, 1.0, 1.0);
1484     lg->y2.unset(SVGLength::PERCENT, 0.0, 0.0);
1485 }
1486
1487 /**
1488  * Callback: set attributes from associated repr.
1489  */
1490 static void sp_lineargradient_build(SPObject *object,
1491                                     SPDocument *document,
1492                                     Inkscape::XML::Node *repr)
1493 {
1494     if (((SPObjectClass *) lg_parent_class)->build)
1495         (* ((SPObjectClass *) lg_parent_class)->build)(object, document, repr);
1496
1497     sp_object_read_attr(object, "x1");
1498     sp_object_read_attr(object, "y1");
1499     sp_object_read_attr(object, "x2");
1500     sp_object_read_attr(object, "y2");
1501 }
1502
1503 /**
1504  * Callback: set attribute.
1505  */
1506 static void
1507 sp_lineargradient_set(SPObject *object, unsigned key, gchar const *value)
1508 {
1509     SPLinearGradient *lg = SP_LINEARGRADIENT(object);
1510
1511     switch (key) {
1512         case SP_ATTR_X1:
1513             lg->x1.readOrUnset(value, SVGLength::PERCENT, 0.0, 0.0);
1514             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
1515             break;
1516         case SP_ATTR_Y1:
1517             lg->y1.readOrUnset(value, SVGLength::PERCENT, 0.0, 0.0);
1518             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
1519             break;
1520         case SP_ATTR_X2:
1521             lg->x2.readOrUnset(value, SVGLength::PERCENT, 1.0, 1.0);
1522             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
1523             break;
1524         case SP_ATTR_Y2:
1525             lg->y2.readOrUnset(value, SVGLength::PERCENT, 0.0, 0.0);
1526             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
1527             break;
1528         default:
1529             if (((SPObjectClass *) lg_parent_class)->set)
1530                 (* ((SPObjectClass *) lg_parent_class)->set)(object, key, value);
1531             break;
1532     }
1533 }
1534
1535 /**
1536  * Callback: write attributes to associated repr.
1537  */
1538 static Inkscape::XML::Node *
1539 sp_lineargradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
1540 {
1541     SPLinearGradient *lg = SP_LINEARGRADIENT(object);
1542
1543     if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
1544         repr = xml_doc->createElement("svg:linearGradient");
1545     }
1546
1547     if ((flags & SP_OBJECT_WRITE_ALL) || lg->x1._set)
1548         sp_repr_set_svg_double(repr, "x1", lg->x1.computed);
1549     if ((flags & SP_OBJECT_WRITE_ALL) || lg->y1._set)
1550         sp_repr_set_svg_double(repr, "y1", lg->y1.computed);
1551     if ((flags & SP_OBJECT_WRITE_ALL) || lg->x2._set)
1552         sp_repr_set_svg_double(repr, "x2", lg->x2.computed);
1553     if ((flags & SP_OBJECT_WRITE_ALL) || lg->y2._set)
1554         sp_repr_set_svg_double(repr, "y2", lg->y2.computed);
1555
1556     if (((SPObjectClass *) lg_parent_class)->write)
1557         (* ((SPObjectClass *) lg_parent_class)->write)(object, xml_doc, repr, flags);
1558
1559     return repr;
1560 }
1561
1562 /**
1563  * Create linear gradient context.
1564  *
1565  * Basically we have to deal with transformations
1566  *
1567  * 1) color2norm - maps point in (0,NCOLORS) vector to (0,1) vector
1568  * 2) norm2pos - maps (0,1) vector to x1,y1 - x2,y2
1569  * 2) gradientTransform
1570  * 3) bbox2user
1571  * 4) ctm == userspace to pixel grid
1572  *
1573  * See also (*) in sp-pattern about why we may need parent_transform.
1574  *
1575  * \todo (point 1 above) fixme: I do not know how to deal with start > 0
1576  * and end < 1.
1577  */
1578 static SPPainter *
1579 sp_lineargradient_painter_new(SPPaintServer *ps,
1580                               Geom::Matrix const &full_transform,
1581                               Geom::Matrix const &/*parent_transform*/,
1582                               NRRect const *bbox)
1583 {
1584     SPLinearGradient *lg = SP_LINEARGRADIENT(ps);
1585     SPGradient *gr = SP_GRADIENT(ps);
1586
1587     if (!gr->color) sp_gradient_ensure_colors(gr);
1588
1589     SPLGPainter *lgp = g_new(SPLGPainter, 1);
1590
1591     lgp->painter.type = SP_PAINTER_IND;
1592     lgp->painter.fill = sp_lg_fill;
1593
1594     lgp->lg = lg;
1595
1596     /** \todo
1597      * Technically speaking, we map NCOLORS on line [start,end] onto line
1598      * [0,1].  I almost think we should fill color array start and end in
1599      * that case. The alternative would be to leave these just empty garbage
1600      * or something similar. Originally I had 1023.9999 here - not sure
1601      * whether we have really to cut out ceil int (Lauris).
1602      */
1603     Geom::Matrix color2norm(Geom::identity());
1604     Geom::Matrix color2px;
1605     if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
1606         Geom::Matrix norm2pos(Geom::identity());
1607
1608         /* BBox to user coordinate system */
1609         Geom::Matrix bbox2user(bbox->x1 - bbox->x0, 0, 0, bbox->y1 - bbox->y0, bbox->x0, bbox->y0);
1610
1611         Geom::Matrix color2pos = color2norm * norm2pos;
1612         Geom::Matrix color2tpos = color2pos * gr->gradientTransform;
1613         Geom::Matrix color2user = color2tpos * bbox2user;
1614         color2px = color2user * full_transform;
1615
1616     } else {
1617         /* Problem: What to do, if we have mixed lengths and percentages? */
1618         /* Currently we do ignore percentages at all, but that is not good (lauris) */
1619
1620         Geom::Matrix norm2pos(Geom::identity());
1621         Geom::Matrix color2pos = color2norm * norm2pos;
1622         Geom::Matrix color2tpos = color2pos * gr->gradientTransform;
1623         color2px = color2tpos * full_transform;
1624
1625     }
1626     // TODO: remove color2px_nr after converting to 2geom
1627     NR::Matrix color2px_nr = from_2geom(color2px);
1628     nr_lgradient_renderer_setup(&lgp->lgr, gr->color, sp_gradient_get_spread(gr), &color2px_nr,
1629                                 lg->x1.computed, lg->y1.computed,
1630                                 lg->x2.computed, lg->y2.computed);
1631
1632     return (SPPainter *) lgp;
1633 }
1634
1635 static void
1636 sp_lineargradient_painter_free(SPPaintServer */*ps*/, SPPainter *painter)
1637 {
1638     g_free(painter);
1639 }
1640
1641 /**
1642  * Directly set properties of linear gradient and request modified.
1643  */
1644 void
1645 sp_lineargradient_set_position(SPLinearGradient *lg,
1646                                gdouble x1, gdouble y1,
1647                                gdouble x2, gdouble y2)
1648 {
1649     g_return_if_fail(lg != NULL);
1650     g_return_if_fail(SP_IS_LINEARGRADIENT(lg));
1651
1652     /* fixme: units? (Lauris)  */
1653     lg->x1.set(SVGLength::NONE, x1, x1);
1654     lg->y1.set(SVGLength::NONE, y1, y1);
1655     lg->x2.set(SVGLength::NONE, x2, x2);
1656     lg->y2.set(SVGLength::NONE, y2, y2);
1657
1658     SP_OBJECT(lg)->requestModified(SP_OBJECT_MODIFIED_FLAG);
1659 }
1660
1661 /**
1662  * Callback when linear gradient object is rendered.
1663  */
1664 static void
1665 sp_lg_fill(SPPainter *painter, NRPixBlock *pb)
1666 {
1667     SPLGPainter *lgp = (SPLGPainter *) painter;
1668
1669     if (lgp->lg->color == NULL) {
1670         sp_gradient_ensure_colors (lgp->lg);
1671         lgp->lgr.vector = lgp->lg->color;
1672     }
1673
1674     nr_render((NRRenderer *) &lgp->lgr, pb, NULL);
1675 }
1676
1677 /*
1678  * Radial Gradient
1679  */
1680
1681 class SPRGPainter;
1682
1683 /// A context with radial gradient, painter, and gradient renderer.
1684 struct SPRGPainter {
1685     SPPainter painter;
1686     SPRadialGradient *rg;
1687     NRRGradientRenderer rgr;
1688 };
1689
1690 static void sp_radialgradient_class_init(SPRadialGradientClass *klass);
1691 static void sp_radialgradient_init(SPRadialGradient *rg);
1692
1693 static void sp_radialgradient_build(SPObject *object,
1694                                     SPDocument *document,
1695                                     Inkscape::XML::Node *repr);
1696 static void sp_radialgradient_set(SPObject *object, unsigned key, gchar const *value);
1697 static Inkscape::XML::Node *sp_radialgradient_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr,
1698                                                     guint flags);
1699
1700 static SPPainter *sp_radialgradient_painter_new(SPPaintServer *ps,
1701                                                 Geom::Matrix const &full_transform,
1702                                                 Geom::Matrix const &parent_transform,
1703                                                 NRRect const *bbox);
1704 static void sp_radialgradient_painter_free(SPPaintServer *ps, SPPainter *painter);
1705
1706 static void sp_rg_fill(SPPainter *painter, NRPixBlock *pb);
1707
1708 static SPGradientClass *rg_parent_class;
1709
1710 /**
1711  * Register SPRadialGradient class and return its type.
1712  */
1713 GType
1714 sp_radialgradient_get_type()
1715 {
1716     static GType type = 0;
1717     if (!type) {
1718         GTypeInfo info = {
1719             sizeof(SPRadialGradientClass),
1720             NULL, NULL,
1721             (GClassInitFunc) sp_radialgradient_class_init,
1722             NULL, NULL,
1723             sizeof(SPRadialGradient),
1724             16,
1725             (GInstanceInitFunc) sp_radialgradient_init,
1726             NULL,   /* value_table */
1727         };
1728         type = g_type_register_static(SP_TYPE_GRADIENT, "SPRadialGradient", &info, (GTypeFlags)0);
1729     }
1730     return type;
1731 }
1732
1733 /**
1734  * SPRadialGradient vtable initialization.
1735  */
1736 static void sp_radialgradient_class_init(SPRadialGradientClass *klass)
1737 {
1738     SPObjectClass *sp_object_class = (SPObjectClass *) klass;
1739     SPPaintServerClass *ps_class = (SPPaintServerClass *) klass;
1740
1741     rg_parent_class = (SPGradientClass*)g_type_class_ref(SP_TYPE_GRADIENT);
1742
1743     sp_object_class->build = sp_radialgradient_build;
1744     sp_object_class->set = sp_radialgradient_set;
1745     sp_object_class->write = sp_radialgradient_write;
1746
1747     ps_class->painter_new = sp_radialgradient_painter_new;
1748     ps_class->painter_free = sp_radialgradient_painter_free;
1749 }
1750
1751 /**
1752  * Callback for SPRadialGradient object initialization.
1753  */
1754 static void
1755 sp_radialgradient_init(SPRadialGradient *rg)
1756 {
1757     rg->cx.unset(SVGLength::PERCENT, 0.5, 0.5);
1758     rg->cy.unset(SVGLength::PERCENT, 0.5, 0.5);
1759     rg->r.unset(SVGLength::PERCENT, 0.5, 0.5);
1760     rg->fx.unset(SVGLength::PERCENT, 0.5, 0.5);
1761     rg->fy.unset(SVGLength::PERCENT, 0.5, 0.5);
1762 }
1763
1764 /**
1765  * Set radial gradient attributes from associated repr.
1766  */
1767 static void
1768 sp_radialgradient_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
1769 {
1770     if (((SPObjectClass *) rg_parent_class)->build)
1771         (* ((SPObjectClass *) rg_parent_class)->build)(object, document, repr);
1772
1773     sp_object_read_attr(object, "cx");
1774     sp_object_read_attr(object, "cy");
1775     sp_object_read_attr(object, "r");
1776     sp_object_read_attr(object, "fx");
1777     sp_object_read_attr(object, "fy");
1778 }
1779
1780 /**
1781  * Set radial gradient attribute.
1782  */
1783 static void
1784 sp_radialgradient_set(SPObject *object, unsigned key, gchar const *value)
1785 {
1786     SPRadialGradient *rg = SP_RADIALGRADIENT(object);
1787
1788     switch (key) {
1789         case SP_ATTR_CX:
1790             if (!rg->cx.read(value)) {
1791                 rg->cx.unset(SVGLength::PERCENT, 0.5, 0.5);
1792             }
1793             if (!rg->fx._set) {
1794                 rg->fx.value = rg->cx.value;
1795                 rg->fx.computed = rg->cx.computed;
1796             }
1797             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
1798             break;
1799         case SP_ATTR_CY:
1800             if (!rg->cy.read(value)) {
1801                 rg->cy.unset(SVGLength::PERCENT, 0.5, 0.5);
1802             }
1803             if (!rg->fy._set) {
1804                 rg->fy.value = rg->cy.value;
1805                 rg->fy.computed = rg->cy.computed;
1806             }
1807             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
1808             break;
1809         case SP_ATTR_R:
1810             if (!rg->r.read(value)) {
1811                 rg->r.unset(SVGLength::PERCENT, 0.5, 0.5);
1812             }
1813             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
1814             break;
1815         case SP_ATTR_FX:
1816             if (!rg->fx.read(value)) {
1817                 rg->fx.unset(rg->cx.unit, rg->cx.value, rg->cx.computed);
1818             }
1819             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
1820             break;
1821         case SP_ATTR_FY:
1822             if (!rg->fy.read(value)) {
1823                 rg->fy.unset(rg->cy.unit, rg->cy.value, rg->cy.computed);
1824             }
1825             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
1826             break;
1827         default:
1828             if (((SPObjectClass *) rg_parent_class)->set)
1829                 ((SPObjectClass *) rg_parent_class)->set(object, key, value);
1830             break;
1831     }
1832 }
1833
1834 /**
1835  * Write radial gradient attributes to associated repr.
1836  */
1837 static Inkscape::XML::Node *
1838 sp_radialgradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
1839 {
1840     SPRadialGradient *rg = SP_RADIALGRADIENT(object);
1841
1842     if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
1843         repr = xml_doc->createElement("svg:radialGradient");
1844     }
1845
1846     if ((flags & SP_OBJECT_WRITE_ALL) || rg->cx._set) sp_repr_set_svg_double(repr, "cx", rg->cx.computed);
1847     if ((flags & SP_OBJECT_WRITE_ALL) || rg->cy._set) sp_repr_set_svg_double(repr, "cy", rg->cy.computed);
1848     if ((flags & SP_OBJECT_WRITE_ALL) || rg->r._set) sp_repr_set_svg_double(repr, "r", rg->r.computed);
1849     if ((flags & SP_OBJECT_WRITE_ALL) || rg->fx._set) sp_repr_set_svg_double(repr, "fx", rg->fx.computed);
1850     if ((flags & SP_OBJECT_WRITE_ALL) || rg->fy._set) sp_repr_set_svg_double(repr, "fy", rg->fy.computed);
1851
1852     if (((SPObjectClass *) rg_parent_class)->write)
1853         (* ((SPObjectClass *) rg_parent_class)->write)(object, xml_doc, repr, flags);
1854
1855     return repr;
1856 }
1857
1858 /**
1859  * Create radial gradient context.
1860  */
1861 static SPPainter *
1862 sp_radialgradient_painter_new(SPPaintServer *ps,
1863                               Geom::Matrix const &full_transform,
1864                               Geom::Matrix const &/*parent_transform*/,
1865                               NRRect const *bbox)
1866 {
1867     SPRadialGradient *rg = SP_RADIALGRADIENT(ps);
1868     SPGradient *gr = SP_GRADIENT(ps);
1869
1870     if (!gr->color) sp_gradient_ensure_colors(gr);
1871
1872     SPRGPainter *rgp = g_new(SPRGPainter, 1);
1873
1874     rgp->painter.type = SP_PAINTER_IND;
1875     rgp->painter.fill = sp_rg_fill;
1876
1877     rgp->rg = rg;
1878
1879     Geom::Matrix gs2px;
1880
1881     if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
1882         /** \todo
1883          * fixme: We may try to normalize here too, look at
1884          * linearGradient (Lauris)
1885          */
1886
1887         /* BBox to user coordinate system */
1888         Geom::Matrix bbox2user(bbox->x1 - bbox->x0, 0, 0, bbox->y1 - bbox->y0, bbox->x0, bbox->y0);
1889
1890         Geom::Matrix gs2user = gr->gradientTransform * bbox2user;
1891
1892         gs2px = gs2user * full_transform;
1893     } else {
1894         /** \todo
1895          * Problem: What to do, if we have mixed lengths and percentages?
1896          * Currently we do ignore percentages at all, but that is not
1897          * good (lauris)
1898          */
1899
1900         gs2px = gr->gradientTransform * full_transform;
1901     }
1902     // TODO: remove gs2px_nr after converting to 2geom
1903     NR::Matrix gs2px_nr = from_2geom(gs2px);
1904     nr_rgradient_renderer_setup(&rgp->rgr, gr->color, sp_gradient_get_spread(gr),
1905                                 &gs2px_nr,
1906                                 rg->cx.computed, rg->cy.computed,
1907                                 rg->fx.computed, rg->fy.computed,
1908                                 rg->r.computed);
1909
1910     return (SPPainter *) rgp;
1911 }
1912
1913 static void
1914 sp_radialgradient_painter_free(SPPaintServer */*ps*/, SPPainter *painter)
1915 {
1916     g_free(painter);
1917 }
1918
1919 /**
1920  * Directly set properties of radial gradient and request modified.
1921  */
1922 void
1923 sp_radialgradient_set_position(SPRadialGradient *rg,
1924                                gdouble cx, gdouble cy, gdouble fx, gdouble fy, gdouble r)
1925 {
1926     g_return_if_fail(rg != NULL);
1927     g_return_if_fail(SP_IS_RADIALGRADIENT(rg));
1928
1929     /* fixme: units? (Lauris)  */
1930     rg->cx.set(SVGLength::NONE, cx, cx);
1931     rg->cy.set(SVGLength::NONE, cy, cy);
1932     rg->fx.set(SVGLength::NONE, fx, fx);
1933     rg->fy.set(SVGLength::NONE, fy, fy);
1934     rg->r.set(SVGLength::NONE, r, r);
1935
1936     SP_OBJECT(rg)->requestModified(SP_OBJECT_MODIFIED_FLAG);
1937 }
1938
1939 /**
1940  * Callback when radial gradient object is rendered.
1941  */
1942 static void
1943 sp_rg_fill(SPPainter *painter, NRPixBlock *pb)
1944 {
1945     SPRGPainter *rgp = (SPRGPainter *) painter;
1946
1947     if (rgp->rg->color == NULL) {
1948         sp_gradient_ensure_colors (rgp->rg);
1949         rgp->rgr.vector = rgp->rg->color;
1950     }
1951
1952     nr_render((NRRenderer *) &rgp->rgr, pb, NULL);
1953 }
1954
1955 /*
1956   Local Variables:
1957   mode:c++
1958   c-file-style:"stroustrup"
1959   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1960   indent-tabs-mode:nil
1961   fill-column:99
1962   End:
1963 */
1964 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :