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