Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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
// Main header first:
#include "SVGContainerFrame.h"
// Keep others in (case-insensitive) order:
#include "ImgDrawResult.h"
#include "mozilla/PresShell.h"
#include "mozilla/RestyleManager.h"
#include "mozilla/SVGObserverUtils.h"
#include "mozilla/SVGTextFrame.h"
#include "mozilla/SVGUtils.h"
#include "mozilla/dom/SVGElement.h"
#include "nsCSSFrameConstructor.h"
#include "SVGAnimatedTransformList.h"
using namespace mozilla::dom;
using namespace mozilla::image;
nsIFrame* NS_NewSVGContainerFrame(mozilla::PresShell* aPresShell,
mozilla::ComputedStyle* aStyle) {
nsIFrame* frame = new (aPresShell)
mozilla::SVGContainerFrame(aStyle, aPresShell->GetPresContext(),
mozilla::SVGContainerFrame::kClassID);
// If we were called directly, then the frame is for a <defs> or
// an unknown element type. In both cases we prevent the content
// from displaying directly.
frame->AddStateBits(NS_FRAME_IS_NONDISPLAY);
return frame;
}
namespace mozilla {
NS_QUERYFRAME_HEAD(SVGContainerFrame)
NS_QUERYFRAME_ENTRY(SVGContainerFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
NS_QUERYFRAME_HEAD(SVGDisplayContainerFrame)
NS_QUERYFRAME_ENTRY(SVGDisplayContainerFrame)
NS_QUERYFRAME_ENTRY(ISVGDisplayableFrame)
NS_QUERYFRAME_TAIL_INHERITING(SVGContainerFrame)
NS_IMPL_FRAMEARENA_HELPERS(SVGContainerFrame)
void SVGContainerFrame::AppendFrames(ChildListID aListID,
nsFrameList&& aFrameList) {
InsertFrames(aListID, mFrames.LastChild(), nullptr, std::move(aFrameList));
}
void SVGContainerFrame::InsertFrames(ChildListID aListID, nsIFrame* aPrevFrame,
const nsLineList::iterator* aPrevFrameLine,
nsFrameList&& aFrameList) {
NS_ASSERTION(aListID == FrameChildListID::Principal, "unexpected child list");
NS_ASSERTION(!aPrevFrame || aPrevFrame->GetParent() == this,
"inserting after sibling frame with different parent");
mFrames.InsertFrames(this, aPrevFrame, std::move(aFrameList));
}
void SVGContainerFrame::RemoveFrame(DestroyContext& aContext,
ChildListID aListID, nsIFrame* aOldFrame) {
NS_ASSERTION(aListID == FrameChildListID::Principal, "unexpected child list");
mFrames.DestroyFrame(aContext, aOldFrame);
}
bool SVGContainerFrame::ComputeCustomOverflow(OverflowAreas& aOverflowAreas) {
if (HasAnyStateBits(NS_FRAME_IS_NONDISPLAY)) {
// We don't maintain overflow rects.
// XXX It would have be better if the restyle request hadn't even happened.
return false;
}
return nsContainerFrame::ComputeCustomOverflow(aOverflowAreas);
}
/**
* Traverses a frame tree, marking any SVGTextFrame frames as dirty
* and calling InvalidateRenderingObservers() on it.
*
* The reason that this helper exists is because SVGTextFrame is special.
* None of the other SVG frames ever need to be reflowed when they have the
* NS_FRAME_IS_NONDISPLAY bit set on them because their PaintSVG methods
* (and those of any containers that they can validly be contained within) do
* not make use of mRect or overflow rects. "em" lengths, etc., are resolved
* as those elements are painted.
*
* SVGTextFrame is different because its anonymous block and inline frames
* need to be reflowed in order to get the correct metrics when things like
* inherited font-size of an ancestor changes, or a delayed webfont loads and
* applies.
*
* However, we only need to do this work if we were reflowed with
* NS_FRAME_IS_DIRTY, which implies that all descendants are dirty. When
* that reflow reaches an NS_FRAME_IS_NONDISPLAY frame it would normally
* stop, but this helper looks for any SVGTextFrame descendants of such
* frames and marks them NS_FRAME_IS_DIRTY so that the next time that they
* are painted their anonymous kid will first get the necessary reflow.
*/
/* static */
void SVGContainerFrame::ReflowSVGNonDisplayText(nsIFrame* aContainer) {
if (!aContainer->HasAnyStateBits(NS_FRAME_IS_DIRTY)) {
return;
}
MOZ_ASSERT(aContainer->HasAnyStateBits(NS_FRAME_IS_NONDISPLAY) ||
!aContainer->IsSVGFrame(),
"it is wasteful to call ReflowSVGNonDisplayText on a container "
"frame that is not NS_FRAME_IS_NONDISPLAY or not SVG");
for (nsIFrame* kid : aContainer->PrincipalChildList()) {
LayoutFrameType type = kid->Type();
if (type == LayoutFrameType::SVGText) {
static_cast<SVGTextFrame*>(kid)->ReflowSVGNonDisplayText();
} else if (kid->IsSVGContainerFrame() ||
type == LayoutFrameType::SVGForeignObject ||
!kid->IsSVGFrame()) {
ReflowSVGNonDisplayText(kid);
}
}
}
void SVGDisplayContainerFrame::Init(nsIContent* aContent,
nsContainerFrame* aParent,
nsIFrame* aPrevInFlow) {
if (!IsSVGOuterSVGFrame()) {
AddStateBits(aParent->GetStateBits() & NS_STATE_SVG_CLIPPATH_CHILD);
}
SVGContainerFrame::Init(aContent, aParent, aPrevInFlow);
}
void SVGDisplayContainerFrame::BuildDisplayList(
nsDisplayListBuilder* aBuilder, const nsDisplayListSet& aLists) {
// content could be a XUL element so check for an SVG element
if (auto* svg = SVGElement::FromNode(GetContent())) {
if (!svg->HasValidDimensions()) {
return;
}
}
DisplayOutline(aBuilder, aLists);
return BuildDisplayListForNonBlockChildren(aBuilder, aLists);
}
void SVGDisplayContainerFrame::InsertFrames(
ChildListID aListID, nsIFrame* aPrevFrame,
const nsLineList::iterator* aPrevFrameLine, nsFrameList&& aFrameList) {
// memorize first old frame after insertion point
// XXXbz once again, this would work a lot better if the nsIFrame
// methods returned framelist iterators....
nsIFrame* nextFrame = aPrevFrame ? aPrevFrame->GetNextSibling()
: GetChildList(aListID).FirstChild();
nsIFrame* firstNewFrame = aFrameList.FirstChild();
// Insert the new frames
SVGContainerFrame::InsertFrames(aListID, aPrevFrame, aPrevFrameLine,
std::move(aFrameList));
// If we are not a non-display SVG frame and we do not have a bounds update
// pending, then we need to schedule one for our new children:
if (!HasAnyStateBits(NS_FRAME_IS_DIRTY | NS_FRAME_HAS_DIRTY_CHILDREN |
NS_FRAME_IS_NONDISPLAY)) {
for (nsIFrame* kid = firstNewFrame; kid != nextFrame;
kid = kid->GetNextSibling()) {
ISVGDisplayableFrame* SVGFrame = do_QueryFrame(kid);
if (SVGFrame && !kid->HasAnyStateBits(NS_FRAME_IS_NONDISPLAY)) {
bool isFirstReflow = kid->HasAnyStateBits(NS_FRAME_FIRST_REFLOW);
// Remove bits so that ScheduleBoundsUpdate will work:
kid->RemoveStateBits(NS_FRAME_FIRST_REFLOW | NS_FRAME_IS_DIRTY |
NS_FRAME_HAS_DIRTY_CHILDREN);
// No need to invalidate the new kid's old bounds, so we just use
// SVGUtils::ScheduleBoundsUpdate.
SVGUtils::ScheduleReflowSVG(kid);
if (isFirstReflow) {
// Add back the NS_FRAME_FIRST_REFLOW bit:
kid->AddStateBits(NS_FRAME_FIRST_REFLOW);
}
}
}
}
}
void SVGDisplayContainerFrame::RemoveFrame(DestroyContext& aContext,
ChildListID aListID,
nsIFrame* aOldFrame) {
SVGObserverUtils::InvalidateRenderingObservers(aOldFrame);
// SVGContainerFrame::RemoveFrame doesn't call down into
// nsContainerFrame::RemoveFrame, so it doesn't call FrameNeedsReflow. We
// need to schedule a repaint and schedule an update to our overflow rects.
SchedulePaint();
if (!HasAnyStateBits(NS_FRAME_IS_NONDISPLAY)) {
PresContext()->RestyleManager()->PostRestyleEvent(
mContent->AsElement(), RestyleHint{0}, nsChangeHint_UpdateOverflow);
}
SVGContainerFrame::RemoveFrame(aContext, aListID, aOldFrame);
}
bool SVGDisplayContainerFrame::DoGetParentSVGTransforms(
gfx::Matrix* aFromParentTransform) const {
return SVGUtils::GetParentSVGTransforms(this, aFromParentTransform);
}
//----------------------------------------------------------------------
// ISVGDisplayableFrame methods
void SVGDisplayContainerFrame::PaintSVG(gfxContext& aContext,
const gfxMatrix& aTransform,
imgDrawingParams& aImgParams) {
NS_ASSERTION(HasAnyStateBits(NS_FRAME_IS_NONDISPLAY) ||
PresContext()->Document()->IsSVGGlyphsDocument(),
"Only painting of non-display SVG should take this code path");
if (StyleEffects()->IsTransparent()) {
return;
}
gfxMatrix matrix = aTransform;
if (auto* svg = SVGElement::FromNode(GetContent())) {
matrix = svg->ChildToUserSpaceTransform() * matrix;
if (matrix.IsSingular()) {
return;
}
}
for (auto* kid : mFrames) {
gfxMatrix m = matrix;
// PaintFrameWithEffects() expects the transform that is passed to it to
// include the transform to the passed frame's user space, so add it:
const nsIContent* content = kid->GetContent();
if (const SVGElement* element = SVGElement::FromNode(content)) {
if (!element->HasValidDimensions()) {
continue; // nothing to paint for kid
}
m = SVGUtils::GetTransformMatrixInUserSpace(kid) * m;
if (m.IsSingular()) {
continue;
}
}
SVGUtils::PaintFrameWithEffects(kid, aContext, m, aImgParams);
}
}
nsIFrame* SVGDisplayContainerFrame::GetFrameForPoint(const gfxPoint& aPoint) {
NS_ASSERTION(HasAnyStateBits(NS_STATE_SVG_CLIPPATH_CHILD),
"Only hit-testing of a clipPath's contents should take this "
"code path");
// First we transform aPoint into the coordinate space established by aFrame
// for its children (e.g. take account of any 'viewBox' attribute):
gfxPoint point = aPoint;
if (const auto* svg = SVGElement::FromNode(GetContent())) {
gfxMatrix m = svg->ChildToUserSpaceTransform();
if (!m.IsIdentity()) {
if (!m.Invert()) {
return nullptr;
}
point = m.TransformPoint(point);
}
}
// Traverse the list in reverse order, so that if we get a hit we know that's
// the topmost frame that intersects the point; then we can just return it.
nsIFrame* result = nullptr;
for (nsIFrame* current = PrincipalChildList().LastChild(); current;
current = current->GetPrevSibling()) {
ISVGDisplayableFrame* SVGFrame = do_QueryFrame(current);
if (!SVGFrame) {
continue;
}
const nsIContent* content = current->GetContent();
if (const auto* svg = SVGElement::FromNode(content)) {
if (!svg->HasValidDimensions()) {
continue;
}
}
result = SVGFrame->GetFrameForPoint(point);
if (result) {
break;
}
}
if (result && !SVGUtils::HitTestClip(this, aPoint)) {
result = nullptr;
}
return result;
}
void SVGDisplayContainerFrame::ReflowSVG() {
MOZ_ASSERT(SVGUtils::AnyOuterSVGIsCallingReflowSVG(this),
"This call is probably a wasteful mistake");
MOZ_ASSERT(!HasAnyStateBits(NS_FRAME_IS_NONDISPLAY),
"ReflowSVG mechanism not designed for this");
MOZ_ASSERT(!IsSVGOuterSVGFrame(), "Do not call on outer-<svg>");
if (!SVGUtils::NeedsReflowSVG(this)) {
return;
}
// If the NS_FRAME_FIRST_REFLOW bit has been removed from our parent frame,
// then our outer-<svg> has previously had its initial reflow. In that case
// we need to make sure that that bit has been removed from ourself _before_
// recursing over our children to ensure that they know too. Otherwise, we
// need to remove it _after_ recursing over our children so that they know
// the initial reflow is currently underway.
bool isFirstReflow = HasAnyStateBits(NS_FRAME_FIRST_REFLOW);
bool outerSVGHasHadFirstReflow =
!GetParent()->HasAnyStateBits(NS_FRAME_FIRST_REFLOW);
if (outerSVGHasHadFirstReflow) {
RemoveStateBits(NS_FRAME_FIRST_REFLOW); // tell our children
}
OverflowAreas overflowRects;
for (auto* kid : mFrames) {
ISVGDisplayableFrame* SVGFrame = do_QueryFrame(kid);
if (SVGFrame && !kid->HasAnyStateBits(NS_FRAME_IS_NONDISPLAY)) {
SVGFrame->ReflowSVG();
// We build up our child frame overflows here instead of using
// nsLayoutUtils::UnionChildOverflow since SVG frame's all use the same
// frame list, and we're iterating over that list now anyway.
ConsiderChildOverflow(overflowRects, kid);
} else {
// Inside a non-display container frame, we might have some
// SVGTextFrames. We need to cause those to get reflowed in
// case they are the target of a rendering observer.
MOZ_ASSERT(
kid->HasAnyStateBits(NS_FRAME_IS_NONDISPLAY) || !kid->IsSVGFrame(),
"expected kid to be a NS_FRAME_IS_NONDISPLAY frame or not SVG");
if (kid->HasAnyStateBits(NS_FRAME_IS_DIRTY)) {
SVGContainerFrame* container = do_QueryFrame(kid);
if (container && container->GetContent()->IsSVGElement()) {
ReflowSVGNonDisplayText(container);
}
}
}
}
// <svg> can create an SVG viewport with an offset due to its
// x/y/width/height attributes, and <use> can introduce an offset with an
// empty mRect (any width/height is copied to an anonymous <svg> child).
// Other than that containers should not set mRect since all other offsets
// come from transforms, which are accounted for by nsDisplayTransform.
// Note that we rely on |overflow:visible| to allow display list items to be
// created for our children.
MOZ_ASSERT(mContent->IsAnyOfSVGElements(nsGkAtoms::svg, nsGkAtoms::symbol) ||
(mContent->IsSVGElement(nsGkAtoms::use) &&
mRect.Size() == nsSize(0, 0)) ||
mRect.IsEqualEdges(nsRect()),
"Only inner-<svg>/<use> is expected to have mRect set");
if (isFirstReflow) {
// Make sure we have our filter property (if any) before calling
// FinishAndStoreOverflow (subsequent filter changes are handled off
// nsChangeHint_UpdateEffects):
SVGObserverUtils::UpdateEffects(this);
}
FinishAndStoreOverflow(overflowRects, mRect.Size());
// Remove state bits after FinishAndStoreOverflow so that it doesn't
// invalidate on first reflow:
RemoveStateBits(NS_FRAME_FIRST_REFLOW | NS_FRAME_IS_DIRTY |
NS_FRAME_HAS_DIRTY_CHILDREN);
}
void SVGDisplayContainerFrame::DidSetComputedStyle(ComputedStyle* aOldStyle) {
nsContainerFrame::DidSetComputedStyle(aOldStyle);
if (!aOldStyle) {
return;
}
if (StyleDisplay()->CalcTransformPropertyDifference(
*aOldStyle->StyleDisplay())) {
NotifySVGChanged(TRANSFORM_CHANGED);
}
}
void SVGDisplayContainerFrame::NotifySVGChanged(uint32_t aFlags) {
MOZ_ASSERT(aFlags & (TRANSFORM_CHANGED | COORD_CONTEXT_CHANGED),
"Invalidation logic may need adjusting");
if (aFlags & TRANSFORM_CHANGED) {
// make sure our cached transform matrix gets (lazily) updated
mCanvasTM = nullptr;
}
SVGUtils::NotifyChildrenOfSVGChange(this, aFlags);
}
SVGBBox SVGDisplayContainerFrame::GetBBoxContribution(
const Matrix& aToBBoxUserspace, uint32_t aFlags) {
SVGBBox bboxUnion;
for (nsIFrame* kid : mFrames) {
ISVGDisplayableFrame* svgKid = do_QueryFrame(kid);
if (!svgKid) {
continue;
}
// content could be a XUL element
auto* svg = SVGElement::FromNode(kid->GetContent());
if (svg && !svg->HasValidDimensions()) {
continue;
}
gfxMatrix transform = gfx::ThebesMatrix(aToBBoxUserspace);
if (svg) {
transform = svg->ChildToUserSpaceTransform() *
SVGUtils::GetTransformMatrixInUserSpace(kid) * transform;
}
// We need to include zero width/height vertical/horizontal lines, so we
// have to use UnionEdges.
bboxUnion.UnionEdges(
svgKid->GetBBoxContribution(gfx::ToMatrix(transform), aFlags));
}
return bboxUnion;
}
gfxMatrix SVGDisplayContainerFrame::GetCanvasTM() {
if (!mCanvasTM) {
NS_ASSERTION(GetParent(), "null parent");
auto* parent = static_cast<SVGContainerFrame*>(GetParent());
auto* content = static_cast<SVGElement*>(GetContent());
mCanvasTM = MakeUnique<gfxMatrix>(content->ChildToUserSpaceTransform() *
parent->GetCanvasTM());
}
return *mCanvasTM;
}
} // namespace mozilla