![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
diff --git a/src/sp-gradient.cpp b/src/sp-gradient.cpp
index 3fd120fb3d0b492c82fd086fc46f588f9361546a..1b8f9a11137a0e1e311200c2c00ca7ad97a81145 100644 (file)
--- a/src/sp-gradient.cpp
+++ b/src/sp-gradient.cpp
-#define __SP_GRADIENT_C__
-
/** \file
* SPGradient, SPStop, SPLinearGradient, SPRadialGradient.
*/
* 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.
#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"
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.
*/
@@ -119,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" );
}
/**
* 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);
- stop->specified_color.set( 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);
- stop->specified_color.set( 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;
}
@@ -210,11 +233,12 @@ sp_stop_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML:
repr = xml_doc->createElement("svg:stop");
}
- guint32 specifiedcolor = stop->specified_color.toRGBA32( 255 );
+ Glib::ustring colorStr = stop->specified_color.toString();
gfloat opacity = stop->opacity;
- if (((SPObjectClass *) stop_parent_class)->write)
+ 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
@@ -225,9 +249,7 @@ sp_stop_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML:
if (stop->currentColor) {
os << "currentColor";
} else {
- gchar c[64];
- sp_svg_write_color(c, sizeof(c), specifiedcolor);
- os << c;
+ os << colorStr;
}
os << ";stop-opacity:" << opacity;
repr->setAttribute("style", os.str().c_str());
@@ -240,6 +262,43 @@ sp_stop_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML:
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);
}
}
}
-/**
- * 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( color );
- return ret;
- } else {
- return stop->specified_color;
- }
-}
-
/*
* 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::Document *doc, 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);
-
-SPGradientSpread sp_gradient_get_spread(SPGradient *gradient);
-SPGradientUnits sp_gradient_get_units(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)
/**
* 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) {
/**
* 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);
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) {
gr->modified_connection.disconnect();
if ( SP_IS_GRADIENT(ref)
&& ref != gr )
{
- gr->modified_connection = ref->connectModified(sigc::bind<2>(sigc::ptr_fun(&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 = sp_gradient_get_units (gr);
- if (!gr->spread_set)
- gr->spread = sp_gradient_get_spread (gr);
+ 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?
@@ -579,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) {
- sp_gradient_ensure_colors(gr);
+ 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);
}
}
}
-
-bool SPGradient::isSolid() const
+SPStop* SPGradient::getFirstStop()
{
- bool solid = false;
- if ( SP_GRADIENT_HAS_STOPS(this) && (sp_number_of_stops(this) == 0) ) {
- gchar const * attr = repr->attribute("osb:paint");
- if (attr && !strcmp(attr, "solid")) {
- solid = true;
+ SPStop* first = 0;
+ for (SPObject *ochild = firstChild(); ochild && !first; ochild = ochild->getNext()) {
+ if (SP_IS_STOP(ochild)) {
+ first = SP_STOP(ochild);
}
}
- return solid;
+ 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::Document *xml_doc, 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)
+ 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(xml_doc, 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);
@@ -702,7 +757,7 @@ sp_gradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::
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:
@@ -717,6 +772,16 @@ sp_gradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::
}
}
+ 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;
}
@@ -725,40 +790,34 @@ sp_gradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::
*
* \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();
}
/**
static bool
has_units_set(SPGradient const *gr)
{
- return gr->units_set;
+ return gr->isUnitsSet();
}
-/**
- * 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.
- */
-SPGradient *
-sp_gradient_get_vector(SPGradient *gradient, bool force_vector)
+SPGradient *SPGradient::getVector(bool force_vector)
{
- g_return_val_if_fail(gradient != NULL, NULL);
- g_return_val_if_fail(SP_IS_GRADIENT(gradient), NULL);
+ SPGradient * src = chase_hrefs(this, has_stopsFN);
- SPGradient *const src = chase_hrefs(gradient, has_stops);
- return ( force_vector
- ? sp_gradient_ensure_vector_normalized(src)
- : src );
+ 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
*
* \pre SP_IS_GRADIENT(gradient).
*/
-SPGradientUnits
-sp_gradient_get_units(SPGradient *gradient)
+SPGradientUnits SPGradient::fetchUnits()
{
- g_return_val_if_fail(SP_IS_GRADIENT(gradient), SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX);
-
- SPGradient const *src = chase_hrefs(gradient, has_units_set);
+ SPGradient const *src = chase_hrefs(this, has_units_set);
return ( src
? src->units
: SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX ); // bbox is the default
g_return_if_fail(gr != NULL);
g_return_if_fail(SP_IS_GRADIENT(gr));
- Inkscape::XML::Document *xml_doc = sp_document_repr_doc(SP_OBJECT_DOCUMENT(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 */
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, sizeof(c), gr->vector.stops[i].color.toRGBA32( 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."
*/
gstop.offset = 0.0;
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;
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;
- 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;
- 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);
+ if (!color) {
+ color = g_new(guchar, 4 * NCOLORS);
}
- // This assumes that gr->vector is a zero-order B-spline (box function) approximation of the "true" gradient.
+ // 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(gr->spread) {
+ switch(spread) {
case SP_GRADIENT_SPREAD_PAD:
- remainder[0] = 0.5*gr->vector.stops[0].color.v.c[0]; // Half of the first cell uses the color of the first stop
- remainder[1] = 0.5*gr->vector.stops[0].color.v.c[1];
- remainder[2] = 0.5*gr->vector.stops[0].color.v.c[2];
- remainder[3] = 0.5*gr->vector.stops[0].opacity;
- 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
- remainder_for_end[1] = 0.5*gr->vector.stops[gr->vector.stops.size() - 1].color.v.c[1];
- remainder_for_end[2] = 0.5*gr->vector.stops[gr->vector.stops.size() - 1].color.v.c[2];
- remainder_for_end[3] = 0.5*gr->vector.stops[gr->vector.stops.size() - 1].opacity;
+ 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:
default:
g_error("Spread type not supported!");
};
- for (unsigned int i = 0; i < gr->vector.stops.size() - 1; i++) {
- double r0 = gr->vector.stops[i].color.v.c[0];
- double g0 = gr->vector.stops[i].color.v.c[1];
- double b0 = gr->vector.stops[i].color.v.c[2];
- double a0 = gr->vector.stops[i].opacity;
- double r1 = gr->vector.stops[i+1].color.v.c[0];
- double g1 = gr->vector.stops[i+1].color.v.c[1];
- double b1 = gr->vector.stops[i+1].color.v.c[2];
- double a1 = gr->vector.stops[i+1].opacity;
- double o0 = gr->vector.stops[i].offset * (NCOLORS-1);
- double o1 = gr->vector.stops[i + 1].offset * (NCOLORS-1);
+ 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
double df = 1. / (o1-o0);
for (unsigned int j = ob+1; j < oe; j++) {
f += df;
- gr->color[4 * j + 0] = (unsigned char) floor(255*(r0 + f*(r1-r0)) + .5);
- gr->color[4 * j + 1] = (unsigned char) floor(255*(g0 + f*(g1-g0)) + .5);
- gr->color[4 * j + 2] = (unsigned char) floor(255*(b0 + f*(b1-b0)) + .5);
- gr->color[4 * j + 3] = (unsigned char) floor(255*(a0 + f*(a1-a0)) + .5);
+ 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
// = (ob+.5-o0)*(c0+(ob+.5-o0)*df*(c1-c0)/2)
double dt = ob+.5-o0;
f = 0.5*dt*df;
- if (ob==0 && gr->spread==SP_GRADIENT_SPREAD_REFLECT) {
+ 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.
- gr->color[4 * ob + 0] = (unsigned char) floor(2*255*(remainder[0] + dt*(r0 + f*(r1-r0))) + .5);
- gr->color[4 * ob + 1] = (unsigned char) floor(2*255*(remainder[1] + dt*(g0 + f*(g1-g0))) + .5);
- gr->color[4 * ob + 2] = (unsigned char) floor(2*255*(remainder[2] + dt*(b0 + f*(b1-b0))) + .5);
- gr->color[4 * ob + 3] = (unsigned char) floor(2*255*(remainder[3] + dt*(a0 + f*(a1-a0))) + .5);
- } else if (ob==0 && gr->spread==SP_GRADIENT_SPREAD_REPEAT) {
+ 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[3] = remainder[3] + dt*(a0 + f*(a1-a0));
} else {
// The first half of the cell was already in remainder.
- gr->color[4 * ob + 0] = (unsigned char) floor(255*(remainder[0] + dt*(r0 + f*(r1-r0))) + .5);
- gr->color[4 * ob + 1] = (unsigned char) floor(255*(remainder[1] + dt*(g0 + f*(g1-g0))) + .5);
- gr->color[4 * ob + 2] = (unsigned char) floor(255*(remainder[2] + dt*(b0 + f*(b1-b0))) + .5);
- gr->color[4 * ob + 3] = (unsigned char) floor(255*(remainder[3] + dt*(a0 + f*(a1-a0))) + .5);
+ 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
remainder[3] = dt*(a0 + f*(a1-a0));
}
}
- switch(gr->spread) {
+ switch(spread) {
case SP_GRADIENT_SPREAD_PAD:
- gr->color[4 * (NCOLORS-1) + 0] = (unsigned char) floor(255*(remainder[0]+remainder_for_end[0]) + .5);
- gr->color[4 * (NCOLORS-1) + 1] = (unsigned char) floor(255*(remainder[1]+remainder_for_end[1]) + .5);
- gr->color[4 * (NCOLORS-1) + 2] = (unsigned char) floor(255*(remainder[2]+remainder_for_end[2]) + .5);
- gr->color[4 * (NCOLORS-1) + 3] = (unsigned char) floor(255*(remainder[3]+remainder_for_end[3]) + .5);
+ 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.
- gr->color[4 * (NCOLORS-1) + 0] = (unsigned char) floor(2*255*remainder[0] + .5);
- gr->color[4 * (NCOLORS-1) + 1] = (unsigned char) floor(2*255*remainder[1] + .5);
- gr->color[4 * (NCOLORS-1) + 2] = (unsigned char) floor(2*255*remainder[2] + .5);
- gr->color[4 * (NCOLORS-1) + 3] = (unsigned char) floor(2*255*remainder[3] + .5);
+ 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).
- gr->color[0] = gr->color[4 * (NCOLORS-1) + 0] = (unsigned char) floor(255*(remainder[0]+remainder_for_end[0]) + .5);
- gr->color[1] = gr->color[4 * (NCOLORS-1) + 1] = (unsigned char) floor(255*(remainder[1]+remainder_for_end[1]) + .5);
- gr->color[2] = gr->color[4 * (NCOLORS-1) + 2] = (unsigned char) floor(255*(remainder[2]+remainder_for_end[2]) + .5);
- gr->color[3] = gr->color[4 * (NCOLORS-1) + 3] = (unsigned char) floor(255*(remainder[3]+remainder_for_end[3]) + .5);
+ 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;
}
}
g_return_if_fail(span > 0);
if (!gradient->color) {
- sp_gradient_ensure_colors(gradient);
+ gradient->ensureColors();
}
gint idx = (pos * 1024 << 8) / span;
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) {
+ if (gr->getUnits() == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
return ( Geom::Scale(bbox.dimensions())
* Geom::Translate(bbox.min())
* Geom::Matrix(ctm) );
@@ -1373,7 +1405,7 @@ sp_gradient_get_g2d_matrix(SPGradient const *gr, Geom::Matrix const &ctm, Geom::
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
* Geom::Scale(bbox.dimensions())
* Geom::Translate(bbox.min())
Geom::Rect const &bbox, Geom::Matrix const &gs2d)
{
gr->gradientTransform = gs2d * ctm.inverse();
- if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX ) {
+ if (gr->getUnits() == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX ) {
gr->gradientTransform = ( gr->gradientTransform
* Geom::Translate(-bbox.min())
* Geom::Scale(bbox.dimensions()).inverse() );
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);
@@ -1422,10 +1459,6 @@ static void sp_lineargradient_set(SPObject *object, unsigned key, gchar const *v
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,
- Geom::Matrix const &full_transform,
- Geom::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;
}
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" );
}
/**
@@ -1575,16 +1608,17 @@ sp_lineargradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inks
* \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,
- Geom::Matrix const &full_transform,
- Geom::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);
}
// 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,
+ nr_lgradient_renderer_setup(&lgp->lgr, gr->color, gr->fetchSpread(), &color2px_nr,
lg->x1.computed, lg->y1.computed,
lg->x2.computed, lg->y2.computed);
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);
static void sp_radialgradient_set(SPObject *object, unsigned key, gchar const *value);
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,
- Geom::Matrix const &full_transform,
- Geom::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;
}
@@ -1770,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" );
}
/**
@@ -1858,16 +1892,17 @@ sp_radialgradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inks
/**
* Create radial gradient context.
*/
-static SPPainter *
-sp_radialgradient_painter_new(SPPaintServer *ps,
- Geom::Matrix const &full_transform,
- Geom::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);
}
// 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),
+ nr_rgradient_renderer_setup(&rgp->rgr, gr->color, gr->fetchSpread(),
&gs2px_nr,
rg->cx.computed, rg->cy.computed,
rg->fx.computed, rg->fy.computed,
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 :