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 SPStop* SPGradient::getFirstStop()
 642 {
 643     SPStop* first = 0;
 644     for (SPObject *ochild = sp_object_first_child(this); ochild && !first; ochild = SP_OBJECT_NEXT(ochild)) {
 645         if (SP_IS_STOP(ochild)) {
 646             first = SP_STOP(ochild);
 647         }
 648     }
 649     return first;
 650 }
 651
 652 int SPGradient::getStopCount() const
 653 {
 654     int count = 0;
 655
 656     for (SPStop *stop = const_cast<SPGradient*>(this)->getFirstStop(); stop && stop->getNextStop(); stop = stop->getNextStop()) {
 657         count++;
 658     }
 659
 660     return count;
 661 }
 662
 663 /**
 664  * Write gradient attributes to repr.
 665  */
 666 static Inkscape::XML::Node *
 667 sp_gradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
 668 {
 669     SPGradient *gr = SP_GRADIENT(object);
 670
 671     if (((SPObjectClass *) gradient_parent_class)->write)
 672         (* ((SPObjectClass *) gradient_parent_class)->write)(object, xml_doc, repr, flags);
 673
 674     if (flags & SP_OBJECT_WRITE_BUILD) {
 675         GSList *l = NULL;
 676         for (SPObject *child = sp_object_first_child(object); child; child = SP_OBJECT_NEXT(child)) {
 677             Inkscape::XML::Node *crepr;
 678             crepr = child->updateRepr(xml_doc, NULL, flags);
 679             if (crepr) l = g_slist_prepend(l, crepr);
 680         }
 681         while (l) {
 682             repr->addChild((Inkscape::XML::Node *) l->data, NULL);
 683             Inkscape::GC::release((Inkscape::XML::Node *) l->data);
 684             l = g_slist_remove(l, l->data);
 685         }
 686     }
 687
 688     if (gr->ref->getURI()) {
 689         gchar *uri_string = gr->ref->getURI()->toString();
 690         repr->setAttribute("xlink:href", uri_string);
 691         g_free(uri_string);
 692     }
 693
 694     if ((flags & SP_OBJECT_WRITE_ALL) || gr->units_set) {
 695         switch (gr->units) {
 696             case SP_GRADIENT_UNITS_USERSPACEONUSE:
 697                 repr->setAttribute("gradientUnits", "userSpaceOnUse");
 698                 break;
 699             default:
 700                 repr->setAttribute("gradientUnits", "objectBoundingBox");
 701                 break;
 702         }
 703     }
 704
 705     if ((flags & SP_OBJECT_WRITE_ALL) || gr->gradientTransform_set) {
 706         gchar *c=sp_svg_transform_write(gr->gradientTransform);
 707         repr->setAttribute("gradientTransform", c);
 708         g_free(c);
 709     }
 710
 711     if ((flags & SP_OBJECT_WRITE_ALL) || gr->spread_set) {
 712         /* FIXME: Ensure that gr->spread is the inherited value
 713          * if !gr->spread_set.  Not currently happening: see sp_gradient_modified.
 714          */
 715         switch (gr->spread) {
 716             case SP_GRADIENT_SPREAD_REFLECT:
 717                 repr->setAttribute("spreadMethod", "reflect");
 718                 break;
 719             case SP_GRADIENT_SPREAD_REPEAT:
 720                 repr->setAttribute("spreadMethod", "repeat");
 721                 break;
 722             default:
 723                 repr->setAttribute("spreadMethod", "pad");
 724                 break;
 725         }
 726     }
 727
 728     return repr;
 729 }
 730
 731 /**
 732  * Forces the vector to be built, if not present (i.e., changed).
 733  *
 734  * \pre SP_IS_GRADIENT(gradient).
 735  */
 736 void
 737 sp_gradient_ensure_vector(SPGradient *gradient)
 738 {
 739     g_return_if_fail(gradient != NULL);
 740     g_return_if_fail(SP_IS_GRADIENT(gradient));
 741
 742     if (!gradient->vector.built) {
 743         sp_gradient_rebuild_vector(gradient);
 744     }
 745 }
 746
 747 /**
 748  * Set units property of gradient and emit modified.
 749  */
 750 void
 751 sp_gradient_set_units(SPGradient *gr, SPGradientUnits units)
 752 {
 753     if (units != gr->units) {
 754         gr->units = units;
 755         gr->units_set = TRUE;
 756         SP_OBJECT(gr)->requestModified(SP_OBJECT_MODIFIED_FLAG);
 757     }
 758 }
 759
 760 /**
 761  * Set spread property of gradient and emit modified.
 762  */
 763 void
 764 sp_gradient_set_spread(SPGradient *gr, SPGradientSpread spread)
 765 {
 766     if (spread != gr->spread) {
 767         gr->spread = spread;
 768         gr->spread_set = TRUE;
 769         SP_OBJECT(gr)->requestModified(SP_OBJECT_MODIFIED_FLAG);
 770     }
 771 }
 772
 773 /**
 774  * Returns the first of {src, src-\>ref-\>getObject(),
 775  * src-\>ref-\>getObject()-\>ref-\>getObject(),...}
 776  * for which \a match is true, or NULL if none found.
 777  *
 778  * The raison d'être of this routine is that it correctly handles cycles in the href chain (e.g., if
 779  * a gradient gives itself as its href, or if each of two gradients gives the other as its href).
 780  *
 781  * \pre SP_IS_GRADIENT(src).
 782  */
 783 static SPGradient *
 784 chase_hrefs(SPGradient *const src, bool (*match)(SPGradient const *))
 785 {
 786     g_return_val_if_fail(SP_IS_GRADIENT(src), NULL);
 787
 788     /* Use a pair of pointers for detecting loops: p1 advances half as fast as p2.  If there is a
 789        loop, then once p1 has entered the loop, we'll detect it the next time the distance between
 790        p1 and p2 is a multiple of the loop size. */
 791     SPGradient *p1 = src, *p2 = src;
 792     bool do1 = false;
 793     for (;;) {
 794         if (match(p2)) {
 795             return p2;
 796         }
 797
 798         p2 = p2->ref->getObject();
 799         if (!p2) {
 800             return p2;
 801         }
 802         if (do1) {
 803             p1 = p1->ref->getObject();
 804         }
 805         do1 = !do1;
 806
 807         if ( p2 == p1 ) {
 808             /* We've been here before, so return NULL to indicate that no matching gradient found
 809              * in the chain. */
 810             return NULL;
 811         }
 812     }
 813 }
 814
 815 /**
 816  * True if gradient has stops.
 817  */
 818 static bool
 819 has_stops(SPGradient const *gr)
 820 {
 821     return SP_GRADIENT_HAS_STOPS(gr);
 822 }
 823
 824 /**
 825  * True if gradient has spread set.
 826  */
 827 static bool
 828 has_spread_set(SPGradient const *gr)
 829 {
 830     return gr->spread_set;
 831 }
 832
 833 /**
 834  * True if gradient has units set.
 835  */
 836 static bool
 837 has_units_set(SPGradient const *gr)
 838 {
 839     return gr->units_set;
 840 }
 841
 842
 843 /**
 844  * Returns private vector of given gradient (the gradient at the end of the href chain which has
 845  * stops), optionally normalizing it.
 846  *
 847  * \pre SP_IS_GRADIENT(gradient).
 848  * \pre There exists a gradient in the chain that has stops.
 849  */
 850 SPGradient *
 851 sp_gradient_get_vector(SPGradient *gradient, bool force_vector)
 852 {
 853     g_return_val_if_fail(gradient != NULL, NULL);
 854     g_return_val_if_fail(SP_IS_GRADIENT(gradient), NULL);
 855
 856     SPGradient *const src = chase_hrefs(gradient, has_stops);
 857     return ( force_vector
 858              ? sp_gradient_ensure_vector_normalized(src)
 859              : src );
 860 }
 861
 862 /**
 863  * Returns the effective spread of given gradient (climbing up the refs chain if needed).
 864  *
 865  * \pre SP_IS_GRADIENT(gradient).
 866  */
 867 SPGradientSpread
 868 sp_gradient_get_spread(SPGradient *gradient)
 869 {
 870     g_return_val_if_fail(SP_IS_GRADIENT(gradient), SP_GRADIENT_SPREAD_PAD);
 871
 872     SPGradient const *src = chase_hrefs(gradient, has_spread_set);
 873     return ( src
 874              ? src->spread
 875              : SP_GRADIENT_SPREAD_PAD ); // pad is the default
 876 }
 877
 878 /**
 879  * Returns the effective units of given gradient (climbing up the refs chain if needed).
 880  *
 881  * \pre SP_IS_GRADIENT(gradient).
 882  */
 883 SPGradientUnits
 884 sp_gradient_get_units(SPGradient *gradient)
 885 {
 886     g_return_val_if_fail(SP_IS_GRADIENT(gradient), SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX);
 887
 888     SPGradient const *src = chase_hrefs(gradient, has_units_set);
 889     return ( src
 890              ? src->units
 891              : SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX ); // bbox is the default
 892 }
 893
 894
 895 /**
 896  * Clears the gradient's svg:stop children from its repr.
 897  */
 898 void
 899 sp_gradient_repr_clear_vector(SPGradient *gr)
 900 {
 901     Inkscape::XML::Node *repr = SP_OBJECT_REPR(gr);
 902
 903     /* Collect stops from original repr */
 904     GSList *sl = NULL;
 905     for (Inkscape::XML::Node *child = repr->firstChild() ; child != NULL; child = child->next() ) {
 906         if (!strcmp(child->name(), "svg:stop")) {
 907             sl = g_slist_prepend(sl, child);
 908         }
 909     }
 910     /* Remove all stops */
 911     while (sl) {
 912         /** \todo
 913          * fixme: This should work, unless we make gradient
 914          * into generic group.
 915          */
 916         sp_repr_unparent((Inkscape::XML::Node *)sl->data);
 917         sl = g_slist_remove(sl, sl->data);
 918     }
 919 }
 920
 921 /**
 922  * Writes the gradient's internal vector (whether from its own stops, or
 923  * inherited from refs) into the gradient repr as svg:stop elements.
 924  */
 925 void
 926 sp_gradient_repr_write_vector(SPGradient *gr)
 927 {
 928     g_return_if_fail(gr != NULL);
 929     g_return_if_fail(SP_IS_GRADIENT(gr));
 930
 931     Inkscape::XML::Document *xml_doc = sp_document_repr_doc(SP_OBJECT_DOCUMENT(gr));
 932     Inkscape::XML::Node *repr = SP_OBJECT_REPR(gr);
 933
 934     /* We have to be careful, as vector may be our own, so construct repr list at first */
 935     GSList *cl = NULL;
 936
 937     for (guint i = 0; i < gr->vector.stops.size(); i++) {
 938         Inkscape::CSSOStringStream os;
 939         Inkscape::XML::Node *child = xml_doc->createElement("svg:stop");
 940         sp_repr_set_css_double(child, "offset", gr->vector.stops[i].offset);
 941         /* strictly speaking, offset an SVG <number> rather than a CSS one, but exponents make no
 942          * sense for offset proportions. */
 943         gchar c[64];
 944         sp_svg_write_color(c, sizeof(c), gr->vector.stops[i].color.toRGBA32( 0x00 ));
 945         os << "stop-color:" << c << ";stop-opacity:" << gr->vector.stops[i].opacity;
 946         child->setAttribute("style", os.str().c_str());
 947         /* Order will be reversed here */
 948         cl = g_slist_prepend(cl, child);
 949     }
 950
 951     sp_gradient_repr_clear_vector(gr);
 952
 953     /* And insert new children from list */
 954     while (cl) {
 955         Inkscape::XML::Node *child = static_cast<Inkscape::XML::Node *>(cl->data);
 956         repr->addChild(child, NULL);
 957         Inkscape::GC::release(child);
 958         cl = g_slist_remove(cl, child);
 959     }
 960 }
 961
 962
 963 static void
 964 gradient_ref_modified(SPObject */*href*/, guint /*flags*/, SPGradient *gradient)
 965 {
 966     if (sp_gradient_invalidate_vector(gradient)) {
 967         SP_OBJECT(gradient)->requestModified(SP_OBJECT_MODIFIED_FLAG);
 968         /* Conditional to avoid causing infinite loop if there's a cycle in the href chain. */
 969     }
 970 }
 971
 972 /** Return true iff change made. */
 973 static bool
 974 sp_gradient_invalidate_vector(SPGradient *gr)
 975 {
 976     bool ret = false;
 977
 978     if (gr->color != NULL) {
 979         g_free(gr->color);
 980         gr->color = NULL;
 981         ret = true;
 982     }
 983
 984     if (gr->vector.built) {
 985         gr->vector.built = false;
 986         gr->vector.stops.clear();
 987         ret = true;
 988     }
 989
 990     return ret;
 991 }
 992
 993 /** Creates normalized color vector */
 994 static void
 995 sp_gradient_rebuild_vector(SPGradient *gr)
 996 {
 997     gint len = 0;
 998     for ( SPObject *child = sp_object_first_child(SP_OBJECT(gr)) ;
 999           child != NULL ;
1000           child = SP_OBJECT_NEXT(child) ) {
1001         if (SP_IS_STOP(child)) {
1002             len ++;
1003         }
1004     }
1005
1006     gr->has_stops = (len != 0);
1007
1008     gr->vector.stops.clear();
1009
1010     SPGradient *ref = gr->ref->getObject();
1011     if ( !gr->has_stops && ref ) {
1012         /* Copy vector from referenced gradient */
1013         gr->vector.built = true;   // Prevent infinite recursion.
1014         sp_gradient_ensure_vector(ref);
1015         if (!ref->vector.stops.empty()) {
1016             gr->vector.built = ref->vector.built;
1017             gr->vector.stops.assign(ref->vector.stops.begin(), ref->vector.stops.end());
1018             return;
1019         }
1020     }
1021
1022     for (SPObject *child = sp_object_first_child(SP_OBJECT(gr)) ;
1023          child != NULL;
1024          child = SP_OBJECT_NEXT(child) ) {
1025         if (SP_IS_STOP(child)) {
1026             SPStop *stop = SP_STOP(child);
1027
1028             SPGradientStop gstop;
1029             if (gr->vector.stops.size() > 0) {
1030                 // "Each gradient offset value is required to be equal to or greater than the
1031                 // previous gradient stop's offset value. If a given gradient stop's offset
1032                 // value is not equal to or greater than all previous offset values, then the
1033                 // offset value is adjusted to be equal to the largest of all previous offset
1034                 // values."
1035                 gstop.offset = MAX(stop->offset, gr->vector.stops.back().offset);
1036             } else {
1037                 gstop.offset = stop->offset;
1038             }
1039
1040             // "Gradient offset values less than 0 (or less than 0%) are rounded up to
1041             // 0%. Gradient offset values greater than 1 (or greater than 100%) are rounded
1042             // down to 100%."
1043             gstop.offset = CLAMP(gstop.offset, 0, 1);
1044
1045             gstop.color = sp_stop_get_color(stop);
1046             gstop.opacity = stop->opacity;
1047
1048             gr->vector.stops.push_back(gstop);
1049         }
1050     }
1051
1052     // Normalize per section 13.2.4 of SVG 1.1.
1053     if (gr->vector.stops.size() == 0) {
1054         /* "If no stops are defined, then painting shall occur as if 'none' were specified as the
1055          * paint style."
1056          */
1057         {
1058             SPGradientStop gstop;
1059             gstop.offset = 0.0;
1060             gstop.color.set( 0x00000000 );
1061             gstop.opacity = 0.0;
1062             gr->vector.stops.push_back(gstop);
1063         }
1064         {
1065             SPGradientStop gstop;
1066             gstop.offset = 1.0;
1067             gstop.color.set( 0x00000000 );
1068             gstop.opacity = 0.0;
1069             gr->vector.stops.push_back(gstop);
1070         }
1071     } else {
1072         /* "If one stop is defined, then paint with the solid color fill using the color defined
1073          * for that gradient stop."
1074          */
1075         if (gr->vector.stops.front().offset > 0.0) {
1076             // If the first one is not at 0, then insert a copy of the first at 0.
1077             SPGradientStop gstop;
1078             gstop.offset = 0.0;
1079             gstop.color = gr->vector.stops.front().color;
1080             gstop.opacity = gr->vector.stops.front().opacity;
1081             gr->vector.stops.insert(gr->vector.stops.begin(), gstop);
1082         }
1083         if (gr->vector.stops.back().offset < 1.0) {
1084             // If the last one is not at 1, then insert a copy of the last at 1.
1085             SPGradientStop gstop;
1086             gstop.offset = 1.0;
1087             gstop.color = gr->vector.stops.back().color;
1088             gstop.opacity = gr->vector.stops.back().opacity;
1089             gr->vector.stops.push_back(gstop);
1090         }
1091     }
1092
1093     gr->vector.built = true;
1094 }
1095
1096 /**
1097  * The gradient's color array is newly created and set up from vector.
1098  */
1099 void
1100 sp_gradient_ensure_colors(SPGradient *gr)
1101 {
1102     if (!gr->vector.built) {
1103         sp_gradient_rebuild_vector(gr);
1104     }
1105     g_return_if_fail(!gr->vector.stops.empty());
1106
1107     /// \todo Where is the memory freed?
1108     if (!gr->color) {
1109         gr->color = g_new(guchar, 4 * NCOLORS);
1110     }
1111
1112     // This assumes that gr->vector is a zero-order B-spline (box function) approximation of the "true" gradient.
1113     // This means that the "true" gradient must be prefiltered using a zero order B-spline and then sampled.
1114     // Furthermore, the first element corresponds to offset="0" and the last element to offset="1".
1115
1116     double remainder[4] = {0,0,0,0};
1117     double remainder_for_end[4] = {0,0,0,0}; // Used at the end
1118     switch(gr->spread) {
1119     case SP_GRADIENT_SPREAD_PAD:
1120         remainder[0] = 0.5*gr->vector.stops[0].color.v.c[0]; // Half of the first cell uses the color of the first stop
1121         remainder[1] = 0.5*gr->vector.stops[0].color.v.c[1];
1122         remainder[2] = 0.5*gr->vector.stops[0].color.v.c[2];
1123         remainder[3] = 0.5*gr->vector.stops[0].opacity;
1124         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
1125         remainder_for_end[1] = 0.5*gr->vector.stops[gr->vector.stops.size() - 1].color.v.c[1];
1126         remainder_for_end[2] = 0.5*gr->vector.stops[gr->vector.stops.size() - 1].color.v.c[2];
1127         remainder_for_end[3] = 0.5*gr->vector.stops[gr->vector.stops.size() - 1].opacity;
1128         break;
1129     case SP_GRADIENT_SPREAD_REFLECT:
1130     case SP_GRADIENT_SPREAD_REPEAT:
1131         // These two are handled differently, see below.
1132         break;
1133     default:
1134         g_error("Spread type not supported!");
1135     };
1136     for (unsigned int i = 0; i < gr->vector.stops.size() - 1; i++) {
1137         double r0 = gr->vector.stops[i].color.v.c[0];
1138         double g0 = gr->vector.stops[i].color.v.c[1];
1139         double b0 = gr->vector.stops[i].color.v.c[2];
1140         double a0 = gr->vector.stops[i].opacity;
1141         double r1 = gr->vector.stops[i+1].color.v.c[0];
1142         double g1 = gr->vector.stops[i+1].color.v.c[1];
1143         double b1 = gr->vector.stops[i+1].color.v.c[2];
1144         double a1 = gr->vector.stops[i+1].opacity;
1145         double o0 = gr->vector.stops[i].offset * (NCOLORS-1);
1146         double o1 = gr->vector.stops[i + 1].offset * (NCOLORS-1);
1147         unsigned int ob = (unsigned int) floor(o0+.5); // These are the first and last element that might be affected by this interval.
1148         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
1149
1150         if (oe == ob) {
1151             // Simple case, this interval starts and stops within one cell
1152             // The contribution of this interval is:
1153             //    (o1-o0)*(c(o0)+c(o1))/2
1154             //  = (o1-o0)*(c0+c1)/2
1155             double dt = 0.5*(o1-o0);
1156             remainder[0] += dt*(r0 + r1);
1157             remainder[1] += dt*(g0 + g1);
1158             remainder[2] += dt*(b0 + b1);
1159             remainder[3] += dt*(a0 + a1);
1160         } else {
1161             // First compute colors for the cells which are fully covered by the current interval.
1162             // The prefiltered values are equal to the midpoint of each cell here.
1163             //  f = (j-o0)/(o1-o0)
1164             //    = j*(1/(o1-o0)) - o0/(o1-o0)
1165             double f = (ob-o0) / (o1-o0);
1166             double df = 1. / (o1-o0);
1167             for (unsigned int j = ob+1; j < oe; j++) {
1168                 f += df;
1169                 gr->color[4 * j + 0] = (unsigned char) floor(255*(r0 + f*(r1-r0)) + .5);
1170                 gr->color[4 * j + 1] = (unsigned char) floor(255*(g0 + f*(g1-g0)) + .5);
1171                 gr->color[4 * j + 2] = (unsigned char) floor(255*(b0 + f*(b1-b0)) + .5);
1172                 gr->color[4 * j + 3] = (unsigned char) floor(255*(a0 + f*(a1-a0)) + .5);
1173             }
1174
1175             // Now handle the beginning
1176             // The contribution of the last point is already in remainder.
1177             // The contribution of this point is:
1178             //    (ob+.5-o0)*(c(o0)+c(ob+.5))/2
1179             //  = (ob+.5-o0)*c((o0+ob+.5)/2)
1180             //  = (ob+.5-o0)*(c0+((o0+ob+.5)/2-o0)*df*(c1-c0))
1181             //  = (ob+.5-o0)*(c0+(ob+.5-o0)*df*(c1-c0)/2)
1182             double dt = ob+.5-o0;
1183             f = 0.5*dt*df;
1184             if (ob==0 && gr->spread==SP_GRADIENT_SPREAD_REFLECT) {
1185                 // The first half of the first cell is just a mirror image of the second half, so simply multiply it by 2.
1186                 gr->color[4 * ob + 0] = (unsigned char) floor(2*255*(remainder[0] + dt*(r0 + f*(r1-r0))) + .5);
1187                 gr->color[4 * ob + 1] = (unsigned char) floor(2*255*(remainder[1] + dt*(g0 + f*(g1-g0))) + .5);
1188                 gr->color[4 * ob + 2] = (unsigned char) floor(2*255*(remainder[2] + dt*(b0 + f*(b1-b0))) + .5);
1189                 gr->color[4 * ob + 3] = (unsigned char) floor(2*255*(remainder[3] + dt*(a0 + f*(a1-a0))) + .5);
1190             } else if (ob==0 && gr->spread==SP_GRADIENT_SPREAD_REPEAT) {
1191                 // 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.
1192                 remainder_for_end[0] = remainder[0] + dt*(r0 + f*(r1-r0));
1193                 remainder_for_end[1] = remainder[1] + dt*(g0 + f*(g1-g0));
1194                 remainder_for_end[2] = remainder[2] + dt*(b0 + f*(b1-b0));
1195                 remainder_for_end[3] = remainder[3] + dt*(a0 + f*(a1-a0));
1196             } else {
1197                 // The first half of the cell was already in remainder.
1198                 gr->color[4 * ob + 0] = (unsigned char) floor(255*(remainder[0] + dt*(r0 + f*(r1-r0))) + .5);
1199                 gr->color[4 * ob + 1] = (unsigned char) floor(255*(remainder[1] + dt*(g0 + f*(g1-g0))) + .5);
1200                 gr->color[4 * ob + 2] = (unsigned char) floor(255*(remainder[2] + dt*(b0 + f*(b1-b0))) + .5);
1201                 gr->color[4 * ob + 3] = (unsigned char) floor(255*(remainder[3] + dt*(a0 + f*(a1-a0))) + .5);
1202             }
1203
1204             // Now handle the end, which should end up in remainder
1205             // The contribution of this point is:
1206             //    (o1-oe+.5)*(c(o1)+c(oe-.5))/2
1207             //  = (o1-oe+.5)*c((o1+oe-.5)/2)
1208             //  = (o1-oe+.5)*(c0+((o1+oe-.5)/2-o0)*df*(c1-c0))
1209             dt = o1-oe+.5;
1210             f = (0.5*(o1+oe-.5)-o0)*df;
1211             remainder[0] = dt*(r0 + f*(r1-r0));
1212             remainder[1] = dt*(g0 + f*(g1-g0));
1213             remainder[2] = dt*(b0 + f*(b1-b0));
1214             remainder[3] = dt*(a0 + f*(a1-a0));
1215         }
1216     }
1217     switch(gr->spread) {
1218     case SP_GRADIENT_SPREAD_PAD:
1219         gr->color[4 * (NCOLORS-1) + 0] = (unsigned char) floor(255*(remainder[0]+remainder_for_end[0]) + .5);
1220         gr->color[4 * (NCOLORS-1) + 1] = (unsigned char) floor(255*(remainder[1]+remainder_for_end[1]) + .5);
1221         gr->color[4 * (NCOLORS-1) + 2] = (unsigned char) floor(255*(remainder[2]+remainder_for_end[2]) + .5);
1222         gr->color[4 * (NCOLORS-1) + 3] = (unsigned char) floor(255*(remainder[3]+remainder_for_end[3]) + .5);
1223         break;
1224     case SP_GRADIENT_SPREAD_REFLECT:
1225         // The second half is the same as the first half, so multiply by 2.
1226         gr->color[4 * (NCOLORS-1) + 0] = (unsigned char) floor(2*255*remainder[0] + .5);
1227         gr->color[4 * (NCOLORS-1) + 1] = (unsigned char) floor(2*255*remainder[1] + .5);
1228         gr->color[4 * (NCOLORS-1) + 2] = (unsigned char) floor(2*255*remainder[2] + .5);
1229         gr->color[4 * (NCOLORS-1) + 3] = (unsigned char) floor(2*255*remainder[3] + .5);
1230         break;
1231     case SP_GRADIENT_SPREAD_REPEAT:
1232         // The second half is the same as the second half of the first cell (which was saved in remainder_for_end).
1233         gr->color[0] = gr->color[4 * (NCOLORS-1) + 0] = (unsigned char) floor(255*(remainder[0]+remainder_for_end[0]) + .5);
1234         gr->color[1] = gr->color[4 * (NCOLORS-1) + 1] = (unsigned char) floor(255*(remainder[1]+remainder_for_end[1]) + .5);
1235         gr->color[2] = gr->color[4 * (NCOLORS-1) + 2] = (unsigned char) floor(255*(remainder[2]+remainder_for_end[2]) + .5);
1236         gr->color[3] = gr->color[4 * (NCOLORS-1) + 3] = (unsigned char) floor(255*(remainder[3]+remainder_for_end[3]) + .5);
1237         break;
1238     }
1239 }
1240
1241 /**
1242  * Renders gradient vector to buffer as line.
1243  *
1244  * RGB buffer background should be set up beforehand.
1245  *
1246  * @param len,width,height,rowstride Buffer parameters (1 or 2 dimensional).
1247  * @param span Full integer width of requested gradient.
1248  * @param pos Buffer starting position in span.
1249  */
1250 static void
1251 sp_gradient_render_vector_line_rgba(SPGradient *const gradient, guchar *buf,
1252                                     gint const len, gint const pos, gint const span)
1253 {
1254     g_return_if_fail(gradient != NULL);
1255     g_return_if_fail(SP_IS_GRADIENT(gradient));
1256     g_return_if_fail(buf != NULL);
1257     g_return_if_fail(len > 0);
1258     g_return_if_fail(pos >= 0);
1259     g_return_if_fail(pos + len <= span);
1260     g_return_if_fail(span > 0);
1261
1262     if (!gradient->color) {
1263         sp_gradient_ensure_colors(gradient);
1264     }
1265
1266     gint idx = (pos * 1024 << 8) / span;
1267     gint didx = (1024 << 8) / span;
1268
1269     for (gint x = 0; x < len; x++) {
1270         /// \todo Can this be done with 4 byte copies?
1271         *buf++ = gradient->color[4 * (idx >> 8)];
1272         *buf++ = gradient->color[4 * (idx >> 8) + 1];
1273         *buf++ = gradient->color[4 * (idx >> 8) + 2];
1274         *buf++ = gradient->color[4 * (idx >> 8) + 3];
1275         idx += didx;
1276     }
1277 }
1278
1279 /**
1280  * Render rectangular RGBA area from gradient vector.
1281  */
1282 void
1283 sp_gradient_render_vector_block_rgba(SPGradient *const gradient, guchar *buf,
1284                                      gint const width, gint const height, gint const rowstride,
1285                                      gint const pos, gint const span, bool const horizontal)
1286 {
1287     g_return_if_fail(gradient != NULL);
1288     g_return_if_fail(SP_IS_GRADIENT(gradient));
1289     g_return_if_fail(buf != NULL);
1290     g_return_if_fail(width > 0);
1291     g_return_if_fail(height > 0);
1292     g_return_if_fail(pos >= 0);
1293     g_return_if_fail((horizontal && (pos + width <= span)) || (!horizontal && (pos + height <= span)));
1294     g_return_if_fail(span > 0);
1295
1296     if (horizontal) {
1297         sp_gradient_render_vector_line_rgba(gradient, buf, width, pos, span);
1298         for (gint y = 1; y < height; y++) {
1299             memcpy(buf + y * rowstride, buf, 4 * width);
1300         }
1301     } else {
1302         guchar *tmp = (guchar *)alloca(4 * height);
1303         sp_gradient_render_vector_line_rgba(gradient, tmp, height, pos, span);
1304         for (gint y = 0; y < height; y++) {
1305             guchar *b = buf + y * rowstride;
1306             for (gint x = 0; x < width; x++) {
1307                 *b++ = tmp[0];
1308                 *b++ = tmp[1];
1309                 *b++ = tmp[2];
1310                 *b++ = tmp[3];
1311             }
1312             tmp += 4;
1313         }
1314     }
1315 }
1316
1317 /**
1318  * Render rectangular RGB area from gradient vector.
1319  */
1320 void
1321 sp_gradient_render_vector_block_rgb(SPGradient *gradient, guchar *buf,
1322                                     gint const width, gint const height, gint const /*rowstride*/,
1323                                     gint const pos, gint const span, bool const horizontal)
1324 {
1325     g_return_if_fail(gradient != NULL);
1326     g_return_if_fail(SP_IS_GRADIENT(gradient));
1327     g_return_if_fail(buf != NULL);
1328     g_return_if_fail(width > 0);
1329     g_return_if_fail(height > 0);
1330     g_return_if_fail(pos >= 0);
1331     g_return_if_fail((horizontal && (pos + width <= span)) || (!horizontal && (pos + height <= span)));
1332     g_return_if_fail(span > 0);
1333
1334     if (horizontal) {
1335         guchar *tmp = (guchar*)alloca(4 * width);
1336         sp_gradient_render_vector_line_rgba(gradient, tmp, width, pos, span);
1337         for (gint y = 0; y < height; y++) {
1338             guchar *t = tmp;
1339             for (gint x = 0; x < width; x++) {
1340                 gint a = t[3];
1341                 gint fc = (t[0] - buf[0]) * a;
1342                 buf[0] = buf[0] + ((fc + (fc >> 8) + 0x80) >> 8);
1343                 fc = (t[1] - buf[1]) * a;
1344                 buf[1] = buf[1] + ((fc + (fc >> 8) + 0x80) >> 8);
1345                 fc = (t[2] - buf[2]) * a;
1346                 buf[2] = buf[2] + ((fc + (fc >> 8) + 0x80) >> 8);
1347                 buf += 3;
1348                 t += 4;
1349             }
1350         }
1351     } else {
1352         guchar *tmp = (guchar*)alloca(4 * height);
1353         sp_gradient_render_vector_line_rgba(gradient, tmp, height, pos, span);
1354         for (gint y = 0; y < height; y++) {
1355             guchar *t = tmp + 4 * y;
1356             for (gint x = 0; x < width; x++) {
1357                 gint a = t[3];
1358                 gint fc = (t[0] - buf[0]) * a;
1359                 buf[0] = buf[0] + ((fc + (fc >> 8) + 0x80) >> 8);
1360                 fc = (t[1] - buf[1]) * a;
1361                 buf[1] = buf[1] + ((fc + (fc >> 8) + 0x80) >> 8);
1362                 fc = (t[2] - buf[2]) * a;
1363                 buf[2] = buf[2] + ((fc + (fc >> 8) + 0x80) >> 8);
1364             }
1365         }
1366     }
1367 }
1368
1369 Geom::Matrix
1370 sp_gradient_get_g2d_matrix(SPGradient const *gr, Geom::Matrix const &ctm, Geom::Rect const &bbox)
1371 {
1372     if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
1373         return ( Geom::Scale(bbox.dimensions())
1374                  * Geom::Translate(bbox.min())
1375                  * Geom::Matrix(ctm) );
1376     } else {
1377         return ctm;
1378     }
1379 }
1380
1381 Geom::Matrix
1382 sp_gradient_get_gs2d_matrix(SPGradient const *gr, Geom::Matrix const &ctm, Geom::Rect const &bbox)
1383 {
1384     if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
1385         return ( gr->gradientTransform
1386                  * Geom::Scale(bbox.dimensions())
1387                  * Geom::Translate(bbox.min())
1388                  * Geom::Matrix(ctm) );
1389     } else {
1390         return gr->gradientTransform * ctm;
1391     }
1392 }
1393
1394 void
1395 sp_gradient_set_gs2d_matrix(SPGradient *gr, Geom::Matrix const &ctm,
1396                             Geom::Rect const &bbox, Geom::Matrix const &gs2d)
1397 {
1398     gr->gradientTransform = gs2d * ctm.inverse();
1399     if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX ) {
1400         gr->gradientTransform = ( gr->gradientTransform
1401                                   * Geom::Translate(-bbox.min())
1402                                   * Geom::Scale(bbox.dimensions()).inverse() );
1403     }
1404     gr->gradientTransform_set = TRUE;
1405
1406     SP_OBJECT(gr)->requestModified(SP_OBJECT_MODIFIED_FLAG);
1407 }
1408
1409 /*
1410  * Linear Gradient
1411  */
1412
1413 class SPLGPainter;
1414
1415 /// A context with linear gradient, painter, and gradient renderer.
1416 struct SPLGPainter {
1417     SPPainter painter;
1418     SPLinearGradient *lg;
1419
1420     NRLGradientRenderer lgr;
1421 };
1422
1423 static void sp_lineargradient_class_init(SPLinearGradientClass *klass);
1424 static void sp_lineargradient_init(SPLinearGradient *lg);
1425
1426 static void sp_lineargradient_build(SPObject *object,
1427                                     SPDocument *document,
1428                                     Inkscape::XML::Node *repr);
1429 static void sp_lineargradient_set(SPObject *object, unsigned key, gchar const *value);
1430 static Inkscape::XML::Node *sp_lineargradient_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr,
1431                                                     guint flags);
1432
1433 static SPPainter *sp_lineargradient_painter_new(SPPaintServer *ps,
1434                                                 Geom::Matrix const &full_transform,
1435                                                 Geom::Matrix const &parent_transform,
1436                                                 NRRect const *bbox);
1437 static void sp_lineargradient_painter_free(SPPaintServer *ps, SPPainter *painter);
1438
1439 static void sp_lg_fill(SPPainter *painter, NRPixBlock *pb);
1440
1441 static SPGradientClass *lg_parent_class;
1442
1443 /**
1444  * Register SPLinearGradient class and return its type.
1445  */
1446 GType
1447 sp_lineargradient_get_type()
1448 {
1449     static GType type = 0;
1450     if (!type) {
1451         GTypeInfo info = {
1452             sizeof(SPLinearGradientClass),
1453             NULL, NULL,
1454             (GClassInitFunc) sp_lineargradient_class_init,
1455             NULL, NULL,
1456             sizeof(SPLinearGradient),
1457             16,
1458             (GInstanceInitFunc) sp_lineargradient_init,
1459             NULL,   /* value_table */
1460         };
1461         type = g_type_register_static(SP_TYPE_GRADIENT, "SPLinearGradient", &info, (GTypeFlags)0);
1462     }
1463     return type;
1464 }
1465
1466 /**
1467  * SPLinearGradient vtable initialization.
1468  */
1469 static void sp_lineargradient_class_init(SPLinearGradientClass *klass)
1470 {
1471     SPObjectClass *sp_object_class = (SPObjectClass *) klass;
1472     SPPaintServerClass *ps_class = (SPPaintServerClass *) klass;
1473
1474     lg_parent_class = (SPGradientClass*)g_type_class_ref(SP_TYPE_GRADIENT);
1475
1476     sp_object_class->build = sp_lineargradient_build;
1477     sp_object_class->set = sp_lineargradient_set;
1478     sp_object_class->write = sp_lineargradient_write;
1479
1480     ps_class->painter_new = sp_lineargradient_painter_new;
1481     ps_class->painter_free = sp_lineargradient_painter_free;
1482 }
1483
1484 /**
1485  * Callback for SPLinearGradient object initialization.
1486  */
1487 static void sp_lineargradient_init(SPLinearGradient *lg)
1488 {
1489     lg->x1.unset(SVGLength::PERCENT, 0.0, 0.0);
1490     lg->y1.unset(SVGLength::PERCENT, 0.0, 0.0);
1491     lg->x2.unset(SVGLength::PERCENT, 1.0, 1.0);
1492     lg->y2.unset(SVGLength::PERCENT, 0.0, 0.0);
1493 }
1494
1495 /**
1496  * Callback: set attributes from associated repr.
1497  */
1498 static void sp_lineargradient_build(SPObject *object,
1499                                     SPDocument *document,
1500                                     Inkscape::XML::Node *repr)
1501 {
1502     if (((SPObjectClass *) lg_parent_class)->build)
1503         (* ((SPObjectClass *) lg_parent_class)->build)(object, document, repr);
1504
1505     sp_object_read_attr(object, "x1");
1506     sp_object_read_attr(object, "y1");
1507     sp_object_read_attr(object, "x2");
1508     sp_object_read_attr(object, "y2");
1509 }
1510
1511 /**
1512  * Callback: set attribute.
1513  */
1514 static void
1515 sp_lineargradient_set(SPObject *object, unsigned key, gchar const *value)
1516 {
1517     SPLinearGradient *lg = SP_LINEARGRADIENT(object);
1518
1519     switch (key) {
1520         case SP_ATTR_X1:
1521             lg->x1.readOrUnset(value, SVGLength::PERCENT, 0.0, 0.0);
1522             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
1523             break;
1524         case SP_ATTR_Y1:
1525             lg->y1.readOrUnset(value, SVGLength::PERCENT, 0.0, 0.0);
1526             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
1527             break;
1528         case SP_ATTR_X2:
1529             lg->x2.readOrUnset(value, SVGLength::PERCENT, 1.0, 1.0);
1530             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
1531             break;
1532         case SP_ATTR_Y2:
1533             lg->y2.readOrUnset(value, SVGLength::PERCENT, 0.0, 0.0);
1534             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
1535             break;
1536         default:
1537             if (((SPObjectClass *) lg_parent_class)->set)
1538                 (* ((SPObjectClass *) lg_parent_class)->set)(object, key, value);
1539             break;
1540     }
1541 }
1542
1543 /**
1544  * Callback: write attributes to associated repr.
1545  */
1546 static Inkscape::XML::Node *
1547 sp_lineargradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
1548 {
1549     SPLinearGradient *lg = SP_LINEARGRADIENT(object);
1550
1551     if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
1552         repr = xml_doc->createElement("svg:linearGradient");
1553     }
1554
1555     if ((flags & SP_OBJECT_WRITE_ALL) || lg->x1._set)
1556         sp_repr_set_svg_double(repr, "x1", lg->x1.computed);
1557     if ((flags & SP_OBJECT_WRITE_ALL) || lg->y1._set)
1558         sp_repr_set_svg_double(repr, "y1", lg->y1.computed);
1559     if ((flags & SP_OBJECT_WRITE_ALL) || lg->x2._set)
1560         sp_repr_set_svg_double(repr, "x2", lg->x2.computed);
1561     if ((flags & SP_OBJECT_WRITE_ALL) || lg->y2._set)
1562         sp_repr_set_svg_double(repr, "y2", lg->y2.computed);
1563
1564     if (((SPObjectClass *) lg_parent_class)->write)
1565         (* ((SPObjectClass *) lg_parent_class)->write)(object, xml_doc, repr, flags);
1566
1567     return repr;
1568 }
1569
1570 /**
1571  * Create linear gradient context.
1572  *
1573  * Basically we have to deal with transformations
1574  *
1575  * 1) color2norm - maps point in (0,NCOLORS) vector to (0,1) vector
1576  * 2) norm2pos - maps (0,1) vector to x1,y1 - x2,y2
1577  * 2) gradientTransform
1578  * 3) bbox2user
1579  * 4) ctm == userspace to pixel grid
1580  *
1581  * See also (*) in sp-pattern about why we may need parent_transform.
1582  *
1583  * \todo (point 1 above) fixme: I do not know how to deal with start > 0
1584  * and end < 1.
1585  */
1586 static SPPainter *
1587 sp_lineargradient_painter_new(SPPaintServer *ps,
1588                               Geom::Matrix const &full_transform,
1589                               Geom::Matrix const &/*parent_transform*/,
1590                               NRRect const *bbox)
1591 {
1592     SPLinearGradient *lg = SP_LINEARGRADIENT(ps);
1593     SPGradient *gr = SP_GRADIENT(ps);
1594
1595     if (!gr->color) sp_gradient_ensure_colors(gr);
1596
1597     SPLGPainter *lgp = g_new(SPLGPainter, 1);
1598
1599     lgp->painter.type = SP_PAINTER_IND;
1600     lgp->painter.fill = sp_lg_fill;
1601
1602     lgp->lg = lg;
1603
1604     /** \todo
1605      * Technically speaking, we map NCOLORS on line [start,end] onto line
1606      * [0,1].  I almost think we should fill color array start and end in
1607      * that case. The alternative would be to leave these just empty garbage
1608      * or something similar. Originally I had 1023.9999 here - not sure
1609      * whether we have really to cut out ceil int (Lauris).
1610      */
1611     Geom::Matrix color2norm(Geom::identity());
1612     Geom::Matrix color2px;
1613     if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
1614         Geom::Matrix norm2pos(Geom::identity());
1615
1616         /* BBox to user coordinate system */
1617         Geom::Matrix bbox2user(bbox->x1 - bbox->x0, 0, 0, bbox->y1 - bbox->y0, bbox->x0, bbox->y0);
1618
1619         Geom::Matrix color2pos = color2norm * norm2pos;
1620         Geom::Matrix color2tpos = color2pos * gr->gradientTransform;
1621         Geom::Matrix color2user = color2tpos * bbox2user;
1622         color2px = color2user * full_transform;
1623
1624     } else {
1625         /* Problem: What to do, if we have mixed lengths and percentages? */
1626         /* Currently we do ignore percentages at all, but that is not good (lauris) */
1627
1628         Geom::Matrix norm2pos(Geom::identity());
1629         Geom::Matrix color2pos = color2norm * norm2pos;
1630         Geom::Matrix color2tpos = color2pos * gr->gradientTransform;
1631         color2px = color2tpos * full_transform;
1632
1633     }
1634     // TODO: remove color2px_nr after converting to 2geom
1635     NR::Matrix color2px_nr = from_2geom(color2px);
1636     nr_lgradient_renderer_setup(&lgp->lgr, gr->color, sp_gradient_get_spread(gr), &color2px_nr,
1637                                 lg->x1.computed, lg->y1.computed,
1638                                 lg->x2.computed, lg->y2.computed);
1639
1640     return (SPPainter *) lgp;
1641 }
1642
1643 static void
1644 sp_lineargradient_painter_free(SPPaintServer */*ps*/, SPPainter *painter)
1645 {
1646     g_free(painter);
1647 }
1648
1649 /**
1650  * Directly set properties of linear gradient and request modified.
1651  */
1652 void
1653 sp_lineargradient_set_position(SPLinearGradient *lg,
1654                                gdouble x1, gdouble y1,
1655                                gdouble x2, gdouble y2)
1656 {
1657     g_return_if_fail(lg != NULL);
1658     g_return_if_fail(SP_IS_LINEARGRADIENT(lg));
1659
1660     /* fixme: units? (Lauris)  */
1661     lg->x1.set(SVGLength::NONE, x1, x1);
1662     lg->y1.set(SVGLength::NONE, y1, y1);
1663     lg->x2.set(SVGLength::NONE, x2, x2);
1664     lg->y2.set(SVGLength::NONE, y2, y2);
1665
1666     SP_OBJECT(lg)->requestModified(SP_OBJECT_MODIFIED_FLAG);
1667 }
1668
1669 /**
1670  * Callback when linear gradient object is rendered.
1671  */
1672 static void
1673 sp_lg_fill(SPPainter *painter, NRPixBlock *pb)
1674 {
1675     SPLGPainter *lgp = (SPLGPainter *) painter;
1676
1677     if (lgp->lg->color == NULL) {
1678         sp_gradient_ensure_colors (lgp->lg);
1679         lgp->lgr.vector = lgp->lg->color;
1680     }
1681
1682     nr_render((NRRenderer *) &lgp->lgr, pb, NULL);
1683 }
1684
1685 /*
1686  * Radial Gradient
1687  */
1688
1689 class SPRGPainter;
1690
1691 /// A context with radial gradient, painter, and gradient renderer.
1692 struct SPRGPainter {
1693     SPPainter painter;
1694     SPRadialGradient *rg;
1695     NRRGradientRenderer rgr;
1696 };
1697
1698 static void sp_radialgradient_class_init(SPRadialGradientClass *klass);
1699 static void sp_radialgradient_init(SPRadialGradient *rg);
1700
1701 static void sp_radialgradient_build(SPObject *object,
1702                                     SPDocument *document,
1703                                     Inkscape::XML::Node *repr);
1704 static void sp_radialgradient_set(SPObject *object, unsigned key, gchar const *value);
1705 static Inkscape::XML::Node *sp_radialgradient_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr,
1706                                                     guint flags);
1707
1708 static SPPainter *sp_radialgradient_painter_new(SPPaintServer *ps,
1709                                                 Geom::Matrix const &full_transform,
1710                                                 Geom::Matrix const &parent_transform,
1711                                                 NRRect const *bbox);
1712 static void sp_radialgradient_painter_free(SPPaintServer *ps, SPPainter *painter);
1713
1714 static void sp_rg_fill(SPPainter *painter, NRPixBlock *pb);
1715
1716 static SPGradientClass *rg_parent_class;
1717
1718 /**
1719  * Register SPRadialGradient class and return its type.
1720  */
1721 GType
1722 sp_radialgradient_get_type()
1723 {
1724     static GType type = 0;
1725     if (!type) {
1726         GTypeInfo info = {
1727             sizeof(SPRadialGradientClass),
1728             NULL, NULL,
1729             (GClassInitFunc) sp_radialgradient_class_init,
1730             NULL, NULL,
1731             sizeof(SPRadialGradient),
1732             16,
1733             (GInstanceInitFunc) sp_radialgradient_init,
1734             NULL,   /* value_table */
1735         };
1736         type = g_type_register_static(SP_TYPE_GRADIENT, "SPRadialGradient", &info, (GTypeFlags)0);
1737     }
1738     return type;
1739 }
1740
1741 /**
1742  * SPRadialGradient vtable initialization.
1743  */
1744 static void sp_radialgradient_class_init(SPRadialGradientClass *klass)
1745 {
1746     SPObjectClass *sp_object_class = (SPObjectClass *) klass;
1747     SPPaintServerClass *ps_class = (SPPaintServerClass *) klass;
1748
1749     rg_parent_class = (SPGradientClass*)g_type_class_ref(SP_TYPE_GRADIENT);
1750
1751     sp_object_class->build = sp_radialgradient_build;
1752     sp_object_class->set = sp_radialgradient_set;
1753     sp_object_class->write = sp_radialgradient_write;
1754
1755     ps_class->painter_new = sp_radialgradient_painter_new;
1756     ps_class->painter_free = sp_radialgradient_painter_free;
1757 }
1758
1759 /**
1760  * Callback for SPRadialGradient object initialization.
1761  */
1762 static void
1763 sp_radialgradient_init(SPRadialGradient *rg)
1764 {
1765     rg->cx.unset(SVGLength::PERCENT, 0.5, 0.5);
1766     rg->cy.unset(SVGLength::PERCENT, 0.5, 0.5);
1767     rg->r.unset(SVGLength::PERCENT, 0.5, 0.5);
1768     rg->fx.unset(SVGLength::PERCENT, 0.5, 0.5);
1769     rg->fy.unset(SVGLength::PERCENT, 0.5, 0.5);
1770 }
1771
1772 /**
1773  * Set radial gradient attributes from associated repr.
1774  */
1775 static void
1776 sp_radialgradient_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
1777 {
1778     if (((SPObjectClass *) rg_parent_class)->build)
1779         (* ((SPObjectClass *) rg_parent_class)->build)(object, document, repr);
1780
1781     sp_object_read_attr(object, "cx");
1782     sp_object_read_attr(object, "cy");
1783     sp_object_read_attr(object, "r");
1784     sp_object_read_attr(object, "fx");
1785     sp_object_read_attr(object, "fy");
1786 }
1787
1788 /**
1789  * Set radial gradient attribute.
1790  */
1791 static void
1792 sp_radialgradient_set(SPObject *object, unsigned key, gchar const *value)
1793 {
1794     SPRadialGradient *rg = SP_RADIALGRADIENT(object);
1795
1796     switch (key) {
1797         case SP_ATTR_CX:
1798             if (!rg->cx.read(value)) {
1799                 rg->cx.unset(SVGLength::PERCENT, 0.5, 0.5);
1800             }
1801             if (!rg->fx._set) {
1802                 rg->fx.value = rg->cx.value;
1803                 rg->fx.computed = rg->cx.computed;
1804             }
1805             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
1806             break;
1807         case SP_ATTR_CY:
1808             if (!rg->cy.read(value)) {
1809                 rg->cy.unset(SVGLength::PERCENT, 0.5, 0.5);
1810             }
1811             if (!rg->fy._set) {
1812                 rg->fy.value = rg->cy.value;
1813                 rg->fy.computed = rg->cy.computed;
1814             }
1815             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
1816             break;
1817         case SP_ATTR_R:
1818             if (!rg->r.read(value)) {
1819                 rg->r.unset(SVGLength::PERCENT, 0.5, 0.5);
1820             }
1821             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
1822             break;
1823         case SP_ATTR_FX:
1824             if (!rg->fx.read(value)) {
1825                 rg->fx.unset(rg->cx.unit, rg->cx.value, rg->cx.computed);
1826             }
1827             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
1828             break;
1829         case SP_ATTR_FY:
1830             if (!rg->fy.read(value)) {
1831                 rg->fy.unset(rg->cy.unit, rg->cy.value, rg->cy.computed);
1832             }
1833             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
1834             break;
1835         default:
1836             if (((SPObjectClass *) rg_parent_class)->set)
1837                 ((SPObjectClass *) rg_parent_class)->set(object, key, value);
1838             break;
1839     }
1840 }
1841
1842 /**
1843  * Write radial gradient attributes to associated repr.
1844  */
1845 static Inkscape::XML::Node *
1846 sp_radialgradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
1847 {
1848     SPRadialGradient *rg = SP_RADIALGRADIENT(object);
1849
1850     if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
1851         repr = xml_doc->createElement("svg:radialGradient");
1852     }
1853
1854     if ((flags & SP_OBJECT_WRITE_ALL) || rg->cx._set) sp_repr_set_svg_double(repr, "cx", rg->cx.computed);
1855     if ((flags & SP_OBJECT_WRITE_ALL) || rg->cy._set) sp_repr_set_svg_double(repr, "cy", rg->cy.computed);
1856     if ((flags & SP_OBJECT_WRITE_ALL) || rg->r._set) sp_repr_set_svg_double(repr, "r", rg->r.computed);
1857     if ((flags & SP_OBJECT_WRITE_ALL) || rg->fx._set) sp_repr_set_svg_double(repr, "fx", rg->fx.computed);
1858     if ((flags & SP_OBJECT_WRITE_ALL) || rg->fy._set) sp_repr_set_svg_double(repr, "fy", rg->fy.computed);
1859
1860     if (((SPObjectClass *) rg_parent_class)->write)
1861         (* ((SPObjectClass *) rg_parent_class)->write)(object, xml_doc, repr, flags);
1862
1863     return repr;
1864 }
1865
1866 /**
1867  * Create radial gradient context.
1868  */
1869 static SPPainter *
1870 sp_radialgradient_painter_new(SPPaintServer *ps,
1871                               Geom::Matrix const &full_transform,
1872                               Geom::Matrix const &/*parent_transform*/,
1873                               NRRect const *bbox)
1874 {
1875     SPRadialGradient *rg = SP_RADIALGRADIENT(ps);
1876     SPGradient *gr = SP_GRADIENT(ps);
1877
1878     if (!gr->color) sp_gradient_ensure_colors(gr);
1879
1880     SPRGPainter *rgp = g_new(SPRGPainter, 1);
1881
1882     rgp->painter.type = SP_PAINTER_IND;
1883     rgp->painter.fill = sp_rg_fill;
1884
1885     rgp->rg = rg;
1886
1887     Geom::Matrix gs2px;
1888
1889     if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
1890         /** \todo
1891          * fixme: We may try to normalize here too, look at
1892          * linearGradient (Lauris)
1893          */
1894
1895         /* BBox to user coordinate system */
1896         Geom::Matrix bbox2user(bbox->x1 - bbox->x0, 0, 0, bbox->y1 - bbox->y0, bbox->x0, bbox->y0);
1897
1898         Geom::Matrix gs2user = gr->gradientTransform * bbox2user;
1899
1900         gs2px = gs2user * full_transform;
1901     } else {
1902         /** \todo
1903          * Problem: What to do, if we have mixed lengths and percentages?
1904          * Currently we do ignore percentages at all, but that is not
1905          * good (lauris)
1906          */
1907
1908         gs2px = gr->gradientTransform * full_transform;
1909     }
1910     // TODO: remove gs2px_nr after converting to 2geom
1911     NR::Matrix gs2px_nr = from_2geom(gs2px);
1912     nr_rgradient_renderer_setup(&rgp->rgr, gr->color, sp_gradient_get_spread(gr),
1913                                 &gs2px_nr,
1914                                 rg->cx.computed, rg->cy.computed,
1915                                 rg->fx.computed, rg->fy.computed,
1916                                 rg->r.computed);
1917
1918     return (SPPainter *) rgp;
1919 }
1920
1921 static void
1922 sp_radialgradient_painter_free(SPPaintServer */*ps*/, SPPainter *painter)
1923 {
1924     g_free(painter);
1925 }
1926
1927 /**
1928  * Directly set properties of radial gradient and request modified.
1929  */
1930 void
1931 sp_radialgradient_set_position(SPRadialGradient *rg,
1932                                gdouble cx, gdouble cy, gdouble fx, gdouble fy, gdouble r)
1933 {
1934     g_return_if_fail(rg != NULL);
1935     g_return_if_fail(SP_IS_RADIALGRADIENT(rg));
1936
1937     /* fixme: units? (Lauris)  */
1938     rg->cx.set(SVGLength::NONE, cx, cx);
1939     rg->cy.set(SVGLength::NONE, cy, cy);
1940     rg->fx.set(SVGLength::NONE, fx, fx);
1941     rg->fy.set(SVGLength::NONE, fy, fy);
1942     rg->r.set(SVGLength::NONE, r, r);
1943
1944     SP_OBJECT(rg)->requestModified(SP_OBJECT_MODIFIED_FLAG);
1945 }
1946
1947 /**
1948  * Callback when radial gradient object is rendered.
1949  */
1950 static void
1951 sp_rg_fill(SPPainter *painter, NRPixBlock *pb)
1952 {
1953     SPRGPainter *rgp = (SPRGPainter *) painter;
1954
1955     if (rgp->rg->color == NULL) {
1956         sp_gradient_ensure_colors (rgp->rg);
1957         rgp->rgr.vector = rgp->rg->color;
1958     }
1959
1960     nr_render((NRRenderer *) &rgp->rgr, pb, NULL);
1961 }
1962
1963 /*
1964   Local Variables:
1965   mode:c++
1966   c-file-style:"stroustrup"
1967   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1968   indent-tabs-mode:nil
1969   fill-column:99
1970   End:
1971 */
1972 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :