gecko-dev/layout/svg/nsSVGSwitchFrame.cpp
Ehsan Akhgari 883849ee32 Bug 1145631 - Part 1: Replace MOZ_OVERRIDE and MOZ_FINAL with override and final in the tree; r=froydnj
This patch was automatically generated using the following script:

function convert() {
echo "Converting $1 to $2..."
find . \
       ! -wholename "*/.git*" \
       ! -wholename "obj-ff-dbg*" \
         -type f \
      \( -iname "*.cpp" \
         -o -iname "*.h" \
         -o -iname "*.c" \
         -o -iname "*.cc" \
         -o -iname "*.idl" \
         -o -iname "*.ipdl" \
         -o -iname "*.ipdlh" \
         -o -iname "*.mm" \) | \
    xargs -n 1 sed -i -e "s/\b$1\b/$2/g"
}

convert MOZ_OVERRIDE override
convert MOZ_FINAL final
2015-03-21 12:28:04 -04:00

270 lines
8.1 KiB
C++

/* -*- 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"
using namespace mozilla::gfx;
typedef nsSVGGFrame nsSVGSwitchFrameBase;
class nsSVGSwitchFrame : public nsSVGSwitchFrameBase
{
friend nsIFrame*
NS_NewSVGSwitchFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
protected:
explicit nsSVGSwitchFrame(nsStyleContext* aContext) :
nsSVGSwitchFrameBase(aContext) {}
public:
NS_DECL_FRAMEARENA_HELPERS
#ifdef DEBUG
virtual void Init(nsIContent* aContent,
nsContainerFrame* aParent,
nsIFrame* aPrevInFlow) override;
#endif
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::svgSwitchFrame
*/
virtual nsIAtom* GetType() const override;
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const override
{
return MakeFrameName(NS_LITERAL_STRING("SVGSwitch"), aResult);
}
#endif
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) override;
// nsISVGChildFrame interface:
virtual nsresult PaintSVG(gfxContext& aContext,
const gfxMatrix& aTransform,
const nsIntRect* aDirtyRect = nullptr) override;
nsIFrame* GetFrameForPoint(const gfxPoint& aPoint) override;
nsRect GetCoveredRegion() override;
virtual void ReflowSVG() override;
virtual SVGBBox GetBBoxContribution(const Matrix &aToBBoxUserspace,
uint32_t aFlags) 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->IsSVGElement(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(gfxContext& aContext,
const gfxMatrix& aTransform,
const nsIntRect* aDirtyRect)
{
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) {
gfxMatrix tm = aTransform;
if (kid->GetContent()->IsSVGElement()) {
tm = static_cast<nsSVGElement*>(kid->GetContent())->
PrependLocalTransformsTo(tm, nsSVGElement::eUserSpaceToParent);
}
nsSVGUtils::PaintFrameWithEffects(kid, aContext, tm, aDirtyRect);
}
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<const nsSVGElement*>(mContent)->
PrependLocalTransformsTo(gfxMatrix(), nsSVGElement::eChildToUserSpace);
m = static_cast<const nsSVGElement*>(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");
MOZ_ASSERT(!(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-<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;
nsIFrame *child = GetActiveChildFrame();
nsISVGChildFrame* svgChild = do_QueryFrame(child);
if (svgChild) {
MOZ_ASSERT(!(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->IsSVGElement()) {
transform = static_cast<nsSVGElement*>(content)->
PrependLocalTransformsTo(transform);
}
return svgKid->GetBBoxContribution(ToMatrix(transform), aFlags);
}
return SVGBBox();
}
nsIFrame *
nsSVGSwitchFrame::GetActiveChildFrame()
{
nsIContent *activeChild =
static_cast<mozilla::dom::SVGSwitchElement*>(mContent)->GetActiveChild();
if (activeChild) {
for (nsIFrame* kid = mFrames.FirstChild(); kid;
kid = kid->GetNextSibling()) {
if (activeChild == kid->GetContent()) {
return kid;
}
}
}
return nullptr;
}