void
gr_apply_gradient_to_item (SPItem *item, SPGradient *gr, SPGradientType new_type, guint new_fill, bool do_fill, bool do_stroke)
{
SPStyle *style = SP_OBJECT_STYLE (item);
if (do_fill) {
if (style && (style->fill.isPaintserver()) &&
SP_IS_GRADIENT (SP_OBJECT_STYLE_FILL_SERVER (item))) {
SPObject *server = SP_OBJECT_STYLE_FILL_SERVER (item);
if (SP_IS_LINEARGRADIENT (server)) {
sp_item_set_gradient(item, gr, SP_GRADIENT_TYPE_LINEAR, true);
} else if (SP_IS_RADIALGRADIENT (server)) {
sp_item_set_gradient(item, gr, SP_GRADIENT_TYPE_RADIAL, true);
}
} else if (new_fill) {
sp_item_set_gradient(item, gr, new_type, true);
}
}
if (do_stroke) {
if (style && (style->stroke.isPaintserver()) &&
SP_IS_GRADIENT (SP_OBJECT_STYLE_STROKE_SERVER (item))) {
SPObject *server = SP_OBJECT_STYLE_STROKE_SERVER (item);
if (SP_IS_LINEARGRADIENT (server)) {
sp_item_set_gradient(item, gr, SP_GRADIENT_TYPE_LINEAR, false);
} else if (SP_IS_RADIALGRADIENT (server)) {
sp_item_set_gradient(item, gr, SP_GRADIENT_TYPE_RADIAL, false);
}
} else if (!new_fill) {
sp_item_set_gradient(item, gr, new_type, false);
}
}
}
static SPPaintSelectorMode
sp_fill_style_determine_paint_selector_mode (SPStyle *style)
{
SPColorSpaceType cstype;
switch (style->fill.type) {
case SP_PAINT_TYPE_NONE:
return SP_PAINT_SELECTOR_MODE_NONE;
case SP_PAINT_TYPE_COLOR:
cstype = sp_color_get_colorspace_type (&style->fill.value.color);
switch (cstype) {
case SP_COLORSPACE_TYPE_RGB:
return SP_PAINT_SELECTOR_MODE_COLOR_RGB;
case SP_COLORSPACE_TYPE_CMYK:
return SP_PAINT_SELECTOR_MODE_COLOR_CMYK;
default:
g_warning ("file %s: line %d: Unknown colorspace type %d", __FILE__, __LINE__, cstype);
return SP_PAINT_SELECTOR_MODE_NONE;
}
case SP_PAINT_TYPE_PAINTSERVER:
if (SP_IS_LINEARGRADIENT (SP_STYLE_FILL_SERVER (style))) {
return SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR;
} else if (SP_IS_RADIALGRADIENT (SP_STYLE_FILL_SERVER (style))) {
return SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL;
}
g_warning ("file %s: line %d: Unknown paintserver", __FILE__, __LINE__);
return SP_PAINT_SELECTOR_MODE_NONE;
default:
g_warning ("file %s: line %d: Unknown paint type %d", __FILE__, __LINE__, style->fill.type);
break;
}
return SP_PAINT_SELECTOR_MODE_NONE;
}
/**
* return true if this gradient is "equivalent" to that gradient.
* Equivalent meaning they have the same stop count, same stop colors and same stop opacity
* @param that - A gradient to compare this to
*/
bool SPGradient::isEquivalent(SPGradient *that)
{
//TODO Make this work for mesh gradients
bool status = false;
while(1){ // not really a loop, used to avoid deep nesting or multiple exit points from function
if (this->getStopCount() != that->getStopCount()) { break; }
if (this->hasStops() != that->hasStops()) { break; }
if (!this->getVector() || !that->getVector()) { break; }
if (this->isSwatch() != that->isSwatch()) { break; }
if ( this->isSwatch() ){
// drop down to check stops.
}
else if (
(SP_IS_LINEARGRADIENT(this) && SP_IS_LINEARGRADIENT(that)) ||
(SP_IS_RADIALGRADIENT(this) && SP_IS_RADIALGRADIENT(that)) ||
(SP_IS_MESH(this) && SP_IS_MESH(that))) {
if(!this->isAligned(that))break;
}
else { break; } // this should never happen, some unhandled type of gradient
SPStop *as = this->getVector()->getFirstStop();
SPStop *bs = that->getVector()->getFirstStop();
bool effective = true;
while (effective && (as && bs)) {
if (!as->getEffectiveColor().isClose(bs->getEffectiveColor(), 0.001) ||
as->offset != bs->offset) {
effective = false;
break;
}
else {
as = as->getNextStop();
bs = bs->getNextStop();
}
}
if (!effective) break;
status = true;
break;
}
return status;
}
void
StyleSwatch::setStyle(SPStyle *query)
{
_place[SS_FILL].remove();
_place[SS_STROKE].remove();
bool has_stroke = true;
for (int i = SS_FILL; i <= SS_STROKE; i++) {
Gtk::EventBox *place = &(_place[i]);
SPIPaint *paint;
if (i == SS_FILL) {
paint = &(query->fill);
} else {
paint = &(query->stroke);
}
if (paint->set && paint->isPaintserver()) {
SPPaintServer *server = (i == SS_FILL)? SP_STYLE_FILL_SERVER (query) : SP_STYLE_STROKE_SERVER (query);
if (SP_IS_LINEARGRADIENT (server)) {
_value[i].set_markup(_("L Gradient"));
place->add(_value[i]);
_tooltips.set_tip(*place, (i == SS_FILL)? (_("Linear gradient fill")) : (_("Linear gradient stroke")));
} else if (SP_IS_RADIALGRADIENT (server)) {
_value[i].set_markup(_("R Gradient"));
place->add(_value[i]);
_tooltips.set_tip(*place, (i == SS_FILL)? (_("Radial gradient fill")) : (_("Radial gradient stroke")));
} else if (SP_IS_PATTERN (server)) {
_value[i].set_markup(_("Pattern"));
place->add(_value[i]);
_tooltips.set_tip(*place, (i == SS_FILL)? (_("Pattern fill")) : (_("Pattern stroke")));
}
} else if (paint->set && paint->isColor()) {
guint32 color = paint->value.color.toRGBA32( SP_SCALE24_TO_FLOAT ((i == SS_FILL)? query->fill_opacity.value : query->stroke_opacity.value) );
((Inkscape::UI::Widget::ColorPreview*)_color_preview[i])->setRgba32 (color);
_color_preview[i]->show_all();
place->add(*_color_preview[i]);
gchar *tip;
if (i == SS_FILL) {
tip = g_strdup_printf (_("Fill: %06x/%.3g"), color >> 8, SP_RGBA32_A_F(color));
} else {
/**
* return true if this gradient is "aligned" to that gradient.
* Aligned means that they have exactly the same coordinates and transform.
* @param that - A gradient to compare this to
*/
bool SPGradient::isAligned(SPGradient *that)
{
bool status = false;
/* Some gradients have coordinates/other values specified, some don't.
yes/yes check the coordinates/other values
no/no aligned (because both have all default values)
yes/no not aligned
no/yes not aligned
It is NOT safe to just compare the computed values because if that field has
not been set the computed value could be full of garbage.
In theory the yes/no and no/yes cases could be aligned if the specified value
matches the default value.
*/
while(1){ // not really a loop, used to avoid deep nesting or multiple exit points from function
if(this->gradientTransform_set != that->gradientTransform_set) { break; }
if(this->gradientTransform_set &&
(this->gradientTransform != that->gradientTransform)) { break; }
if (SP_IS_LINEARGRADIENT(this) && SP_IS_LINEARGRADIENT(that)) {
SPLinearGradient *sg=SP_LINEARGRADIENT(this);
SPLinearGradient *tg=SP_LINEARGRADIENT(that);
if( sg->x1._set != tg->x1._set) { break; }
if( sg->y1._set != tg->y1._set) { break; }
if( sg->x2._set != tg->x2._set) { break; }
if( sg->y2._set != tg->y2._set) { break; }
if( sg->x1._set && sg->y1._set && sg->x2._set && sg->y2._set) {
if( (sg->x1.computed != tg->x1.computed) ||
(sg->y1.computed != tg->y1.computed) ||
(sg->x2.computed != tg->x2.computed) ||
(sg->y2.computed != tg->y2.computed) ) { break; }
} else if( sg->x1._set || sg->y1._set || sg->x2._set || sg->y2._set) { break; } // some mix of set and not set
// none set? assume aligned and fall through
} else if (SP_IS_RADIALGRADIENT(this) && SP_IS_LINEARGRADIENT(that)) {
SPRadialGradient *sg=SP_RADIALGRADIENT(this);
SPRadialGradient *tg=SP_RADIALGRADIENT(that);
if( sg->cx._set != tg->cx._set) { break; }
if( sg->cy._set != tg->cy._set) { break; }
if( sg->r._set != tg->r._set) { break; }
if( sg->fx._set != tg->fx._set) { break; }
if( sg->fy._set != tg->fy._set) { break; }
if( sg->cx._set && sg->cy._set && sg->fx._set && sg->fy._set && sg->r._set) {
if( (sg->cx.computed != tg->cx.computed) ||
(sg->cy.computed != tg->cy.computed) ||
(sg->r.computed != tg->r.computed ) ||
(sg->fx.computed != tg->fx.computed) ||
(sg->fy.computed != tg->fy.computed) ) { break; }
} else if( sg->cx._set || sg->cy._set || sg->fx._set || sg->fy._set || sg->r._set ) { break; } // some mix of set and not set
// none set? assume aligned and fall through
} else if (SP_IS_MESH(this) && SP_IS_MESH(that)) {
SPMesh *sg=SP_MESH(this);
SPMesh *tg=SP_MESH(that);
if( sg->x._set != !tg->x._set) { break; }
if( sg->y._set != !tg->y._set) { break; }
if( sg->x._set && sg->y._set) {
if( (sg->x.computed != tg->x.computed) ||
(sg->y.computed != tg->y.computed) ) { break; }
} else if( sg->x._set || sg->y._set) { break; } // some mix of set and not set
// none set? assume aligned and fall through
} else {
break;
}
status = true;
break;
}
return status;
}
