diff options
Diffstat (limited to 'layout/svg/nsSVGContainerFrame.cpp')
| -rw-r--r-- | layout/svg/nsSVGContainerFrame.cpp | 445 |
1 files changed, 445 insertions, 0 deletions
diff --git a/layout/svg/nsSVGContainerFrame.cpp b/layout/svg/nsSVGContainerFrame.cpp new file mode 100644 index 0000000000..750dcc9da0 --- /dev/null +++ b/layout/svg/nsSVGContainerFrame.cpp @@ -0,0 +1,445 @@ +/* -*- 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 "nsSVGContainerFrame.h" + +// Keep others in (case-insensitive) order: +#include "mozilla/RestyleManagerHandle.h" +#include "mozilla/RestyleManagerHandleInlines.h" +#include "nsCSSFrameConstructor.h" +#include "nsSVGEffects.h" +#include "nsSVGElement.h" +#include "nsSVGUtils.h" +#include "nsSVGAnimatedTransformList.h" +#include "SVGTextFrame.h" + +using namespace mozilla; + +NS_QUERYFRAME_HEAD(nsSVGContainerFrame) + NS_QUERYFRAME_ENTRY(nsSVGContainerFrame) +NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame) + +NS_QUERYFRAME_HEAD(nsSVGDisplayContainerFrame) + NS_QUERYFRAME_ENTRY(nsSVGDisplayContainerFrame) + NS_QUERYFRAME_ENTRY(nsISVGChildFrame) +NS_QUERYFRAME_TAIL_INHERITING(nsSVGContainerFrame) + +nsIFrame* +NS_NewSVGContainerFrame(nsIPresShell* aPresShell, + nsStyleContext* aContext) +{ + nsIFrame *frame = new (aPresShell) nsSVGContainerFrame(aContext); + // 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; +} + +NS_IMPL_FRAMEARENA_HELPERS(nsSVGContainerFrame) +NS_IMPL_FRAMEARENA_HELPERS(nsSVGDisplayContainerFrame) + +void +nsSVGContainerFrame::AppendFrames(ChildListID aListID, + nsFrameList& aFrameList) +{ + InsertFrames(aListID, mFrames.LastChild(), aFrameList); +} + +void +nsSVGContainerFrame::InsertFrames(ChildListID aListID, + nsIFrame* aPrevFrame, + nsFrameList& aFrameList) +{ + NS_ASSERTION(aListID == kPrincipalList, "unexpected child list"); + NS_ASSERTION(!aPrevFrame || aPrevFrame->GetParent() == this, + "inserting after sibling frame with different parent"); + + mFrames.InsertFrames(this, aPrevFrame, aFrameList); +} + +void +nsSVGContainerFrame::RemoveFrame(ChildListID aListID, + nsIFrame* aOldFrame) +{ + NS_ASSERTION(aListID == kPrincipalList, "unexpected child list"); + + mFrames.DestroyFrame(aOldFrame); +} + +bool +nsSVGContainerFrame::ComputeCustomOverflow(nsOverflowAreas& aOverflowAreas) +{ + if (mState & 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. + * + * We assume that any change that requires the anonymous kid of an + * SVGTextFrame to reflow will result in an NS_FRAME_IS_DIRTY reflow. 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 +nsSVGContainerFrame::ReflowSVGNonDisplayText(nsIFrame* aContainer) +{ + NS_ASSERTION(aContainer->GetStateBits() & NS_FRAME_IS_DIRTY, + "expected aContainer to be NS_FRAME_IS_DIRTY"); + NS_ASSERTION((aContainer->GetStateBits() & NS_FRAME_IS_NONDISPLAY) || + !aContainer->IsFrameOfType(nsIFrame::eSVG), + "it is wasteful to call ReflowSVGNonDisplayText on a container " + "frame that is not NS_FRAME_IS_NONDISPLAY"); + for (nsIFrame* kid : aContainer->PrincipalChildList()) { + nsIAtom* type = kid->GetType(); + if (type == nsGkAtoms::svgTextFrame) { + static_cast<SVGTextFrame*>(kid)->ReflowSVGNonDisplayText(); + } else { + if (kid->IsFrameOfType(nsIFrame::eSVG | nsIFrame::eSVGContainer) || + type == nsGkAtoms::svgForeignObjectFrame || + !kid->IsFrameOfType(nsIFrame::eSVG)) { + ReflowSVGNonDisplayText(kid); + } + } + } +} + +void +nsSVGDisplayContainerFrame::Init(nsIContent* aContent, + nsContainerFrame* aParent, + nsIFrame* aPrevInFlow) +{ + if (!(GetStateBits() & NS_STATE_IS_OUTER_SVG)) { + AddStateBits(aParent->GetStateBits() & NS_STATE_SVG_CLIPPATH_CHILD); + } + nsSVGContainerFrame::Init(aContent, aParent, aPrevInFlow); +} + +void +nsSVGDisplayContainerFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder, + const nsRect& aDirtyRect, + const nsDisplayListSet& aLists) +{ + // mContent could be a XUL element so check for an SVG element before casting + if (mContent->IsSVGElement() && + !static_cast<const nsSVGElement*>(mContent)->HasValidDimensions()) { + return; + } + DisplayOutline(aBuilder, aLists); + return BuildDisplayListForNonBlockChildren(aBuilder, aDirtyRect, aLists); +} + +void +nsSVGDisplayContainerFrame::InsertFrames(ChildListID aListID, + nsIFrame* aPrevFrame, + 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 + nsSVGContainerFrame::InsertFrames(aListID, aPrevFrame, 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 (!(GetStateBits() & + (NS_FRAME_IS_DIRTY | NS_FRAME_HAS_DIRTY_CHILDREN | + NS_FRAME_IS_NONDISPLAY))) { + for (nsIFrame* kid = firstNewFrame; kid != nextFrame; + kid = kid->GetNextSibling()) { + nsISVGChildFrame* SVGFrame = do_QueryFrame(kid); + if (SVGFrame) { + MOZ_ASSERT(!(kid->GetStateBits() & NS_FRAME_IS_NONDISPLAY), + "Check for this explicitly in the |if|, then"); + bool isFirstReflow = (kid->GetStateBits() & 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 + // nsSVGUtils::ScheduleBoundsUpdate. + nsSVGUtils::ScheduleReflowSVG(kid); + if (isFirstReflow) { + // Add back the NS_FRAME_FIRST_REFLOW bit: + kid->AddStateBits(NS_FRAME_FIRST_REFLOW); + } + } + } + } +} + +void +nsSVGDisplayContainerFrame::RemoveFrame(ChildListID aListID, + nsIFrame* aOldFrame) +{ + nsSVGEffects::InvalidateRenderingObservers(aOldFrame); + + // nsSVGContainerFrame::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(); + PresContext()->RestyleManager()->PostRestyleEvent( + mContent->AsElement(), nsRestyleHint(0), nsChangeHint_UpdateOverflow); + + nsSVGContainerFrame::RemoveFrame(aListID, aOldFrame); + + if (!(GetStateBits() & (NS_FRAME_IS_NONDISPLAY | NS_STATE_IS_OUTER_SVG))) { + nsSVGUtils::NotifyAncestorsOfFilterRegionChange(this); + } +} + +bool +nsSVGDisplayContainerFrame::IsSVGTransformed(gfx::Matrix *aOwnTransform, + gfx::Matrix *aFromParentTransform) const +{ + bool foundTransform = false; + + // Check if our parent has children-only transforms: + nsIFrame *parent = GetParent(); + if (parent && + parent->IsFrameOfType(nsIFrame::eSVG | nsIFrame::eSVGContainer)) { + foundTransform = static_cast<nsSVGContainerFrame*>(parent)-> + HasChildrenOnlyTransform(aFromParentTransform); + } + + // mContent could be a XUL element so check for an SVG element before casting + if (mContent->IsSVGElement()) { + nsSVGElement *content = static_cast<nsSVGElement*>(mContent); + nsSVGAnimatedTransformList* transformList = + content->GetAnimatedTransformList(); + if ((transformList && transformList->HasTransform()) || + content->GetAnimateMotionTransform()) { + if (aOwnTransform) { + *aOwnTransform = gfx::ToMatrix( + content->PrependLocalTransformsTo( + gfxMatrix(), eUserSpaceToParent)); + } + foundTransform = true; + } + } + return foundTransform; +} + +//---------------------------------------------------------------------- +// nsISVGChildFrame methods + +DrawResult +nsSVGDisplayContainerFrame::PaintSVG(gfxContext& aContext, + const gfxMatrix& aTransform, + const nsIntRect *aDirtyRect) +{ + NS_ASSERTION(!NS_SVGDisplayListPaintingEnabled() || + (mState & NS_FRAME_IS_NONDISPLAY) || + PresContext()->IsGlyph(), + "If display lists are enabled, only painting of non-display " + "SVG should take this code path"); + + if (StyleEffects()->mOpacity == 0.0) { + return DrawResult::SUCCESS; + } + + gfxMatrix matrix = aTransform; + if (GetContent()->IsSVGElement()) { // must check before cast + matrix = static_cast<const nsSVGElement*>(GetContent())-> + PrependLocalTransformsTo(matrix, eChildToUserSpace); + if (matrix.IsSingular()) { + return DrawResult::SUCCESS; + } + } + + DrawResult result = DrawResult::SUCCESS; + for (nsIFrame* kid = mFrames.FirstChild(); kid; + kid = kid->GetNextSibling()) { + 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 (content->IsSVGElement()) { // must check before cast + const nsSVGElement* element = static_cast<const nsSVGElement*>(content); + if (!element->HasValidDimensions()) { + continue; // nothing to paint for kid + } + m = element->PrependLocalTransformsTo(m, eUserSpaceToParent); + if (m.IsSingular()) { + continue; + } + } + result = nsSVGUtils::PaintFrameWithEffects(kid, aContext, m, aDirtyRect); + if (result != DrawResult::SUCCESS) { + return result; + } + } + + return result; +} + +nsIFrame* +nsSVGDisplayContainerFrame::GetFrameForPoint(const gfxPoint& aPoint) +{ + NS_ASSERTION(!NS_SVGDisplayListHitTestingEnabled() || + (mState & NS_FRAME_IS_NONDISPLAY), + "If display lists are enabled, only hit-testing of a " + "clipPath's contents should take this code path"); + return nsSVGUtils::HitTestChildren(this, aPoint); +} + +nsRect +nsSVGDisplayContainerFrame::GetCoveredRegion() +{ + return nsSVGUtils::GetCoveredRegion(mFrames); +} + +void +nsSVGDisplayContainerFrame::ReflowSVG() +{ + NS_ASSERTION(nsSVGUtils::OuterSVGIsCallingReflowSVG(this), + "This call is probably a wasteful mistake"); + + MOZ_ASSERT(!(GetStateBits() & NS_FRAME_IS_NONDISPLAY), + "ReflowSVG mechanism not designed for this"); + + MOZ_ASSERT(GetType() != nsGkAtoms::svgOuterSVGFrame, + "Do not call on outer-<svg>"); + + if (!nsSVGUtils::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 = (mState & NS_FRAME_FIRST_REFLOW); + + bool outerSVGHasHadFirstReflow = + (GetParent()->GetStateBits() & NS_FRAME_FIRST_REFLOW) == 0; + + if (outerSVGHasHadFirstReflow) { + mState &= ~NS_FRAME_FIRST_REFLOW; // tell our children + } + + nsOverflowAreas overflowRects; + + for (nsIFrame* kid = mFrames.FirstChild(); kid; + kid = kid->GetNextSibling()) { + nsISVGChildFrame* SVGFrame = do_QueryFrame(kid); + if (SVGFrame) { + MOZ_ASSERT(!(kid->GetStateBits() & NS_FRAME_IS_NONDISPLAY), + "Check for this explicitly in the |if|, then"); + kid->AddStateBits(mState & NS_FRAME_IS_DIRTY); + 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. + NS_ASSERTION(kid->GetStateBits() & NS_FRAME_IS_NONDISPLAY, + "expected kid to be a NS_FRAME_IS_NONDISPLAY frame"); + if (kid->GetStateBits() & NS_FRAME_IS_DIRTY) { + nsSVGContainerFrame* 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->IsSVGElement(nsGkAtoms::svg) || + (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): + nsSVGEffects::UpdateEffects(this); + } + + FinishAndStoreOverflow(overflowRects, mRect.Size()); + + // Remove state bits after FinishAndStoreOverflow so that it doesn't + // invalidate on first reflow: + mState &= ~(NS_FRAME_FIRST_REFLOW | NS_FRAME_IS_DIRTY | + NS_FRAME_HAS_DIRTY_CHILDREN); +} + +void +nsSVGDisplayContainerFrame::NotifySVGChanged(uint32_t aFlags) +{ + MOZ_ASSERT(aFlags & (TRANSFORM_CHANGED | COORD_CONTEXT_CHANGED), + "Invalidation logic may need adjusting"); + + nsSVGUtils::NotifyChildrenOfSVGChange(this, aFlags); +} + +SVGBBox +nsSVGDisplayContainerFrame::GetBBoxContribution( + const Matrix &aToBBoxUserspace, + uint32_t aFlags) +{ + SVGBBox bboxUnion; + + nsIFrame* kid = mFrames.FirstChild(); + while (kid) { + nsIContent *content = kid->GetContent(); + nsISVGChildFrame* svgKid = do_QueryFrame(kid); + // content could be a XUL element so check for an SVG element before casting + if (svgKid && (!content->IsSVGElement() || + static_cast<const nsSVGElement*>(content)->HasValidDimensions())) { + + gfxMatrix transform = gfx::ThebesMatrix(aToBBoxUserspace); + if (content->IsSVGElement()) { + transform = static_cast<nsSVGElement*>(content)-> + PrependLocalTransformsTo(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)); + } + kid = kid->GetNextSibling(); + } + + return bboxUnion; +} |