static void setGradientAttributes(SVGGradientElement* element, RadialGradientAttributes& attributes, bool isRadial = true)
{
if (!attributes.hasSpreadMethod() && element->spreadMethod()->isSpecified())
attributes.setSpreadMethod(element->spreadMethod()->currentValue()->enumValue());
if (!attributes.hasGradientUnits() && element->gradientUnits()->isSpecified())
attributes.setGradientUnits(element->gradientUnits()->currentValue()->enumValue());
if (!attributes.hasGradientTransform() && element->gradientTransform()->isSpecified()) {
AffineTransform transform;
element->gradientTransform()->currentValue()->concatenate(transform);
attributes.setGradientTransform(transform);
}
if (!attributes.hasStops()) {
const Vector<Gradient::ColorStop>& stops(element->buildStops());
if (!stops.isEmpty())
attributes.setStops(stops);
}
if (isRadial) {
SVGRadialGradientElement* radial = toSVGRadialGradientElement(element);
if (!attributes.hasCx() && radial->cx()->isSpecified())
attributes.setCx(radial->cx()->currentValue());
if (!attributes.hasCy() && radial->cy()->isSpecified())
attributes.setCy(radial->cy()->currentValue());
if (!attributes.hasR() && radial->r()->isSpecified())
attributes.setR(radial->r()->currentValue());
if (!attributes.hasFx() && radial->fx()->isSpecified())
attributes.setFx(radial->fx()->currentValue());
if (!attributes.hasFy() && radial->fy()->isSpecified())
attributes.setFy(radial->fy()->currentValue());
if (!attributes.hasFr() && radial->fr()->isSpecified())
attributes.setFr(radial->fr()->currentValue());
}
}
static void setGradientAttributes(SVGGradientElement& element, RadialGradientAttributes& attributes, bool isRadial = true)
{
if (!attributes.hasSpreadMethod() && element.hasAttribute(SVGNames::spreadMethodAttr))
attributes.setSpreadMethod(element.spreadMethod());
if (!attributes.hasGradientUnits() && element.hasAttribute(SVGNames::gradientUnitsAttr))
attributes.setGradientUnits(element.gradientUnits());
if (!attributes.hasGradientTransform() && element.hasAttribute(SVGNames::gradientTransformAttr)) {
AffineTransform transform;
element.gradientTransform().concatenate(transform);
attributes.setGradientTransform(transform);
}
if (!attributes.hasStops()) {
const Vector<Gradient::ColorStop>& stops(element.buildStops());
if (!stops.isEmpty())
attributes.setStops(stops);
}
if (isRadial) {
SVGRadialGradientElement& radial = downcast<SVGRadialGradientElement>(element);
if (!attributes.hasCx() && element.hasAttribute(SVGNames::cxAttr))
attributes.setCx(radial.cx());
if (!attributes.hasCy() && element.hasAttribute(SVGNames::cyAttr))
attributes.setCy(radial.cy());
if (!attributes.hasR() && element.hasAttribute(SVGNames::rAttr))
attributes.setR(radial.r());
if (!attributes.hasFx() && element.hasAttribute(SVGNames::fxAttr))
attributes.setFx(radial.fx());
if (!attributes.hasFy() && element.hasAttribute(SVGNames::fyAttr))
attributes.setFy(radial.fy());
if (!attributes.hasFr() && element.hasAttribute(SVGNames::frAttr))
attributes.setFr(radial.fr());
}
}
bool SVGRadialGradientElement::collectGradientAttributes(RadialGradientAttributes& attributes)
{
if (!renderer())
return false;
WillBeHeapHashSet<RawPtrWillBeMember<SVGGradientElement> > processedGradients;
SVGGradientElement* current = this;
setGradientAttributes(current, attributes);
processedGradients.add(current);
while (true) {
// Respect xlink:href, take attributes from referenced element
Node* refNode = SVGURIReference::targetElementFromIRIString(current->href()->currentValue()->value(), treeScope());
if (refNode && isSVGGradientElement(*refNode)) {
current = toSVGGradientElement(refNode);
// Cycle detection
if (processedGradients.contains(current))
break;
if (!current->renderer())
return false;
setGradientAttributes(current, attributes, isSVGRadialGradientElement(*current));
processedGradients.add(current);
} else {
break;
}
}
// Handle default values for fx/fy
if (!attributes.hasFx())
attributes.setFx(attributes.cx());
if (!attributes.hasFy())
attributes.setFy(attributes.cy());
return true;
}
bool SVGRadialGradientElement::collectGradientAttributes(RadialGradientAttributes& attributes)
{
if (!renderer())
return false;
HashSet<SVGGradientElement*> processedGradients;
SVGGradientElement* current = this;
setGradientAttributes(*current, attributes);
processedGradients.add(current);
while (true) {
// Respect xlink:href, take attributes from referenced element
Node* refNode = SVGURIReference::targetElementFromIRIString(current->href(), document());
if (is<SVGGradientElement>(refNode)) {
current = downcast<SVGGradientElement>(refNode);
// Cycle detection
if (processedGradients.contains(current))
break;
if (!current->renderer())
return false;
setGradientAttributes(*current, attributes, current->hasTagName(SVGNames::radialGradientTag));
processedGradients.add(current);
} else
break;
}
// Handle default values for fx/fy
if (!attributes.hasFx())
attributes.setFx(attributes.cx());
if (!attributes.hasFy())
attributes.setFy(attributes.cy());
return true;
}
RadialGradientAttributes SVGRadialGradientElement::collectGradientProperties() const
{
RadialGradientAttributes attributes;
HashSet<const SVGGradientElement*> processedGradients;
bool isRadial = true;
const SVGGradientElement* current = this;
while (current) {
if (!attributes.hasSpreadMethod() && current->hasAttribute(SVGNames::spreadMethodAttr))
attributes.setSpreadMethod((GradientSpreadMethod) current->spreadMethod());
if (!attributes.hasBoundingBoxMode() && current->hasAttribute(SVGNames::gradientUnitsAttr))
attributes.setBoundingBoxMode(current->gradientUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX);
if (!attributes.hasGradientTransform() && current->hasAttribute(SVGNames::gradientTransformAttr))
attributes.setGradientTransform(current->gradientTransform()->consolidate().matrix());
if (!attributes.hasStops()) {
const Vector<SVGGradientStop>& stops(current->buildStops());
if (!stops.isEmpty())
attributes.setStops(stops);
}
if (isRadial) {
const SVGRadialGradientElement* radial = static_cast<const SVGRadialGradientElement*>(current);
if (!attributes.hasCx() && current->hasAttribute(SVGNames::cxAttr))
attributes.setCx(radial->cx().valueAsPercentage());
if (!attributes.hasCy() && current->hasAttribute(SVGNames::cyAttr))
attributes.setCy(radial->cy().valueAsPercentage());
if (!attributes.hasR() && current->hasAttribute(SVGNames::rAttr))
attributes.setR(radial->r().valueAsPercentage());
if (!attributes.hasFx() && current->hasAttribute(SVGNames::fxAttr))
attributes.setFx(radial->fx().valueAsPercentage());
if (!attributes.hasFy() && current->hasAttribute(SVGNames::fyAttr))
attributes.setFy(radial->fy().valueAsPercentage());
}
processedGradients.add(current);
// Respect xlink:href, take attributes from referenced element
Node* refNode = ownerDocument()->getElementById(SVGURIReference::getTarget(current->href()));
if (refNode && (refNode->hasTagName(SVGNames::radialGradientTag) || refNode->hasTagName(SVGNames::linearGradientTag))) {
current = static_cast<const SVGGradientElement*>(const_cast<const Node*>(refNode));
// Cycle detection
if (processedGradients.contains(current))
return RadialGradientAttributes();
isRadial = current->gradientType() == RadialGradientPaintServer;
} else
current = 0;
}
// Handle default values for fx/fy
if (!attributes.hasFx())
attributes.setFx(attributes.cx());
if (!attributes.hasFy())
attributes.setFy(attributes.cy());
return attributes;
}
