![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
diff --git a/src/sp-gradient.cpp b/src/sp-gradient.cpp
index db2360225c6c4b033e0115b7bd46602bfdaeb09e..1b8f9a11137a0e1e311200c2c00ca7ad97a81145 100644 (file)
--- a/src/sp-gradient.cpp
+++ b/src/sp-gradient.cpp
-#define __SP_GRADIENT_C__
-
/** \file
* SPGradient, SPStop, SPLinearGradient, SPRadialGradient.
*/
* Authors:
* Lauris Kaplinski <lauris@kaplinski.com>
* bulia byak <buliabyak@users.sf.net>
+ * Jasper van de Gronde <th.v.d.gronde@hccnet.nl>
+ * Jon A. Cruz <jon@joncruz.org>
+ * Abhishek Sharma
*
* Copyright (C) 1999-2002 Lauris Kaplinski
* Copyright (C) 2000-2001 Ximian, Inc.
* Copyright (C) 2004 David Turner
+ * Copyright (C) 2009 Jasper van de Gronde
*
* Released under GNU GPL, read the file 'COPYING' for more information
*
#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 "libnr/nr-pixops.h"
#include "svg/svg.h"
+#include "svg/svg-color.h"
#include "svg/css-ostringstream.h"
#include "attributes.h"
#include "document-private.h"
+#include "sp-gradient.h"
#include "gradient-chemistry.h"
#include "sp-gradient-reference.h"
#include "sp-linear-gradient.h"
#include "streq.h"
#include "uri.h"
#include "xml/repr.h"
+#include "style.h"
#define SP_MACROS_SILENT
#include "macros.h"
-/// Has to be power of 2
+/// Has to be power of 2
#define NCOLORS NR_GRADIENT_VECTOR_LENGTH
static void sp_stop_class_init(SPStopClass *klass);
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;
+class SPGradientImpl
+{
+ friend class SPGradient;
+
+ static void classInit(SPGradientClass *klass);
+
+ static void init(SPGradient *gr);
+ static void build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
+ static void release(SPObject *object);
+ static void modified(SPObject *object, guint flags);
+ static Inkscape::XML::Node *write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags);
+
+ static void gradientRefModified(SPObject *href, guint flags, SPGradient *gradient);
+ static void gradientRefChanged(SPObject *old_ref, SPObject *ref, SPGradient *gr);
+
+ static void childAdded(SPObject *object,
+ Inkscape::XML::Node *child,
+ Inkscape::XML::Node *ref);
+ static void removeChild(SPObject *object, Inkscape::XML::Node *child);
+
+ static void setGradientAttr(SPObject *object, unsigned key, gchar const *value);
+};
+
/**
* Registers SPStop class and returns its type.
*/
{
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;
}
@@ -113,10 +144,10 @@ static void sp_stop_build(SPObject *object, SPDocument *document, Inkscape::XML:
if (((SPObjectClass *) stop_parent_class)->build)
(* ((SPObjectClass *) stop_parent_class)->build)(object, document, repr);
- sp_object_read_attr(object, "offset");
- sp_object_read_attr(object, "stop-color");
- sp_object_read_attr(object, "stop-opacity");
- sp_object_read_attr(object, "style");
+ object->readAttr( "offset" );
+ object->readAttr( "stop-color" );
+ object->readAttr( "stop-opacity" );
+ object->readAttr( "style" );
}
/**
* We need presentation attributes etc.
* \par
* remove the hackish "style reading" from here: see comments in
- * sp_object_get_style_property about the bugs in our current
- * approach. However, note that SPStyle doesn't currently have
+ * sp_object_get_style_property about the bugs in our current
+ * approach. However, note that SPStyle doesn't currently have
* stop-color and stop-opacity properties.
*/
{
- gchar const *p = sp_object_get_style_property(object, "stop-color", "black");
+ gchar const *p = object->getStyleProperty( "stop-color", "black");
if (streq(p, "currentColor")) {
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 = SPStop::readStopColor( p );
}
}
{
- gchar const *p = sp_object_get_style_property(object, "stop-opacity", "1");
+ gchar const *p = object->getStyleProperty( "stop-opacity", "1");
gdouble opacity = sp_svg_read_percentage(p, stop->opacity);
stop->opacity = opacity;
}
}
case SP_PROP_STOP_COLOR: {
{
- gchar const *p = sp_object_get_style_property(object, "stop-color", "black");
+ gchar const *p = object->getStyleProperty( "stop-color", "black");
if (streq(p, "currentColor")) {
stop->currentColor = true;
} 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 = SPStop::readStopColor( p );
}
}
object->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
}
case SP_PROP_STOP_OPACITY: {
{
- gchar const *p = sp_object_get_style_property(object, "stop-opacity", "1");
+ gchar const *p = object->getStyleProperty( "stop-opacity", "1");
gdouble opacity = sp_svg_read_percentage(p, stop->opacity);
stop->opacity = opacity;
}
}
case SP_ATTR_OFFSET: {
stop->offset = sp_svg_read_percentage(value, 0.0);
- object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+ object->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
break;
}
default: {
* 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) {
- repr = sp_repr_new("svg:stop");
+ repr = xml_doc->createElement("svg:stop");
}
+ Glib::ustring colorStr = stop->specified_color.toString();
+ 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:";
if (stop->currentColor) {
os << "currentColor";
} else {
- gchar c[64];
- sp_svg_write_color(c, 64, sp_color_get_rgba32_ualpha(&stop->specified_color, 255));
- os << c;
+ os << colorStr;
}
- 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;
}
+
+bool SPGradient::hasStops() const
+{
+ return has_stops;
+}
+
+bool SPGradient::isUnitsSet() const
+{
+ return units_set;
+}
+
+SPGradientUnits SPGradient::getUnits() const
+{
+ return units;
+}
+
+bool SPGradient::isSpreadSet() const
+{
+ return spread_set;
+}
+
+SPGradientSpread SPGradient::getSpread() const
+{
+ return spread;
+}
+
+void SPGradient::setSwatch( bool swatch )
+{
+ if ( swatch != isSwatch() ) {
+ this->swatch = swatch; // to make isSolid() work, this happens first
+ gchar const* paintVal = swatch ? (isSolid() ? "solid" : "gradient") : 0;
+ setAttribute( "osb:paint", paintVal, 0 );
+
+ requestModified( SP_OBJECT_MODIFIED_FLAG );
+ }
+}
+
/**
* Return stop's color as 32bit value.
*/
* value depends on user agent, and don't give any further restrictions that I can
* see.) */
if (stop->currentColor) {
- char const *str = sp_object_get_style_property(stop, "color", NULL);
+ char const *str = stop->getStyleProperty( "color", NULL);
if (str) {
rgb0 = sp_svg_read_color(str, rgb0);
}
rgb0 | 0xff);
return rgb0 | alpha;
} else {
- return sp_color_get_rgba32_falpha(&stop->specified_color, stop->opacity);
- }
-}
-
-/**
- * Return stop's color as SPColor.
- */
-static SPColor
-sp_stop_get_color(SPStop const *const stop)
-{
- if (stop->currentColor) {
- char const *str = sp_object_get_style_property(stop, "color", NULL);
- guint32 const dfl = 0;
- /* Default value: arbitrarily black. (SVG1.1 and CSS2 both say that the initial
- * value depends on user agent, and don't give any further restrictions that I can
- * see.) */
- guint32 color = dfl;
- if (str) {
- color = sp_svg_read_color(str, dfl);
- }
- SPColor ret;
- sp_color_set_rgb_rgba32(&ret, color);
- return ret;
- } else {
- return stop->specified_color;
+ return stop->specified_color.toRGBA32( stop->opacity );
}
}
* Gradient
*/
-static void sp_gradient_class_init(SPGradientClass *klass);
-static void sp_gradient_init(SPGradient *gr);
-
-static void sp_gradient_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
-static void sp_gradient_release(SPObject *object);
-static void sp_gradient_set(SPObject *object, unsigned key, gchar const *value);
-static void sp_gradient_child_added(SPObject *object,
- Inkscape::XML::Node *child,
- 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,
- guint flags);
-
-static void gradient_ref_modified(SPObject *href, guint flags, SPGradient *gradient);
-
-static bool sp_gradient_invalidate_vector(SPGradient *gr);
-static void sp_gradient_rebuild_vector(SPGradient *gr);
-
-static void gradient_ref_changed(SPObject *old_ref, SPObject *ref, SPGradient *gradient);
-
static SPPaintServerClass *gradient_parent_class;
/**
* Registers SPGradient class and returns its type.
*/
-GType
-sp_gradient_get_type()
+GType SPGradient::getType()
{
static GType gradient_type = 0;
if (!gradient_type) {
GTypeInfo gradient_info = {
sizeof(SPGradientClass),
NULL, NULL,
- (GClassInitFunc) sp_gradient_class_init,
+ (GClassInitFunc) SPGradientImpl::classInit,
NULL, NULL,
sizeof(SPGradient),
16,
- (GInstanceInitFunc) sp_gradient_init,
+ (GInstanceInitFunc) SPGradientImpl::init,
NULL, /* value_table */
};
gradient_type = g_type_register_static(SP_TYPE_PAINT_SERVER, "SPGradient",
/**
* SPGradient vtable initialization.
*/
-static void
-sp_gradient_class_init(SPGradientClass *klass)
+void SPGradientImpl::classInit(SPGradientClass *klass)
{
SPObjectClass *sp_object_class = (SPObjectClass *) klass;
gradient_parent_class = (SPPaintServerClass *)g_type_class_ref(SP_TYPE_PAINT_SERVER);
- sp_object_class->build = sp_gradient_build;
- sp_object_class->release = sp_gradient_release;
- sp_object_class->set = sp_gradient_set;
- sp_object_class->child_added = sp_gradient_child_added;
- sp_object_class->remove_child = sp_gradient_remove_child;
- sp_object_class->modified = sp_gradient_modified;
- sp_object_class->write = sp_gradient_write;
+ sp_object_class->build = SPGradientImpl::build;
+ sp_object_class->release = SPGradientImpl::release;
+ sp_object_class->set = SPGradientImpl::setGradientAttr;
+ sp_object_class->child_added = SPGradientImpl::childAdded;
+ sp_object_class->remove_child = SPGradientImpl::removeChild;
+ sp_object_class->modified = SPGradientImpl::modified;
+ sp_object_class->write = SPGradientImpl::write;
}
/**
* Callback for SPGradient object initialization.
*/
-static void
-sp_gradient_init(SPGradient *gr)
+void SPGradientImpl::init(SPGradient *gr)
{
gr->ref = new SPGradientReference(SP_OBJECT(gr));
- gr->ref->changedSignal().connect(sigc::bind(sigc::ptr_fun(gradient_ref_changed), gr));
+ gr->ref->changedSignal().connect(sigc::bind(sigc::ptr_fun(SPGradientImpl::gradientRefChanged), gr));
/** \todo
* Fixme: reprs being rearranged (e.g. via the XML editor)
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;
gr->vector.stops.clear();
gr->color = NULL;
+
+ new (&gr->modified_connection) sigc::connection();
}
/**
* Virtual build: set gradient attributes from its associated repr.
*/
-static void
-sp_gradient_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
+void SPGradientImpl::build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
{
SPGradient *gradient = SP_GRADIENT(object);
- if (((SPObjectClass *) gradient_parent_class)->build)
+ // Work-around in case a swatch had been marked for immediate collection:
+ if ( repr->attribute("osb:paint") && repr->attribute("inkscape:collect") ) {
+ repr->setAttribute("inkscape:collect", 0);
+ }
+
+ if (((SPObjectClass *) gradient_parent_class)->build) {
(* ((SPObjectClass *) gradient_parent_class)->build)(object, document, repr);
+ }
- SPObject *ochild;
- for ( ochild = sp_object_first_child(object) ; ochild ; ochild = SP_OBJECT_NEXT(ochild) ) {
+ for ( SPObject *ochild = object->firstChild() ; ochild ; ochild = ochild->getNext() ) {
if (SP_IS_STOP(ochild)) {
gradient->has_stops = TRUE;
break;
}
}
- sp_object_read_attr(object, "gradientUnits");
- sp_object_read_attr(object, "gradientTransform");
- sp_object_read_attr(object, "spreadMethod");
- sp_object_read_attr(object, "xlink:href");
+ object->readAttr( "gradientUnits" );
+ object->readAttr( "gradientTransform" );
+ object->readAttr( "spreadMethod" );
+ object->readAttr( "xlink:href" );
+ object->readAttr( "osb:paint" );
- /* Register ourselves */
- sp_document_add_resource(document, "gradient", object);
+ // Register ourselves
+ document->addResource("gradient", object);
}
/**
* Virtual release of SPGradient members before destruction.
*/
-static void
-sp_gradient_release(SPObject *object)
+void SPGradientImpl::release(SPObject *object)
{
SPGradient *gradient = (SPGradient *) object;
#ifdef SP_GRADIENT_VERBOSE
- g_print("Releasing gradient %s\n", SP_OBJECT_ID(object));
+ g_print("Releasing gradient %s\n", object->getId());
#endif
if (SP_OBJECT_DOCUMENT(object)) {
/* Unregister ourselves */
- sp_document_remove_resource(SP_OBJECT_DOCUMENT(object), "gradient", SP_OBJECT(object));
+ SP_OBJECT_DOCUMENT(object)->removeResource("gradient", SP_OBJECT(object));
}
if (gradient->ref) {
- if (gradient->ref->getObject()) {
- sp_signal_disconnect_by_data(gradient->ref->getObject(), gradient);
- }
+ gradient->modified_connection.disconnect();
gradient->ref->detach();
delete gradient->ref;
gradient->ref = NULL;
gradient->color = NULL;
}
+ gradient->modified_connection.~connection();
+
if (((SPObjectClass *) gradient_parent_class)->release)
((SPObjectClass *) gradient_parent_class)->release(object);
}
/**
* Set gradient attribute to value.
*/
-static void
-sp_gradient_set(SPObject *object, unsigned key, gchar const *value)
+void SPGradientImpl::setGradientAttr(SPObject *object, unsigned key, gchar const *value)
{
SPGradient *gr = SP_GRADIENT(object);
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->ref->detach();
}
break;
+ case SP_ATTR_OSB_SWATCH:
+ {
+ bool newVal = (value != 0);
+ bool modified = false;
+ if (newVal != gr->swatch) {
+ gr->swatch = newVal;
+ modified = true;
+ }
+ if (newVal) {
+ // Might need to flip solid/gradient
+ Glib::ustring paintVal = ( gr->hasStops() && (gr->getStopCount() == 0) ) ? "solid" : "gradient";
+ if ( paintVal != value ) {
+ gr->setAttribute( "osb:paint", paintVal.c_str(), 0 );
+ modified = true;
+ }
+ }
+ if (modified) {
+ object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+ }
+ }
+ break;
default:
- if (((SPObjectClass *) gradient_parent_class)->set)
+ if (((SPObjectClass *) gradient_parent_class)->set) {
((SPObjectClass *) gradient_parent_class)->set(object, key, value);
+ }
break;
}
}
/**
* Gets called when the gradient is (re)attached to another gradient.
*/
-static void
-gradient_ref_changed(SPObject *old_ref, SPObject *ref, SPGradient *gr)
+void SPGradientImpl::gradientRefChanged(SPObject *old_ref, SPObject *ref, SPGradient *gr)
{
if (old_ref) {
- sp_signal_disconnect_by_data(old_ref, gr);
+ gr->modified_connection.disconnect();
}
if ( SP_IS_GRADIENT(ref)
&& ref != gr )
{
- g_signal_connect(G_OBJECT(ref), "modified", G_CALLBACK(gradient_ref_modified), gr);
+ gr->modified_connection = ref->connectModified(sigc::bind<2>(sigc::ptr_fun(&SPGradientImpl::gradientRefModified), 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 = gr->fetchUnits();
+ }
+ if (!gr->spread_set) {
+ gr->spread = gr->fetchSpread();
}
+
/// \todo Fixme: what should the flags (second) argument be? */
- gradient_ref_modified(ref, 0, gr);
+ gradientRefModified(ref, 0, gr);
}
/**
* Callback for child_added event.
*/
-static void
-sp_gradient_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
+void SPGradientImpl::childAdded(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
{
SPGradient *gr = SP_GRADIENT(object);
- sp_gradient_invalidate_vector(gr);
+ gr->invalidateVector();
- if (((SPObjectClass *) gradient_parent_class)->child_added)
+ if (((SPObjectClass *) gradient_parent_class)->child_added) {
(* ((SPObjectClass *) gradient_parent_class)->child_added)(object, child, ref);
+ }
- SPObject *ochild = sp_object_get_child_by_repr(object, child);
+ SPObject *ochild = object->get_child_by_repr(child);
if ( ochild && SP_IS_STOP(ochild) ) {
gr->has_stops = TRUE;
+ if ( gr->getStopCount() > 0 ) {
+ gchar const * attr = gr->getAttribute("osb:paint");
+ if ( attr && strcmp(attr, "gradient") ) {
+ gr->setAttribute( "osb:paint", "gradient", 0 );
+ }
+ }
}
/// \todo Fixme: should we schedule "modified" here?
@@ -553,25 +620,31 @@ sp_gradient_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::
/**
* Callback for remove_child event.
*/
-static void
-sp_gradient_remove_child(SPObject *object, Inkscape::XML::Node *child)
+void SPGradientImpl::removeChild(SPObject *object, Inkscape::XML::Node *child)
{
SPGradient *gr = SP_GRADIENT(object);
- sp_gradient_invalidate_vector(gr);
+ gr->invalidateVector();
- if (((SPObjectClass *) gradient_parent_class)->remove_child)
+ if (((SPObjectClass *) gradient_parent_class)->remove_child) {
(* ((SPObjectClass *) gradient_parent_class)->remove_child)(object, child);
+ }
gr->has_stops = FALSE;
- SPObject *ochild;
- for ( ochild = sp_object_first_child(object) ; ochild ; ochild = SP_OBJECT_NEXT(ochild) ) {
+ for ( SPObject *ochild = object->firstChild() ; ochild ; ochild = ochild->getNext() ) {
if (SP_IS_STOP(ochild)) {
gr->has_stops = TRUE;
break;
}
}
+ if ( gr->getStopCount() == 0 ) {
+ gchar const * attr = gr->getAttribute("osb:paint");
+ if ( attr && strcmp(attr, "solid") ) {
+ gr->setAttribute( "osb:paint", "solid", 0 );
+ }
+ }
+
/* Fixme: should we schedule "modified" here? */
object->requestModified(SP_OBJECT_MODIFIED_FLAG);
}
/**
* Callback for modified event.
*/
-static void
-sp_gradient_modified(SPObject *object, guint flags)
+void SPGradientImpl::modified(SPObject *object, guint flags)
{
SPGradient *gr = SP_GRADIENT(object);
if (flags & SP_OBJECT_CHILD_MODIFIED_FLAG) {
- sp_gradient_invalidate_vector(gr);
+ gr->invalidateVector();
+ }
+
+ if (flags & SP_OBJECT_STYLE_MODIFIED_FLAG) {
+ gr->ensureColors();
}
if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
// FIXME: climb up the ladder of hrefs
GSList *l = NULL;
- for (SPObject *child = sp_object_first_child(object) ; child != NULL; child = SP_OBJECT_NEXT(child) ) {
+ for (SPObject *child = object->firstChild() ; child; child = child->getNext() ) {
g_object_ref(G_OBJECT(child));
l = g_slist_prepend(l, child);
}
}
}
+SPStop* SPGradient::getFirstStop()
+{
+ SPStop* first = 0;
+ for (SPObject *ochild = firstChild(); ochild && !first; ochild = ochild->getNext()) {
+ if (SP_IS_STOP(ochild)) {
+ first = SP_STOP(ochild);
+ }
+ }
+ return first;
+}
+
+int SPGradient::getStopCount() const
+{
+ int count = 0;
+
+ for (SPStop *stop = const_cast<SPGradient*>(this)->getFirstStop(); stop && stop->getNextStop(); stop = stop->getNextStop()) {
+ count++;
+ }
+
+ return count;
+}
+
/**
* Write gradient attributes to repr.
*/
-static Inkscape::XML::Node *
-sp_gradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
+Inkscape::XML::Node *SPGradientImpl::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);
+ if (((SPObjectClass *) gradient_parent_class)->write) {
+ (* ((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);
- if (crepr) l = g_slist_prepend(l, crepr);
+ for (SPObject *child = object->firstChild(); child; child = child->getNext()) {
+ Inkscape::XML::Node *crepr = child->updateRepr(xml_doc, NULL, flags);
+ if (crepr) {
+ l = g_slist_prepend(l, crepr);
+ }
}
while (l) {
repr->addChild((Inkscape::XML::Node *) l->data, NULL);
}
if ((flags & SP_OBJECT_WRITE_ALL) || gr->gradientTransform_set) {
- gchar c[256];
- if (sp_svg_transform_write(c, 256, gr->gradientTransform)) {
- repr->setAttribute("gradientTransform", c);
- } else {
- repr->setAttribute("gradientTransform", NULL);
- }
+ gchar *c=sp_svg_transform_write(gr->gradientTransform);
+ repr->setAttribute("gradientTransform", c);
+ g_free(c);
}
if ((flags & SP_OBJECT_WRITE_ALL) || gr->spread_set) {
/* FIXME: Ensure that gr->spread is the inherited value
- * if !gr->spread_set. Not currently happening: see sp_gradient_modified.
+ * if !gr->spread_set. Not currently happening: see SPGradient::modified.
*/
switch (gr->spread) {
case SP_GRADIENT_SPREAD_REFLECT:
}
}
+ if ( (flags & SP_OBJECT_WRITE_EXT) && gr->isSwatch() ) {
+ if ( gr->isSolid() ) {
+ repr->setAttribute( "osb:paint", "solid" );
+ } else {
+ repr->setAttribute( "osb:paint", "gradient" );
+ }
+ } else {
+ repr->setAttribute( "osb:paint", 0 );
+ }
+
return repr;
}
*
* \pre SP_IS_GRADIENT(gradient).
*/
-void
-sp_gradient_ensure_vector(SPGradient *gradient)
+void SPGradient::ensureVector()
{
- g_return_if_fail(gradient != NULL);
- g_return_if_fail(SP_IS_GRADIENT(gradient));
-
- if (!gradient->vector.built) {
- sp_gradient_rebuild_vector(gradient);
+ if ( !vector.built ) {
+ rebuildVector();
}
}
/**
* Set units property of gradient and emit modified.
*/
-void
-sp_gradient_set_units(SPGradient *gr, SPGradientUnits units)
+void SPGradient::setUnits(SPGradientUnits units)
{
- if (units != gr->units) {
- gr->units = units;
- gr->units_set = TRUE;
- SP_OBJECT(gr)->requestModified(SP_OBJECT_MODIFIED_FLAG);
+ if (units != this->units) {
+ this->units = units;
+ units_set = TRUE;
+ requestModified(SP_OBJECT_MODIFIED_FLAG);
}
}
/**
* Set spread property of gradient and emit modified.
*/
-void
-sp_gradient_set_spread(SPGradient *gr, SPGradientSpread spread)
+void SPGradient::setSpread(SPGradientSpread spread)
{
- if (spread != gr->spread) {
- gr->spread = spread;
- gr->spread_set = TRUE;
- SP_OBJECT(gr)->requestModified(SP_OBJECT_MODIFIED_FLAG);
+ if (spread != this->spread) {
+ this->spread = spread;
+ spread_set = TRUE;
+ requestModified(SP_OBJECT_MODIFIED_FLAG);
}
}
/**
* True if gradient has stops.
*/
-static bool
-has_stops(SPGradient const *gr)
+static bool has_stopsFN(SPGradient const *gr)
{
- return SP_GRADIENT_HAS_STOPS(gr);
+ return gr->hasStops();
}
/**
* True if gradient has spread set.
*/
-static bool
-has_spread_set(SPGradient const *gr)
+static bool has_spread_set(SPGradient const *gr)
{
- return gr->spread_set;
+ return gr->isSpreadSet();
}
-
/**
- * Returns private vector of given gradient (the gradient at the end of the href chain which has
- * stops), optionally normalizing it.
- *
- * \pre SP_IS_GRADIENT(gradient).
- * \pre There exists a gradient in the chain that has stops.
+ * True if gradient has units set.
*/
-SPGradient *
-sp_gradient_get_vector(SPGradient *gradient, bool force_vector)
+static bool
+has_units_set(SPGradient const *gr)
{
- g_return_val_if_fail(gradient != NULL, NULL);
- g_return_val_if_fail(SP_IS_GRADIENT(gradient), NULL);
+ return gr->isUnitsSet();
+}
+
- SPGradient *const src = chase_hrefs(gradient, has_stops);
- return ( force_vector
- ? sp_gradient_ensure_vector_normalized(src)
- : src );
+SPGradient *SPGradient::getVector(bool force_vector)
+{
+ SPGradient * src = chase_hrefs(this, has_stopsFN);
+
+ if (force_vector) {
+ src = sp_gradient_ensure_vector_normalized(src);
+ }
+ return src;
}
/**
*
* \pre SP_IS_GRADIENT(gradient).
*/
-SPGradientSpread
-sp_gradient_get_spread(SPGradient *gradient)
+SPGradientSpread SPGradient::fetchSpread()
{
- g_return_val_if_fail(SP_IS_GRADIENT(gradient), SP_GRADIENT_SPREAD_PAD);
-
- SPGradient const *src = chase_hrefs(gradient, has_spread_set);
+ SPGradient const *src = chase_hrefs(this, has_spread_set);
return ( src
? src->spread
: 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 SPGradient::fetchUnits()
+{
+ SPGradient const *src = chase_hrefs(this, 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.
*/
}
/**
- * Writes the gradient's internal vector (whether from its own stops, or
+ * Writes the gradient's internal vector (whether from its own stops, or
* inherited from refs) into the gradient repr as svg:stop elements.
*/
void
g_return_if_fail(gr != NULL);
g_return_if_fail(SP_IS_GRADIENT(gr));
+ Inkscape::XML::Document *xml_doc = SP_OBJECT_DOCUMENT(gr)->getReprDoc();
Inkscape::XML::Node *repr = SP_OBJECT_REPR(gr);
/* We have to be careful, as vector may be our own, so construct repr list at first */
for (guint i = 0; i < gr->vector.stops.size(); i++) {
Inkscape::CSSOStringStream os;
- Inkscape::XML::Node *child = sp_repr_new("svg:stop");
+ Inkscape::XML::Node *child = xml_doc->createElement("svg:stop");
sp_repr_set_css_double(child, "offset", gr->vector.stops[i].offset);
/* 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));
- os << "stop-color:" << c << ";stop-opacity:" << gr->vector.stops[i].opacity;
+ os << "stop-color:" << gr->vector.stops[i].color.toString() << ";stop-opacity:" << gr->vector.stops[i].opacity;
child->setAttribute("style", os.str().c_str());
/* Order will be reversed here */
cl = g_slist_prepend(cl, child);
}
-static void
-gradient_ref_modified(SPObject *href, guint flags, SPGradient *gradient)
+void SPGradientImpl::gradientRefModified(SPObject */*href*/, guint /*flags*/, SPGradient *gradient)
{
- if (sp_gradient_invalidate_vector(gradient)) {
+ if ( gradient->invalidateVector() ) {
SP_OBJECT(gradient)->requestModified(SP_OBJECT_MODIFIED_FLAG);
- /* Conditional to avoid causing infinite loop if there's a cycle in the href chain. */
+ // Conditional to avoid causing infinite loop if there's a cycle in the href chain.
}
}
-/** Return true iff change made. */
-static bool
-sp_gradient_invalidate_vector(SPGradient *gr)
+/** Return true if change made. */
+bool SPGradient::invalidateVector()
{
bool ret = false;
- if (gr->color != NULL) {
- g_free(gr->color);
- gr->color = NULL;
+ if (color != NULL) {
+ g_free(color);
+ color = NULL;
ret = true;
}
- if (gr->vector.built) {
- gr->vector.built = false;
- gr->vector.stops.clear();
+ if (vector.built) {
+ vector.built = false;
+ vector.stops.clear();
ret = true;
}
}
/** Creates normalized color vector */
-static void
-sp_gradient_rebuild_vector(SPGradient *gr)
+void SPGradient::rebuildVector()
{
gint len = 0;
- for ( SPObject *child = sp_object_first_child(SP_OBJECT(gr)) ;
- child != NULL ;
- child = SP_OBJECT_NEXT(child) ) {
+ for ( SPObject *child = firstChild() ; child ; child = child->getNext() ) {
if (SP_IS_STOP(child)) {
len ++;
}
}
- gr->has_stops = (len != 0);
+ has_stops = (len != 0);
- gr->vector.stops.clear();
+ vector.stops.clear();
- SPGradient *ref = gr->ref->getObject();
- if ( !gr->has_stops && ref ) {
+ SPGradient *reffed = ref->getObject();
+ if ( !hasStops() && reffed ) {
/* Copy vector from referenced gradient */
- gr->vector.built = true; // Prevent infinite recursion.
- sp_gradient_ensure_vector(ref);
- if (!ref->vector.stops.empty()) {
- gr->vector.built = ref->vector.built;
- gr->vector.stops.assign(ref->vector.stops.begin(), ref->vector.stops.end());
+ vector.built = true; // Prevent infinite recursion.
+ reffed->ensureVector();
+ if (!reffed->vector.stops.empty()) {
+ vector.built = reffed->vector.built;
+ vector.stops.assign(reffed->vector.stops.begin(), reffed->vector.stops.end());
return;
}
}
- for (SPObject *child = sp_object_first_child(SP_OBJECT(gr)) ;
- child != NULL;
- child = SP_OBJECT_NEXT(child) ) {
+ for ( SPObject *child = firstChild(); child; child = child->getNext() ) {
if (SP_IS_STOP(child)) {
SPStop *stop = SP_STOP(child);
SPGradientStop gstop;
- if (gr->vector.stops.size() > 0) {
+ if (vector.stops.size() > 0) {
// "Each gradient offset value is required to be equal to or greater than the
// previous gradient stop's offset value. If a given gradient stop's offset
// value is not equal to or greater than all previous offset values, then the
// offset value is adjusted to be equal to the largest of all previous offset
// values."
- gstop.offset = MAX(stop->offset, gr->vector.stops.back().offset);
+ gstop.offset = MAX(stop->offset, vector.stops.back().offset);
} else {
gstop.offset = stop->offset;
}
// down to 100%."
gstop.offset = CLAMP(gstop.offset, 0, 1);
- gstop.color = sp_stop_get_color(stop);
+ gstop.color = stop->getEffectiveColor();
gstop.opacity = stop->opacity;
- gr->vector.stops.push_back(gstop);
+ vector.stops.push_back(gstop);
}
}
// Normalize per section 13.2.4 of SVG 1.1.
- if (gr->vector.stops.size() == 0) {
+ if (vector.stops.size() == 0) {
/* "If no stops are defined, then painting shall occur as if 'none' were specified as the
* paint style."
*/
{
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);
+ 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);
+ vector.stops.push_back(gstop);
}
} else {
/* "If one stop is defined, then paint with the solid color fill using the color defined
* for that gradient stop."
*/
- if (gr->vector.stops.front().offset > 0.0) {
+ if (vector.stops.front().offset > 0.0) {
// 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.opacity = gr->vector.stops.front().opacity;
- gr->vector.stops.insert(gr->vector.stops.begin(), gstop);
+ gstop.color = vector.stops.front().color;
+ gstop.opacity = vector.stops.front().opacity;
+ vector.stops.insert(vector.stops.begin(), gstop);
}
- if (gr->vector.stops.back().offset < 1.0) {
+ if (vector.stops.back().offset < 1.0) {
// 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.opacity = gr->vector.stops.back().opacity;
- gr->vector.stops.push_back(gstop);
+ gstop.color = vector.stops.back().color;
+ gstop.opacity = vector.stops.back().opacity;
+ vector.stops.push_back(gstop);
}
}
- gr->vector.built = true;
+ vector.built = true;
}
/**
* The gradient's color array is newly created and set up from vector.
*/
-void
-sp_gradient_ensure_colors(SPGradient *gr)
+void SPGradient::ensureColors()
{
- if (!gr->vector.built) {
- sp_gradient_rebuild_vector(gr);
+ if (!vector.built) {
+ rebuildVector();
}
- g_return_if_fail(!gr->vector.stops.empty());
+ g_return_if_fail(!vector.stops.empty());
/// \todo Where is the memory freed?
- if (!gr->color) {
- gr->color = g_new(guchar, 4 * NCOLORS);
- }
-
- 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);
- 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);
- gint r1 = (color >> 24) & 0xff;
- gint g1 = (color >> 16) & 0xff;
- gint b1 = (color >> 8) & 0xff;
- gint a1 = color & 0xff;
- gint o0 = (gint) floor(gr->vector.stops[i].offset * (NCOLORS - 0.001));
- gint o1 = (gint) floor(gr->vector.stops[i + 1].offset * (NCOLORS - 0.001));
- if (o1 > o0) {
- gint dr = ((r1 - r0) << 16) / (o1 - o0);
- gint dg = ((g1 - g0) << 16) / (o1 - o0);
- gint db = ((b1 - b0) << 16) / (o1 - o0);
- gint da = ((a1 - a0) << 16) / (o1 - o0);
- gint r = r0 << 16;
- gint g = g0 << 16;
- gint b = b0 << 16;
- gint a = a0 << 16;
- for (int j = o0; j < o1 + 1; j++) {
- gr->color[4 * j] = r >> 16;
- gr->color[4 * j + 1] = g >> 16;
- gr->color[4 * j + 2] = b >> 16;
- gr->color[4 * j + 3] = a >> 16;
- r += dr;
- g += dg;
- b += db;
- a += da;
+ if (!color) {
+ color = g_new(guchar, 4 * NCOLORS);
+ }
+
+ // This assumes that vector is a zero-order B-spline (box function) approximation of the "true" gradient.
+ // This means that the "true" gradient must be prefiltered using a zero order B-spline and then sampled.
+ // Furthermore, the first element corresponds to offset="0" and the last element to offset="1".
+
+ double remainder[4] = {0,0,0,0};
+ double remainder_for_end[4] = {0,0,0,0}; // Used at the end
+ switch(spread) {
+ case SP_GRADIENT_SPREAD_PAD:
+ remainder[0] = 0.5*vector.stops[0].color.v.c[0]; // Half of the first cell uses the color of the first stop
+ remainder[1] = 0.5*vector.stops[0].color.v.c[1];
+ remainder[2] = 0.5*vector.stops[0].color.v.c[2];
+ remainder[3] = 0.5*vector.stops[0].opacity;
+ remainder_for_end[0] = 0.5*vector.stops[vector.stops.size() - 1].color.v.c[0]; // Half of the first cell uses the color of the last stop
+ remainder_for_end[1] = 0.5*vector.stops[vector.stops.size() - 1].color.v.c[1];
+ remainder_for_end[2] = 0.5*vector.stops[vector.stops.size() - 1].color.v.c[2];
+ remainder_for_end[3] = 0.5*vector.stops[vector.stops.size() - 1].opacity;
+ break;
+ case SP_GRADIENT_SPREAD_REFLECT:
+ case SP_GRADIENT_SPREAD_REPEAT:
+ // These two are handled differently, see below.
+ break;
+ default:
+ g_error("Spread type not supported!");
+ };
+ for (unsigned int i = 0; i < vector.stops.size() - 1; i++) {
+ double r0 = vector.stops[i].color.v.c[0];
+ double g0 = vector.stops[i].color.v.c[1];
+ double b0 = vector.stops[i].color.v.c[2];
+ double a0 = vector.stops[i].opacity;
+ double r1 = vector.stops[i+1].color.v.c[0];
+ double g1 = vector.stops[i+1].color.v.c[1];
+ double b1 = vector.stops[i+1].color.v.c[2];
+ double a1 = vector.stops[i+1].opacity;
+ double o0 = vector.stops[i].offset * (NCOLORS-1);
+ double o1 = vector.stops[i + 1].offset * (NCOLORS-1);
+ unsigned int ob = (unsigned int) floor(o0+.5); // These are the first and last element that might be affected by this interval.
+ 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
+
+ if (oe == ob) {
+ // Simple case, this interval starts and stops within one cell
+ // The contribution of this interval is:
+ // (o1-o0)*(c(o0)+c(o1))/2
+ // = (o1-o0)*(c0+c1)/2
+ double dt = 0.5*(o1-o0);
+ remainder[0] += dt*(r0 + r1);
+ remainder[1] += dt*(g0 + g1);
+ remainder[2] += dt*(b0 + b1);
+ remainder[3] += dt*(a0 + a1);
+ } else {
+ // First compute colors for the cells which are fully covered by the current interval.
+ // The prefiltered values are equal to the midpoint of each cell here.
+ // f = (j-o0)/(o1-o0)
+ // = j*(1/(o1-o0)) - o0/(o1-o0)
+ double f = (ob-o0) / (o1-o0);
+ double df = 1. / (o1-o0);
+ for (unsigned int j = ob+1; j < oe; j++) {
+ f += df;
+ color[4 * j + 0] = (unsigned char) floor(255*(r0 + f*(r1-r0)) + .5);
+ color[4 * j + 1] = (unsigned char) floor(255*(g0 + f*(g1-g0)) + .5);
+ color[4 * j + 2] = (unsigned char) floor(255*(b0 + f*(b1-b0)) + .5);
+ color[4 * j + 3] = (unsigned char) floor(255*(a0 + f*(a1-a0)) + .5);
+ }
+
+ // Now handle the beginning
+ // The contribution of the last point is already in remainder.
+ // The contribution of this point is:
+ // (ob+.5-o0)*(c(o0)+c(ob+.5))/2
+ // = (ob+.5-o0)*c((o0+ob+.5)/2)
+ // = (ob+.5-o0)*(c0+((o0+ob+.5)/2-o0)*df*(c1-c0))
+ // = (ob+.5-o0)*(c0+(ob+.5-o0)*df*(c1-c0)/2)
+ double dt = ob+.5-o0;
+ f = 0.5*dt*df;
+ if (ob==0 && spread==SP_GRADIENT_SPREAD_REFLECT) {
+ // The first half of the first cell is just a mirror image of the second half, so simply multiply it by 2.
+ color[4 * ob + 0] = (unsigned char) floor(2*255*(remainder[0] + dt*(r0 + f*(r1-r0))) + .5);
+ color[4 * ob + 1] = (unsigned char) floor(2*255*(remainder[1] + dt*(g0 + f*(g1-g0))) + .5);
+ color[4 * ob + 2] = (unsigned char) floor(2*255*(remainder[2] + dt*(b0 + f*(b1-b0))) + .5);
+ color[4 * ob + 3] = (unsigned char) floor(2*255*(remainder[3] + dt*(a0 + f*(a1-a0))) + .5);
+ } else if (ob==0 && spread==SP_GRADIENT_SPREAD_REPEAT) {
+ // 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.
+ remainder_for_end[0] = remainder[0] + dt*(r0 + f*(r1-r0));
+ remainder_for_end[1] = remainder[1] + dt*(g0 + f*(g1-g0));
+ remainder_for_end[2] = remainder[2] + dt*(b0 + f*(b1-b0));
+ remainder_for_end[3] = remainder[3] + dt*(a0 + f*(a1-a0));
+ } else {
+ // The first half of the cell was already in remainder.
+ color[4 * ob + 0] = (unsigned char) floor(255*(remainder[0] + dt*(r0 + f*(r1-r0))) + .5);
+ color[4 * ob + 1] = (unsigned char) floor(255*(remainder[1] + dt*(g0 + f*(g1-g0))) + .5);
+ color[4 * ob + 2] = (unsigned char) floor(255*(remainder[2] + dt*(b0 + f*(b1-b0))) + .5);
+ color[4 * ob + 3] = (unsigned char) floor(255*(remainder[3] + dt*(a0 + f*(a1-a0))) + .5);
}
+
+ // Now handle the end, which should end up in remainder
+ // The contribution of this point is:
+ // (o1-oe+.5)*(c(o1)+c(oe-.5))/2
+ // = (o1-oe+.5)*c((o1+oe-.5)/2)
+ // = (o1-oe+.5)*(c0+((o1+oe-.5)/2-o0)*df*(c1-c0))
+ dt = o1-oe+.5;
+ f = (0.5*(o1+oe-.5)-o0)*df;
+ remainder[0] = dt*(r0 + f*(r1-r0));
+ remainder[1] = dt*(g0 + f*(g1-g0));
+ remainder[2] = dt*(b0 + f*(b1-b0));
+ remainder[3] = dt*(a0 + f*(a1-a0));
}
}
+ switch(spread) {
+ case SP_GRADIENT_SPREAD_PAD:
+ color[4 * (NCOLORS-1) + 0] = (unsigned char) floor(255*(remainder[0]+remainder_for_end[0]) + .5);
+ color[4 * (NCOLORS-1) + 1] = (unsigned char) floor(255*(remainder[1]+remainder_for_end[1]) + .5);
+ color[4 * (NCOLORS-1) + 2] = (unsigned char) floor(255*(remainder[2]+remainder_for_end[2]) + .5);
+ color[4 * (NCOLORS-1) + 3] = (unsigned char) floor(255*(remainder[3]+remainder_for_end[3]) + .5);
+ break;
+ case SP_GRADIENT_SPREAD_REFLECT:
+ // The second half is the same as the first half, so multiply by 2.
+ color[4 * (NCOLORS-1) + 0] = (unsigned char) floor(2*255*remainder[0] + .5);
+ color[4 * (NCOLORS-1) + 1] = (unsigned char) floor(2*255*remainder[1] + .5);
+ color[4 * (NCOLORS-1) + 2] = (unsigned char) floor(2*255*remainder[2] + .5);
+ color[4 * (NCOLORS-1) + 3] = (unsigned char) floor(2*255*remainder[3] + .5);
+ break;
+ case SP_GRADIENT_SPREAD_REPEAT:
+ // The second half is the same as the second half of the first cell (which was saved in remainder_for_end).
+ color[0] = color[4 * (NCOLORS-1) + 0] = (unsigned char) floor(255*(remainder[0]+remainder_for_end[0]) + .5);
+ color[1] = color[4 * (NCOLORS-1) + 1] = (unsigned char) floor(255*(remainder[1]+remainder_for_end[1]) + .5);
+ color[2] = color[4 * (NCOLORS-1) + 2] = (unsigned char) floor(255*(remainder[2]+remainder_for_end[2]) + .5);
+ color[3] = color[4 * (NCOLORS-1) + 3] = (unsigned char) floor(255*(remainder[3]+remainder_for_end[3]) + .5);
+ break;
+ }
}
/**
* Renders gradient vector to buffer as line.
- *
+ *
* RGB buffer background should be set up beforehand.
*
* @param len,width,height,rowstride Buffer parameters (1 or 2 dimensional).
g_return_if_fail(span > 0);
if (!gradient->color) {
- sp_gradient_ensure_colors(gradient);
+ gradient->ensureColors();
}
gint idx = (pos * 1024 << 8) / span;
@@ -1149,10 +1340,10 @@ sp_gradient_render_vector_block_rgba(SPGradient *const gradient, guchar *buf,
/**
* Render rectangular RGB area from gradient vector.
- */
+ */
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 );
+ if (gr->getUnits() == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
+ 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) {
+ if (gr->getUnits() == 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->getUnits() == 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;
SPLinearGradient *lg;
NRLGradientRenderer lgr;
+
+ static SPPainter * painter_new(SPPaintServer *ps,
+ Geom::Matrix const &full_transform,
+ Geom::Matrix const &parent_transform,
+ NRRect const *bbox);
};
static void sp_lineargradient_class_init(SPLinearGradientClass *klass);
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,
- NRRect const *bbox);
static void sp_lineargradient_painter_free(SPPaintServer *ps, SPPainter *painter);
static void sp_lg_fill(SPPainter *painter, NRPixBlock *pb);
sp_object_class->set = sp_lineargradient_set;
sp_object_class->write = sp_lineargradient_write;
- ps_class->painter_new = sp_lineargradient_painter_new;
+ ps_class->painter_new = SPLGPainter::painter_new;
ps_class->painter_free = sp_lineargradient_painter_free;
}
static void sp_lineargradient_init(SPLinearGradient *lg)
{
lg->x1.unset(SVGLength::PERCENT, 0.0, 0.0);
- lg->y1.unset(SVGLength::PERCENT, 0.5, 0.5);
+ lg->y1.unset(SVGLength::PERCENT, 0.0, 0.0);
lg->x2.unset(SVGLength::PERCENT, 1.0, 1.0);
- lg->y2.unset(SVGLength::PERCENT, 0.5, 0.5);
+ lg->y2.unset(SVGLength::PERCENT, 0.0, 0.0);
}
/**
if (((SPObjectClass *) lg_parent_class)->build)
(* ((SPObjectClass *) lg_parent_class)->build)(object, document, repr);
- sp_object_read_attr(object, "x1");
- sp_object_read_attr(object, "y1");
- sp_object_read_attr(object, "x2");
- sp_object_read_attr(object, "y2");
+ object->readAttr( "x1" );
+ object->readAttr( "y1" );
+ object->readAttr( "x2" );
+ object->readAttr( "y2" );
}
/**
object->requestModified(SP_OBJECT_MODIFIED_FLAG);
break;
case SP_ATTR_Y1:
- lg->y1.readOrUnset(value, SVGLength::PERCENT, 0.5, 0.5);
+ lg->y1.readOrUnset(value, SVGLength::PERCENT, 0.0, 0.0);
object->requestModified(SP_OBJECT_MODIFIED_FLAG);
break;
case SP_ATTR_X2:
object->requestModified(SP_OBJECT_MODIFIED_FLAG);
break;
case SP_ATTR_Y2:
- lg->y2.readOrUnset(value, SVGLength::PERCENT, 0.5, 0.5);
+ lg->y2.readOrUnset(value, SVGLength::PERCENT, 0.0, 0.0);
object->requestModified(SP_OBJECT_MODIFIED_FLAG);
break;
default:
* 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) {
- repr = sp_repr_new("svg:linearGradient");
+ repr = xml_doc->createElement("svg:linearGradient");
}
if ((flags & SP_OBJECT_WRITE_ALL) || lg->x1._set)
@@ -1395,14 +1587,14 @@ 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;
}
/**
* Create linear gradient context.
- *
+ *
* Basically we have to deal with transformations
*
* 1) color2norm - maps point in (0,NCOLORS) vector to (0,1) vector
@@ -1410,22 +1602,23 @@ sp_lineargradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags
* 2) gradientTransform
* 3) bbox2user
* 4) ctm == userspace to pixel grid
- *
+ *
* See also (*) in sp-pattern about why we may need parent_transform.
- *
- * \todo (point 1 above) fixme: I do not know how to deal with start > 0
+ *
+ * \todo (point 1 above) fixme: I do not know how to deal with start > 0
* and end < 1.
*/
-static SPPainter *
-sp_lineargradient_painter_new(SPPaintServer *ps,
- NR::Matrix const &full_transform,
- NR::Matrix const &parent_transform,
- NRRect const *bbox)
+SPPainter * SPLGPainter::painter_new(SPPaintServer *ps,
+ Geom::Matrix const &full_transform,
+ Geom::Matrix const &/*parent_transform*/,
+ NRRect const *bbox)
{
SPLinearGradient *lg = SP_LINEARGRADIENT(ps);
SPGradient *gr = SP_GRADIENT(ps);
- if (!gr->color) sp_gradient_ensure_colors(gr);
+ if (!gr->color) {
+ gr->ensureColors();
+ }
SPLGPainter *lgp = g_new(SPLGPainter, 1);
lgp->lg = lg;
/** \todo
- * Technically speaking, we map NCOLORS on line [start,end] onto line
- * [0,1]. I almost think we should fill color array start and end in
- * that case. The alternative would be to leave these just empty garbage
- * or something similar. Originally I had 1023.9999 here - not sure
+ * Technically speaking, we map NCOLORS on line [start,end] onto line
+ * [0,1]. I almost think we should fill color array start and end in
+ * that case. The alternative would be to leave these just empty garbage
+ * 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, gr->fetchSpread(), &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);
}
SPLGPainter *lgp = (SPLGPainter *) painter;
if (lgp->lg->color == NULL) {
- sp_gradient_ensure_colors (lgp->lg);
+ lgp->lg->ensureColors();
lgp->lgr.vector = lgp->lg->color;
}
SPPainter painter;
SPRadialGradient *rg;
NRRGradientRenderer rgr;
+
+ static SPPainter *painter_new(SPPaintServer *ps,
+ Geom::Matrix const &full_transform,
+ Geom::Matrix const &parent_transform,
+ NRRect const *bbox);
};
static void sp_radialgradient_class_init(SPRadialGradientClass *klass);
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,
- NRRect const *bbox);
static void sp_radialgradient_painter_free(SPPaintServer *ps, SPPainter *painter);
static void sp_rg_fill(SPPainter *painter, NRPixBlock *pb);
sp_object_class->set = sp_radialgradient_set;
sp_object_class->write = sp_radialgradient_write;
- ps_class->painter_new = sp_radialgradient_painter_new;
+ ps_class->painter_new = SPRGPainter::painter_new;
ps_class->painter_free = sp_radialgradient_painter_free;
}
@@ -1613,11 +1804,11 @@ sp_radialgradient_build(SPObject *object, SPDocument *document, Inkscape::XML::N
if (((SPObjectClass *) rg_parent_class)->build)
(* ((SPObjectClass *) rg_parent_class)->build)(object, document, repr);
- sp_object_read_attr(object, "cx");
- sp_object_read_attr(object, "cy");
- sp_object_read_attr(object, "r");
- sp_object_read_attr(object, "fx");
- sp_object_read_attr(object, "fy");
+ object->readAttr( "cx" );
+ object->readAttr( "cy" );
+ object->readAttr( "r" );
+ object->readAttr( "fx" );
+ object->readAttr( "fy" );
}
/**
* 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) {
- repr = sp_repr_new("svg:radialGradient");
+ repr = xml_doc->createElement("svg:radialGradient");
}
if ((flags & SP_OBJECT_WRITE_ALL) || rg->cx._set) sp_repr_set_svg_double(repr, "cx", rg->cx.computed);
@@ -1693,7 +1884,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;
}
@@ -1701,16 +1892,17 @@ sp_radialgradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags
/**
* Create radial gradient context.
*/
-static SPPainter *
-sp_radialgradient_painter_new(SPPaintServer *ps,
- NR::Matrix const &full_transform,
- NR::Matrix const &parent_transform,
- NRRect const *bbox)
+SPPainter *SPRGPainter::painter_new(SPPaintServer *ps,
+ Geom::Matrix const &full_transform,
+ Geom::Matrix const &/*parent_transform*/,
+ NRRect const *bbox)
{
SPRadialGradient *rg = SP_RADIALGRADIENT(ps);
SPGradient *gr = SP_GRADIENT(ps);
- if (!gr->color) sp_gradient_ensure_colors(gr);
+ if (!gr->color) {
+ gr->ensureColors();
+ }
SPRGPainter *rgp = g_new(SPRGPainter, 1);
rgp->rg = rg;
- NR::Matrix gs2px;
+ Geom::Matrix gs2px;
if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
/** \todo
- * fixme: We may try to normalize here too, look at
+ * fixme: We may try to normalize here too, look at
* linearGradient (Lauris)
*/
/* 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 {
/** \todo
* Problem: What to do, if we have mixed lengths and percentages?
- * Currently we do ignore percentages at all, but that is not
+ * Currently we do ignore percentages at all, but that is not
* good (lauris)
*/
gs2px = gr->gradientTransform * full_transform;
}
-
- NRMatrix gs2px_nr;
- gs2px.copyto(&gs2px_nr);
-
- nr_rgradient_renderer_setup(&rgp->rgr, gr->color, sp_gradient_get_spread(gr),
+ // TODO: remove gs2px_nr after converting to 2geom
+ NR::Matrix gs2px_nr = from_2geom(gs2px);
+ nr_rgradient_renderer_setup(&rgp->rgr, gr->color, gr->fetchSpread(),
&gs2px_nr,
rg->cx.computed, rg->cy.computed,
rg->fx.computed, rg->fy.computed,
}
static void
-sp_radialgradient_painter_free(SPPaintServer *ps, SPPainter *painter)
+sp_radialgradient_painter_free(SPPaintServer */*ps*/, SPPainter *painter)
{
g_free(painter);
}
SPRGPainter *rgp = (SPRGPainter *) painter;
if (rgp->rg->color == NULL) {
- sp_gradient_ensure_colors (rgp->rg);
+ rgp->rg->ensureColors();
rgp->rgr.vector = rgp->rg->color;
}
fill-column:99
End:
*/
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :