280 lines
8.5 KiB
C++
280 lines
8.5 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/. */
|
|
|
|
// Main header first:
|
|
#include "nsSVGMarkerFrame.h"
|
|
|
|
// Keep others in (case-insensitive) order:
|
|
#include "gfxContext.h"
|
|
#include "nsSVGEffects.h"
|
|
#include "mozilla/dom/SVGMarkerElement.h"
|
|
#include "nsSVGPathGeometryElement.h"
|
|
#include "nsSVGPathGeometryFrame.h"
|
|
|
|
using namespace mozilla::dom;
|
|
using namespace mozilla::gfx;
|
|
using namespace mozilla::image;
|
|
|
|
nsContainerFrame*
|
|
NS_NewSVGMarkerFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
|
|
{
|
|
return new (aPresShell) nsSVGMarkerFrame(aContext);
|
|
}
|
|
|
|
NS_IMPL_FRAMEARENA_HELPERS(nsSVGMarkerFrame)
|
|
|
|
//----------------------------------------------------------------------
|
|
// nsIFrame methods:
|
|
|
|
nsresult
|
|
nsSVGMarkerFrame::AttributeChanged(int32_t aNameSpaceID,
|
|
nsIAtom* aAttribute,
|
|
int32_t aModType)
|
|
{
|
|
if (aNameSpaceID == kNameSpaceID_None &&
|
|
(aAttribute == nsGkAtoms::markerUnits ||
|
|
aAttribute == nsGkAtoms::refX ||
|
|
aAttribute == nsGkAtoms::refY ||
|
|
aAttribute == nsGkAtoms::markerWidth ||
|
|
aAttribute == nsGkAtoms::markerHeight ||
|
|
aAttribute == nsGkAtoms::orient ||
|
|
aAttribute == nsGkAtoms::preserveAspectRatio ||
|
|
aAttribute == nsGkAtoms::viewBox)) {
|
|
nsSVGEffects::InvalidateDirectRenderingObservers(this);
|
|
}
|
|
|
|
return nsSVGContainerFrame::AttributeChanged(aNameSpaceID,
|
|
aAttribute, aModType);
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
void
|
|
nsSVGMarkerFrame::Init(nsIContent* aContent,
|
|
nsContainerFrame* aParent,
|
|
nsIFrame* aPrevInFlow)
|
|
{
|
|
NS_ASSERTION(aContent->IsSVGElement(nsGkAtoms::marker), "Content is not an SVG marker");
|
|
|
|
nsSVGContainerFrame::Init(aContent, aParent, aPrevInFlow);
|
|
}
|
|
#endif /* DEBUG */
|
|
|
|
nsIAtom *
|
|
nsSVGMarkerFrame::GetType() const
|
|
{
|
|
return nsGkAtoms::svgMarkerFrame;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// nsSVGContainerFrame methods:
|
|
|
|
gfxMatrix
|
|
nsSVGMarkerFrame::GetCanvasTM()
|
|
{
|
|
NS_ASSERTION(mMarkedFrame, "null nsSVGPathGeometry frame");
|
|
|
|
if (mInUse2) {
|
|
// We're going to be bailing drawing the marker, so return an identity.
|
|
return gfxMatrix();
|
|
}
|
|
|
|
SVGMarkerElement *content = static_cast<SVGMarkerElement*>(mContent);
|
|
|
|
mInUse2 = true;
|
|
gfxMatrix markedTM = mMarkedFrame->GetCanvasTM();
|
|
mInUse2 = false;
|
|
|
|
Matrix markerTM = content->GetMarkerTransform(mStrokeWidth, mX, mY,
|
|
mAutoAngle, mIsStart);
|
|
Matrix viewBoxTM = content->GetViewBoxTransform();
|
|
|
|
return ThebesMatrix(viewBoxTM * markerTM) * markedTM;
|
|
}
|
|
|
|
static nsIFrame*
|
|
GetAnonymousChildFrame(nsIFrame* aFrame)
|
|
{
|
|
nsIFrame* kid = aFrame->PrincipalChildList().FirstChild();
|
|
MOZ_ASSERT(kid && kid->GetType() == nsGkAtoms::svgMarkerAnonChildFrame,
|
|
"expected to find anonymous child of marker frame");
|
|
return kid;
|
|
}
|
|
|
|
nsresult
|
|
nsSVGMarkerFrame::PaintMark(gfxContext& aContext,
|
|
const gfxMatrix& aToMarkedFrameUserSpace,
|
|
nsSVGPathGeometryFrame *aMarkedFrame,
|
|
nsSVGMark *aMark, float aStrokeWidth)
|
|
{
|
|
// If the flag is set when we get here, it means this marker frame
|
|
// has already been used painting the current mark, and the document
|
|
// has a marker reference loop.
|
|
if (mInUse)
|
|
return NS_OK;
|
|
|
|
AutoMarkerReferencer markerRef(this, aMarkedFrame);
|
|
|
|
SVGMarkerElement *marker = static_cast<SVGMarkerElement*>(mContent);
|
|
if (!marker->HasValidDimensions()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
const nsSVGViewBoxRect viewBox = marker->GetViewBoxRect();
|
|
|
|
if (viewBox.width <= 0.0f || viewBox.height <= 0.0f) {
|
|
// We must disable rendering if the viewBox width or height are zero.
|
|
return NS_OK;
|
|
}
|
|
|
|
mStrokeWidth = aStrokeWidth;
|
|
mX = aMark->x;
|
|
mY = aMark->y;
|
|
mAutoAngle = aMark->angle;
|
|
mIsStart = aMark->type == nsSVGMark::eStart;
|
|
|
|
Matrix viewBoxTM = marker->GetViewBoxTransform();
|
|
|
|
Matrix markerTM = marker->GetMarkerTransform(mStrokeWidth, mX, mY,
|
|
mAutoAngle, mIsStart);
|
|
|
|
gfxMatrix markTM = ThebesMatrix(viewBoxTM) * ThebesMatrix(markerTM) *
|
|
aToMarkedFrameUserSpace;
|
|
|
|
if (StyleDisplay()->IsScrollableOverflow()) {
|
|
aContext.Save();
|
|
gfxRect clipRect =
|
|
nsSVGUtils::GetClipRectForFrame(this, viewBox.x, viewBox.y,
|
|
viewBox.width, viewBox.height);
|
|
nsSVGUtils::SetClipRect(&aContext, markTM, clipRect);
|
|
}
|
|
|
|
|
|
nsIFrame* kid = GetAnonymousChildFrame(this);
|
|
nsISVGChildFrame* SVGFrame = do_QueryFrame(kid);
|
|
// The CTM of each frame referencing us may be different.
|
|
SVGFrame->NotifySVGChanged(nsISVGChildFrame::TRANSFORM_CHANGED);
|
|
DrawResult result = nsSVGUtils::PaintFrameWithEffects(kid, aContext, markTM);
|
|
|
|
if (StyleDisplay()->IsScrollableOverflow())
|
|
aContext.Restore();
|
|
|
|
return (result == DrawResult::SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
|
|
}
|
|
|
|
SVGBBox
|
|
nsSVGMarkerFrame::GetMarkBBoxContribution(const Matrix &aToBBoxUserspace,
|
|
uint32_t aFlags,
|
|
nsSVGPathGeometryFrame *aMarkedFrame,
|
|
const nsSVGMark *aMark,
|
|
float aStrokeWidth)
|
|
{
|
|
SVGBBox bbox;
|
|
|
|
// If the flag is set when we get here, it means this marker frame
|
|
// has already been used in calculating the current mark bbox, and
|
|
// the document has a marker reference loop.
|
|
if (mInUse)
|
|
return bbox;
|
|
|
|
AutoMarkerReferencer markerRef(this, aMarkedFrame);
|
|
|
|
SVGMarkerElement *content = static_cast<SVGMarkerElement*>(mContent);
|
|
if (!content->HasValidDimensions()) {
|
|
return bbox;
|
|
}
|
|
|
|
const nsSVGViewBoxRect viewBox = content->GetViewBoxRect();
|
|
|
|
if (viewBox.width <= 0.0f || viewBox.height <= 0.0f) {
|
|
return bbox;
|
|
}
|
|
|
|
mStrokeWidth = aStrokeWidth;
|
|
mX = aMark->x;
|
|
mY = aMark->y;
|
|
mAutoAngle = aMark->angle;
|
|
mIsStart = aMark->type == nsSVGMark::eStart;
|
|
|
|
Matrix markerTM =
|
|
content->GetMarkerTransform(mStrokeWidth, mX, mY, mAutoAngle, mIsStart);
|
|
Matrix viewBoxTM = content->GetViewBoxTransform();
|
|
|
|
Matrix tm = viewBoxTM * markerTM * aToBBoxUserspace;
|
|
|
|
nsISVGChildFrame* child = do_QueryFrame(GetAnonymousChildFrame(this));
|
|
// When we're being called to obtain the invalidation area, we need to
|
|
// pass down all the flags so that stroke is included. However, once DOM
|
|
// getBBox() accepts flags, maybe we should strip some of those here?
|
|
|
|
// We need to include zero width/height vertical/horizontal lines, so we have
|
|
// to use UnionEdges.
|
|
bbox.UnionEdges(child->GetBBoxContribution(tm, aFlags));
|
|
|
|
return bbox;
|
|
}
|
|
|
|
void
|
|
nsSVGMarkerFrame::SetParentCoordCtxProvider(SVGSVGElement *aContext)
|
|
{
|
|
SVGMarkerElement *marker = static_cast<SVGMarkerElement*>(mContent);
|
|
marker->SetParentCoordCtxProvider(aContext);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// helper class
|
|
|
|
nsSVGMarkerFrame::AutoMarkerReferencer::AutoMarkerReferencer(
|
|
nsSVGMarkerFrame *aFrame,
|
|
nsSVGPathGeometryFrame *aMarkedFrame
|
|
MOZ_GUARD_OBJECT_NOTIFIER_PARAM_IN_IMPL)
|
|
: mFrame(aFrame)
|
|
{
|
|
MOZ_GUARD_OBJECT_NOTIFIER_INIT;
|
|
mFrame->mInUse = true;
|
|
mFrame->mMarkedFrame = aMarkedFrame;
|
|
|
|
SVGSVGElement *ctx =
|
|
static_cast<nsSVGElement*>(aMarkedFrame->GetContent())->GetCtx();
|
|
mFrame->SetParentCoordCtxProvider(ctx);
|
|
}
|
|
|
|
nsSVGMarkerFrame::AutoMarkerReferencer::~AutoMarkerReferencer()
|
|
{
|
|
mFrame->SetParentCoordCtxProvider(nullptr);
|
|
|
|
mFrame->mMarkedFrame = nullptr;
|
|
mFrame->mInUse = false;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Implementation of nsSVGMarkerAnonChildFrame
|
|
|
|
nsContainerFrame*
|
|
NS_NewSVGMarkerAnonChildFrame(nsIPresShell* aPresShell,
|
|
nsStyleContext* aContext)
|
|
{
|
|
return new (aPresShell) nsSVGMarkerAnonChildFrame(aContext);
|
|
}
|
|
|
|
NS_IMPL_FRAMEARENA_HELPERS(nsSVGMarkerAnonChildFrame)
|
|
|
|
#ifdef DEBUG
|
|
void
|
|
nsSVGMarkerAnonChildFrame::Init(nsIContent* aContent,
|
|
nsContainerFrame* aParent,
|
|
nsIFrame* aPrevInFlow)
|
|
{
|
|
MOZ_ASSERT(aParent->GetType() == nsGkAtoms::svgMarkerFrame,
|
|
"Unexpected parent");
|
|
nsSVGDisplayContainerFrame::Init(aContent, aParent, aPrevInFlow);
|
|
}
|
|
#endif
|
|
|
|
nsIAtom *
|
|
nsSVGMarkerAnonChildFrame::GetType() const
|
|
{
|
|
return nsGkAtoms::svgMarkerAnonChildFrame;
|
|
}
|