diff options
Diffstat (limited to 'layout/svg/nsSVGGradientFrame.cpp')
| -rw-r--r-- | layout/svg/nsSVGGradientFrame.cpp | 678 |
1 files changed, 678 insertions, 0 deletions
diff --git a/layout/svg/nsSVGGradientFrame.cpp b/layout/svg/nsSVGGradientFrame.cpp new file mode 100644 index 000000000..217ab8c4a --- /dev/null +++ b/layout/svg/nsSVGGradientFrame.cpp @@ -0,0 +1,678 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +// Main header first: +#include "nsSVGGradientFrame.h" +#include <algorithm> + +// Keep others in (case-insensitive) order: +#include "gfxPattern.h" +#include "mozilla/dom/SVGGradientElement.h" +#include "mozilla/dom/SVGStopElement.h" +#include "nsContentUtils.h" +#include "nsSVGEffects.h" +#include "nsSVGAnimatedTransformList.h" + +// XXX Tight coupling with content classes ahead! + +using namespace mozilla; +using namespace mozilla::dom; +using namespace mozilla::gfx; + +//---------------------------------------------------------------------- +// Helper classes + +class MOZ_RAII nsSVGGradientFrame::AutoGradientReferencer +{ +public: + explicit AutoGradientReferencer(nsSVGGradientFrame *aFrame + MOZ_GUARD_OBJECT_NOTIFIER_PARAM) + : mFrame(aFrame) + { + MOZ_GUARD_OBJECT_NOTIFIER_INIT; + // Reference loops should normally be detected in advance and handled, so + // we're not expecting to encounter them here + MOZ_ASSERT(!mFrame->mLoopFlag, "Undetected reference loop!"); + mFrame->mLoopFlag = true; + } + ~AutoGradientReferencer() { + mFrame->mLoopFlag = false; + } +private: + nsSVGGradientFrame *mFrame; + MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER +}; + +//---------------------------------------------------------------------- +// Implementation + +nsSVGGradientFrame::nsSVGGradientFrame(nsStyleContext* aContext) + : nsSVGPaintServerFrame(aContext) + , mLoopFlag(false) + , mNoHRefURI(false) +{ +} + +//---------------------------------------------------------------------- +// nsIFrame methods: + +nsresult +nsSVGGradientFrame::AttributeChanged(int32_t aNameSpaceID, + nsIAtom* aAttribute, + int32_t aModType) +{ + if (aNameSpaceID == kNameSpaceID_None && + (aAttribute == nsGkAtoms::gradientUnits || + aAttribute == nsGkAtoms::gradientTransform || + aAttribute == nsGkAtoms::spreadMethod)) { + nsSVGEffects::InvalidateDirectRenderingObservers(this); + } else if ((aNameSpaceID == kNameSpaceID_XLink || + aNameSpaceID == kNameSpaceID_None) && + aAttribute == nsGkAtoms::href) { + // Blow away our reference, if any + Properties().Delete(nsSVGEffects::HrefAsPaintingProperty()); + mNoHRefURI = false; + // And update whoever references us + nsSVGEffects::InvalidateDirectRenderingObservers(this); + } + + return nsSVGPaintServerFrame::AttributeChanged(aNameSpaceID, + aAttribute, aModType); +} + +//---------------------------------------------------------------------- + +uint16_t +nsSVGGradientFrame::GetEnumValue(uint32_t aIndex, nsIContent *aDefault) +{ + const nsSVGEnum& thisEnum = + static_cast<dom::SVGGradientElement*>(mContent)->mEnumAttributes[aIndex]; + + if (thisEnum.IsExplicitlySet()) + return thisEnum.GetAnimValue(); + + AutoGradientReferencer gradientRef(this); + + nsSVGGradientFrame *next = GetReferencedGradientIfNotInUse(); + return next ? next->GetEnumValue(aIndex, aDefault) : + static_cast<dom::SVGGradientElement*>(aDefault)-> + mEnumAttributes[aIndex].GetAnimValue(); +} + +uint16_t +nsSVGGradientFrame::GetGradientUnits() +{ + // This getter is called every time the others are called - maybe cache it? + return GetEnumValue(dom::SVGGradientElement::GRADIENTUNITS); +} + +uint16_t +nsSVGGradientFrame::GetSpreadMethod() +{ + return GetEnumValue(dom::SVGGradientElement::SPREADMETHOD); +} + +const nsSVGAnimatedTransformList* +nsSVGGradientFrame::GetGradientTransformList(nsIContent* aDefault) +{ + nsSVGAnimatedTransformList *thisTransformList = + static_cast<dom::SVGGradientElement*>(mContent)->GetAnimatedTransformList(); + + if (thisTransformList && thisTransformList->IsExplicitlySet()) + return thisTransformList; + + AutoGradientReferencer gradientRef(this); + + nsSVGGradientFrame *next = GetReferencedGradientIfNotInUse(); + return next ? next->GetGradientTransformList(aDefault) : + static_cast<const dom::SVGGradientElement*>(aDefault) + ->mGradientTransform.get(); +} + +gfxMatrix +nsSVGGradientFrame::GetGradientTransform(nsIFrame *aSource, + const gfxRect *aOverrideBounds) +{ + gfxMatrix bboxMatrix; + + uint16_t gradientUnits = GetGradientUnits(); + if (gradientUnits != SVG_UNIT_TYPE_USERSPACEONUSE) { + NS_ASSERTION(gradientUnits == SVG_UNIT_TYPE_OBJECTBOUNDINGBOX, + "Unknown gradientUnits type"); + // objectBoundingBox is the default anyway + + gfxRect bbox = + aOverrideBounds ? *aOverrideBounds : nsSVGUtils::GetBBox(aSource); + bboxMatrix = + gfxMatrix(bbox.Width(), 0, 0, bbox.Height(), bbox.X(), bbox.Y()); + } + + const nsSVGAnimatedTransformList* animTransformList = + GetGradientTransformList(mContent); + if (!animTransformList) + return bboxMatrix; + + gfxMatrix gradientTransform = + animTransformList->GetAnimValue().GetConsolidationMatrix(); + return bboxMatrix.PreMultiply(gradientTransform); +} + +dom::SVGLinearGradientElement* +nsSVGGradientFrame::GetLinearGradientWithLength(uint32_t aIndex, + dom::SVGLinearGradientElement* aDefault) +{ + // If this was a linear gradient with the required length, we would have + // already found it in nsSVGLinearGradientFrame::GetLinearGradientWithLength. + // Since we didn't find the length, continue looking down the chain. + + AutoGradientReferencer gradientRef(this); + + nsSVGGradientFrame *next = GetReferencedGradientIfNotInUse(); + return next ? next->GetLinearGradientWithLength(aIndex, aDefault) : aDefault; +} + +dom::SVGRadialGradientElement* +nsSVGGradientFrame::GetRadialGradientWithLength(uint32_t aIndex, + dom::SVGRadialGradientElement* aDefault) +{ + // If this was a radial gradient with the required length, we would have + // already found it in nsSVGRadialGradientFrame::GetRadialGradientWithLength. + // Since we didn't find the length, continue looking down the chain. + + AutoGradientReferencer gradientRef(this); + + nsSVGGradientFrame *next = GetReferencedGradientIfNotInUse(); + return next ? next->GetRadialGradientWithLength(aIndex, aDefault) : aDefault; +} + +//---------------------------------------------------------------------- +// nsSVGPaintServerFrame methods: + +//helper +static void GetStopInformation(nsIFrame* aStopFrame, + float *aOffset, + nscolor *aStopColor, + float *aStopOpacity) +{ + nsIContent* stopContent = aStopFrame->GetContent(); + MOZ_ASSERT(stopContent && stopContent->IsSVGElement(nsGkAtoms::stop)); + + static_cast<SVGStopElement*>(stopContent)-> + GetAnimatedNumberValues(aOffset, nullptr); + + *aOffset = mozilla::clamped(*aOffset, 0.0f, 1.0f); + *aStopColor = aStopFrame->StyleSVGReset()->mStopColor; + *aStopOpacity = aStopFrame->StyleSVGReset()->mStopOpacity; +} + +already_AddRefed<gfxPattern> +nsSVGGradientFrame::GetPaintServerPattern(nsIFrame* aSource, + const DrawTarget* aDrawTarget, + const gfxMatrix& aContextMatrix, + nsStyleSVGPaint nsStyleSVG::*aFillOrStroke, + float aGraphicOpacity, + const gfxRect* aOverrideBounds) +{ + uint16_t gradientUnits = GetGradientUnits(); + MOZ_ASSERT(gradientUnits == SVG_UNIT_TYPE_OBJECTBOUNDINGBOX || + gradientUnits == SVG_UNIT_TYPE_USERSPACEONUSE); + if (gradientUnits == SVG_UNIT_TYPE_USERSPACEONUSE) { + // Set mSource for this consumer. + // If this gradient is applied to text, our caller will be the glyph, which + // is not an element, so we need to get the parent + mSource = aSource->GetContent()->IsNodeOfType(nsINode::eTEXT) ? + aSource->GetParent() : aSource; + } + + AutoTArray<nsIFrame*,8> stopFrames; + GetStopFrames(&stopFrames); + + uint32_t nStops = stopFrames.Length(); + + // SVG specification says that no stops should be treated like + // the corresponding fill or stroke had "none" specified. + if (nStops == 0) { + RefPtr<gfxPattern> pattern = new gfxPattern(Color()); + return pattern.forget(); + } + + if (nStops == 1 || GradientVectorLengthIsZero()) { + // The gradient paints a single colour, using the stop-color of the last + // gradient step if there are more than one. + float stopOpacity = stopFrames[nStops-1]->StyleSVGReset()->mStopOpacity; + nscolor stopColor = stopFrames[nStops-1]->StyleSVGReset()->mStopColor; + + Color stopColor2 = Color::FromABGR(stopColor); + stopColor2.a *= stopOpacity * aGraphicOpacity; + RefPtr<gfxPattern> pattern = new gfxPattern(stopColor2); + return pattern.forget(); + } + + // Get the transform list (if there is one). We do this after the returns + // above since this call can be expensive when "gradientUnits" is set to + // "objectBoundingBox" (since that requiring a GetBBox() call). + gfxMatrix patternMatrix = GetGradientTransform(aSource, aOverrideBounds); + + if (patternMatrix.IsSingular()) { + return nullptr; + } + + // revert any vector effect transform so that the gradient appears unchanged + if (aFillOrStroke == &nsStyleSVG::mStroke) { + gfxMatrix userToOuterSVG; + if (nsSVGUtils::GetNonScalingStrokeTransform(aSource, &userToOuterSVG)) { + patternMatrix *= userToOuterSVG; + } + } + + if (!patternMatrix.Invert()) { + return nullptr; + } + + RefPtr<gfxPattern> gradient = CreateGradient(); + if (!gradient || gradient->CairoStatus()) + return nullptr; + + uint16_t aSpread = GetSpreadMethod(); + if (aSpread == SVG_SPREADMETHOD_PAD) + gradient->SetExtend(ExtendMode::CLAMP); + else if (aSpread == SVG_SPREADMETHOD_REFLECT) + gradient->SetExtend(ExtendMode::REFLECT); + else if (aSpread == SVG_SPREADMETHOD_REPEAT) + gradient->SetExtend(ExtendMode::REPEAT); + + gradient->SetMatrix(patternMatrix); + + // setup stops + float lastOffset = 0.0f; + + for (uint32_t i = 0; i < nStops; i++) { + float offset, stopOpacity; + nscolor stopColor; + + GetStopInformation(stopFrames[i], &offset, &stopColor, &stopOpacity); + + if (offset < lastOffset) + offset = lastOffset; + else + lastOffset = offset; + + Color stopColor2 = Color::FromABGR(stopColor); + stopColor2.a *= stopOpacity * aGraphicOpacity; + gradient->AddColorStop(offset, stopColor2); + } + + return gradient.forget(); +} + +// Private (helper) methods + +nsSVGGradientFrame * +nsSVGGradientFrame::GetReferencedGradient() +{ + if (mNoHRefURI) + return nullptr; + + nsSVGPaintingProperty *property = + Properties().Get(nsSVGEffects::HrefAsPaintingProperty()); + + if (!property) { + // Fetch our gradient element's href or xlink:href attribute + dom::SVGGradientElement* grad = + static_cast<dom::SVGGradientElement*>(mContent); + nsAutoString href; + if (grad->mStringAttributes[dom::SVGGradientElement::HREF] + .IsExplicitlySet()) { + grad->mStringAttributes[dom::SVGGradientElement::HREF] + .GetAnimValue(href, grad); + } else { + grad->mStringAttributes[dom::SVGGradientElement::XLINK_HREF] + .GetAnimValue(href, grad); + } + + if (href.IsEmpty()) { + mNoHRefURI = true; + return nullptr; // no URL + } + + // Convert href to an nsIURI + nsCOMPtr<nsIURI> targetURI; + nsCOMPtr<nsIURI> base = mContent->GetBaseURI(); + nsContentUtils::NewURIWithDocumentCharset(getter_AddRefs(targetURI), href, + mContent->GetUncomposedDoc(), base); + + property = + nsSVGEffects::GetPaintingProperty(targetURI, this, + nsSVGEffects::HrefAsPaintingProperty()); + if (!property) + return nullptr; + } + + nsIFrame *result = property->GetReferencedFrame(); + if (!result) + return nullptr; + + nsIAtom* frameType = result->GetType(); + if (frameType != nsGkAtoms::svgLinearGradientFrame && + frameType != nsGkAtoms::svgRadialGradientFrame) + return nullptr; + + return static_cast<nsSVGGradientFrame*>(result); +} + +nsSVGGradientFrame * +nsSVGGradientFrame::GetReferencedGradientIfNotInUse() +{ + nsSVGGradientFrame *referenced = GetReferencedGradient(); + if (!referenced) + return nullptr; + + if (referenced->mLoopFlag) { + // XXXjwatt: we should really send an error to the JavaScript Console here: + NS_WARNING("gradient reference loop detected while inheriting attribute!"); + return nullptr; + } + + return referenced; +} + +void +nsSVGGradientFrame::GetStopFrames(nsTArray<nsIFrame*>* aStopFrames) +{ + nsIFrame *stopFrame = nullptr; + for (stopFrame = mFrames.FirstChild(); stopFrame; + stopFrame = stopFrame->GetNextSibling()) { + if (stopFrame->GetType() == nsGkAtoms::svgStopFrame) { + aStopFrames->AppendElement(stopFrame); + } + } + if (aStopFrames->Length() > 0) { + return; + } + + // Our gradient element doesn't have stops - try to "inherit" them + + AutoGradientReferencer gradientRef(this); + nsSVGGradientFrame* next = GetReferencedGradientIfNotInUse(); + if (!next) { + return; + } + + return next->GetStopFrames(aStopFrames); +} + +// ------------------------------------------------------------------------- +// Linear Gradients +// ------------------------------------------------------------------------- + +#ifdef DEBUG +void +nsSVGLinearGradientFrame::Init(nsIContent* aContent, + nsContainerFrame* aParent, + nsIFrame* aPrevInFlow) +{ + NS_ASSERTION(aContent->IsSVGElement(nsGkAtoms::linearGradient), + "Content is not an SVG linearGradient"); + + nsSVGGradientFrame::Init(aContent, aParent, aPrevInFlow); +} +#endif /* DEBUG */ + +nsIAtom* +nsSVGLinearGradientFrame::GetType() const +{ + return nsGkAtoms::svgLinearGradientFrame; +} + +nsresult +nsSVGLinearGradientFrame::AttributeChanged(int32_t aNameSpaceID, + nsIAtom* aAttribute, + int32_t aModType) +{ + if (aNameSpaceID == kNameSpaceID_None && + (aAttribute == nsGkAtoms::x1 || + aAttribute == nsGkAtoms::y1 || + aAttribute == nsGkAtoms::x2 || + aAttribute == nsGkAtoms::y2)) { + nsSVGEffects::InvalidateDirectRenderingObservers(this); + } + + return nsSVGGradientFrame::AttributeChanged(aNameSpaceID, + aAttribute, aModType); +} + +//---------------------------------------------------------------------- + +float +nsSVGLinearGradientFrame::GetLengthValue(uint32_t aIndex) +{ + dom::SVGLinearGradientElement* lengthElement = + GetLinearGradientWithLength(aIndex, + static_cast<dom::SVGLinearGradientElement*>(mContent)); + // We passed in mContent as a fallback, so, assuming mContent is non-null, the + // return value should also be non-null. + MOZ_ASSERT(lengthElement, + "Got unexpected null element from GetLinearGradientWithLength"); + const nsSVGLength2 &length = lengthElement->mLengthAttributes[aIndex]; + + // Object bounding box units are handled by setting the appropriate + // transform in GetGradientTransform, but we need to handle user + // space units as part of the individual Get* routines. Fixes 323669. + + uint16_t gradientUnits = GetGradientUnits(); + if (gradientUnits == SVG_UNIT_TYPE_USERSPACEONUSE) { + return nsSVGUtils::UserSpace(mSource, &length); + } + + NS_ASSERTION( + gradientUnits == SVG_UNIT_TYPE_OBJECTBOUNDINGBOX, + "Unknown gradientUnits type"); + + return length.GetAnimValue(static_cast<SVGSVGElement*>(nullptr)); +} + +dom::SVGLinearGradientElement* +nsSVGLinearGradientFrame::GetLinearGradientWithLength(uint32_t aIndex, + dom::SVGLinearGradientElement* aDefault) +{ + dom::SVGLinearGradientElement* thisElement = + static_cast<dom::SVGLinearGradientElement*>(mContent); + const nsSVGLength2 &length = thisElement->mLengthAttributes[aIndex]; + + if (length.IsExplicitlySet()) { + return thisElement; + } + + return nsSVGGradientFrame::GetLinearGradientWithLength(aIndex, aDefault); +} + +bool +nsSVGLinearGradientFrame::GradientVectorLengthIsZero() +{ + return GetLengthValue(dom::SVGLinearGradientElement::ATTR_X1) == + GetLengthValue(dom::SVGLinearGradientElement::ATTR_X2) && + GetLengthValue(dom::SVGLinearGradientElement::ATTR_Y1) == + GetLengthValue(dom::SVGLinearGradientElement::ATTR_Y2); +} + +already_AddRefed<gfxPattern> +nsSVGLinearGradientFrame::CreateGradient() +{ + float x1, y1, x2, y2; + + x1 = GetLengthValue(dom::SVGLinearGradientElement::ATTR_X1); + y1 = GetLengthValue(dom::SVGLinearGradientElement::ATTR_Y1); + x2 = GetLengthValue(dom::SVGLinearGradientElement::ATTR_X2); + y2 = GetLengthValue(dom::SVGLinearGradientElement::ATTR_Y2); + + RefPtr<gfxPattern> pattern = new gfxPattern(x1, y1, x2, y2); + return pattern.forget(); +} + +// ------------------------------------------------------------------------- +// Radial Gradients +// ------------------------------------------------------------------------- + +#ifdef DEBUG +void +nsSVGRadialGradientFrame::Init(nsIContent* aContent, + nsContainerFrame* aParent, + nsIFrame* aPrevInFlow) +{ + NS_ASSERTION(aContent->IsSVGElement(nsGkAtoms::radialGradient), + "Content is not an SVG radialGradient"); + + nsSVGGradientFrame::Init(aContent, aParent, aPrevInFlow); +} +#endif /* DEBUG */ + +nsIAtom* +nsSVGRadialGradientFrame::GetType() const +{ + return nsGkAtoms::svgRadialGradientFrame; +} + +nsresult +nsSVGRadialGradientFrame::AttributeChanged(int32_t aNameSpaceID, + nsIAtom* aAttribute, + int32_t aModType) +{ + if (aNameSpaceID == kNameSpaceID_None && + (aAttribute == nsGkAtoms::r || + aAttribute == nsGkAtoms::cx || + aAttribute == nsGkAtoms::cy || + aAttribute == nsGkAtoms::fx || + aAttribute == nsGkAtoms::fy)) { + nsSVGEffects::InvalidateDirectRenderingObservers(this); + } + + return nsSVGGradientFrame::AttributeChanged(aNameSpaceID, + aAttribute, aModType); +} + +//---------------------------------------------------------------------- + +float +nsSVGRadialGradientFrame::GetLengthValue(uint32_t aIndex) +{ + dom::SVGRadialGradientElement* lengthElement = + GetRadialGradientWithLength(aIndex, + static_cast<dom::SVGRadialGradientElement*>(mContent)); + // We passed in mContent as a fallback, so, assuming mContent is non-null, + // the return value should also be non-null. + MOZ_ASSERT(lengthElement, + "Got unexpected null element from GetRadialGradientWithLength"); + return GetLengthValueFromElement(aIndex, *lengthElement); +} + +float +nsSVGRadialGradientFrame::GetLengthValue(uint32_t aIndex, float aDefaultValue) +{ + dom::SVGRadialGradientElement* lengthElement = + GetRadialGradientWithLength(aIndex, nullptr); + + return lengthElement ? GetLengthValueFromElement(aIndex, *lengthElement) + : aDefaultValue; +} + +float +nsSVGRadialGradientFrame::GetLengthValueFromElement(uint32_t aIndex, + dom::SVGRadialGradientElement& aElement) +{ + const nsSVGLength2 &length = aElement.mLengthAttributes[aIndex]; + + // Object bounding box units are handled by setting the appropriate + // transform in GetGradientTransform, but we need to handle user + // space units as part of the individual Get* routines. Fixes 323669. + + uint16_t gradientUnits = GetGradientUnits(); + if (gradientUnits == SVG_UNIT_TYPE_USERSPACEONUSE) { + return nsSVGUtils::UserSpace(mSource, &length); + } + + NS_ASSERTION( + gradientUnits == SVG_UNIT_TYPE_OBJECTBOUNDINGBOX, + "Unknown gradientUnits type"); + + return length.GetAnimValue(static_cast<SVGSVGElement*>(nullptr)); +} + +dom::SVGRadialGradientElement* +nsSVGRadialGradientFrame::GetRadialGradientWithLength(uint32_t aIndex, + dom::SVGRadialGradientElement* aDefault) +{ + dom::SVGRadialGradientElement* thisElement = + static_cast<dom::SVGRadialGradientElement*>(mContent); + const nsSVGLength2 &length = thisElement->mLengthAttributes[aIndex]; + + if (length.IsExplicitlySet()) { + return thisElement; + } + + return nsSVGGradientFrame::GetRadialGradientWithLength(aIndex, aDefault); +} + +bool +nsSVGRadialGradientFrame::GradientVectorLengthIsZero() +{ + return GetLengthValue(dom::SVGRadialGradientElement::ATTR_R) == 0; +} + +already_AddRefed<gfxPattern> +nsSVGRadialGradientFrame::CreateGradient() +{ + float cx, cy, r, fx, fy; + + cx = GetLengthValue(dom::SVGRadialGradientElement::ATTR_CX); + cy = GetLengthValue(dom::SVGRadialGradientElement::ATTR_CY); + r = GetLengthValue(dom::SVGRadialGradientElement::ATTR_R); + // If fx or fy are not set, use cx/cy instead + fx = GetLengthValue(dom::SVGRadialGradientElement::ATTR_FX, cx); + fy = GetLengthValue(dom::SVGRadialGradientElement::ATTR_FY, cy); + + if (fx != cx || fy != cy) { + // The focal point (fFx and fFy) must be clamped to be *inside* - not on - + // the circumference of the gradient or we'll get rendering anomalies. We + // calculate the distance from the focal point to the gradient center and + // make sure it is *less* than the gradient radius. + // 1/128 is the limit of the fractional part of cairo's 24.8 fixed point + // representation divided by 2 to ensure that we get different cairo + // fractions + double dMax = std::max(0.0, r - 1.0/128); + float dx = fx - cx; + float dy = fy - cy; + double d = sqrt((dx * dx) + (dy * dy)); + if (d > dMax) { + double angle = atan2(dy, dx); + fx = (float)(dMax * cos(angle)) + cx; + fy = (float)(dMax * sin(angle)) + cy; + } + } + + RefPtr<gfxPattern> pattern = new gfxPattern(fx, fy, 0, cx, cy, r); + return pattern.forget(); +} + +// ------------------------------------------------------------------------- +// Public functions +// ------------------------------------------------------------------------- + +nsIFrame* +NS_NewSVGLinearGradientFrame(nsIPresShell* aPresShell, + nsStyleContext* aContext) +{ + return new (aPresShell) nsSVGLinearGradientFrame(aContext); +} + +NS_IMPL_FRAMEARENA_HELPERS(nsSVGLinearGradientFrame) + +nsIFrame* +NS_NewSVGRadialGradientFrame(nsIPresShell* aPresShell, + nsStyleContext* aContext) +{ + return new (aPresShell) nsSVGRadialGradientFrame(aContext); +} + +NS_IMPL_FRAMEARENA_HELPERS(nsSVGRadialGradientFrame) |