/* -*- 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/. */ // Keep in (case-insensitive) order: #include "gfxRect.h" #include "nsSVGEffects.h" #include "nsSVGGFrame.h" #include "mozilla/dom/SVGSwitchElement.h" #include "nsSVGUtils.h" class nsRenderingContext; using namespace mozilla::gfx; typedef nsSVGGFrame nsSVGSwitchFrameBase; class nsSVGSwitchFrame : public nsSVGSwitchFrameBase { friend nsIFrame* NS_NewSVGSwitchFrame(nsIPresShell* aPresShell, nsStyleContext* aContext); protected: nsSVGSwitchFrame(nsStyleContext* aContext) : nsSVGSwitchFrameBase(aContext) {} public: NS_DECL_FRAMEARENA_HELPERS #ifdef DEBUG virtual void Init(nsIContent* aContent, nsContainerFrame* aParent, nsIFrame* aPrevInFlow) MOZ_OVERRIDE; #endif /** * Get the "type" of the frame * * @see nsGkAtoms::svgSwitchFrame */ virtual nsIAtom* GetType() const MOZ_OVERRIDE; #ifdef DEBUG_FRAME_DUMP virtual nsresult GetFrameName(nsAString& aResult) const MOZ_OVERRIDE { return MakeFrameName(NS_LITERAL_STRING("SVGSwitch"), aResult); } #endif virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) MOZ_OVERRIDE; // nsISVGChildFrame interface: virtual nsresult PaintSVG(nsRenderingContext* aContext, const nsIntRect *aDirtyRect, nsIFrame* aTransformRoot) MOZ_OVERRIDE; nsIFrame* GetFrameForPoint(const gfxPoint& aPoint) MOZ_OVERRIDE; nsRect GetCoveredRegion() MOZ_OVERRIDE; virtual void ReflowSVG() MOZ_OVERRIDE; virtual SVGBBox GetBBoxContribution(const Matrix &aToBBoxUserspace, uint32_t aFlags) MOZ_OVERRIDE; private: nsIFrame *GetActiveChildFrame(); }; //---------------------------------------------------------------------- // Implementation nsIFrame* NS_NewSVGSwitchFrame(nsIPresShell* aPresShell, nsStyleContext* aContext) { return new (aPresShell) nsSVGSwitchFrame(aContext); } NS_IMPL_FRAMEARENA_HELPERS(nsSVGSwitchFrame) #ifdef DEBUG void nsSVGSwitchFrame::Init(nsIContent* aContent, nsContainerFrame* aParent, nsIFrame* aPrevInFlow) { NS_ASSERTION(aContent->IsSVG(nsGkAtoms::svgSwitch), "Content is not an SVG switch"); nsSVGSwitchFrameBase::Init(aContent, aParent, aPrevInFlow); } #endif /* DEBUG */ nsIAtom * nsSVGSwitchFrame::GetType() const { return nsGkAtoms::svgSwitchFrame; } void nsSVGSwitchFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) { nsIFrame* kid = GetActiveChildFrame(); if (kid) { BuildDisplayListForChild(aBuilder, kid, aDirtyRect, aLists); } } nsresult nsSVGSwitchFrame::PaintSVG(nsRenderingContext* aContext, const nsIntRect *aDirtyRect, nsIFrame* aTransformRoot) { NS_ASSERTION(!NS_SVGDisplayListPaintingEnabled() || (mState & NS_FRAME_IS_NONDISPLAY), "If display lists are enabled, only painting of non-display " "SVG should take this code path"); if (StyleDisplay()->mOpacity == 0.0) return NS_OK; nsIFrame *kid = GetActiveChildFrame(); if (kid) { nsSVGUtils::PaintFrameWithEffects(aContext, aDirtyRect, kid, aTransformRoot); } return NS_OK; } nsIFrame* nsSVGSwitchFrame::GetFrameForPoint(const gfxPoint& aPoint) { NS_ASSERTION(!NS_SVGDisplayListHitTestingEnabled() || (mState & NS_FRAME_IS_NONDISPLAY), "If display lists are enabled, only hit-testing of non-display " "SVG should take this code path"); nsIFrame *kid = GetActiveChildFrame(); nsISVGChildFrame* svgFrame = do_QueryFrame(kid); if (svgFrame) { // Transform the point from our SVG user space to our child's. gfxPoint point = aPoint; gfxMatrix m = static_cast(mContent)-> PrependLocalTransformsTo(gfxMatrix(), nsSVGElement::eChildToUserSpace); m = static_cast(kid->GetContent())-> PrependLocalTransformsTo(m, nsSVGElement::eUserSpaceToParent); if (!m.IsIdentity()) { if (!m.Invert()) { return nullptr; } point = m.Transform(point); } return svgFrame->GetFrameForPoint(point); } return nullptr; } nsRect nsSVGSwitchFrame::GetCoveredRegion() { nsRect rect; nsIFrame *kid = GetActiveChildFrame(); nsISVGChildFrame* child = do_QueryFrame(kid); if (child) { rect = child->GetCoveredRegion(); } return rect; } void nsSVGSwitchFrame::ReflowSVG() { NS_ASSERTION(nsSVGUtils::OuterSVGIsCallingReflowSVG(this), "This call is probably a wasteful mistake"); NS_ABORT_IF_FALSE(!(GetStateBits() & NS_FRAME_IS_NONDISPLAY), "ReflowSVG mechanism not designed for this"); if (!nsSVGUtils::NeedsReflowSVG(this)) { return; } // If the NS_FRAME_FIRST_REFLOW bit has been removed from our parent frame, // then our outer- 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; nsIFrame *child = GetActiveChildFrame(); nsISVGChildFrame* svgChild = do_QueryFrame(child); if (svgChild) { NS_ABORT_IF_FALSE(!(child->GetStateBits() & NS_FRAME_IS_NONDISPLAY), "Check for this explicitly in the |if|, then"); svgChild->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, child); } 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); } SVGBBox nsSVGSwitchFrame::GetBBoxContribution(const Matrix &aToBBoxUserspace, uint32_t aFlags) { nsIFrame* kid = GetActiveChildFrame(); nsISVGChildFrame* svgKid = do_QueryFrame(kid); if (svgKid) { nsIContent *content = kid->GetContent(); gfxMatrix transform = ThebesMatrix(aToBBoxUserspace); if (content->IsSVG()) { transform = static_cast(content)-> PrependLocalTransformsTo(transform); } return svgKid->GetBBoxContribution(ToMatrix(transform), aFlags); } return SVGBBox(); } nsIFrame * nsSVGSwitchFrame::GetActiveChildFrame() { nsIContent *activeChild = static_cast(mContent)->GetActiveChild(); if (activeChild) { for (nsIFrame* kid = mFrames.FirstChild(); kid; kid = kid->GetNextSibling()) { if (activeChild == kid->GetContent()) { return kid; } } } return nullptr; }