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