gecko-dev/layout/svg/nsSVGPatternFrame.cpp
Robert Longson 1bae76206e Bug 1239100 - Implement SVGGeometryElement interface. r=cam r=peterv
--HG--
rename : dom/svg/nsSVGPathGeometryElement.cpp => dom/svg/SVGGeometryElement.cpp
rename : dom/svg/nsSVGPathGeometryElement.h => dom/svg/SVGGeometryElement.h
rename : dom/svg/nsSVGPolyElement.cpp => dom/svg/SVGPolyElement.cpp
rename : dom/svg/nsSVGPolyElement.h => dom/svg/SVGPolyElement.h
rename : layout/svg/nsSVGPathGeometryFrame.cpp => layout/svg/SVGGeometryFrame.cpp
rename : layout/svg/nsSVGPathGeometryFrame.h => layout/svg/SVGGeometryFrame.h
2016-12-18 11:11:47 +00:00

752 lines
24 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* -*- 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 "nsSVGPatternFrame.h"
// Keep others in (case-insensitive) order:
#include "gfx2DGlue.h"
#include "gfxContext.h"
#include "gfxMatrix.h"
#include "gfxPattern.h"
#include "gfxPlatform.h"
#include "mozilla/gfx/2D.h"
#include "nsContentUtils.h"
#include "nsGkAtoms.h"
#include "nsISVGChildFrame.h"
#include "nsStyleContext.h"
#include "nsSVGEffects.h"
#include "SVGGeometryFrame.h"
#include "mozilla/dom/SVGPatternElement.h"
#include "nsSVGUtils.h"
#include "nsSVGAnimatedTransformList.h"
#include "SVGContentUtils.h"
using namespace mozilla;
using namespace mozilla::dom;
using namespace mozilla::gfx;
//----------------------------------------------------------------------
// Helper classes
class MOZ_RAII nsSVGPatternFrame::AutoPatternReferencer
{
public:
explicit AutoPatternReferencer(nsSVGPatternFrame *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;
}
~AutoPatternReferencer() {
mFrame->mLoopFlag = false;
}
private:
nsSVGPatternFrame *mFrame;
MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
};
//----------------------------------------------------------------------
// Implementation
nsSVGPatternFrame::nsSVGPatternFrame(nsStyleContext* aContext)
: nsSVGPaintServerFrame(aContext)
, mLoopFlag(false)
, mNoHRefURI(false)
{
}
NS_IMPL_FRAMEARENA_HELPERS(nsSVGPatternFrame)
//----------------------------------------------------------------------
// nsIFrame methods:
nsresult
nsSVGPatternFrame::AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType)
{
if (aNameSpaceID == kNameSpaceID_None &&
(aAttribute == nsGkAtoms::patternUnits ||
aAttribute == nsGkAtoms::patternContentUnits ||
aAttribute == nsGkAtoms::patternTransform ||
aAttribute == nsGkAtoms::x ||
aAttribute == nsGkAtoms::y ||
aAttribute == nsGkAtoms::width ||
aAttribute == nsGkAtoms::height ||
aAttribute == nsGkAtoms::preserveAspectRatio ||
aAttribute == nsGkAtoms::viewBox)) {
nsSVGEffects::InvalidateDirectRenderingObservers(this);
}
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);
}
#ifdef DEBUG
void
nsSVGPatternFrame::Init(nsIContent* aContent,
nsContainerFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVGElement(nsGkAtoms::pattern), "Content is not an SVG pattern");
nsSVGPaintServerFrame::Init(aContent, aParent, aPrevInFlow);
}
#endif /* DEBUG */
nsIAtom*
nsSVGPatternFrame::GetType() const
{
return nsGkAtoms::svgPatternFrame;
}
//----------------------------------------------------------------------
// nsSVGContainerFrame methods:
// If our GetCanvasTM is getting called, we
// need to return *our current* transformation
// matrix, which depends on our units parameters
// and X, Y, Width, and Height
gfxMatrix
nsSVGPatternFrame::GetCanvasTM()
{
if (mCTM) {
return *mCTM;
}
// Do we know our rendering parent?
if (mSource) {
// Yes, use it!
return mSource->GetCanvasTM();
}
// We get here when geometry in the <pattern> container is updated
return gfxMatrix();
}
// -------------------------------------------------------------------------
// Helper functions
// -------------------------------------------------------------------------
/** Calculate the maximum expansion of a matrix */
static float
MaxExpansion(const Matrix &aMatrix)
{
// maximum expansion derivation from
// http://lists.cairographics.org/archives/cairo/2004-October/001980.html
// and also implemented in cairo_matrix_transformed_circle_major_axis
double a = aMatrix._11;
double b = aMatrix._12;
double c = aMatrix._21;
double d = aMatrix._22;
double f = (a * a + b * b + c * c + d * d) / 2;
double g = (a * a + b * b - c * c - d * d) / 2;
double h = a * c + b * d;
return sqrt(f + sqrt(g * g + h * h));
}
// The SVG specification says that the 'patternContentUnits' attribute "has no effect if
// attribute viewBox is specified". We still need to include a bbox scale
// if the viewBox is specified and _patternUnits_ is set to or defaults to
// objectBoundingBox though, since in that case the viewBox is relative to the bbox
static bool
IncludeBBoxScale(const nsSVGViewBox& aViewBox,
uint32_t aPatternContentUnits, uint32_t aPatternUnits)
{
return (!aViewBox.IsExplicitlySet() &&
aPatternContentUnits == SVG_UNIT_TYPE_OBJECTBOUNDINGBOX) ||
(aViewBox.IsExplicitlySet() &&
aPatternUnits == SVG_UNIT_TYPE_OBJECTBOUNDINGBOX);
}
// Given the matrix for the pattern element's own transform, this returns a
// combined matrix including the transforms applicable to its target.
static Matrix
GetPatternMatrix(uint16_t aPatternUnits,
const Matrix &patternTransform,
const gfxRect &bbox,
const gfxRect &callerBBox,
const Matrix &callerCTM)
{
// We really want the pattern matrix to handle translations
gfxFloat minx = bbox.X();
gfxFloat miny = bbox.Y();
if (aPatternUnits == SVG_UNIT_TYPE_OBJECTBOUNDINGBOX) {
minx += callerBBox.X();
miny += callerBBox.Y();
}
float scale = 1.0f / MaxExpansion(callerCTM);
Matrix patternMatrix = patternTransform;
patternMatrix.PreScale(scale, scale);
patternMatrix.PreTranslate(minx, miny);
return patternMatrix;
}
static nsresult
GetTargetGeometry(gfxRect *aBBox,
const nsSVGViewBox &aViewBox,
uint16_t aPatternContentUnits,
uint16_t aPatternUnits,
nsIFrame *aTarget,
const Matrix &aContextMatrix,
const gfxRect *aOverrideBounds)
{
*aBBox = aOverrideBounds ? *aOverrideBounds : nsSVGUtils::GetBBox(aTarget);
// Sanity check
if (IncludeBBoxScale(aViewBox, aPatternContentUnits, aPatternUnits) &&
(aBBox->Width() <= 0 || aBBox->Height() <= 0)) {
return NS_ERROR_FAILURE;
}
// OK, now fix up the bounding box to reflect user coordinates
// We handle device unit scaling in pattern matrix
float scale = MaxExpansion(aContextMatrix);
if (scale <= 0) {
return NS_ERROR_FAILURE;
}
aBBox->Scale(scale);
return NS_OK;
}
already_AddRefed<SourceSurface>
nsSVGPatternFrame::PaintPattern(const DrawTarget* aDrawTarget,
Matrix* patternMatrix,
const Matrix &aContextMatrix,
nsIFrame *aSource,
nsStyleSVGPaint nsStyleSVG::*aFillOrStroke,
float aGraphicOpacity,
const gfxRect *aOverrideBounds)
{
/*
* General approach:
* Set the content geometry stuff
* Calculate our bbox (using x,y,width,height & patternUnits &
* patternTransform)
* Create the surface
* Calculate the content transformation matrix
* Get our children (we may need to get them from another Pattern)
* Call SVGPaint on all of our children
* Return
*/
nsSVGPatternFrame* patternWithChildren = GetPatternWithChildren();
if (!patternWithChildren) {
return nullptr; // Either no kids or a bad reference
}
nsIFrame* firstKid = patternWithChildren->mFrames.FirstChild();
const nsSVGViewBox& viewBox = GetViewBox();
uint16_t patternContentUnits =
GetEnumValue(SVGPatternElement::PATTERNCONTENTUNITS);
uint16_t patternUnits =
GetEnumValue(SVGPatternElement::PATTERNUNITS);
/*
* Get the content geometry information. This is a little tricky --
* our parent is probably a <defs>, but we are rendering in the context
* of some geometry source. Our content geometry information needs to
* come from our rendering parent as opposed to our content parent. We
* get that information from aSource, which is passed to us from the
* backend renderer.
*
* There are three "geometries" that we need:
* 1) The bounding box for the pattern. We use this to get the
* width and height for the surface, and as the return to
* GetBBox.
* 2) The transformation matrix for the pattern. This is not *quite*
* the same as the canvas transformation matrix that we will
* provide to our rendering children since we "fudge" it a little
* to get the renderer to handle the translations correctly for us.
* 3) The CTM that we return to our children who make up the pattern.
*/
// Get all of the information we need from our "caller" -- i.e.
// the geometry that is being rendered with a pattern
gfxRect callerBBox;
if (NS_FAILED(GetTargetGeometry(&callerBBox,
viewBox,
patternContentUnits, patternUnits,
aSource,
aContextMatrix,
aOverrideBounds))) {
return nullptr;
}
// Construct the CTM that we will provide to our children when we
// render them into the tile.
gfxMatrix ctm = ConstructCTM(viewBox, patternContentUnits, patternUnits,
callerBBox, aContextMatrix, aSource);
if (ctm.IsSingular()) {
return nullptr;
}
if (patternWithChildren->mCTM) {
*patternWithChildren->mCTM = ctm;
} else {
patternWithChildren->mCTM = new gfxMatrix(ctm);
}
// Get the bounding box of the pattern. This will be used to determine
// the size of the surface, and will also be used to define the bounding
// box for the pattern tile.
gfxRect bbox = GetPatternRect(patternUnits, callerBBox, aContextMatrix, aSource);
if (bbox.Width() <= 0.0 || bbox.Height() <= 0.0) {
return nullptr;
}
// Get the pattern transform
Matrix patternTransform = ToMatrix(GetPatternTransform());
// revert the vector effect transform so that the pattern appears unchanged
if (aFillOrStroke == &nsStyleSVG::mStroke) {
gfxMatrix userToOuterSVG;
if (nsSVGUtils::GetNonScalingStrokeTransform(aSource, &userToOuterSVG)) {
patternTransform *= ToMatrix(userToOuterSVG);
if (patternTransform.IsSingular()) {
NS_WARNING("Singular matrix painting non-scaling-stroke");
return nullptr;
}
}
}
// Get the transformation matrix that we will hand to the renderer's pattern
// routine.
*patternMatrix = GetPatternMatrix(patternUnits, patternTransform,
bbox, callerBBox, aContextMatrix);
if (patternMatrix->IsSingular()) {
return nullptr;
}
// Now that we have all of the necessary geometries, we can
// create our surface.
gfxRect transformedBBox = ThebesRect(patternTransform.TransformBounds(ToRect(bbox)));
bool resultOverflows;
IntSize surfaceSize =
nsSVGUtils::ConvertToSurfaceSize(
transformedBBox.Size(), &resultOverflows);
// 0 disables rendering, < 0 is an error
if (surfaceSize.width <= 0 || surfaceSize.height <= 0) {
return nullptr;
}
gfxFloat patternWidth = bbox.Width();
gfxFloat patternHeight = bbox.Height();
if (resultOverflows ||
patternWidth != surfaceSize.width ||
patternHeight != surfaceSize.height) {
// scale drawing to pattern surface size
gfxMatrix tempTM =
gfxMatrix(surfaceSize.width / patternWidth, 0.0,
0.0, surfaceSize.height / patternHeight,
0.0, 0.0);
patternWithChildren->mCTM->PreMultiply(tempTM);
// and rescale pattern to compensate
patternMatrix->PreScale(patternWidth / surfaceSize.width,
patternHeight / surfaceSize.height);
}
RefPtr<DrawTarget> dt =
aDrawTarget->CreateSimilarDrawTarget(surfaceSize, SurfaceFormat::B8G8R8A8);
if (!dt || !dt->IsValid()) {
return nullptr;
}
dt->ClearRect(Rect(0, 0, surfaceSize.width, surfaceSize.height));
RefPtr<gfxContext> gfx = gfxContext::CreateOrNull(dt);
MOZ_ASSERT(gfx); // already checked the draw target above
if (aGraphicOpacity != 1.0f) {
gfx->Save();
gfx->PushGroupForBlendBack(gfxContentType::COLOR_ALPHA, aGraphicOpacity);
}
// OK, now render -- note that we use "firstKid", which
// we got at the beginning because it takes care of the
// referenced pattern situation for us
if (aSource->IsFrameOfType(nsIFrame::eSVGGeometry)) {
// Set the geometrical parent of the pattern we are rendering
patternWithChildren->mSource = static_cast<SVGGeometryFrame*>(aSource);
}
// Delay checking NS_FRAME_DRAWING_AS_PAINTSERVER bit until here so we can
// give back a clear surface if there's a loop
if (!(patternWithChildren->GetStateBits() & NS_FRAME_DRAWING_AS_PAINTSERVER)) {
patternWithChildren->AddStateBits(NS_FRAME_DRAWING_AS_PAINTSERVER);
for (nsIFrame* kid = firstKid; kid;
kid = kid->GetNextSibling()) {
// The CTM of each frame referencing us can be different
nsISVGChildFrame* SVGFrame = do_QueryFrame(kid);
if (SVGFrame) {
SVGFrame->NotifySVGChanged(nsISVGChildFrame::TRANSFORM_CHANGED);
}
gfxMatrix tm = *(patternWithChildren->mCTM);
if (kid->GetContent()->IsSVGElement()) {
tm = static_cast<nsSVGElement*>(kid->GetContent())->
PrependLocalTransformsTo(tm, eUserSpaceToParent);
}
DrawResult result = nsSVGUtils::PaintFrameWithEffects(kid, *gfx, tm);
if (result != DrawResult::SUCCESS) {
return nullptr;
}
}
patternWithChildren->RemoveStateBits(NS_FRAME_DRAWING_AS_PAINTSERVER);
}
patternWithChildren->mSource = nullptr;
if (aGraphicOpacity != 1.0f) {
gfx->PopGroupAndBlend();
gfx->Restore();
}
// caller now owns the surface
return dt->Snapshot();
}
/* Will probably need something like this... */
// How do we handle the insertion of a new frame?
// We really don't want to rerender this every time,
// do we?
nsSVGPatternFrame*
nsSVGPatternFrame::GetPatternWithChildren()
{
// Do we have any children ourselves?
if (!mFrames.IsEmpty())
return this;
// No, see if we chain to someone who does
AutoPatternReferencer patternRef(this);
nsSVGPatternFrame* next = GetReferencedPatternIfNotInUse();
if (!next)
return nullptr;
return next->GetPatternWithChildren();
}
uint16_t
nsSVGPatternFrame::GetEnumValue(uint32_t aIndex, nsIContent *aDefault)
{
nsSVGEnum& thisEnum =
static_cast<SVGPatternElement *>(mContent)->mEnumAttributes[aIndex];
if (thisEnum.IsExplicitlySet())
return thisEnum.GetAnimValue();
AutoPatternReferencer patternRef(this);
nsSVGPatternFrame *next = GetReferencedPatternIfNotInUse();
return next ? next->GetEnumValue(aIndex, aDefault) :
static_cast<SVGPatternElement *>(aDefault)->
mEnumAttributes[aIndex].GetAnimValue();
}
nsSVGAnimatedTransformList*
nsSVGPatternFrame::GetPatternTransformList(nsIContent* aDefault)
{
nsSVGAnimatedTransformList *thisTransformList =
static_cast<SVGPatternElement *>(mContent)->GetAnimatedTransformList();
if (thisTransformList && thisTransformList->IsExplicitlySet())
return thisTransformList;
AutoPatternReferencer patternRef(this);
nsSVGPatternFrame *next = GetReferencedPatternIfNotInUse();
return next ? next->GetPatternTransformList(aDefault) :
static_cast<SVGPatternElement *>(aDefault)->mPatternTransform.get();
}
gfxMatrix
nsSVGPatternFrame::GetPatternTransform()
{
nsSVGAnimatedTransformList* animTransformList =
GetPatternTransformList(mContent);
if (!animTransformList)
return gfxMatrix();
return animTransformList->GetAnimValue().GetConsolidationMatrix();
}
const nsSVGViewBox &
nsSVGPatternFrame::GetViewBox(nsIContent* aDefault)
{
const nsSVGViewBox &thisViewBox =
static_cast<SVGPatternElement *>(mContent)->mViewBox;
if (thisViewBox.IsExplicitlySet())
return thisViewBox;
AutoPatternReferencer patternRef(this);
nsSVGPatternFrame *next = GetReferencedPatternIfNotInUse();
return next ? next->GetViewBox(aDefault) :
static_cast<SVGPatternElement *>(aDefault)->mViewBox;
}
const SVGAnimatedPreserveAspectRatio &
nsSVGPatternFrame::GetPreserveAspectRatio(nsIContent *aDefault)
{
const SVGAnimatedPreserveAspectRatio &thisPar =
static_cast<SVGPatternElement *>(mContent)->mPreserveAspectRatio;
if (thisPar.IsExplicitlySet())
return thisPar;
AutoPatternReferencer patternRef(this);
nsSVGPatternFrame *next = GetReferencedPatternIfNotInUse();
return next ? next->GetPreserveAspectRatio(aDefault) :
static_cast<SVGPatternElement *>(aDefault)->mPreserveAspectRatio;
}
const nsSVGLength2 *
nsSVGPatternFrame::GetLengthValue(uint32_t aIndex, nsIContent *aDefault)
{
const nsSVGLength2 *thisLength =
&static_cast<SVGPatternElement *>(mContent)->mLengthAttributes[aIndex];
if (thisLength->IsExplicitlySet())
return thisLength;
AutoPatternReferencer patternRef(this);
nsSVGPatternFrame *next = GetReferencedPatternIfNotInUse();
return next ? next->GetLengthValue(aIndex, aDefault) :
&static_cast<SVGPatternElement *>(aDefault)->mLengthAttributes[aIndex];
}
// Private (helper) methods
nsSVGPatternFrame *
nsSVGPatternFrame::GetReferencedPattern()
{
if (mNoHRefURI)
return nullptr;
nsSVGPaintingProperty *property =
Properties().Get(nsSVGEffects::HrefAsPaintingProperty());
if (!property) {
// Fetch our pattern element's href or xlink:href attribute
SVGPatternElement *pattern = static_cast<SVGPatternElement *>(mContent);
nsAutoString href;
if (pattern->mStringAttributes[SVGPatternElement::HREF].IsExplicitlySet()) {
pattern->mStringAttributes[SVGPatternElement::HREF]
.GetAnimValue(href, pattern);
} else {
pattern->mStringAttributes[SVGPatternElement::XLINK_HREF]
.GetAnimValue(href, pattern);
}
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::svgPatternFrame)
return nullptr;
return static_cast<nsSVGPatternFrame*>(result);
}
nsSVGPatternFrame *
nsSVGPatternFrame::GetReferencedPatternIfNotInUse()
{
nsSVGPatternFrame *referenced = GetReferencedPattern();
if (!referenced)
return nullptr;
if (referenced->mLoopFlag) {
// XXXjwatt: we should really send an error to the JavaScript Console here:
NS_WARNING("pattern reference loop detected while inheriting attribute!");
return nullptr;
}
return referenced;
}
gfxRect
nsSVGPatternFrame::GetPatternRect(uint16_t aPatternUnits,
const gfxRect &aTargetBBox,
const Matrix &aTargetCTM,
nsIFrame *aTarget)
{
// We need to initialize our box
float x,y,width,height;
// Get the pattern x,y,width, and height
const nsSVGLength2 *tmpX, *tmpY, *tmpHeight, *tmpWidth;
tmpX = GetLengthValue(SVGPatternElement::ATTR_X);
tmpY = GetLengthValue(SVGPatternElement::ATTR_Y);
tmpHeight = GetLengthValue(SVGPatternElement::ATTR_HEIGHT);
tmpWidth = GetLengthValue(SVGPatternElement::ATTR_WIDTH);
if (aPatternUnits == SVG_UNIT_TYPE_OBJECTBOUNDINGBOX) {
x = nsSVGUtils::ObjectSpace(aTargetBBox, tmpX);
y = nsSVGUtils::ObjectSpace(aTargetBBox, tmpY);
width = nsSVGUtils::ObjectSpace(aTargetBBox, tmpWidth);
height = nsSVGUtils::ObjectSpace(aTargetBBox, tmpHeight);
} else {
float scale = MaxExpansion(aTargetCTM);
x = nsSVGUtils::UserSpace(aTarget, tmpX) * scale;
y = nsSVGUtils::UserSpace(aTarget, tmpY) * scale;
width = nsSVGUtils::UserSpace(aTarget, tmpWidth) * scale;
height = nsSVGUtils::UserSpace(aTarget, tmpHeight) * scale;
}
return gfxRect(x, y, width, height);
}
gfxMatrix
nsSVGPatternFrame::ConstructCTM(const nsSVGViewBox& aViewBox,
uint16_t aPatternContentUnits,
uint16_t aPatternUnits,
const gfxRect &callerBBox,
const Matrix &callerCTM,
nsIFrame *aTarget)
{
SVGSVGElement *ctx = nullptr;
nsIContent* targetContent = aTarget->GetContent();
gfxFloat scaleX, scaleY;
// The objectBoundingBox conversion must be handled in the CTM:
if (IncludeBBoxScale(aViewBox, aPatternContentUnits, aPatternUnits)) {
scaleX = callerBBox.Width();
scaleY = callerBBox.Height();
} else {
if (targetContent->IsSVGElement()) {
ctx = static_cast<nsSVGElement*>(targetContent)->GetCtx();
}
scaleX = scaleY = MaxExpansion(callerCTM);
}
if (!aViewBox.IsExplicitlySet()) {
return gfxMatrix(scaleX, 0.0, 0.0, scaleY, 0.0, 0.0);
}
const nsSVGViewBoxRect viewBoxRect = aViewBox.GetAnimValue();
if (viewBoxRect.height <= 0.0f || viewBoxRect.width <= 0.0f) {
return gfxMatrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0); // singular
}
float viewportWidth, viewportHeight;
if (targetContent->IsSVGElement()) {
// If we're dealing with an SVG target only retrieve the context once.
// Calling the nsIFrame* variant of GetAnimValue would look it up on
// every call.
viewportWidth =
GetLengthValue(SVGPatternElement::ATTR_WIDTH)->GetAnimValue(ctx);
viewportHeight =
GetLengthValue(SVGPatternElement::ATTR_HEIGHT)->GetAnimValue(ctx);
} else {
// No SVG target, call the nsIFrame* variant of GetAnimValue.
viewportWidth =
GetLengthValue(SVGPatternElement::ATTR_WIDTH)->GetAnimValue(aTarget);
viewportHeight =
GetLengthValue(SVGPatternElement::ATTR_HEIGHT)->GetAnimValue(aTarget);
}
if (viewportWidth <= 0.0f || viewportHeight <= 0.0f) {
return gfxMatrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0); // singular
}
Matrix tm = SVGContentUtils::GetViewBoxTransform(
viewportWidth * scaleX, viewportHeight * scaleY,
viewBoxRect.x, viewBoxRect.y,
viewBoxRect.width, viewBoxRect.height,
GetPreserveAspectRatio());
return ThebesMatrix(tm);
}
//----------------------------------------------------------------------
// nsSVGPaintServerFrame methods:
already_AddRefed<gfxPattern>
nsSVGPatternFrame::GetPaintServerPattern(nsIFrame *aSource,
const DrawTarget* aDrawTarget,
const gfxMatrix& aContextMatrix,
nsStyleSVGPaint nsStyleSVG::*aFillOrStroke,
float aGraphicOpacity,
const gfxRect *aOverrideBounds)
{
if (aGraphicOpacity == 0.0f) {
RefPtr<gfxPattern> pattern = new gfxPattern(Color());
return pattern.forget();
}
// Paint it!
Matrix pMatrix;
RefPtr<SourceSurface> surface =
PaintPattern(aDrawTarget, &pMatrix, ToMatrix(aContextMatrix), aSource,
aFillOrStroke, aGraphicOpacity, aOverrideBounds);
if (!surface) {
return nullptr;
}
RefPtr<gfxPattern> pattern = new gfxPattern(surface, pMatrix);
if (!pattern || pattern->CairoStatus())
return nullptr;
pattern->SetExtend(ExtendMode::REPEAT);
return pattern.forget();
}
// -------------------------------------------------------------------------
// Public functions
// -------------------------------------------------------------------------
nsIFrame* NS_NewSVGPatternFrame(nsIPresShell* aPresShell,
nsStyleContext* aContext)
{
return new (aPresShell) nsSVGPatternFrame(aContext);
}