2008-01-03 14:30:02 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
2012-05-21 11:12:37 +00:00
|
|
|
/* 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/. */
|
2008-01-03 14:30:02 +00:00
|
|
|
|
2012-03-26 11:58:59 +00:00
|
|
|
// Keep in (case-insensitive) order:
|
|
|
|
#include "gfxRect.h"
|
2012-05-17 04:05:09 +00:00
|
|
|
#include "nsSVGEffects.h"
|
2008-01-03 14:30:02 +00:00
|
|
|
#include "nsSVGGFrame.h"
|
2013-01-06 06:25:54 +00:00
|
|
|
#include "mozilla/dom/SVGSwitchElement.h"
|
2012-03-18 10:32:02 +00:00
|
|
|
#include "nsSVGUtils.h"
|
2008-01-03 14:30:02 +00:00
|
|
|
|
2012-03-02 08:28:59 +00:00
|
|
|
class nsRenderingContext;
|
|
|
|
|
2013-12-30 06:50:07 +00:00
|
|
|
using namespace mozilla::gfx;
|
|
|
|
|
2008-07-13 11:30:48 +00:00
|
|
|
typedef nsSVGGFrame nsSVGSwitchFrameBase;
|
2008-01-03 14:30:02 +00:00
|
|
|
|
2008-07-13 11:30:48 +00:00
|
|
|
class nsSVGSwitchFrame : public nsSVGSwitchFrameBase
|
2008-01-03 14:30:02 +00:00
|
|
|
{
|
|
|
|
friend nsIFrame*
|
2009-01-19 18:31:34 +00:00
|
|
|
NS_NewSVGSwitchFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
|
2008-01-03 14:30:02 +00:00
|
|
|
protected:
|
|
|
|
nsSVGSwitchFrame(nsStyleContext* aContext) :
|
2008-07-13 11:30:48 +00:00
|
|
|
nsSVGSwitchFrameBase(aContext) {}
|
2008-01-03 14:30:02 +00:00
|
|
|
|
|
|
|
public:
|
2009-09-12 16:49:24 +00:00
|
|
|
NS_DECL_FRAMEARENA_HELPERS
|
|
|
|
|
2009-01-19 18:31:34 +00:00
|
|
|
#ifdef DEBUG
|
2014-05-24 22:20:40 +00:00
|
|
|
virtual void Init(nsIContent* aContent,
|
|
|
|
nsContainerFrame* aParent,
|
|
|
|
nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
|
2009-01-19 18:31:34 +00:00
|
|
|
#endif
|
|
|
|
|
2008-01-03 14:30:02 +00:00
|
|
|
/**
|
|
|
|
* Get the "type" of the frame
|
|
|
|
*
|
|
|
|
* @see nsGkAtoms::svgSwitchFrame
|
|
|
|
*/
|
2014-02-24 14:41:56 +00:00
|
|
|
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
|
2008-01-03 14:30:02 +00:00
|
|
|
|
2014-01-05 23:31:14 +00:00
|
|
|
#ifdef DEBUG_FRAME_DUMP
|
2014-02-24 14:41:56 +00:00
|
|
|
virtual nsresult GetFrameName(nsAString& aResult) const MOZ_OVERRIDE
|
2008-01-03 14:30:02 +00:00
|
|
|
{
|
|
|
|
return MakeFrameName(NS_LITERAL_STRING("SVGSwitch"), aResult);
|
|
|
|
}
|
|
|
|
#endif
|
2008-07-13 11:30:48 +00:00
|
|
|
|
2013-02-14 11:12:27 +00:00
|
|
|
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
|
|
|
const nsRect& aDirtyRect,
|
|
|
|
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
|
2012-07-20 18:12:29 +00:00
|
|
|
|
2008-07-13 11:30:48 +00:00
|
|
|
// nsISVGChildFrame interface:
|
2014-02-19 22:34:31 +00:00
|
|
|
virtual nsresult PaintSVG(nsRenderingContext* aContext,
|
|
|
|
const nsIntRect *aDirtyRect,
|
|
|
|
nsIFrame* aTransformRoot) MOZ_OVERRIDE;
|
2014-08-07 07:09:31 +00:00
|
|
|
nsIFrame* GetFrameForPoint(const gfxPoint& aPoint) MOZ_OVERRIDE;
|
2014-02-24 14:41:56 +00:00
|
|
|
nsRect GetCoveredRegion() MOZ_OVERRIDE;
|
|
|
|
virtual void ReflowSVG() MOZ_OVERRIDE;
|
2013-12-30 06:50:07 +00:00
|
|
|
virtual SVGBBox GetBBoxContribution(const Matrix &aToBBoxUserspace,
|
2014-02-24 14:41:56 +00:00
|
|
|
uint32_t aFlags) MOZ_OVERRIDE;
|
2008-07-13 11:30:48 +00:00
|
|
|
|
|
|
|
private:
|
|
|
|
nsIFrame *GetActiveChildFrame();
|
2008-01-03 14:30:02 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Implementation
|
|
|
|
|
|
|
|
nsIFrame*
|
2009-01-19 18:31:34 +00:00
|
|
|
NS_NewSVGSwitchFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
|
2008-01-03 14:30:02 +00:00
|
|
|
{
|
2009-01-19 18:31:34 +00:00
|
|
|
return new (aPresShell) nsSVGSwitchFrame(aContext);
|
|
|
|
}
|
|
|
|
|
2009-09-12 16:49:24 +00:00
|
|
|
NS_IMPL_FRAMEARENA_HELPERS(nsSVGSwitchFrame)
|
|
|
|
|
2009-01-19 18:31:34 +00:00
|
|
|
#ifdef DEBUG
|
2013-03-20 01:47:48 +00:00
|
|
|
void
|
2014-05-24 22:20:40 +00:00
|
|
|
nsSVGSwitchFrame::Init(nsIContent* aContent,
|
|
|
|
nsContainerFrame* aParent,
|
|
|
|
nsIFrame* aPrevInFlow)
|
2009-01-19 18:31:34 +00:00
|
|
|
{
|
2013-01-08 03:22:41 +00:00
|
|
|
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::svgSwitch),
|
2013-03-20 16:50:36 +00:00
|
|
|
"Content is not an SVG switch");
|
2008-01-03 14:30:02 +00:00
|
|
|
|
2013-03-20 01:47:48 +00:00
|
|
|
nsSVGSwitchFrameBase::Init(aContent, aParent, aPrevInFlow);
|
2008-01-03 14:30:02 +00:00
|
|
|
}
|
2009-01-19 18:31:34 +00:00
|
|
|
#endif /* DEBUG */
|
2008-01-03 14:30:02 +00:00
|
|
|
|
|
|
|
nsIAtom *
|
|
|
|
nsSVGSwitchFrame::GetType() const
|
|
|
|
{
|
|
|
|
return nsGkAtoms::svgSwitchFrame;
|
|
|
|
}
|
2008-07-13 11:30:48 +00:00
|
|
|
|
2013-02-14 11:12:27 +00:00
|
|
|
void
|
2012-07-20 18:12:29 +00:00
|
|
|
nsSVGSwitchFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
|
|
|
const nsRect& aDirtyRect,
|
|
|
|
const nsDisplayListSet& aLists)
|
|
|
|
{
|
|
|
|
nsIFrame* kid = GetActiveChildFrame();
|
|
|
|
if (kid) {
|
2013-02-14 11:08:08 +00:00
|
|
|
BuildDisplayListForChild(aBuilder, kid, aDirtyRect, aLists);
|
2012-07-20 18:12:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-19 22:34:31 +00:00
|
|
|
nsresult
|
2012-03-02 08:28:59 +00:00
|
|
|
nsSVGSwitchFrame::PaintSVG(nsRenderingContext* aContext,
|
2013-09-11 07:27:45 +00:00
|
|
|
const nsIntRect *aDirtyRect,
|
|
|
|
nsIFrame* aTransformRoot)
|
2008-07-13 11:30:48 +00:00
|
|
|
{
|
2012-07-20 18:12:29 +00:00
|
|
|
NS_ASSERTION(!NS_SVGDisplayListPaintingEnabled() ||
|
2013-07-12 07:13:07 +00:00
|
|
|
(mState & NS_FRAME_IS_NONDISPLAY),
|
2012-07-20 18:12:29 +00:00
|
|
|
"If display lists are enabled, only painting of non-display "
|
|
|
|
"SVG should take this code path");
|
|
|
|
|
2013-02-16 21:51:02 +00:00
|
|
|
if (StyleDisplay()->mOpacity == 0.0)
|
2008-07-13 11:30:48 +00:00
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
nsIFrame *kid = GetActiveChildFrame();
|
|
|
|
if (kid) {
|
2013-09-11 07:27:45 +00:00
|
|
|
nsSVGUtils::PaintFrameWithEffects(aContext, aDirtyRect, kid, aTransformRoot);
|
2008-07-13 11:30:48 +00:00
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-02-19 22:34:31 +00:00
|
|
|
nsIFrame*
|
2014-08-07 07:09:31 +00:00
|
|
|
nsSVGSwitchFrame::GetFrameForPoint(const gfxPoint& aPoint)
|
2008-07-13 11:30:48 +00:00
|
|
|
{
|
2012-07-20 18:12:29 +00:00
|
|
|
NS_ASSERTION(!NS_SVGDisplayListHitTestingEnabled() ||
|
2013-07-12 07:13:07 +00:00
|
|
|
(mState & NS_FRAME_IS_NONDISPLAY),
|
2012-07-20 18:12:29 +00:00
|
|
|
"If display lists are enabled, only hit-testing of non-display "
|
|
|
|
"SVG should take this code path");
|
|
|
|
|
2008-07-13 11:30:48 +00:00
|
|
|
nsIFrame *kid = GetActiveChildFrame();
|
2014-03-25 15:36:49 +00:00
|
|
|
nsISVGChildFrame* svgFrame = do_QueryFrame(kid);
|
|
|
|
if (svgFrame) {
|
2014-08-07 07:09:31 +00:00
|
|
|
// 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);
|
2008-07-13 11:30:48 +00:00
|
|
|
}
|
|
|
|
|
2012-07-30 14:20:58 +00:00
|
|
|
return nullptr;
|
2008-07-13 11:30:48 +00:00
|
|
|
}
|
|
|
|
|
2014-02-19 22:34:31 +00:00
|
|
|
nsRect
|
2008-07-13 11:30:48 +00:00
|
|
|
nsSVGSwitchFrame::GetCoveredRegion()
|
|
|
|
{
|
|
|
|
nsRect rect;
|
|
|
|
|
|
|
|
nsIFrame *kid = GetActiveChildFrame();
|
2014-03-25 15:36:49 +00:00
|
|
|
nsISVGChildFrame* child = do_QueryFrame(kid);
|
|
|
|
if (child) {
|
|
|
|
rect = child->GetCoveredRegion();
|
2008-07-13 11:30:48 +00:00
|
|
|
}
|
|
|
|
return rect;
|
|
|
|
}
|
|
|
|
|
2012-05-17 04:05:09 +00:00
|
|
|
void
|
2012-07-22 00:01:44 +00:00
|
|
|
nsSVGSwitchFrame::ReflowSVG()
|
2012-05-17 04:05:09 +00:00
|
|
|
{
|
2012-07-22 00:01:44 +00:00
|
|
|
NS_ASSERTION(nsSVGUtils::OuterSVGIsCallingReflowSVG(this),
|
|
|
|
"This call is probably a wasteful mistake");
|
2012-05-17 04:05:09 +00:00
|
|
|
|
2013-07-12 07:13:07 +00:00
|
|
|
NS_ABORT_IF_FALSE(!(GetStateBits() & NS_FRAME_IS_NONDISPLAY),
|
2012-07-22 00:01:44 +00:00
|
|
|
"ReflowSVG mechanism not designed for this");
|
2012-05-17 04:05:09 +00:00
|
|
|
|
2012-07-22 00:01:44 +00:00
|
|
|
if (!nsSVGUtils::NeedsReflowSVG(this)) {
|
2012-05-17 04:05:09 +00:00
|
|
|
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.
|
|
|
|
|
2013-08-24 11:31:48 +00:00
|
|
|
bool isFirstReflow = (mState & NS_FRAME_FIRST_REFLOW);
|
|
|
|
|
2012-05-17 04:05:09 +00:00
|
|
|
bool outerSVGHasHadFirstReflow =
|
|
|
|
(GetParent()->GetStateBits() & NS_FRAME_FIRST_REFLOW) == 0;
|
|
|
|
|
|
|
|
if (outerSVGHasHadFirstReflow) {
|
|
|
|
mState &= ~NS_FRAME_FIRST_REFLOW; // tell our children
|
|
|
|
}
|
|
|
|
|
|
|
|
nsOverflowAreas overflowRects;
|
|
|
|
|
|
|
|
nsIFrame *child = GetActiveChildFrame();
|
2014-03-25 15:36:49 +00:00
|
|
|
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);
|
2012-05-17 04:05:09 +00:00
|
|
|
}
|
|
|
|
|
2013-08-24 11:31:48 +00:00
|
|
|
if (isFirstReflow) {
|
2012-05-17 04:05:09 +00:00
|
|
|
// 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);
|
|
|
|
}
|
|
|
|
|
2012-04-16 08:23:48 +00:00
|
|
|
SVGBBox
|
2013-12-30 06:50:07 +00:00
|
|
|
nsSVGSwitchFrame::GetBBoxContribution(const Matrix &aToBBoxUserspace,
|
2012-08-22 15:56:38 +00:00
|
|
|
uint32_t aFlags)
|
2008-07-13 11:30:48 +00:00
|
|
|
{
|
2009-04-29 04:31:34 +00:00
|
|
|
nsIFrame* kid = GetActiveChildFrame();
|
2014-03-25 15:36:49 +00:00
|
|
|
nsISVGChildFrame* svgKid = do_QueryFrame(kid);
|
|
|
|
if (svgKid) {
|
|
|
|
nsIContent *content = kid->GetContent();
|
|
|
|
gfxMatrix transform = ThebesMatrix(aToBBoxUserspace);
|
|
|
|
if (content->IsSVG()) {
|
|
|
|
transform = static_cast<nsSVGElement*>(content)->
|
|
|
|
PrependLocalTransformsTo(transform);
|
2009-06-17 21:29:55 +00:00
|
|
|
}
|
2014-03-25 15:36:49 +00:00
|
|
|
return svgKid->GetBBoxContribution(ToMatrix(transform), aFlags);
|
2008-07-13 11:30:48 +00:00
|
|
|
}
|
2012-04-16 08:23:48 +00:00
|
|
|
return SVGBBox();
|
2008-07-13 11:30:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
nsIFrame *
|
|
|
|
nsSVGSwitchFrame::GetActiveChildFrame()
|
|
|
|
{
|
|
|
|
nsIContent *activeChild =
|
2013-01-06 06:25:54 +00:00
|
|
|
static_cast<mozilla::dom::SVGSwitchElement*>(mContent)->GetActiveChild();
|
2008-07-13 11:30:48 +00:00
|
|
|
|
|
|
|
if (activeChild) {
|
|
|
|
for (nsIFrame* kid = mFrames.FirstChild(); kid;
|
|
|
|
kid = kid->GetNextSibling()) {
|
|
|
|
|
|
|
|
if (activeChild == kid->GetContent()) {
|
|
|
|
return kid;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-07-30 14:20:58 +00:00
|
|
|
return nullptr;
|
2008-07-13 11:30:48 +00:00
|
|
|
}
|