src/gradient-chemistry.cpp

   1 #define __SP_GRADIENT_CHEMISTRY_C__
   2
   3 /*
   4  * Various utility methods for gradients
   5  *
   6  * Authors:
   7  *   Lauris Kaplinski <lauris@kaplinski.com>
   8  *   bulia byak
   9  *   Johan Engelen <j.b.c.engelen@ewi.utwente.nl>
  10  *
  11  * Copyright (C) 2007 Johan Engelen
  12  * Copyright (C) 2001-2005 authors
  13  * Copyright (C) 2001 Ximian, Inc.
  14  *
  15  * Released under GNU GPL, read the file 'COPYING' for more information
  16  */
  17
  18
  19 #include "style.h"
  20 #include "document-private.h"
  21 #include "desktop-style.h"
  22
  23 #include "sp-gradient-reference.h"
  24 #include "sp-gradient-vector.h"
  25 #include "sp-linear-gradient.h"
  26 #include "sp-radial-gradient.h"
  27 #include "sp-stop.h"
  28 #include "widgets/gradient-vector.h"
  29
  30 #include "sp-text.h"
  31 #include "sp-tspan.h"
  32 #include <libnr/nr-matrix-fns.h>
  33 #include <libnr/nr-point-fns.h>
  34 #include "xml/repr.h"
  35 #include "svg/svg.h"
  36 #include "svg/svg-color.h"
  37 #include "svg/css-ostringstream.h"
  38 #include "prefs-utils.h"
  39
  40
  41 // Terminology:
  42 //
  43 // "vector" is a gradient that has stops but not position coords. It can be referenced by one or
  44 // more privates. Objects should not refer to it directly. It has no radial/linear distinction.
  45 //
  46 // "private" is a gradient that has no stops but has position coords (e.g. center, radius etc for a
  47 // radial). It references a vector for the actual colors. Each private is only used by one
  48 // object. It is either linear or radial.
  49
  50 static void sp_gradient_repr_set_link(Inkscape::XML::Node *repr, SPGradient *gr);
  51
  52 SPGradient *
  53 sp_gradient_ensure_vector_normalized(SPGradient *gr)
  54 {
  55     g_return_val_if_fail(gr != NULL, NULL);
  56     g_return_val_if_fail(SP_IS_GRADIENT(gr), NULL);
  57
  58     /* If we are already normalized vector, just return */
  59     if (gr->state == SP_GRADIENT_STATE_VECTOR) return gr;
  60     /* Fail, if we have wrong state set */
  61     if (gr->state != SP_GRADIENT_STATE_UNKNOWN) {
  62         g_warning("file %s: line %d: Cannot normalize private gradient to vector (%s)", __FILE__, __LINE__, SP_OBJECT_ID(gr));
  63         return NULL;
  64     }
  65
  66     /* First make sure we have vector directly defined (i.e. gr has its own stops) */
  67     if (!gr->has_stops) {
  68         /* We do not have stops ourselves, so flatten stops as well */
  69         sp_gradient_ensure_vector(gr);
  70         g_assert(gr->vector.built);
  71         // this adds stops from gr->vector as children to gr
  72         sp_gradient_repr_write_vector (gr);
  73     }
  74
  75     /* If gr hrefs some other gradient, remove the href */
  76     if (gr->ref->getObject()) {
  77         /* We are hrefing someone, so require flattening */
  78         SP_OBJECT(gr)->updateRepr(((SPObject *) gr)->repr, SP_OBJECT_WRITE_EXT | SP_OBJECT_WRITE_ALL);
  79         sp_gradient_repr_set_link(SP_OBJECT_REPR(gr), NULL);
  80     }
  81
  82     /* Everything is OK, set state flag */
  83     gr->state = SP_GRADIENT_STATE_VECTOR;
  84     return gr;
  85 }
  86
  87 /**
  88  * Creates new private gradient for the given vector
  89  */
  90
  91 static SPGradient *
  92 sp_gradient_get_private_normalized(SPDocument *document, SPGradient *vector, SPGradientType type)
  93 {
  94     g_return_val_if_fail(document != NULL, NULL);
  95     g_return_val_if_fail(vector != NULL, NULL);
  96     g_return_val_if_fail(SP_IS_GRADIENT(vector), NULL);
  97     g_return_val_if_fail(SP_GRADIENT_HAS_STOPS(vector), NULL);
  98
  99     SPDefs *defs = (SPDefs *) SP_DOCUMENT_DEFS(document);
 100
 101     Inkscape::XML::Document *xml_doc = sp_document_repr_doc(document);
 102     // create a new private gradient of the requested type
 103     Inkscape::XML::Node *repr;
 104     if (type == SP_GRADIENT_TYPE_LINEAR) {
 105         repr = xml_doc->createElement("svg:linearGradient");
 106     } else {
 107         repr = xml_doc->createElement("svg:radialGradient");
 108     }
 109
 110     // privates are garbage-collectable
 111     repr->setAttribute("inkscape:collect", "always");
 112
 113     // link to vector
 114     sp_gradient_repr_set_link(repr, vector);
 115
 116     /* Append the new private gradient to defs */
 117     SP_OBJECT_REPR(defs)->appendChild(repr);
 118     Inkscape::GC::release(repr);
 119
 120     // get corresponding object
 121     SPGradient *gr = (SPGradient *) document->getObjectByRepr(repr);
 122     g_assert(gr != NULL);
 123     g_assert(SP_IS_GRADIENT(gr));
 124
 125     return gr;
 126 }
 127
 128 /**
 129 Count how many times gr is used by the styles of o and its descendants
 130 */
 131 guint
 132 count_gradient_hrefs(SPObject *o, SPGradient *gr)
 133 {
 134     if (!o)
 135         return 1;
 136
 137     guint i = 0;
 138
 139     SPStyle *style = SP_OBJECT_STYLE(o);
 140     if (style
 141         && style->fill.isPaintserver()
 142         && SP_IS_GRADIENT(SP_STYLE_FILL_SERVER(style))
 143         && SP_GRADIENT(SP_STYLE_FILL_SERVER(style)) == gr)
 144     {
 145         i ++;
 146     }
 147     if (style
 148         && style->stroke.isPaintserver()
 149         && SP_IS_GRADIENT(SP_STYLE_STROKE_SERVER(style))
 150         && SP_GRADIENT(SP_STYLE_STROKE_SERVER(style)) == gr)
 151     {
 152         i ++;
 153     }
 154
 155     for (SPObject *child = sp_object_first_child(o);
 156          child != NULL; child = SP_OBJECT_NEXT(child)) {
 157         i += count_gradient_hrefs(child, gr);
 158     }
 159
 160     return i;
 161 }
 162
 163
 164 /**
 165  * If gr has other users, create a new private; also check if gr links to vector, relink if not
 166  */
 167 SPGradient *
 168 sp_gradient_fork_private_if_necessary(SPGradient *gr, SPGradient *vector,
 169                                       SPGradientType type, SPObject *o)
 170 {
 171     g_return_val_if_fail(gr != NULL, NULL);
 172     g_return_val_if_fail(SP_IS_GRADIENT(gr), NULL);
 173
 174     // Orphaned gradient, no vector with stops at the end of the line; this used to be an assert
 175     // but i think we should not abort on this - maybe just write a validity warning into some sort
 176     // of log
 177     if (!vector || !SP_GRADIENT_HAS_STOPS(vector))
 178         return (gr);
 179
 180     // user is the object that uses this gradient; normally it's item but for tspans, we
 181     // check its ancestor text so that tspans don't get different gradients from their
 182     // texts.
 183     SPObject *user = o;
 184     while (SP_IS_TSPAN(user)) {
 185         user = SP_OBJECT_PARENT(user);
 186     }
 187
 188     // Check the number of uses of the gradient within this object;
 189     // if we are private and there are no other users,
 190     if (SP_OBJECT_HREFCOUNT(gr) <= count_gradient_hrefs(user, gr)) {
 191         // check vector
 192         if ( gr != vector && gr->ref->getObject() != vector ) {
 193             /* our href is not the vector, and vector is different from gr; relink */
 194             sp_gradient_repr_set_link(SP_OBJECT_REPR(gr), vector);
 195         }
 196         return gr;
 197     }
 198
 199     SPDocument *doc = SP_OBJECT_DOCUMENT(gr);
 200     SPObject *defs = SP_DOCUMENT_DEFS(doc);
 201
 202     if ((gr->has_stops) ||
 203         (gr->state != SP_GRADIENT_STATE_UNKNOWN) ||
 204         (SP_OBJECT_PARENT(gr) != SP_OBJECT(defs)) ||
 205         (SP_OBJECT_HREFCOUNT(gr) > 1)) {
 206         // we have to clone a fresh new private gradient for the given vector
 207
 208         // create an empty one
 209         SPGradient *gr_new = sp_gradient_get_private_normalized(doc, vector, type);
 210
 211         // copy all the attributes to it
 212         Inkscape::XML::Node *repr_new = SP_OBJECT_REPR(gr_new);
 213         Inkscape::XML::Node *repr = SP_OBJECT_REPR(gr);
 214         repr_new->setAttribute("gradientUnits", repr->attribute("gradientUnits"));
 215         repr_new->setAttribute("gradientTransform", repr->attribute("gradientTransform"));
 216         repr_new->setAttribute("spreadMethod", repr->attribute("spreadMethod"));
 217         if (SP_IS_RADIALGRADIENT(gr)) {
 218             repr_new->setAttribute("cx", repr->attribute("cx"));
 219             repr_new->setAttribute("cy", repr->attribute("cy"));
 220             repr_new->setAttribute("fx", repr->attribute("fx"));
 221             repr_new->setAttribute("fy", repr->attribute("fy"));
 222             repr_new->setAttribute("r", repr->attribute("r"));
 223         } else {
 224             repr_new->setAttribute("x1", repr->attribute("x1"));
 225             repr_new->setAttribute("y1", repr->attribute("y1"));
 226             repr_new->setAttribute("x2", repr->attribute("x2"));
 227             repr_new->setAttribute("y2", repr->attribute("y2"));
 228         }
 229
 230         return gr_new;
 231     } else {
 232         return gr;
 233     }
 234 }
 235
 236 SPGradient *
 237 sp_gradient_fork_vector_if_necessary (SPGradient *gr)
 238 {
 239     // Some people actually prefer their gradient vectors to be shared...
 240     if (prefs_get_int_attribute("options.forkgradientvectors", "value", 1) == 0)
 241         return gr;
 242
 243     if (SP_OBJECT_HREFCOUNT(gr) > 1) {
 244         SPDocument *doc = SP_OBJECT_DOCUMENT(gr);
 245         Inkscape::XML::Document *xml_doc = sp_document_repr_doc(doc);
 246
 247         Inkscape::XML::Node *repr = SP_OBJECT_REPR (gr)->duplicate(xml_doc);
 248         SP_OBJECT_REPR (SP_DOCUMENT_DEFS (doc))->addChild(repr, NULL);
 249         SPGradient *gr_new = (SPGradient *) doc->getObjectByRepr(repr);
 250         gr_new = sp_gradient_ensure_vector_normalized (gr_new);
 251         Inkscape::GC::release(repr);
 252         return gr_new;
 253     }
 254     return gr;
 255 }
 256
 257 /**
 258  *  Obtain the vector from the gradient. A forked vector will be created and linked to this gradient if another gradient uses it.
 259  */
 260 SPGradient *
 261 sp_gradient_get_forked_vector_if_necessary(SPGradient *gradient, bool force_vector)
 262 {
 263     SPGradient *vector = sp_gradient_get_vector (gradient, force_vector);
 264     vector = sp_gradient_fork_vector_if_necessary (vector);
 265     if ( gradient != vector && gradient->ref->getObject() != vector ) {
 266         sp_gradient_repr_set_link(SP_OBJECT_REPR(gradient), vector);
 267     }
 268     return vector;
 269 }
 270
 271
 272 /**
 273  * Convert an item's gradient to userspace _without_ preserving coords, setting them to defaults
 274  * instead. No forking or reapplying is done because this is only called for newly created privates.
 275  * @return The new gradient.
 276  */
 277 SPGradient *
 278 sp_gradient_reset_to_userspace (SPGradient *gr, SPItem *item)
 279 {
 280     Inkscape::XML::Node *repr = SP_OBJECT_REPR(gr);
 281
 282     // calculate the bbox of the item
 283     sp_document_ensure_up_to_date(SP_OBJECT_DOCUMENT(item));
 284     NR::Maybe<NR::Rect> bbox = item->getBounds(NR::identity()); // we need "true" bbox without item_i2d_affine
 285
 286     if ( !bbox || bbox->isEmpty() )
 287         return gr;
 288
 289     NR::Coord const width = bbox->dimensions()[NR::X];
 290     NR::Coord const height = bbox->dimensions()[NR::Y];
 291
 292     NR::Point const center = bbox->midpoint();
 293
 294     if (SP_IS_RADIALGRADIENT(gr)) {
 295         sp_repr_set_svg_double(repr, "cx", center[NR::X]);
 296         sp_repr_set_svg_double(repr, "cy", center[NR::Y]);
 297         sp_repr_set_svg_double(repr, "fx", center[NR::X]);
 298         sp_repr_set_svg_double(repr, "fy", center[NR::Y]);
 299         sp_repr_set_svg_double(repr, "r", width/2);
 300
 301         // we want it to be elliptic, not circular
 302         NR::Matrix squeeze = NR::Matrix (NR::translate (-center)) *
 303             NR::Matrix (NR::scale(1, height/width)) *
 304             NR::Matrix (NR::translate (center));
 305
 306         gr->gradientTransform = squeeze;
 307         {
 308             gchar *c=sp_svg_transform_write(gr->gradientTransform);
 309             SP_OBJECT_REPR(gr)->setAttribute("gradientTransform", c);
 310             g_free(c);
 311         }
 312     } else {
 313         sp_repr_set_svg_double(repr, "x1", (center - NR::Point(width/2, 0))[NR::X]);
 314         sp_repr_set_svg_double(repr, "y1", (center - NR::Point(width/2, 0))[NR::Y]);
 315         sp_repr_set_svg_double(repr, "x2", (center + NR::Point(width/2, 0))[NR::X]);
 316         sp_repr_set_svg_double(repr, "y2", (center + NR::Point(width/2, 0))[NR::Y]);
 317     }
 318
 319     // set the gradientUnits
 320     repr->setAttribute("gradientUnits", "userSpaceOnUse");
 321
 322     return gr;
 323 }
 324
 325 /**
 326  * Convert an item's gradient to userspace if necessary, also fork it if necessary.
 327  * @return The new gradient.
 328  */
 329 SPGradient *
 330 sp_gradient_convert_to_userspace(SPGradient *gr, SPItem *item, gchar const *property)
 331 {
 332     g_return_val_if_fail(SP_IS_GRADIENT(gr), NULL);
 333
 334     // First, fork it if it is shared
 335     gr = sp_gradient_fork_private_if_necessary(gr, sp_gradient_get_vector(gr, FALSE),
 336                                                SP_IS_RADIALGRADIENT(gr) ? SP_GRADIENT_TYPE_RADIAL : SP_GRADIENT_TYPE_LINEAR, SP_OBJECT(item));
 337
 338     if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
 339
 340         Inkscape::XML::Node *repr = SP_OBJECT_REPR(gr);
 341
 342         // calculate the bbox of the item
 343         sp_document_ensure_up_to_date(SP_OBJECT_DOCUMENT(item));
 344         NR::Matrix bbox2user;
 345         NR::Maybe<NR::Rect> bbox = item->getBounds(NR::identity()); // we need "true" bbox without item_i2d_affine
 346         if ( bbox && !bbox->isEmpty() ) {
 347             bbox2user = NR::Matrix(bbox->dimensions()[NR::X], 0,
 348                                    0, bbox->dimensions()[NR::Y],
 349                                    bbox->min()[NR::X], bbox->min()[NR::Y]);
 350         } else {
 351             // would be degenerate otherwise
 352             bbox2user = NR::identity();
 353         }
 354
 355         /* skew is the additional transform, defined by the proportions of the item, that we need
 356          * to apply to the gradient in order to work around this weird bit from SVG 1.1
 357          * (http://www.w3.org/TR/SVG11/pservers.html#LinearGradients):
 358          *
 359          *   When gradientUnits="objectBoundingBox" and gradientTransform is the identity
 360          *   matrix, the stripes of the linear gradient are perpendicular to the gradient
 361          *   vector in object bounding box space (i.e., the abstract coordinate system where
 362          *   (0,0) is at the top/left of the object bounding box and (1,1) is at the
 363          *   bottom/right of the object bounding box). When the object's bounding box is not
 364          *   square, the stripes that are conceptually perpendicular to the gradient vector
 365          *   within object bounding box space will render non-perpendicular relative to the
 366          *   gradient vector in user space due to application of the non-uniform scaling
 367          *   transformation from bounding box space to user space.
 368          */
 369         NR::Matrix skew = bbox2user;
 370         double exp = NR::expansion(skew);
 371         skew[0] /= exp;
 372         skew[1] /= exp;
 373         skew[2] /= exp;
 374         skew[3] /= exp;
 375         skew[4] = 0;
 376         skew[5] = 0;
 377
 378         // apply skew to the gradient
 379         gr->gradientTransform = skew;
 380         {
 381             gchar *c=sp_svg_transform_write(gr->gradientTransform);
 382             SP_OBJECT_REPR(gr)->setAttribute("gradientTransform", c);
 383             g_free(c);
 384         }
 385
 386         // Matrix to convert points to userspace coords; postmultiply by inverse of skew so
 387         // as to cancel it out when it's applied to the gradient during rendering
 388         NR::Matrix point_convert = bbox2user * skew.inverse();
 389
 390         if (SP_IS_RADIALGRADIENT(gr)) {
 391             SPRadialGradient *rg = SP_RADIALGRADIENT(gr);
 392
 393             // original points in the bbox coords
 394             NR::Point c_b = NR::Point(rg->cx.computed, rg->cy.computed);
 395             NR::Point f_b = NR::Point(rg->fx.computed, rg->fy.computed);
 396             double r_b = rg->r.computed;
 397
 398             // converted points in userspace coords
 399             NR::Point c_u = c_b * point_convert;
 400             NR::Point f_u = f_b * point_convert;
 401             double r_u = r_b * NR::expansion(point_convert);
 402
 403             sp_repr_set_svg_double(repr, "cx", c_u[NR::X]);
 404             sp_repr_set_svg_double(repr, "cy", c_u[NR::Y]);
 405             sp_repr_set_svg_double(repr, "fx", f_u[NR::X]);
 406             sp_repr_set_svg_double(repr, "fy", f_u[NR::Y]);
 407             sp_repr_set_svg_double(repr, "r", r_u);
 408
 409         } else {
 410             SPLinearGradient *lg = SP_LINEARGRADIENT(gr);
 411
 412             NR::Point p1_b = NR::Point(lg->x1.computed, lg->y1.computed);
 413             NR::Point p2_b = NR::Point(lg->x2.computed, lg->y2.computed);
 414
 415             NR::Point p1_u = p1_b * point_convert;
 416             NR::Point p2_u = p2_b * point_convert;
 417
 418             sp_repr_set_svg_double(repr, "x1", p1_u[NR::X]);
 419             sp_repr_set_svg_double(repr, "y1", p1_u[NR::Y]);
 420             sp_repr_set_svg_double(repr, "x2", p2_u[NR::X]);
 421             sp_repr_set_svg_double(repr, "y2", p2_u[NR::Y]);
 422         }
 423
 424         // set the gradientUnits
 425         repr->setAttribute("gradientUnits", "userSpaceOnUse");
 426     }
 427
 428     // apply the gradient to the item (may be necessary if we forked it); not recursive
 429     // generally because grouped items will be taken care of later (we're being called
 430     // from sp_item_adjust_paint_recursive); however text and all its children should all
 431     // refer to one gradient, hence the recursive call for text (because we can't/don't
 432     // want to access tspans and set gradients on them separately)
 433     if (SP_IS_TEXT(item))
 434         sp_style_set_property_url(SP_OBJECT(item), property, SP_OBJECT(gr), true);
 435     else
 436         sp_style_set_property_url(SP_OBJECT(item), property, SP_OBJECT(gr), false);
 437
 438     return gr;
 439 }
 440
 441 void
 442 sp_gradient_transform_multiply(SPGradient *gradient, NR::Matrix postmul, bool set)
 443 {
 444     if (set) {
 445         gradient->gradientTransform = postmul;
 446     } else {
 447         gradient->gradientTransform *= postmul; // fixme: get gradient transform by climbing to hrefs?
 448     }
 449     gradient->gradientTransform_set = TRUE;
 450
 451     gchar *c=sp_svg_transform_write(gradient->gradientTransform);
 452     SP_OBJECT_REPR(gradient)->setAttribute("gradientTransform", c);
 453     g_free(c);
 454 }
 455
 456 SPGradient *
 457 sp_item_gradient (SPItem *item, bool fill_or_stroke)
 458 {
 459     SPStyle *style = SP_OBJECT_STYLE (item);
 460     SPGradient *gradient = NULL;
 461
 462     if (fill_or_stroke) {
 463         if (style && (style->fill.isPaintserver())) {
 464             SPObject *server = SP_OBJECT_STYLE_FILL_SERVER(item);
 465             if (SP_IS_GRADIENT (server)) {
 466                 gradient = SP_GRADIENT (server);
 467             }
 468         }
 469     } else {
 470         if (style && (style->stroke.isPaintserver())) {
 471             SPObject *server = SP_OBJECT_STYLE_STROKE_SERVER(item);
 472             if (SP_IS_GRADIENT (server)) {
 473                 gradient = SP_GRADIENT (server);
 474             }
 475         }
 476     }
 477
 478    return gradient;
 479 }
 480
 481
 482 SPStop*
 483 sp_first_stop(SPGradient *gradient)
 484 {
 485   for (SPObject *ochild = sp_object_first_child(gradient); ochild != NULL; ochild = SP_OBJECT_NEXT(ochild)) {
 486         if (SP_IS_STOP (ochild))
 487                 return SP_STOP(ochild);
 488   }
 489   return NULL;
 490 }
 491
 492 SPStop*
 493 sp_prev_stop(SPStop *stop, SPGradient *gradient)
 494 {
 495         if (sp_object_first_child(SP_OBJECT(gradient)) == SP_OBJECT(stop))
 496                 return NULL;
 497         SPObject *found = NULL;
 498         for ( SPObject *ochild = sp_object_first_child(SP_OBJECT(gradient)) ; ochild != NULL ; ochild = SP_OBJECT_NEXT(ochild) ) {
 499                 if (SP_IS_STOP (ochild)) {
 500                         found = ochild;
 501                 }
 502                 if (SP_OBJECT_NEXT(ochild) == SP_OBJECT(stop) || SP_OBJECT(ochild) == SP_OBJECT(stop)) {
 503                         break;
 504                 }
 505         }
 506         return SP_STOP(found);
 507 }
 508
 509 SPStop*
 510 sp_next_stop(SPStop *stop)
 511 {
 512     for (SPObject *ochild = SP_OBJECT_NEXT(stop); ochild != NULL; ochild = SP_OBJECT_NEXT(ochild)) {
 513         if (SP_IS_STOP (ochild))
 514             return SP_STOP(ochild);
 515     }
 516     return NULL;
 517 }
 518
 519 SPStop*
 520 sp_last_stop(SPGradient *gradient)
 521 {
 522     for (SPStop *stop = sp_first_stop (gradient); stop != NULL; stop = sp_next_stop (stop)) {
 523         if (sp_next_stop (stop) == NULL)
 524             return stop;
 525     }
 526     return NULL;
 527 }
 528
 529 guint
 530 sp_number_of_stops(SPGradient *gradient)
 531 {
 532     guint n = 0;
 533     for (SPStop *stop = sp_first_stop (gradient); stop != NULL; stop = sp_next_stop (stop)) {
 534         if (sp_next_stop (stop) == NULL)
 535             return n;
 536         n ++;
 537     }
 538     return n;
 539 }
 540
 541 guint
 542 sp_number_of_stops_before_stop(SPGradient *gradient, SPStop *target)
 543 {
 544     guint n = 0;
 545     for (SPStop *stop = sp_first_stop (gradient); stop != NULL; stop = sp_next_stop (stop)) {
 546         if (stop == target)
 547             return n;
 548         n ++;
 549     }
 550     return n;
 551 }
 552
 553
 554 SPStop*
 555 sp_get_stop_i(SPGradient *gradient, guint stop_i)
 556 {
 557     SPStop *stop = sp_first_stop (gradient);
 558
 559     for (guint i=0; i < stop_i; i++) {
 560         if (!stop) return NULL;
 561         stop = sp_next_stop (stop);
 562     }
 563
 564     return stop;
 565 }
 566
 567 guint32
 568 average_color (guint32 c1, guint32 c2, gdouble p)
 569 {
 570         guint32 r = (guint32) (SP_RGBA32_R_U (c1) * (1 - p) + SP_RGBA32_R_U (c2) * p);
 571         guint32 g = (guint32) (SP_RGBA32_G_U (c1) * (1 - p) + SP_RGBA32_G_U (c2) * p);
 572         guint32 b = (guint32) (SP_RGBA32_B_U (c1) * (1 - p) + SP_RGBA32_B_U (c2) * p);
 573         guint32 a = (guint32) (SP_RGBA32_A_U (c1) * (1 - p) + SP_RGBA32_A_U (c2) * p);
 574
 575         return SP_RGBA32_U_COMPOSE (r, g, b, a);
 576 }
 577
 578 SPStop *
 579 sp_vector_add_stop (SPGradient *vector, SPStop* prev_stop, SPStop* next_stop, gfloat offset)
 580 {
 581     Inkscape::XML::Node *new_stop_repr = NULL;
 582     new_stop_repr = SP_OBJECT_REPR(prev_stop)->duplicate(SP_OBJECT_REPR(vector)->document());
 583     SP_OBJECT_REPR(vector)->addChild(new_stop_repr, SP_OBJECT_REPR(prev_stop));
 584
 585     SPStop *newstop = (SPStop *) SP_OBJECT_DOCUMENT(vector)->getObjectByRepr(new_stop_repr);
 586     newstop->offset = offset;
 587     sp_repr_set_css_double( SP_OBJECT_REPR(newstop), "offset", (double)offset);
 588     guint32 const c1 = sp_stop_get_rgba32(prev_stop);
 589     guint32 const c2 = sp_stop_get_rgba32(next_stop);
 590     guint32 cnew = average_color (c1, c2, (offset - prev_stop->offset) / (next_stop->offset - prev_stop->offset));
 591     Inkscape::CSSOStringStream os;
 592     gchar c[64];
 593     sp_svg_write_color (c, sizeof(c), cnew);
 594     gdouble opacity = (gdouble) SP_RGBA32_A_F (cnew);
 595     os << "stop-color:" << c << ";stop-opacity:" << opacity <<";";
 596     SP_OBJECT_REPR (newstop)->setAttribute("style", os.str().c_str());
 597     Inkscape::GC::release(new_stop_repr);
 598
 599     return newstop;
 600 }
 601
 602 void
 603 sp_item_gradient_edit_stop (SPItem *item, guint point_type, guint point_i, bool fill_or_stroke)
 604 {
 605     SPGradient *gradient = sp_item_gradient (item, fill_or_stroke);
 606
 607     if (!gradient || !SP_IS_GRADIENT(gradient))
 608         return;
 609
 610     SPGradient *vector = sp_gradient_get_vector (gradient, false);
 611     switch (point_type) {
 612         case POINT_LG_BEGIN:
 613         case POINT_RG_CENTER:
 614         case POINT_RG_FOCUS:
 615         {
 616             GtkWidget *dialog = sp_gradient_vector_editor_new (vector, sp_first_stop (vector));
 617             gtk_widget_show (dialog);
 618         }
 619         break;
 620
 621         case POINT_LG_END:
 622         case POINT_RG_R1:
 623         case POINT_RG_R2:
 624         {
 625             GtkWidget *dialog = sp_gradient_vector_editor_new (vector, sp_last_stop (vector));
 626             gtk_widget_show (dialog);
 627         }
 628         break;
 629
 630         case POINT_LG_MID:
 631         case POINT_RG_MID1:
 632         case POINT_RG_MID2:
 633         {
 634             GtkWidget *dialog = sp_gradient_vector_editor_new (vector, sp_get_stop_i (vector, point_i));
 635             gtk_widget_show (dialog);
 636         }
 637         break;
 638         default:
 639             break;
 640     }
 641 }
 642
 643 guint32
 644 sp_item_gradient_stop_query_style (SPItem *item, guint point_type, guint point_i, bool fill_or_stroke)
 645 {
 646     SPGradient *gradient = sp_item_gradient (item, fill_or_stroke);
 647
 648     if (!gradient || !SP_IS_GRADIENT(gradient))
 649         return 0;
 650
 651     SPGradient *vector = sp_gradient_get_vector (gradient, false);
 652
 653     if (!vector) // orphan!
 654         return 0; // what else to do?
 655
 656     switch (point_type) {
 657         case POINT_LG_BEGIN:
 658         case POINT_RG_CENTER:
 659         case POINT_RG_FOCUS:
 660         {
 661             SPStop *first = sp_first_stop (vector);
 662             if (first) {
 663                 return sp_stop_get_rgba32(first);
 664             }
 665         }
 666         break;
 667
 668         case POINT_LG_END:
 669         case POINT_RG_R1:
 670         case POINT_RG_R2:
 671         {
 672             SPStop *last = sp_last_stop (vector);
 673             if (last) {
 674                 return sp_stop_get_rgba32(last);
 675             }
 676         }
 677         break;
 678
 679         case POINT_LG_MID:
 680         case POINT_RG_MID1:
 681         case POINT_RG_MID2:
 682         {
 683             SPStop *stopi = sp_get_stop_i (vector, point_i);
 684             if (stopi) {
 685                 return sp_stop_get_rgba32(stopi);
 686             }
 687         }
 688         break;
 689
 690         default:
 691             break;
 692     }
 693     return 0;
 694 }
 695
 696 void
 697 sp_item_gradient_stop_set_style (SPItem *item, guint point_type, guint point_i, bool fill_or_stroke, SPCSSAttr *stop)
 698 {
 699     SPGradient *gradient = sp_item_gradient (item, fill_or_stroke);
 700
 701     if (!gradient || !SP_IS_GRADIENT(gradient))
 702         return;
 703
 704     SPGradient *vector = sp_gradient_get_vector (gradient, false);
 705
 706     if (!vector) // orphan!
 707         return;
 708
 709     vector = sp_gradient_fork_vector_if_necessary (vector);
 710     if ( gradient != vector && gradient->ref->getObject() != vector ) {
 711         sp_gradient_repr_set_link(SP_OBJECT_REPR(gradient), vector);
 712     }
 713
 714     switch (point_type) {
 715         case POINT_LG_BEGIN:
 716         case POINT_RG_CENTER:
 717         case POINT_RG_FOCUS:
 718         {
 719             SPStop *first = sp_first_stop (vector);
 720             if (first) {
 721                 sp_repr_css_change (SP_OBJECT_REPR (first), stop, "style");
 722             }
 723         }
 724         break;
 725
 726         case POINT_LG_END:
 727         case POINT_RG_R1:
 728         case POINT_RG_R2:
 729         {
 730             SPStop *last = sp_last_stop (vector);
 731             if (last) {
 732                 sp_repr_css_change (SP_OBJECT_REPR (last), stop, "style");
 733             }
 734         }
 735         break;
 736
 737         case POINT_LG_MID:
 738         case POINT_RG_MID1:
 739         case POINT_RG_MID2:
 740         {
 741             SPStop *stopi = sp_get_stop_i (vector, point_i);
 742             if (stopi) {
 743                 sp_repr_css_change (SP_OBJECT_REPR (stopi), stop, "style");
 744             }
 745         }
 746         break;
 747
 748         default:
 749             break;
 750     }
 751 }
 752
 753 void
 754 sp_item_gradient_reverse_vector (SPItem *item, bool fill_or_stroke)
 755 {
 756     SPGradient *gradient = sp_item_gradient (item, fill_or_stroke);
 757     if (!gradient || !SP_IS_GRADIENT(gradient))
 758         return;
 759
 760     SPGradient *vector = sp_gradient_get_vector (gradient, false);
 761     if (!vector) // orphan!
 762         return;
 763
 764     vector = sp_gradient_fork_vector_if_necessary (vector);
 765     if ( gradient != vector && gradient->ref->getObject() != vector ) {
 766         sp_gradient_repr_set_link(SP_OBJECT_REPR(gradient), vector);
 767     }
 768
 769     GSList *child_reprs = NULL;
 770     GSList *child_objects = NULL;
 771     std::vector<double> offsets;
 772     for (SPObject *child = sp_object_first_child(vector);
 773          child != NULL; child = SP_OBJECT_NEXT(child)) {
 774         child_reprs = g_slist_prepend (child_reprs, SP_OBJECT_REPR(child));
 775         child_objects = g_slist_prepend (child_objects, child);
 776         offsets.push_back(sp_repr_get_double_attribute(SP_OBJECT_REPR(child), "offset", 0));
 777     }
 778
 779     GSList *child_copies = NULL;
 780     for (GSList *i = child_reprs; i != NULL; i = i->next) {
 781         Inkscape::XML::Node *repr = (Inkscape::XML::Node *) i->data;
 782         Inkscape::XML::Document *xml_doc = SP_OBJECT_REPR(vector)->document();
 783         child_copies = g_slist_append (child_copies, repr->duplicate(xml_doc));
 784     }
 785
 786
 787     for (GSList *i = child_objects; i != NULL; i = i->next) {
 788         SPObject *child = SP_OBJECT (i->data);
 789         child->deleteObject();
 790     }
 791
 792     std::vector<double>::iterator iter = offsets.end() - 1;
 793     for (GSList *i = child_copies; i != NULL; i = i->next) {
 794         Inkscape::XML::Node *copy = (Inkscape::XML::Node *) i->data;
 795         vector->appendChildRepr(copy);
 796         sp_repr_set_svg_double (copy, "offset", 1 - *iter);
 797         iter --;
 798         Inkscape::GC::release(copy);
 799     }
 800
 801     g_slist_free (child_reprs);
 802     g_slist_free (child_copies);
 803     g_slist_free (child_objects);
 804 }
 805
 806
 807 /**
 808 Set the position of point point_type of the gradient applied to item (either fill_or_stroke) to
 809 p_w (in desktop coordinates). Write_repr if you want the change to become permanent.
 810 */
 811 void
 812 sp_item_gradient_set_coords (SPItem *item, guint point_type, guint point_i, NR::Point p_w, bool fill_or_stroke, bool write_repr, bool scale)
 813 {
 814     SPGradient *gradient = sp_item_gradient (item, fill_or_stroke);
 815
 816     if (!gradient || !SP_IS_GRADIENT(gradient))
 817         return;
 818
 819     gradient = sp_gradient_convert_to_userspace (gradient, item, fill_or_stroke? "fill" : "stroke");
 820
 821     NR::Matrix i2d = sp_item_i2d_affine (item);
 822     NR::Point p = p_w * i2d.inverse();
 823     p *= (gradient->gradientTransform).inverse();
 824     // now p is in gradient's original coordinates
 825
 826     Inkscape::XML::Node *repr = SP_OBJECT_REPR(gradient);
 827
 828     if (SP_IS_LINEARGRADIENT(gradient)) {
 829         SPLinearGradient *lg = SP_LINEARGRADIENT(gradient);
 830         switch (point_type) {
 831             case POINT_LG_BEGIN:
 832                 if (scale) {
 833                     lg->x2.computed += (lg->x1.computed - p[NR::X]);
 834                     lg->y2.computed += (lg->y1.computed - p[NR::Y]);
 835                 }
 836                 lg->x1.computed = p[NR::X];
 837                 lg->y1.computed = p[NR::Y];
 838                 if (write_repr) {
 839                     if (scale) {
 840                         sp_repr_set_svg_double(repr, "x2", lg->x2.computed);
 841                         sp_repr_set_svg_double(repr, "y2", lg->y2.computed);
 842                     }
 843                     sp_repr_set_svg_double(repr, "x1", lg->x1.computed);
 844                     sp_repr_set_svg_double(repr, "y1", lg->y1.computed);
 845                 } else {
 846                     SP_OBJECT (gradient)->requestModified(SP_OBJECT_MODIFIED_FLAG);
 847                 }
 848                 break;
 849             case POINT_LG_END:
 850                 if (scale) {
 851                     lg->x1.computed += (lg->x2.computed - p[NR::X]);
 852                     lg->y1.computed += (lg->y2.computed - p[NR::Y]);
 853                 }
 854                 lg->x2.computed = p[NR::X];
 855                 lg->y2.computed = p[NR::Y];
 856                 if (write_repr) {
 857                     if (scale) {
 858                         sp_repr_set_svg_double(repr, "x1", lg->x1.computed);
 859                         sp_repr_set_svg_double(repr, "y1", lg->y1.computed);
 860                     }
 861                     sp_repr_set_svg_double(repr, "x2", lg->x2.computed);
 862                     sp_repr_set_svg_double(repr, "y2", lg->y2.computed);
 863                 } else {
 864                     SP_OBJECT (gradient)->requestModified(SP_OBJECT_MODIFIED_FLAG);
 865                 }
 866                         break;
 867             case POINT_LG_MID:
 868             {
 869                 // using X-coordinates only to determine the offset, assuming p has been snapped to the vector from begin to end.
 870                 double offset = get_offset_between_points (p, NR::Point(lg->x1.computed, lg->y1.computed), NR::Point(lg->x2.computed, lg->y2.computed));
 871                 SPGradient *vector = sp_gradient_get_forked_vector_if_necessary (lg, false);
 872                 sp_gradient_ensure_vector(lg);
 873                 lg->vector.stops.at(point_i).offset = offset;
 874                 SPStop* stopi = sp_get_stop_i(vector, point_i);
 875                 stopi->offset = offset;
 876                 if (write_repr) {
 877                     sp_repr_set_css_double(SP_OBJECT_REPR(stopi), "offset", stopi->offset);
 878                 } else {
 879                     SP_OBJECT (stopi)->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
 880                 }
 881             }
 882             break;
 883                 default:
 884                         break;
 885                 }
 886         } else if (SP_IS_RADIALGRADIENT(gradient)) {
 887         SPRadialGradient *rg = SP_RADIALGRADIENT(gradient);
 888         NR::Point c (rg->cx.computed, rg->cy.computed);
 889         NR::Point c_w = c * gradient->gradientTransform * i2d; // now in desktop coords
 890         if ((point_type == POINT_RG_R1 || point_type == POINT_RG_R2) && NR::L2 (p_w - c_w) < 1e-3) {
 891             // prevent setting a radius too close to the center
 892             return;
 893         }
 894         NR::Matrix new_transform;
 895         bool transform_set = false;
 896
 897                 switch (point_type) {
 898                 case POINT_RG_CENTER:
 899                         rg->fx.computed = p[NR::X] + (rg->fx.computed - rg->cx.computed);
 900                         rg->fy.computed = p[NR::Y] + (rg->fy.computed - rg->cy.computed);
 901                         rg->cx.computed = p[NR::X];
 902                         rg->cy.computed = p[NR::Y];
 903                         if (write_repr) {
 904                                 sp_repr_set_svg_double(repr, "fx", rg->fx.computed);
 905                                 sp_repr_set_svg_double(repr, "fy", rg->fy.computed);
 906                                 sp_repr_set_svg_double(repr, "cx", rg->cx.computed);
 907                                 sp_repr_set_svg_double(repr, "cy", rg->cy.computed);
 908                         } else {
 909                                 SP_OBJECT (gradient)->requestModified(SP_OBJECT_MODIFIED_FLAG);
 910                         }
 911                         break;
 912                 case POINT_RG_FOCUS:
 913                         rg->fx.computed = p[NR::X];
 914                         rg->fy.computed = p[NR::Y];
 915                         if (write_repr) {
 916                                 sp_repr_set_svg_double(repr, "fx", rg->fx.computed);
 917                                 sp_repr_set_svg_double(repr, "fy", rg->fy.computed);
 918                         } else {
 919                                 SP_OBJECT (gradient)->requestModified(SP_OBJECT_MODIFIED_FLAG);
 920                         }
 921                         break;
 922                 case POINT_RG_R1:
 923                         {
 924                 NR::Point r1_w = (c + NR::Point(rg->r.computed, 0)) * gradient->gradientTransform * i2d;
 925                                 double r1_angle = NR::atan2(r1_w - c_w);
 926                                 double move_angle = NR::atan2(p_w - c_w) - r1_angle;
 927                                 double move_stretch = NR::L2(p_w - c_w) / NR::L2(r1_w - c_w);
 928
 929                                 NR::Matrix move = NR::Matrix (NR::translate (-c_w)) *
 930                                                                                                  NR::Matrix (NR::rotate(-r1_angle)) *
 931                                                                                                  NR::Matrix (NR::scale(move_stretch, scale? move_stretch : 1)) *
 932                                                                                                  NR::Matrix (NR::rotate(r1_angle)) *
 933                                                                                                  NR::Matrix (NR::rotate(move_angle)) *
 934                                                                                                  NR::Matrix (NR::translate (c_w));
 935
 936                                 new_transform = gradient->gradientTransform * i2d * move * i2d.inverse();
 937                                 transform_set = true;
 938
 939                                 break;
 940                         }
 941                 case POINT_RG_R2:
 942                         {
 943                                 NR::Point r2_w = (c + NR::Point(0, -rg->r.computed)) * gradient->gradientTransform * i2d;
 944                                 double r2_angle = NR::atan2(r2_w - c_w);
 945                                 double move_angle = NR::atan2(p_w - c_w) - r2_angle;
 946                                 double move_stretch = NR::L2(p_w - c_w) / NR::L2(r2_w - c_w);
 947
 948                                 NR::Matrix move = NR::Matrix (NR::translate (-c_w)) *
 949                                                                                                  NR::Matrix (NR::rotate(-r2_angle)) *
 950                                                                                                  NR::Matrix (NR::scale(move_stretch, scale? move_stretch : 1)) *
 951                                                                                                  NR::Matrix (NR::rotate(r2_angle)) *
 952                                                                                                  NR::Matrix (NR::rotate(move_angle)) *
 953                                                                                                  NR::Matrix (NR::translate (c_w));
 954
 955                                 new_transform = gradient->gradientTransform * i2d * move * i2d.inverse();
 956                                 transform_set = true;
 957
 958                 break;
 959             }
 960         case POINT_RG_MID1:
 961             {
 962                 NR::Point start = NR::Point (rg->cx.computed, rg->cy.computed);
 963                  NR::Point end   = NR::Point (rg->cx.computed + rg->r.computed, rg->cy.computed);
 964                 double offset = get_offset_between_points (p, start, end);
 965                 SPGradient *vector = sp_gradient_get_forked_vector_if_necessary (rg, false);
 966                 sp_gradient_ensure_vector(rg);
 967                 rg->vector.stops.at(point_i).offset = offset;
 968                 SPStop* stopi = sp_get_stop_i(vector, point_i);
 969                 stopi->offset = offset;
 970                 if (write_repr) {
 971                     sp_repr_set_css_double(SP_OBJECT_REPR(stopi), "offset", stopi->offset);
 972                 } else {
 973                     SP_OBJECT (stopi)->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
 974                 }
 975                 break;
 976             }
 977         case POINT_RG_MID2:
 978                 NR::Point start = NR::Point (rg->cx.computed, rg->cy.computed);
 979                 NR::Point end   = NR::Point (rg->cx.computed, rg->cy.computed - rg->r.computed);
 980                 double offset = get_offset_between_points (p, start, end);
 981                 SPGradient *vector = sp_gradient_get_forked_vector_if_necessary(rg, false);
 982                 sp_gradient_ensure_vector(rg);
 983                 rg->vector.stops.at(point_i).offset = offset;
 984                 SPStop* stopi = sp_get_stop_i(vector, point_i);
 985                 stopi->offset = offset;
 986                 if (write_repr) {
 987                     sp_repr_set_css_double(SP_OBJECT_REPR(stopi), "offset", stopi->offset);
 988                 } else {
 989                     SP_OBJECT (stopi)->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
 990                 }
 991                 break;
 992             }
 993                 if (transform_set) {
 994                                 gradient->gradientTransform = new_transform;
 995                                 gradient->gradientTransform_set = TRUE;
 996                                 if (write_repr) {
 997                                         gchar *s=sp_svg_transform_write(gradient->gradientTransform);
 998                                         SP_OBJECT_REPR(gradient)->setAttribute("gradientTransform", s);
 999                                         g_free(s);
1000                                 } else {
1001                                         SP_OBJECT (gradient)->requestModified(SP_OBJECT_MODIFIED_FLAG);
1002                                 }
1003                 }
1004         }
1005 }
1006
1007 SPGradient *
1008 sp_item_gradient_get_vector (SPItem *item, bool fill_or_stroke)
1009 {
1010     SPGradient *gradient = sp_item_gradient (item, fill_or_stroke);
1011
1012     if (gradient)
1013         return sp_gradient_get_vector (gradient, false);
1014     return NULL;
1015 }
1016
1017 SPGradientSpread
1018 sp_item_gradient_get_spread (SPItem *item, bool fill_or_stroke)
1019 {
1020     SPGradient *gradient = sp_item_gradient (item, fill_or_stroke);
1021
1022     if (gradient)
1023         return sp_gradient_get_spread (gradient);
1024     return SP_GRADIENT_SPREAD_PAD;
1025 }
1026
1027
1028 /**
1029 Returns the position of point point_type of the gradient applied to item (either fill_or_stroke),
1030 in desktop coordinates.
1031 */
1032
1033 NR::Point
1034 sp_item_gradient_get_coords (SPItem *item, guint point_type, guint point_i, bool fill_or_stroke)
1035 {
1036     SPGradient *gradient = sp_item_gradient (item, fill_or_stroke);
1037
1038     NR::Point p (0, 0);
1039
1040     if (!gradient)
1041         return p;
1042
1043     if (SP_IS_LINEARGRADIENT(gradient)) {
1044         SPLinearGradient *lg = SP_LINEARGRADIENT(gradient);
1045         switch (point_type) {
1046             case POINT_LG_BEGIN:
1047                 p = NR::Point (lg->x1.computed, lg->y1.computed);
1048                 break;
1049             case POINT_LG_END:
1050                 p = NR::Point (lg->x2.computed, lg->y2.computed);
1051                 break;
1052             case POINT_LG_MID:
1053                 {
1054                     gdouble offset = lg->vector.stops.at(point_i).offset;
1055                     p = (1-offset) * NR::Point(lg->x1.computed, lg->y1.computed) + offset * NR::Point(lg->x2.computed, lg->y2.computed);
1056                 }
1057                 break;
1058         }
1059     } else     if (SP_IS_RADIALGRADIENT(gradient)) {
1060         SPRadialGradient *rg = SP_RADIALGRADIENT(gradient);
1061         switch (point_type) {
1062             case POINT_RG_CENTER:
1063                 p = NR::Point (rg->cx.computed, rg->cy.computed);
1064                 break;
1065             case POINT_RG_FOCUS:
1066                 p = NR::Point (rg->fx.computed, rg->fy.computed);
1067                 break;
1068             case POINT_RG_R1:
1069                 p = NR::Point (rg->cx.computed + rg->r.computed, rg->cy.computed);
1070                 break;
1071             case POINT_RG_R2:
1072                 p = NR::Point (rg->cx.computed, rg->cy.computed - rg->r.computed);
1073                 break;
1074             case POINT_RG_MID1:
1075                 {
1076                     gdouble offset = rg->vector.stops.at(point_i).offset;
1077                     p = (1-offset) * NR::Point (rg->cx.computed, rg->cy.computed) + offset * NR::Point(rg->cx.computed + rg->r.computed, rg->cy.computed);
1078                 }
1079                 break;
1080             case POINT_RG_MID2:
1081                 {
1082                     gdouble offset = rg->vector.stops.at(point_i).offset;
1083                     p = (1-offset) * NR::Point (rg->cx.computed, rg->cy.computed) + offset * NR::Point(rg->cx.computed, rg->cy.computed - rg->r.computed);
1084                 }
1085                 break;
1086         }
1087     }
1088
1089     if (SP_GRADIENT(gradient)->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
1090         sp_document_ensure_up_to_date(SP_OBJECT_DOCUMENT(item));
1091         NR::Maybe<NR::Rect> bbox = item->getBounds(NR::identity()); // we need "true" bbox without item_i2d_affine
1092         if (bbox) {
1093             p *= NR::Matrix(bbox->dimensions()[NR::X], 0,
1094                             0, bbox->dimensions()[NR::Y],
1095                             bbox->min()[NR::X], bbox->min()[NR::Y]);
1096         }
1097     }
1098     p *= NR::Matrix(gradient->gradientTransform) * sp_item_i2d_affine(item);
1099     return p;
1100 }
1101
1102
1103 /**
1104  * Sets item fill or stroke to the gradient of the specified type with given vector, creating
1105  * new private gradient, if needed.
1106  * gr has to be a normalized vector.
1107  */
1108
1109 SPGradient *
1110 sp_item_set_gradient(SPItem *item, SPGradient *gr, SPGradientType type, bool is_fill)
1111 {
1112     g_return_val_if_fail(item != NULL, NULL);
1113     g_return_val_if_fail(SP_IS_ITEM(item), NULL);
1114     g_return_val_if_fail(gr != NULL, NULL);
1115     g_return_val_if_fail(SP_IS_GRADIENT(gr), NULL);
1116     g_return_val_if_fail(gr->state == SP_GRADIENT_STATE_VECTOR, NULL);
1117
1118     SPStyle *style = SP_OBJECT_STYLE(item);
1119     g_assert(style != NULL);
1120
1121     SPPaintServer *ps = NULL;
1122     if (is_fill? style->fill.isPaintserver() : style->stroke.isPaintserver())
1123         ps = is_fill? SP_STYLE_FILL_SERVER(style) : SP_STYLE_STROKE_SERVER(style);
1124
1125     if (ps
1126         && ( (type == SP_GRADIENT_TYPE_LINEAR && SP_IS_LINEARGRADIENT(ps)) ||
1127              (type == SP_GRADIENT_TYPE_RADIAL && SP_IS_RADIALGRADIENT(ps))   ) )
1128     {
1129
1130         /* Current fill style is the gradient of the required type */
1131         SPGradient *current = SP_GRADIENT(ps);
1132
1133         //g_print("hrefcount %d   count %d\n", SP_OBJECT_HREFCOUNT(ig), count_gradient_hrefs(SP_OBJECT(item), ig));
1134
1135         if (SP_OBJECT_HREFCOUNT(current) == 1 ||
1136             SP_OBJECT_HREFCOUNT(current) == count_gradient_hrefs(SP_OBJECT(item), current)) {
1137
1138             // current is private and it's either used once, or all its uses are by children of item;
1139             // so just change its href to vector
1140
1141             if ( current != gr && sp_gradient_get_vector(current, false) != gr ) {
1142                 /* href is not the vector */
1143                 sp_gradient_repr_set_link(SP_OBJECT_REPR(current), gr);
1144             }
1145             SP_OBJECT(item)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
1146             return current;
1147
1148         } else {
1149
1150             // the gradient is not private, or it is shared with someone else;
1151             // normalize it (this includes creating new private if necessary)
1152             SPGradient *normalized = sp_gradient_fork_private_if_necessary(current, gr, type, item);
1153
1154             g_return_val_if_fail(normalized != NULL, NULL);
1155
1156             if (normalized != current) {
1157
1158                 /* We have to change object style here; recursive because this is used from
1159                  * fill&stroke and must work for groups etc. */
1160                 sp_style_set_property_url(SP_OBJECT(item), is_fill? "fill" : "stroke", SP_OBJECT(normalized), true);
1161             }
1162             SP_OBJECT(item)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
1163             return normalized;
1164         }
1165
1166     } else {
1167         /* Current fill style is not a gradient or wrong type, so construct everything */
1168         SPGradient *constructed = sp_gradient_get_private_normalized(SP_OBJECT_DOCUMENT(item), gr, type);
1169         constructed = sp_gradient_reset_to_userspace(constructed, item);
1170         sp_style_set_property_url(SP_OBJECT(item), ( is_fill ? "fill" : "stroke" ), SP_OBJECT(constructed), true);
1171         SP_OBJECT(item)->requestDisplayUpdate(( SP_OBJECT_MODIFIED_FLAG |
1172                                                 SP_OBJECT_STYLE_MODIFIED_FLAG ));
1173         return constructed;
1174     }
1175 }
1176
1177 static void
1178 sp_gradient_repr_set_link(Inkscape::XML::Node *repr, SPGradient *link)
1179 {
1180     g_return_if_fail(repr != NULL);
1181     g_return_if_fail(link != NULL);
1182     g_return_if_fail(SP_IS_GRADIENT(link));
1183
1184     gchar *ref;
1185     if (link) {
1186         gchar const *id = SP_OBJECT_ID(link);
1187         size_t const len = strlen(id);
1188         ref = (gchar*) alloca(len + 2);
1189         *ref = '#';
1190         memcpy(ref + 1, id, len + 1);
1191     } else {
1192         ref = NULL;
1193     }
1194
1195     repr->setAttribute("xlink:href", ref);
1196 }
1197
1198 /*
1199  * Get default normalized gradient vector of document, create if there is none
1200  */
1201
1202 SPGradient *
1203 sp_document_default_gradient_vector(SPDocument *document, guint32 color)
1204 {
1205     SPDefs *defs = (SPDefs *) SP_DOCUMENT_DEFS(document);
1206     Inkscape::XML::Document *xml_doc = sp_document_repr_doc(document);
1207
1208     Inkscape::XML::Node *repr = xml_doc->createElement("svg:linearGradient");
1209
1210     repr->setAttribute("inkscape:collect", "always");
1211     // set here, but removed when it's edited in the gradient editor
1212     // to further reduce clutter, we could
1213     // (1) here, search gradients by color and return what is found without duplication
1214     // (2) in fill & stroke, show only one copy of each gradient in list
1215
1216     Inkscape::XML::Node *stop = xml_doc->createElement("svg:stop");
1217
1218     gchar b[64];
1219     sp_svg_write_color(b, sizeof(b), color);
1220
1221     {
1222         gchar *t = g_strdup_printf("stop-color:%s;stop-opacity:1;", b);
1223         stop->setAttribute("style", t);
1224         g_free(t);
1225     }
1226
1227     stop->setAttribute("offset", "0");
1228
1229     repr->appendChild(stop);
1230     Inkscape::GC::release(stop);
1231
1232     stop = xml_doc->createElement("svg:stop");
1233
1234     {
1235         gchar *t = g_strdup_printf("stop-color:%s;stop-opacity:0;", b);
1236         stop->setAttribute("style", t);
1237         g_free(t);
1238     }
1239
1240     stop->setAttribute("offset", "1");
1241
1242     repr->appendChild(stop);
1243     Inkscape::GC::release(stop);
1244
1245     SP_OBJECT_REPR(defs)->addChild(repr, NULL);
1246     Inkscape::GC::release(repr);
1247
1248     /* fixme: This does not look like nice */
1249     SPGradient *gr;
1250     gr = (SPGradient *) document->getObjectByRepr(repr);
1251     g_assert(gr != NULL);
1252     g_assert(SP_IS_GRADIENT(gr));
1253     /* fixme: Maybe add extra sanity check here */
1254     gr->state = SP_GRADIENT_STATE_VECTOR;
1255
1256     return gr;
1257 }
1258
1259 /**
1260 Return the preferred vector for \a o, made from (in order of preference) its current vector,
1261 current fill or stroke color, or from desktop style if \a o is NULL or doesn't have style.
1262 */
1263 SPGradient *
1264 sp_gradient_vector_for_object(SPDocument *const doc, SPDesktop *const desktop,
1265                               SPObject *const o, bool const is_fill)
1266 {
1267     guint32 rgba = 0;
1268     if (o == NULL || SP_OBJECT_STYLE(o) == NULL) {
1269         rgba = sp_desktop_get_color(desktop, is_fill);
1270     } else {
1271         // take the color of the object
1272         SPStyle const &style = *SP_OBJECT_STYLE(o);
1273         SPIPaint const &paint = ( is_fill
1274                                   ? style.fill
1275                                   : style.stroke );
1276         if (paint.isPaintserver()) {
1277             SPObject *server = is_fill? SP_OBJECT_STYLE_FILL_SERVER(o) : SP_OBJECT_STYLE_STROKE_SERVER(o);
1278             if (SP_IS_GRADIENT (server)) {
1279                 return sp_gradient_get_vector(SP_GRADIENT (server), TRUE);
1280             } else {
1281                 rgba = sp_desktop_get_color(desktop, is_fill);
1282             }
1283         } else if (paint.isColor()) {
1284             rgba = paint.value.color.toRGBA32( 0xff );
1285         } else {
1286             // if o doesn't use flat color, then take current color of the desktop.
1287             rgba = sp_desktop_get_color(desktop, is_fill);
1288         }
1289     }
1290
1291     return sp_document_default_gradient_vector(doc, rgba);
1292 }
1293
1294
1295 /*
1296   Local Variables:
1297   mode:c++
1298   c-file-style:"stroustrup"
1299   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1300   indent-tabs-mode:nil
1301   fill-column:99
1302   End:
1303 */
1304 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :