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