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(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     boost::optional<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         boost::optional<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     // if this is valid but weird gradient without an offset-zero stop element,
 560     // inkscape has created a handle for the start of gradient anyway,
 561     // so when it asks for stop N that corresponds to stop element N-1
 562     if (stop->offset != 0)
 563         stop_i --;
 564
 565     for (guint i=0; i < stop_i; i++) {
 566         if (!stop) return NULL;
 567         stop = sp_next_stop (stop);
 568     }
 569
 570     return stop;
 571 }
 572
 573 guint32
 574 average_color (guint32 c1, guint32 c2, gdouble p)
 575 {
 576         guint32 r = (guint32) (SP_RGBA32_R_U (c1) * (1 - p) + SP_RGBA32_R_U (c2) * p);
 577         guint32 g = (guint32) (SP_RGBA32_G_U (c1) * (1 - p) + SP_RGBA32_G_U (c2) * p);
 578         guint32 b = (guint32) (SP_RGBA32_B_U (c1) * (1 - p) + SP_RGBA32_B_U (c2) * p);
 579         guint32 a = (guint32) (SP_RGBA32_A_U (c1) * (1 - p) + SP_RGBA32_A_U (c2) * p);
 580
 581         return SP_RGBA32_U_COMPOSE (r, g, b, a);
 582 }
 583
 584 SPStop *
 585 sp_vector_add_stop (SPGradient *vector, SPStop* prev_stop, SPStop* next_stop, gfloat offset)
 586 {
 587     Inkscape::XML::Node *new_stop_repr = NULL;
 588     new_stop_repr = SP_OBJECT_REPR(prev_stop)->duplicate(SP_OBJECT_REPR(vector)->document());
 589     SP_OBJECT_REPR(vector)->addChild(new_stop_repr, SP_OBJECT_REPR(prev_stop));
 590
 591     SPStop *newstop = (SPStop *) SP_OBJECT_DOCUMENT(vector)->getObjectByRepr(new_stop_repr);
 592     newstop->offset = offset;
 593     sp_repr_set_css_double( SP_OBJECT_REPR(newstop), "offset", (double)offset);
 594     guint32 const c1 = sp_stop_get_rgba32(prev_stop);
 595     guint32 const c2 = sp_stop_get_rgba32(next_stop);
 596     guint32 cnew = average_color (c1, c2, (offset - prev_stop->offset) / (next_stop->offset - prev_stop->offset));
 597     Inkscape::CSSOStringStream os;
 598     gchar c[64];
 599     sp_svg_write_color (c, sizeof(c), cnew);
 600     gdouble opacity = (gdouble) SP_RGBA32_A_F (cnew);
 601     os << "stop-color:" << c << ";stop-opacity:" << opacity <<";";
 602     SP_OBJECT_REPR (newstop)->setAttribute("style", os.str().c_str());
 603     Inkscape::GC::release(new_stop_repr);
 604
 605     return newstop;
 606 }
 607
 608 void
 609 sp_item_gradient_edit_stop (SPItem *item, guint point_type, guint point_i, bool fill_or_stroke)
 610 {
 611     SPGradient *gradient = sp_item_gradient (item, fill_or_stroke);
 612
 613     if (!gradient || !SP_IS_GRADIENT(gradient))
 614         return;
 615
 616     SPGradient *vector = sp_gradient_get_vector (gradient, false);
 617     switch (point_type) {
 618         case POINT_LG_BEGIN:
 619         case POINT_RG_CENTER:
 620         case POINT_RG_FOCUS:
 621         {
 622             GtkWidget *dialog = sp_gradient_vector_editor_new (vector, sp_first_stop (vector));
 623             gtk_widget_show (dialog);
 624         }
 625         break;
 626
 627         case POINT_LG_END:
 628         case POINT_RG_R1:
 629         case POINT_RG_R2:
 630         {
 631             GtkWidget *dialog = sp_gradient_vector_editor_new (vector, sp_last_stop (vector));
 632             gtk_widget_show (dialog);
 633         }
 634         break;
 635
 636         case POINT_LG_MID:
 637         case POINT_RG_MID1:
 638         case POINT_RG_MID2:
 639         {
 640             GtkWidget *dialog = sp_gradient_vector_editor_new (vector, sp_get_stop_i (vector, point_i));
 641             gtk_widget_show (dialog);
 642         }
 643         break;
 644         default:
 645             break;
 646     }
 647 }
 648
 649 guint32
 650 sp_item_gradient_stop_query_style (SPItem *item, guint point_type, guint point_i, bool fill_or_stroke)
 651 {
 652     SPGradient *gradient = sp_item_gradient (item, fill_or_stroke);
 653
 654     if (!gradient || !SP_IS_GRADIENT(gradient))
 655         return 0;
 656
 657     SPGradient *vector = sp_gradient_get_vector (gradient, false);
 658
 659     if (!vector) // orphan!
 660         return 0; // what else to do?
 661
 662     switch (point_type) {
 663         case POINT_LG_BEGIN:
 664         case POINT_RG_CENTER:
 665         case POINT_RG_FOCUS:
 666         {
 667             SPStop *first = sp_first_stop (vector);
 668             if (first) {
 669                 return sp_stop_get_rgba32(first);
 670             }
 671         }
 672         break;
 673
 674         case POINT_LG_END:
 675         case POINT_RG_R1:
 676         case POINT_RG_R2:
 677         {
 678             SPStop *last = sp_last_stop (vector);
 679             if (last) {
 680                 return sp_stop_get_rgba32(last);
 681             }
 682         }
 683         break;
 684
 685         case POINT_LG_MID:
 686         case POINT_RG_MID1:
 687         case POINT_RG_MID2:
 688         {
 689             SPStop *stopi = sp_get_stop_i (vector, point_i);
 690             if (stopi) {
 691                 return sp_stop_get_rgba32(stopi);
 692             }
 693         }
 694         break;
 695
 696         default:
 697             break;
 698     }
 699     return 0;
 700 }
 701
 702 void
 703 sp_item_gradient_stop_set_style (SPItem *item, guint point_type, guint point_i, bool fill_or_stroke, SPCSSAttr *stop)
 704 {
 705     SPGradient *gradient = sp_item_gradient (item, fill_or_stroke);
 706
 707     if (!gradient || !SP_IS_GRADIENT(gradient))
 708         return;
 709
 710     SPGradient *vector = sp_gradient_get_vector (gradient, false);
 711
 712     if (!vector) // orphan!
 713         return;
 714
 715     vector = sp_gradient_fork_vector_if_necessary (vector);
 716     if ( gradient != vector && gradient->ref->getObject() != vector ) {
 717         sp_gradient_repr_set_link(SP_OBJECT_REPR(gradient), vector);
 718     }
 719
 720     switch (point_type) {
 721         case POINT_LG_BEGIN:
 722         case POINT_RG_CENTER:
 723         case POINT_RG_FOCUS:
 724         {
 725             SPStop *first = sp_first_stop (vector);
 726             if (first) {
 727                 sp_repr_css_change (SP_OBJECT_REPR (first), stop, "style");
 728             }
 729         }
 730         break;
 731
 732         case POINT_LG_END:
 733         case POINT_RG_R1:
 734         case POINT_RG_R2:
 735         {
 736             SPStop *last = sp_last_stop (vector);
 737             if (last) {
 738                 sp_repr_css_change (SP_OBJECT_REPR (last), stop, "style");
 739             }
 740         }
 741         break;
 742
 743         case POINT_LG_MID:
 744         case POINT_RG_MID1:
 745         case POINT_RG_MID2:
 746         {
 747             SPStop *stopi = sp_get_stop_i (vector, point_i);
 748             if (stopi) {
 749                 sp_repr_css_change (SP_OBJECT_REPR (stopi), stop, "style");
 750             }
 751         }
 752         break;
 753
 754         default:
 755             break;
 756     }
 757 }
 758
 759 void
 760 sp_item_gradient_reverse_vector (SPItem *item, bool fill_or_stroke)
 761 {
 762     SPGradient *gradient = sp_item_gradient (item, fill_or_stroke);
 763     if (!gradient || !SP_IS_GRADIENT(gradient))
 764         return;
 765
 766     SPGradient *vector = sp_gradient_get_vector (gradient, false);
 767     if (!vector) // orphan!
 768         return;
 769
 770     vector = sp_gradient_fork_vector_if_necessary (vector);
 771     if ( gradient != vector && gradient->ref->getObject() != vector ) {
 772         sp_gradient_repr_set_link(SP_OBJECT_REPR(gradient), vector);
 773     }
 774
 775     GSList *child_reprs = NULL;
 776     GSList *child_objects = NULL;
 777     std::vector<double> offsets;
 778     for (SPObject *child = sp_object_first_child(vector);
 779          child != NULL; child = SP_OBJECT_NEXT(child)) {
 780         child_reprs = g_slist_prepend (child_reprs, SP_OBJECT_REPR(child));
 781         child_objects = g_slist_prepend (child_objects, child);
 782         offsets.push_back(sp_repr_get_double_attribute(SP_OBJECT_REPR(child), "offset", 0));
 783     }
 784
 785     GSList *child_copies = NULL;
 786     for (GSList *i = child_reprs; i != NULL; i = i->next) {
 787         Inkscape::XML::Node *repr = (Inkscape::XML::Node *) i->data;
 788         Inkscape::XML::Document *xml_doc = SP_OBJECT_REPR(vector)->document();
 789         child_copies = g_slist_append (child_copies, repr->duplicate(xml_doc));
 790     }
 791
 792
 793     for (GSList *i = child_objects; i != NULL; i = i->next) {
 794         SPObject *child = SP_OBJECT (i->data);
 795         child->deleteObject();
 796     }
 797
 798     std::vector<double>::iterator iter = offsets.end() - 1;
 799     for (GSList *i = child_copies; i != NULL; i = i->next) {
 800         Inkscape::XML::Node *copy = (Inkscape::XML::Node *) i->data;
 801         vector->appendChildRepr(copy);
 802         sp_repr_set_svg_double (copy, "offset", 1 - *iter);
 803         iter --;
 804         Inkscape::GC::release(copy);
 805     }
 806
 807     g_slist_free (child_reprs);
 808     g_slist_free (child_copies);
 809     g_slist_free (child_objects);
 810 }
 811
 812
 813 /**
 814 Set the position of point point_type of the gradient applied to item (either fill_or_stroke) to
 815 p_w (in desktop coordinates). Write_repr if you want the change to become permanent.
 816 */
 817 void
 818 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)
 819 {
 820     SPGradient *gradient = sp_item_gradient (item, fill_or_stroke);
 821
 822     if (!gradient || !SP_IS_GRADIENT(gradient))
 823         return;
 824
 825     gradient = sp_gradient_convert_to_userspace (gradient, item, fill_or_stroke? "fill" : "stroke");
 826
 827     NR::Matrix i2d (sp_item_i2d_affine (item));
 828     NR::Point p = p_w * i2d.inverse();
 829     p *= (gradient->gradientTransform).inverse();
 830     // now p is in gradient's original coordinates
 831
 832     Inkscape::XML::Node *repr = SP_OBJECT_REPR(gradient);
 833
 834     if (SP_IS_LINEARGRADIENT(gradient)) {
 835         SPLinearGradient *lg = SP_LINEARGRADIENT(gradient);
 836         switch (point_type) {
 837             case POINT_LG_BEGIN:
 838                 if (scale) {
 839                     lg->x2.computed += (lg->x1.computed - p[NR::X]);
 840                     lg->y2.computed += (lg->y1.computed - p[NR::Y]);
 841                 }
 842                 lg->x1.computed = p[NR::X];
 843                 lg->y1.computed = p[NR::Y];
 844                 if (write_repr) {
 845                     if (scale) {
 846                         sp_repr_set_svg_double(repr, "x2", lg->x2.computed);
 847                         sp_repr_set_svg_double(repr, "y2", lg->y2.computed);
 848                     }
 849                     sp_repr_set_svg_double(repr, "x1", lg->x1.computed);
 850                     sp_repr_set_svg_double(repr, "y1", lg->y1.computed);
 851                 } else {
 852                     SP_OBJECT (gradient)->requestModified(SP_OBJECT_MODIFIED_FLAG);
 853                 }
 854                 break;
 855             case POINT_LG_END:
 856                 if (scale) {
 857                     lg->x1.computed += (lg->x2.computed - p[NR::X]);
 858                     lg->y1.computed += (lg->y2.computed - p[NR::Y]);
 859                 }
 860                 lg->x2.computed = p[NR::X];
 861                 lg->y2.computed = p[NR::Y];
 862                 if (write_repr) {
 863                     if (scale) {
 864                         sp_repr_set_svg_double(repr, "x1", lg->x1.computed);
 865                         sp_repr_set_svg_double(repr, "y1", lg->y1.computed);
 866                     }
 867                     sp_repr_set_svg_double(repr, "x2", lg->x2.computed);
 868                     sp_repr_set_svg_double(repr, "y2", lg->y2.computed);
 869                 } else {
 870                     SP_OBJECT (gradient)->requestModified(SP_OBJECT_MODIFIED_FLAG);
 871                 }
 872                         break;
 873             case POINT_LG_MID:
 874             {
 875                 // using X-coordinates only to determine the offset, assuming p has been snapped to the vector from begin to end.
 876                 double offset = get_offset_between_points (p, NR::Point(lg->x1.computed, lg->y1.computed), NR::Point(lg->x2.computed, lg->y2.computed));
 877                 SPGradient *vector = sp_gradient_get_forked_vector_if_necessary (lg, false);
 878                 sp_gradient_ensure_vector(lg);
 879                 lg->vector.stops.at(point_i).offset = offset;
 880                 SPStop* stopi = sp_get_stop_i(vector, point_i);
 881                 stopi->offset = offset;
 882                 if (write_repr) {
 883                     sp_repr_set_css_double(SP_OBJECT_REPR(stopi), "offset", stopi->offset);
 884                 } else {
 885                     SP_OBJECT (stopi)->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
 886                 }
 887             }
 888             break;
 889                 default:
 890                         break;
 891                 }
 892         } else if (SP_IS_RADIALGRADIENT(gradient)) {
 893         SPRadialGradient *rg = SP_RADIALGRADIENT(gradient);
 894         NR::Point c (rg->cx.computed, rg->cy.computed);
 895         NR::Point c_w = c * gradient->gradientTransform * i2d; // now in desktop coords
 896         if ((point_type == POINT_RG_R1 || point_type == POINT_RG_R2) && NR::L2 (p_w - c_w) < 1e-3) {
 897             // prevent setting a radius too close to the center
 898             return;
 899         }
 900         NR::Matrix new_transform;
 901         bool transform_set = false;
 902
 903                 switch (point_type) {
 904                 case POINT_RG_CENTER:
 905                         rg->fx.computed = p[NR::X] + (rg->fx.computed - rg->cx.computed);
 906                         rg->fy.computed = p[NR::Y] + (rg->fy.computed - rg->cy.computed);
 907                         rg->cx.computed = p[NR::X];
 908                         rg->cy.computed = p[NR::Y];
 909                         if (write_repr) {
 910                                 sp_repr_set_svg_double(repr, "fx", rg->fx.computed);
 911                                 sp_repr_set_svg_double(repr, "fy", rg->fy.computed);
 912                                 sp_repr_set_svg_double(repr, "cx", rg->cx.computed);
 913                                 sp_repr_set_svg_double(repr, "cy", rg->cy.computed);
 914                         } else {
 915                                 SP_OBJECT (gradient)->requestModified(SP_OBJECT_MODIFIED_FLAG);
 916                         }
 917                         break;
 918                 case POINT_RG_FOCUS:
 919                         rg->fx.computed = p[NR::X];
 920                         rg->fy.computed = p[NR::Y];
 921                         if (write_repr) {
 922                                 sp_repr_set_svg_double(repr, "fx", rg->fx.computed);
 923                                 sp_repr_set_svg_double(repr, "fy", rg->fy.computed);
 924                         } else {
 925                                 SP_OBJECT (gradient)->requestModified(SP_OBJECT_MODIFIED_FLAG);
 926                         }
 927                         break;
 928                 case POINT_RG_R1:
 929                         {
 930                 NR::Point r1_w = (c + NR::Point(rg->r.computed, 0)) * gradient->gradientTransform * i2d;
 931                                 double r1_angle = NR::atan2(r1_w - c_w);
 932                                 double move_angle = NR::atan2(p_w - c_w) - r1_angle;
 933                                 double move_stretch = NR::L2(p_w - c_w) / NR::L2(r1_w - c_w);
 934
 935                                 NR::Matrix move = NR::Matrix (NR::translate (-c_w)) *
 936                                                                                                  NR::Matrix (NR::rotate(-r1_angle)) *
 937                                                                                                  NR::Matrix (NR::scale(move_stretch, scale? move_stretch : 1)) *
 938                                                                                                  NR::Matrix (NR::rotate(r1_angle)) *
 939                                                                                                  NR::Matrix (NR::rotate(move_angle)) *
 940                                                                                                  NR::Matrix (NR::translate (c_w));
 941
 942                                 new_transform = gradient->gradientTransform * i2d * move * i2d.inverse();
 943                                 transform_set = true;
 944
 945                                 break;
 946                         }
 947                 case POINT_RG_R2:
 948                         {
 949                                 NR::Point r2_w = (c + NR::Point(0, -rg->r.computed)) * gradient->gradientTransform * i2d;
 950                                 double r2_angle = NR::atan2(r2_w - c_w);
 951                                 double move_angle = NR::atan2(p_w - c_w) - r2_angle;
 952                                 double move_stretch = NR::L2(p_w - c_w) / NR::L2(r2_w - c_w);
 953
 954                                 NR::Matrix move = NR::Matrix (NR::translate (-c_w)) *
 955                                                                                                  NR::Matrix (NR::rotate(-r2_angle)) *
 956                                                                                                  NR::Matrix (NR::scale(move_stretch, scale? move_stretch : 1)) *
 957                                                                                                  NR::Matrix (NR::rotate(r2_angle)) *
 958                                                                                                  NR::Matrix (NR::rotate(move_angle)) *
 959                                                                                                  NR::Matrix (NR::translate (c_w));
 960
 961                                 new_transform = gradient->gradientTransform * i2d * move * i2d.inverse();
 962                                 transform_set = true;
 963
 964                 break;
 965             }
 966         case POINT_RG_MID1:
 967             {
 968                 NR::Point start = NR::Point (rg->cx.computed, rg->cy.computed);
 969                  NR::Point end   = NR::Point (rg->cx.computed + rg->r.computed, rg->cy.computed);
 970                 double offset = get_offset_between_points (p, start, end);
 971                 SPGradient *vector = sp_gradient_get_forked_vector_if_necessary (rg, false);
 972                 sp_gradient_ensure_vector(rg);
 973                 rg->vector.stops.at(point_i).offset = offset;
 974                 SPStop* stopi = sp_get_stop_i(vector, point_i);
 975                 stopi->offset = offset;
 976                 if (write_repr) {
 977                     sp_repr_set_css_double(SP_OBJECT_REPR(stopi), "offset", stopi->offset);
 978                 } else {
 979                     SP_OBJECT (stopi)->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
 980                 }
 981                 break;
 982             }
 983         case POINT_RG_MID2:
 984                 NR::Point start = NR::Point (rg->cx.computed, rg->cy.computed);
 985                 NR::Point end   = NR::Point (rg->cx.computed, rg->cy.computed - rg->r.computed);
 986                 double offset = get_offset_between_points (p, start, end);
 987                 SPGradient *vector = sp_gradient_get_forked_vector_if_necessary(rg, false);
 988                 sp_gradient_ensure_vector(rg);
 989                 rg->vector.stops.at(point_i).offset = offset;
 990                 SPStop* stopi = sp_get_stop_i(vector, point_i);
 991                 stopi->offset = offset;
 992                 if (write_repr) {
 993                     sp_repr_set_css_double(SP_OBJECT_REPR(stopi), "offset", stopi->offset);
 994                 } else {
 995                     SP_OBJECT (stopi)->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
 996                 }
 997                 break;
 998             }
 999                 if (transform_set) {
1000                                 gradient->gradientTransform = new_transform;
1001                                 gradient->gradientTransform_set = TRUE;
1002                                 if (write_repr) {
1003                                         gchar *s=sp_svg_transform_write(gradient->gradientTransform);
1004                                         SP_OBJECT_REPR(gradient)->setAttribute("gradientTransform", s);
1005                                         g_free(s);
1006                                 } else {
1007                                         SP_OBJECT (gradient)->requestModified(SP_OBJECT_MODIFIED_FLAG);
1008                                 }
1009                 }
1010         }
1011 }
1012
1013 SPGradient *
1014 sp_item_gradient_get_vector (SPItem *item, bool fill_or_stroke)
1015 {
1016     SPGradient *gradient = sp_item_gradient (item, fill_or_stroke);
1017
1018     if (gradient)
1019         return sp_gradient_get_vector (gradient, false);
1020     return NULL;
1021 }
1022
1023 SPGradientSpread
1024 sp_item_gradient_get_spread (SPItem *item, bool fill_or_stroke)
1025 {
1026     SPGradient *gradient = sp_item_gradient (item, fill_or_stroke);
1027
1028     if (gradient)
1029         return sp_gradient_get_spread (gradient);
1030     return SP_GRADIENT_SPREAD_PAD;
1031 }
1032
1033
1034 /**
1035 Returns the position of point point_type of the gradient applied to item (either fill_or_stroke),
1036 in desktop coordinates.
1037 */
1038
1039 NR::Point
1040 sp_item_gradient_get_coords (SPItem *item, guint point_type, guint point_i, bool fill_or_stroke)
1041 {
1042     SPGradient *gradient = sp_item_gradient (item, fill_or_stroke);
1043
1044     NR::Point p (0, 0);
1045
1046     if (!gradient)
1047         return p;
1048
1049     if (SP_IS_LINEARGRADIENT(gradient)) {
1050         SPLinearGradient *lg = SP_LINEARGRADIENT(gradient);
1051         switch (point_type) {
1052             case POINT_LG_BEGIN:
1053                 p = NR::Point (lg->x1.computed, lg->y1.computed);
1054                 break;
1055             case POINT_LG_END:
1056                 p = NR::Point (lg->x2.computed, lg->y2.computed);
1057                 break;
1058             case POINT_LG_MID:
1059                 {
1060                     gdouble offset = lg->vector.stops.at(point_i).offset;
1061                     p = (1-offset) * NR::Point(lg->x1.computed, lg->y1.computed) + offset * NR::Point(lg->x2.computed, lg->y2.computed);
1062                 }
1063                 break;
1064         }
1065     } else     if (SP_IS_RADIALGRADIENT(gradient)) {
1066         SPRadialGradient *rg = SP_RADIALGRADIENT(gradient);
1067         switch (point_type) {
1068             case POINT_RG_CENTER:
1069                 p = NR::Point (rg->cx.computed, rg->cy.computed);
1070                 break;
1071             case POINT_RG_FOCUS:
1072                 p = NR::Point (rg->fx.computed, rg->fy.computed);
1073                 break;
1074             case POINT_RG_R1:
1075                 p = NR::Point (rg->cx.computed + rg->r.computed, rg->cy.computed);
1076                 break;
1077             case POINT_RG_R2:
1078                 p = NR::Point (rg->cx.computed, rg->cy.computed - rg->r.computed);
1079                 break;
1080             case POINT_RG_MID1:
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->r.computed, rg->cy.computed);
1084                 }
1085                 break;
1086             case POINT_RG_MID2:
1087                 {
1088                     gdouble offset = rg->vector.stops.at(point_i).offset;
1089                     p = (1-offset) * NR::Point (rg->cx.computed, rg->cy.computed) + offset * NR::Point(rg->cx.computed, rg->cy.computed - rg->r.computed);
1090                 }
1091                 break;
1092         }
1093     }
1094
1095     if (SP_GRADIENT(gradient)->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
1096         sp_document_ensure_up_to_date(SP_OBJECT_DOCUMENT(item));
1097         boost::optional<NR::Rect> bbox = item->getBounds(NR::identity()); // we need "true" bbox without item_i2d_affine
1098         if (bbox) {
1099             p *= NR::Matrix(bbox->dimensions()[NR::X], 0,
1100                             0, bbox->dimensions()[NR::Y],
1101                             bbox->min()[NR::X], bbox->min()[NR::Y]);
1102         }
1103     }
1104     p *= NR::Matrix(gradient->gradientTransform) * (NR::Matrix)sp_item_i2d_affine(item);
1105     return p;
1106 }
1107
1108
1109 /**
1110  * Sets item fill or stroke to the gradient of the specified type with given vector, creating
1111  * new private gradient, if needed.
1112  * gr has to be a normalized vector.
1113  */
1114
1115 SPGradient *
1116 sp_item_set_gradient(SPItem *item, SPGradient *gr, SPGradientType type, bool is_fill)
1117 {
1118     g_return_val_if_fail(item != NULL, NULL);
1119     g_return_val_if_fail(SP_IS_ITEM(item), NULL);
1120     g_return_val_if_fail(gr != NULL, NULL);
1121     g_return_val_if_fail(SP_IS_GRADIENT(gr), NULL);
1122     g_return_val_if_fail(gr->state == SP_GRADIENT_STATE_VECTOR, NULL);
1123
1124     SPStyle *style = SP_OBJECT_STYLE(item);
1125     g_assert(style != NULL);
1126
1127     SPPaintServer *ps = NULL;
1128     if (is_fill? style->fill.isPaintserver() : style->stroke.isPaintserver())
1129         ps = is_fill? SP_STYLE_FILL_SERVER(style) : SP_STYLE_STROKE_SERVER(style);
1130
1131     if (ps
1132         && ( (type == SP_GRADIENT_TYPE_LINEAR && SP_IS_LINEARGRADIENT(ps)) ||
1133              (type == SP_GRADIENT_TYPE_RADIAL && SP_IS_RADIALGRADIENT(ps))   ) )
1134     {
1135
1136         /* Current fill style is the gradient of the required type */
1137         SPGradient *current = SP_GRADIENT(ps);
1138
1139         //g_print("hrefcount %d   count %d\n", SP_OBJECT_HREFCOUNT(ig), count_gradient_hrefs(SP_OBJECT(item), ig));
1140
1141         if (SP_OBJECT_HREFCOUNT(current) == 1 ||
1142             SP_OBJECT_HREFCOUNT(current) == count_gradient_hrefs(SP_OBJECT(item), current)) {
1143
1144             // current is private and it's either used once, or all its uses are by children of item;
1145             // so just change its href to vector
1146
1147             if ( current != gr && sp_gradient_get_vector(current, false) != gr ) {
1148                 /* href is not the vector */
1149                 sp_gradient_repr_set_link(SP_OBJECT_REPR(current), gr);
1150             }
1151             SP_OBJECT(item)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
1152             return current;
1153
1154         } else {
1155
1156             // the gradient is not private, or it is shared with someone else;
1157             // normalize it (this includes creating new private if necessary)
1158             SPGradient *normalized = sp_gradient_fork_private_if_necessary(current, gr, type, item);
1159
1160             g_return_val_if_fail(normalized != NULL, NULL);
1161
1162             if (normalized != current) {
1163
1164                 /* We have to change object style here; recursive because this is used from
1165                  * fill&stroke and must work for groups etc. */
1166                 sp_style_set_property_url(SP_OBJECT(item), is_fill? "fill" : "stroke", SP_OBJECT(normalized), true);
1167             }
1168             SP_OBJECT(item)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
1169             return normalized;
1170         }
1171
1172     } else {
1173         /* Current fill style is not a gradient or wrong type, so construct everything */
1174         SPGradient *constructed = sp_gradient_get_private_normalized(SP_OBJECT_DOCUMENT(item), gr, type);
1175         constructed = sp_gradient_reset_to_userspace(constructed, item);
1176         sp_style_set_property_url(SP_OBJECT(item), ( is_fill ? "fill" : "stroke" ), SP_OBJECT(constructed), true);
1177         SP_OBJECT(item)->requestDisplayUpdate(( SP_OBJECT_MODIFIED_FLAG |
1178                                                 SP_OBJECT_STYLE_MODIFIED_FLAG ));
1179         return constructed;
1180     }
1181 }
1182
1183 static void
1184 sp_gradient_repr_set_link(Inkscape::XML::Node *repr, SPGradient *link)
1185 {
1186     g_return_if_fail(repr != NULL);
1187     g_return_if_fail(link != NULL);
1188     g_return_if_fail(SP_IS_GRADIENT(link));
1189
1190     gchar *ref;
1191     if (link) {
1192         gchar const *id = SP_OBJECT_ID(link);
1193         size_t const len = strlen(id);
1194         ref = (gchar*) alloca(len + 2);
1195         *ref = '#';
1196         memcpy(ref + 1, id, len + 1);
1197     } else {
1198         ref = NULL;
1199     }
1200
1201     repr->setAttribute("xlink:href", ref);
1202 }
1203
1204 /*
1205  * Get default normalized gradient vector of document, create if there is none
1206  */
1207
1208 SPGradient *
1209 sp_document_default_gradient_vector(SPDocument *document, guint32 color)
1210 {
1211     SPDefs *defs = (SPDefs *) SP_DOCUMENT_DEFS(document);
1212     Inkscape::XML::Document *xml_doc = sp_document_repr_doc(document);
1213
1214     Inkscape::XML::Node *repr = xml_doc->createElement("svg:linearGradient");
1215
1216     repr->setAttribute("inkscape:collect", "always");
1217     // set here, but removed when it's edited in the gradient editor
1218     // to further reduce clutter, we could
1219     // (1) here, search gradients by color and return what is found without duplication
1220     // (2) in fill & stroke, show only one copy of each gradient in list
1221
1222     Inkscape::XML::Node *stop = xml_doc->createElement("svg:stop");
1223
1224     gchar b[64];
1225     sp_svg_write_color(b, sizeof(b), color);
1226
1227     {
1228         gchar *t = g_strdup_printf("stop-color:%s;stop-opacity:1;", b);
1229         stop->setAttribute("style", t);
1230         g_free(t);
1231     }
1232
1233     stop->setAttribute("offset", "0");
1234
1235     repr->appendChild(stop);
1236     Inkscape::GC::release(stop);
1237
1238     stop = xml_doc->createElement("svg:stop");
1239
1240     {
1241         gchar *t = g_strdup_printf("stop-color:%s;stop-opacity:0;", b);
1242         stop->setAttribute("style", t);
1243         g_free(t);
1244     }
1245
1246     stop->setAttribute("offset", "1");
1247
1248     repr->appendChild(stop);
1249     Inkscape::GC::release(stop);
1250
1251     SP_OBJECT_REPR(defs)->addChild(repr, NULL);
1252     Inkscape::GC::release(repr);
1253
1254     /* fixme: This does not look like nice */
1255     SPGradient *gr;
1256     gr = (SPGradient *) document->getObjectByRepr(repr);
1257     g_assert(gr != NULL);
1258     g_assert(SP_IS_GRADIENT(gr));
1259     /* fixme: Maybe add extra sanity check here */
1260     gr->state = SP_GRADIENT_STATE_VECTOR;
1261
1262     return gr;
1263 }
1264
1265 /**
1266 Return the preferred vector for \a o, made from (in order of preference) its current vector,
1267 current fill or stroke color, or from desktop style if \a o is NULL or doesn't have style.
1268 */
1269 SPGradient *
1270 sp_gradient_vector_for_object(SPDocument *const doc, SPDesktop *const desktop,
1271                               SPObject *const o, bool const is_fill)
1272 {
1273     guint32 rgba = 0;
1274     if (o == NULL || SP_OBJECT_STYLE(o) == NULL) {
1275         rgba = sp_desktop_get_color(desktop, is_fill);
1276     } else {
1277         // take the color of the object
1278         SPStyle const &style = *SP_OBJECT_STYLE(o);
1279         SPIPaint const &paint = ( is_fill
1280                                   ? style.fill
1281                                   : style.stroke );
1282         if (paint.isPaintserver()) {
1283             SPObject *server = is_fill? SP_OBJECT_STYLE_FILL_SERVER(o) : SP_OBJECT_STYLE_STROKE_SERVER(o);
1284             if (SP_IS_GRADIENT (server)) {
1285                 return sp_gradient_get_vector(SP_GRADIENT (server), TRUE);
1286             } else {
1287                 rgba = sp_desktop_get_color(desktop, is_fill);
1288             }
1289         } else if (paint.isColor()) {
1290             rgba = paint.value.color.toRGBA32( 0xff );
1291         } else {
1292             // if o doesn't use flat color, then take current color of the desktop.
1293             rgba = sp_desktop_get_color(desktop, is_fill);
1294         }
1295     }
1296
1297     return sp_document_default_gradient_vector(doc, rgba);
1298 }
1299
1300
1301 /*
1302   Local Variables:
1303   mode:c++
1304   c-file-style:"stroustrup"
1305   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1306   indent-tabs-mode:nil
1307   fill-column:99
1308   End:
1309 */
1310 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :