src/sp-gradient.cpp

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