![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
diff --git a/src/sp-gradient.cpp b/src/sp-gradient.cpp
index 94e6ce6c200c41d70604144082e91df9e5f237cf..5c973cf0df4ad04c76bf0cfc7111862ce2f5625f 100644 (file)
--- a/src/sp-gradient.cpp
+++ b/src/sp-gradient.cpp
#define noSP_GRADIENT_VERBOSE
+#include <cstring>
+#include <string>
-#include <libnr/nr-matrix-div.h>
#include <libnr/nr-matrix-fns.h>
#include <libnr/nr-matrix-ops.h>
#include <libnr/nr-matrix-scale-ops.h>
-#include <libnr/nr-matrix-translate-ops.h>
-#include "libnr/nr-scale-translate-ops.h"
+#include <2geom/transforms.h>
#include <sigc++/functors/ptr_fun.h>
#include <sigc++/adaptors/bind.h>
-#include "display/nr-gradient-gpl.h"
+#include "libnr/nr-gradient.h"
#include "svg/svg.h"
#include "svg/svg-color.h"
#include "svg/css-ostringstream.h"
static void sp_stop_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
static void sp_stop_set(SPObject *object, unsigned key, gchar const *value);
-static Inkscape::XML::Node *sp_stop_write(SPObject *object, Inkscape::XML::Node *repr, guint flags);
+static Inkscape::XML::Node *sp_stop_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags);
static SPObjectClass *stop_parent_class;
{
stop->offset = 0.0;
stop->currentColor = false;
- sp_color_set_rgb_rgba32(&stop->specified_color, 0x000000ff);
+ stop->specified_color.set( 0x000000ff );
stop->opacity = 1.0;
}
stop->currentColor = true;
} else {
guint32 const color = sp_svg_read_color(p, 0);
- sp_color_set_rgb_rgba32(&stop->specified_color, color);
+ stop->specified_color.set( color );
}
}
{
} else {
stop->currentColor = false;
guint32 const color = sp_svg_read_color(p, 0);
- sp_color_set_rgb_rgba32(&stop->specified_color, color);
+ stop->specified_color.set( color );
}
}
object->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
* Virtual write: write object attributes to repr.
*/
static Inkscape::XML::Node *
-sp_stop_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
+sp_stop_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
{
SPStop *stop = SP_STOP(object);
if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
- Inkscape::XML::Document *xml_doc = sp_document_repr_doc(SP_OBJECT_DOCUMENT(object));
repr = xml_doc->createElement("svg:stop");
}
+ guint32 specifiedcolor = stop->specified_color.toRGBA32( 255 );
+ gfloat opacity = stop->opacity;
+
+ if (((SPObjectClass *) stop_parent_class)->write)
+ (* ((SPObjectClass *) stop_parent_class)->write)(object, xml_doc, repr, flags);
+
+ // Since we do a hackish style setting here (because SPStyle does not support stop-color and
+ // stop-opacity), we must do it AFTER calling the parent write method; otherwise
+ // sp_object_write would clear our style= attribute (bug 1695287)
Inkscape::CSSOStringStream os;
os << "stop-color:";
os << "currentColor";
} else {
gchar c[64];
- sp_svg_write_color(c, 64, sp_color_get_rgba32_ualpha(&stop->specified_color, 255));
+ sp_svg_write_color(c, sizeof(c), specifiedcolor);
os << c;
}
- os << ";stop-opacity:" << stop->opacity;
+ os << ";stop-opacity:" << opacity;
repr->setAttribute("style", os.str().c_str());
repr->setAttribute("stop-color", NULL);
repr->setAttribute("stop-opacity", NULL);
/* strictly speaking, offset an SVG <number> rather than a CSS one, but exponents make no sense
* for offset proportions. */
- if (((SPObjectClass *) stop_parent_class)->write)
- (* ((SPObjectClass *) stop_parent_class)->write)(object, repr, flags);
-
return repr;
}
rgb0 | 0xff);
return rgb0 | alpha;
} else {
- return sp_color_get_rgba32_falpha(&stop->specified_color, stop->opacity);
+ return stop->specified_color.toRGBA32( stop->opacity );
}
}
if (str) {
color = sp_svg_read_color(str, dfl);
}
- SPColor ret;
- sp_color_set_rgb_rgba32(&ret, color);
+ SPColor ret( color );
return ret;
} else {
return stop->specified_color;
Inkscape::XML::Node *ref);
static void sp_gradient_remove_child(SPObject *object, Inkscape::XML::Node *child);
static void sp_gradient_modified(SPObject *object, guint flags);
-static Inkscape::XML::Node *sp_gradient_write(SPObject *object, Inkscape::XML::Node *repr,
+static Inkscape::XML::Node *sp_gradient_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr,
guint flags);
static void gradient_ref_modified(SPObject *href, guint flags, SPGradient *gradient);
static void gradient_ref_changed(SPObject *old_ref, SPObject *ref, SPGradient *gradient);
+SPGradientSpread sp_gradient_get_spread(SPGradient *gradient);
+SPGradientUnits sp_gradient_get_units(SPGradient *gradient);
+
static SPPaintServerClass *gradient_parent_class;
/**
gr->units = SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX;
gr->units_set = FALSE;
- gr->gradientTransform = NR::identity();
+ gr->gradientTransform = Geom::identity();
gr->gradientTransform_set = FALSE;
gr->spread = SP_GRADIENT_SPREAD_PAD;
object->requestModified(SP_OBJECT_MODIFIED_FLAG);
break;
case SP_ATTR_GRADIENTTRANSFORM: {
- NR::Matrix t;
+ Geom::Matrix t;
if (value && sp_svg_transform_read(value, &t)) {
gr->gradientTransform = t;
gr->gradientTransform_set = TRUE;
} else {
- gr->gradientTransform = NR::identity();
+ gr->gradientTransform = Geom::identity();
gr->gradientTransform_set = FALSE;
}
object->requestModified(SP_OBJECT_MODIFIED_FLAG);
{
gr->modified_connection = ref->connectModified(sigc::bind<2>(sigc::ptr_fun(&gradient_ref_modified), gr));
}
+
+ // Per SVG, all unset attributes must be inherited from linked gradient.
+ // So, as we're now (re)linked, we assign linkee's values to this gradient if they are not yet set -
+ // but without setting the _set flags.
+ // FIXME: do the same for gradientTransform too
+ if (!gr->units_set)
+ gr->units = sp_gradient_get_units (gr);
+ if (!gr->spread_set)
+ gr->spread = sp_gradient_get_spread (gr);
+
/// \todo Fixme: what should the flags (second) argument be? */
gradient_ref_modified(ref, 0, gr);
}
if (flags & SP_OBJECT_STYLE_MODIFIED_FLAG) {
sp_gradient_ensure_colors(gr);
}
-
+
if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
flags &= SP_OBJECT_MODIFIED_CASCADE;
* Write gradient attributes to repr.
*/
static Inkscape::XML::Node *
-sp_gradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
+sp_gradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
{
SPGradient *gr = SP_GRADIENT(object);
if (((SPObjectClass *) gradient_parent_class)->write)
- (* ((SPObjectClass *) gradient_parent_class)->write)(object, repr, flags);
+ (* ((SPObjectClass *) gradient_parent_class)->write)(object, xml_doc, repr, flags);
if (flags & SP_OBJECT_WRITE_BUILD) {
GSList *l = NULL;
for (SPObject *child = sp_object_first_child(object); child; child = SP_OBJECT_NEXT(child)) {
Inkscape::XML::Node *crepr;
- crepr = child->updateRepr(NULL, flags);
+ crepr = child->updateRepr(xml_doc, NULL, flags);
if (crepr) l = g_slist_prepend(l, crepr);
}
while (l) {
return gr->spread_set;
}
+/**
+ * True if gradient has units set.
+ */
+static bool
+has_units_set(SPGradient const *gr)
+{
+ return gr->units_set;
+}
+
/**
* Returns private vector of given gradient (the gradient at the end of the href chain which has
: SP_GRADIENT_SPREAD_PAD ); // pad is the default
}
+/**
+ * Returns the effective units of given gradient (climbing up the refs chain if needed).
+ *
+ * \pre SP_IS_GRADIENT(gradient).
+ */
+SPGradientUnits
+sp_gradient_get_units(SPGradient *gradient)
+{
+ g_return_val_if_fail(SP_IS_GRADIENT(gradient), SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX);
+
+ SPGradient const *src = chase_hrefs(gradient, has_units_set);
+ return ( src
+ ? src->units
+ : SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX ); // bbox is the default
+}
+
+
/**
* Clears the gradient's svg:stop children from its repr.
*/
/* strictly speaking, offset an SVG <number> rather than a CSS one, but exponents make no
* sense for offset proportions. */
gchar c[64];
- sp_svg_write_color(c, 64, sp_color_get_rgba32_ualpha(&gr->vector.stops[i].color, 0x00));
+ sp_svg_write_color(c, sizeof(c), gr->vector.stops[i].color.toRGBA32( 0x00 ));
os << "stop-color:" << c << ";stop-opacity:" << gr->vector.stops[i].opacity;
child->setAttribute("style", os.str().c_str());
/* Order will be reversed here */
static void
-gradient_ref_modified(SPObject *href, guint flags, SPGradient *gradient)
+gradient_ref_modified(SPObject */*href*/, guint /*flags*/, SPGradient *gradient)
{
if (sp_gradient_invalidate_vector(gradient)) {
SP_OBJECT(gradient)->requestModified(SP_OBJECT_MODIFIED_FLAG);
{
SPGradientStop gstop;
gstop.offset = 0.0;
- sp_color_set_rgb_rgba32(&gstop.color, 0x00000000);
+ gstop.color.set( 0x00000000 );
gstop.opacity = 0.0;
gr->vector.stops.push_back(gstop);
}
{
SPGradientStop gstop;
gstop.offset = 1.0;
- sp_color_set_rgb_rgba32(&gstop.color, 0x00000000);
+ gstop.color.set( 0x00000000 );
gstop.opacity = 0.0;
gr->vector.stops.push_back(gstop);
}
// If the first one is not at 0, then insert a copy of the first at 0.
SPGradientStop gstop;
gstop.offset = 0.0;
- sp_color_copy(&gstop.color, &gr->vector.stops.front().color);
+ gstop.color = gr->vector.stops.front().color;
gstop.opacity = gr->vector.stops.front().opacity;
gr->vector.stops.insert(gr->vector.stops.begin(), gstop);
}
// If the last one is not at 1, then insert a copy of the last at 1.
SPGradientStop gstop;
gstop.offset = 1.0;
- sp_color_copy(&gstop.color, &gr->vector.stops.back().color);
+ gstop.color = gr->vector.stops.back().color;
gstop.opacity = gr->vector.stops.back().opacity;
gr->vector.stops.push_back(gstop);
}
}
for (guint i = 0; i < gr->vector.stops.size() - 1; i++) {
- guint32 color = sp_color_get_rgba32_falpha(&gr->vector.stops[i].color,
- gr->vector.stops[i].opacity);
+ guint32 color = gr->vector.stops[i].color.toRGBA32( gr->vector.stops[i].opacity );
gint r0 = (color >> 24) & 0xff;
gint g0 = (color >> 16) & 0xff;
gint b0 = (color >> 8) & 0xff;
gint a0 = color & 0xff;
- color = sp_color_get_rgba32_falpha(&gr->vector.stops[i + 1].color,
- gr->vector.stops[i + 1].opacity);
+ color = gr->vector.stops[i + 1].color.toRGBA32( gr->vector.stops[i + 1].opacity );
gint r1 = (color >> 24) & 0xff;
gint g1 = (color >> 16) & 0xff;
gint b1 = (color >> 8) & 0xff;
*/
void
sp_gradient_render_vector_block_rgb(SPGradient *gradient, guchar *buf,
- gint const width, gint const height, gint const rowstride,
+ gint const width, gint const height, gint const /*rowstride*/,
gint const pos, gint const span, bool const horizontal)
{
g_return_if_fail(gradient != NULL);
}
}
-NR::Matrix
-sp_gradient_get_g2d_matrix(SPGradient const *gr, NR::Matrix const &ctm, NR::Rect const &bbox)
+Geom::Matrix
+sp_gradient_get_g2d_matrix(SPGradient const *gr, Geom::Matrix const &ctm, Geom::Rect const &bbox)
{
if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
- return ( NR::scale(bbox.dimensions())
- * NR::translate(bbox.min())
- * ctm );
+ return ( Geom::Scale(bbox.dimensions())
+ * Geom::Translate(bbox.min())
+ * Geom::Matrix(ctm) );
} else {
return ctm;
}
}
-NR::Matrix
-sp_gradient_get_gs2d_matrix(SPGradient const *gr, NR::Matrix const &ctm, NR::Rect const &bbox)
+Geom::Matrix
+sp_gradient_get_gs2d_matrix(SPGradient const *gr, Geom::Matrix const &ctm, Geom::Rect const &bbox)
{
if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
return ( gr->gradientTransform
- * NR::scale(bbox.dimensions())
- * NR::translate(bbox.min())
- * ctm );
+ * Geom::Scale(bbox.dimensions())
+ * Geom::Translate(bbox.min())
+ * Geom::Matrix(ctm) );
} else {
return gr->gradientTransform * ctm;
}
}
void
-sp_gradient_set_gs2d_matrix(SPGradient *gr, NR::Matrix const &ctm,
- NR::Rect const &bbox, NR::Matrix const &gs2d)
+sp_gradient_set_gs2d_matrix(SPGradient *gr, Geom::Matrix const &ctm,
+ Geom::Rect const &bbox, Geom::Matrix const &gs2d)
{
- gr->gradientTransform = gs2d / ctm;
- if ( gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX ) {
+ gr->gradientTransform = gs2d * ctm.inverse();
+ if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX ) {
gr->gradientTransform = ( gr->gradientTransform
- / NR::translate(bbox.min())
- / NR::scale(bbox.dimensions()) );
+ * Geom::Translate(-bbox.min())
+ * Geom::Scale(bbox.dimensions()).inverse() );
}
gr->gradientTransform_set = TRUE;
SPDocument *document,
Inkscape::XML::Node *repr);
static void sp_lineargradient_set(SPObject *object, unsigned key, gchar const *value);
-static Inkscape::XML::Node *sp_lineargradient_write(SPObject *object, Inkscape::XML::Node *repr,
+static Inkscape::XML::Node *sp_lineargradient_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr,
guint flags);
static SPPainter *sp_lineargradient_painter_new(SPPaintServer *ps,
- NR::Matrix const &full_transform,
- NR::Matrix const &parent_transform,
+ Geom::Matrix const &full_transform,
+ Geom::Matrix const &parent_transform,
NRRect const *bbox);
static void sp_lineargradient_painter_free(SPPaintServer *ps, SPPainter *painter);
* Callback: write attributes to associated repr.
*/
static Inkscape::XML::Node *
-sp_lineargradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
+sp_lineargradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
{
SPLinearGradient *lg = SP_LINEARGRADIENT(object);
if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
- Inkscape::XML::Document *xml_doc = sp_document_repr_doc(SP_OBJECT_DOCUMENT(object));
repr = xml_doc->createElement("svg:linearGradient");
}
@@ -1404,7 +1444,7 @@ sp_lineargradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags
sp_repr_set_svg_double(repr, "y2", lg->y2.computed);
if (((SPObjectClass *) lg_parent_class)->write)
- (* ((SPObjectClass *) lg_parent_class)->write)(object, repr, flags);
+ (* ((SPObjectClass *) lg_parent_class)->write)(object, xml_doc, repr, flags);
return repr;
}
@@ -1427,8 +1467,8 @@ sp_lineargradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags
*/
static SPPainter *
sp_lineargradient_painter_new(SPPaintServer *ps,
- NR::Matrix const &full_transform,
- NR::Matrix const &parent_transform,
+ Geom::Matrix const &full_transform,
+ Geom::Matrix const &/*parent_transform*/,
NRRect const *bbox)
{
SPLinearGradient *lg = SP_LINEARGRADIENT(ps);
* or something similar. Originally I had 1023.9999 here - not sure
* whether we have really to cut out ceil int (Lauris).
*/
- NR::Matrix color2norm(NR::identity());
- NR::Matrix color2px;
+ Geom::Matrix color2norm(Geom::identity());
+ Geom::Matrix color2px;
if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
- NR::Matrix norm2pos(NR::identity());
+ Geom::Matrix norm2pos(Geom::identity());
/* BBox to user coordinate system */
- NR::Matrix bbox2user(bbox->x1 - bbox->x0, 0, 0, bbox->y1 - bbox->y0, bbox->x0, bbox->y0);
+ Geom::Matrix bbox2user(bbox->x1 - bbox->x0, 0, 0, bbox->y1 - bbox->y0, bbox->x0, bbox->y0);
- NR::Matrix color2pos = color2norm * norm2pos;
- NR::Matrix color2tpos = color2pos * gr->gradientTransform;
- NR::Matrix color2user = color2tpos * bbox2user;
+ Geom::Matrix color2pos = color2norm * norm2pos;
+ Geom::Matrix color2tpos = color2pos * gr->gradientTransform;
+ Geom::Matrix color2user = color2tpos * bbox2user;
color2px = color2user * full_transform;
} else {
/* Problem: What to do, if we have mixed lengths and percentages? */
/* Currently we do ignore percentages at all, but that is not good (lauris) */
- NR::Matrix norm2pos(NR::identity());
- NR::Matrix color2pos = color2norm * norm2pos;
- NR::Matrix color2tpos = color2pos * gr->gradientTransform;
+ Geom::Matrix norm2pos(Geom::identity());
+ Geom::Matrix color2pos = color2norm * norm2pos;
+ Geom::Matrix color2tpos = color2pos * gr->gradientTransform;
color2px = color2tpos * full_transform;
}
-
- NRMatrix v2px;
- color2px.copyto(&v2px);
-
- nr_lgradient_renderer_setup(&lgp->lgr, gr->color, sp_gradient_get_spread(gr), &v2px,
+ // TODO: remove color2px_nr after converting to 2geom
+ NR::Matrix color2px_nr = from_2geom(color2px);
+ nr_lgradient_renderer_setup(&lgp->lgr, gr->color, sp_gradient_get_spread(gr), &color2px_nr,
lg->x1.computed, lg->y1.computed,
lg->x2.computed, lg->y2.computed);
}
static void
-sp_lineargradient_painter_free(SPPaintServer *ps, SPPainter *painter)
+sp_lineargradient_painter_free(SPPaintServer */*ps*/, SPPainter *painter)
{
g_free(painter);
}
SPDocument *document,
Inkscape::XML::Node *repr);
static void sp_radialgradient_set(SPObject *object, unsigned key, gchar const *value);
-static Inkscape::XML::Node *sp_radialgradient_write(SPObject *object, Inkscape::XML::Node *repr,
+static Inkscape::XML::Node *sp_radialgradient_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr,
guint flags);
static SPPainter *sp_radialgradient_painter_new(SPPaintServer *ps,
- NR::Matrix const &full_transform,
- NR::Matrix const &parent_transform,
+ Geom::Matrix const &full_transform,
+ Geom::Matrix const &parent_transform,
NRRect const *bbox);
static void sp_radialgradient_painter_free(SPPaintServer *ps, SPPainter *painter);
* Write radial gradient attributes to associated repr.
*/
static Inkscape::XML::Node *
-sp_radialgradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
+sp_radialgradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
{
SPRadialGradient *rg = SP_RADIALGRADIENT(object);
if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
- Inkscape::XML::Document *xml_doc = sp_document_repr_doc(SP_OBJECT_DOCUMENT(object));
repr = xml_doc->createElement("svg:radialGradient");
}
@@ -1703,7 +1740,7 @@ sp_radialgradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags
if ((flags & SP_OBJECT_WRITE_ALL) || rg->fy._set) sp_repr_set_svg_double(repr, "fy", rg->fy.computed);
if (((SPObjectClass *) rg_parent_class)->write)
- (* ((SPObjectClass *) rg_parent_class)->write)(object, repr, flags);
+ (* ((SPObjectClass *) rg_parent_class)->write)(object, xml_doc, repr, flags);
return repr;
}
@@ -1713,8 +1750,8 @@ sp_radialgradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags
*/
static SPPainter *
sp_radialgradient_painter_new(SPPaintServer *ps,
- NR::Matrix const &full_transform,
- NR::Matrix const &parent_transform,
+ Geom::Matrix const &full_transform,
+ Geom::Matrix const &/*parent_transform*/,
NRRect const *bbox)
{
SPRadialGradient *rg = SP_RADIALGRADIENT(ps);
rgp->rg = rg;
- NR::Matrix gs2px;
+ Geom::Matrix gs2px;
if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
/** \todo
*/
/* BBox to user coordinate system */
- NR::Matrix bbox2user(bbox->x1 - bbox->x0, 0, 0, bbox->y1 - bbox->y0, bbox->x0, bbox->y0);
+ Geom::Matrix bbox2user(bbox->x1 - bbox->x0, 0, 0, bbox->y1 - bbox->y0, bbox->x0, bbox->y0);
- NR::Matrix gs2user = gr->gradientTransform * bbox2user;
+ Geom::Matrix gs2user = gr->gradientTransform * bbox2user;
gs2px = gs2user * full_transform;
} else {
gs2px = gr->gradientTransform * full_transform;
}
-
- NRMatrix gs2px_nr;
- gs2px.copyto(&gs2px_nr);
-
+ // TODO: remove gs2px_nr after converting to 2geom
+ NR::Matrix gs2px_nr = from_2geom(gs2px);
nr_rgradient_renderer_setup(&rgp->rgr, gr->color, sp_gradient_get_spread(gr),
&gs2px_nr,
rg->cx.computed, rg->cy.computed,
}
static void
-sp_radialgradient_painter_free(SPPaintServer *ps, SPPainter *painter)
+sp_radialgradient_painter_free(SPPaintServer */*ps*/, SPPainter *painter)
{
g_free(painter);
}