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