/*
Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>
2004, 2005, 2008 Rob Buis <buis@kde.org>
2005, 2007 Eric Seidel <eric@webkit.org>
2009 Google, Inc.
2009 Dirk Schulze <krit@webkit.org>
Copyright (C) Research In Motion Limited 2010. All rights reserved.
2009 Jeff Schiller <codedread@gmail.com>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
aint with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include "config.h"
#if ENABLE(SVG)
#include "RenderPath.h"
#include "FloatPoint.h"
#include "FloatQuad.h"
#include "GraphicsContext.h"
#include "HitTestRequest.h"
#include "PointerEventsHitRules.h"
#include "RenderSVGContainer.h"
#include "RenderSVGResourceMarker.h"
#include "StrokeStyleApplier.h"
#include "SVGRenderSupport.h"
#include "SVGStyledTransformableElement.h"
#include "SVGTransformList.h"
#include "SVGURIReference.h"
#include <wtf/MathExtras.h>
namespace WebCore {
class BoundingRectStrokeStyleApplier : public StrokeStyleApplier {
public:
BoundingRectStrokeStyleApplier(const RenderObject* object, RenderStyle* style)
: m_object(object)
, m_style(style)
{
ASSERT(style);
ASSERT(object);
}
void strokeStyle(GraphicsContext* gc)
{
SVGRenderSupport::applyStrokeStyleToContext(gc, m_style, m_object);
}
private:
const RenderObject* m_object;
RenderStyle* m_style;
};
RenderPath::RenderPath(SVGStyledTransformableElement* node)
: RenderSVGModelObject(node)
, m_needsBoundariesUpdate(false) // default is false, the cached rects are empty from the beginning
, m_needsPathUpdate(true) // default is true, so we grab a Path object once from SVGStyledTransformableElement
, m_needsTransformUpdate(true) // default is true, so we grab a AffineTransform object once from SVGStyledTransformableElement
{
}
bool RenderPath::fillContains(const FloatPoint& point, bool requiresFill, WindRule fillRule) const
{
if (!m_fillBoundingBox.contains(point))
return false;
if (requiresFill && !RenderSVGResource::fillPaintingResource(this, style()))
return false;
return m_path.contains(point, fillRule);
}
bool RenderPath::strokeContains(const FloatPoint& point, bool requiresStroke) const
{
if (!m_strokeAndMarkerBoundingBox.contains(point))
return false;
if (requiresStroke && !RenderSVGResource::strokePaintingResource(this, style()))
return false;
BoundingRectStrokeStyleApplier strokeStyle(this, style());
return m_path.strokeContains(&strokeStyle, point);
}
void RenderPath::layout()
{
LayoutRepainter repainter(*this, m_everHadLayout && checkForRepaintDuringLayout());
SVGStyledTransformableElement* element = static_cast<SVGStyledTransformableElement*>(node());
bool needsPathUpdate = m_needsPathUpdate;
if (needsPathUpdate) {
m_path = element->toPathData();
m_needsPathUpdate = false;
}
if (m_needsTransformUpdate) {
m_localTransform = element->animatedLocalTransform();
m_needsTransformUpdate = false;
}
// Invalidate all resources of this client, if we changed something.
if (m_everHadLayout && selfNeedsLayout())
RenderSVGResource::invalidateAllResourcesOfRenderer(this);
// At this point LayoutRepainter already grabbed the old bounds,
// recalculate them now so repaintAfterLayout() uses the new bounds
if (needsPathUpdate || m_needsBoundariesUpdate) {
updateCachedBoundaries();
m_needsBoundariesUpdate = false;
}
repainter.repaintAfterLayout();
setNeedsLayout(false);
}
static inline void fillAndStrokePath(const Path& path, GraphicsContext* context, RenderPath* object)
{
context->beginPath();
RenderStyle* style = object->style();
if (RenderSVGResource* fillPaintingResource = RenderSVGResource::fillPaintingResource(object, style)) {
context->addPath(path);
if (fillPaintingResource->applyResource(object, style, context, ApplyToFillMode))
fillPaintingResource->postApplyResource(object, context, ApplyToFillMode);
}
if (RenderSVGResource* strokePaintingResource = RenderSVGResource::strokePaintingResource(object, style)) {
if (style->svgStyle()->vectorEffect() == VE_NON_SCALING_STROKE) {
SVGStyledTransformableElement* element = static_cast<SVGStyledTransformableElement*>(object->node());
AffineTransform transform = element->getScreenCTM();
if (!transform.isInvertible())
return;
Path transformedPath = path;
context->concatCTM(transform.inverse());
transformedPath.transform(transform);
context->addPath(transformedPath);
} else
context->addPath(path);
if (strokePaintingResource->applyResource(object, style, context, ApplyToStrokeMode))
strokePaintingResource->postApplyResource(object, context, ApplyToStrokeMode);
}
}
void RenderPath::paint(PaintInfo& paintInfo, int, int)
{
if (paintInfo.context->paintingDisabled() || style()->visibility() == HIDDEN || m_path.isEmpty())
return;
FloatRect boundingBox = repaintRectInLocalCoordinates();
FloatRect nonLocalBoundingBox = m_localTransform.mapRect(boundingBox);
if (!nonLocalBoundingBox.intersects(paintInfo.rect))
return;
PaintInfo childPaintInfo(paintInfo);
bool drawsOutline = style()->outlineWidth() && (childPaintInfo.phase == PaintPhaseOutline || childPaintInfo.phase == PaintPhaseSelfOutline);
if (drawsOutline || childPaintInfo.phase == PaintPhaseForeground) {
childPaintInfo.context->save();
childPaintInfo.applyTransform(m_localTransform);
if (childPaintInfo.phase == PaintPhaseForeground) {
PaintInfo savedInfo(childPaintInfo);
if (SVGRenderSupport::prepareToRenderSVGContent(this, childPaintInfo)) {
const SVGRenderStyle* svgStyle = style()->svgStyle();
if (svgStyle->shapeRendering() == SR_CRISPEDGES)
childPaintInfo.context->setShouldAntialias(false);
fillAndStrokePath(m_path, childPaintInfo.context, this);
if (svgStyle->hasMarkers())
m_markerLayoutInfo.drawMarkers(childPaintInfo);
}
SVGRenderSupport::finishRenderSVGContent(this, childPaintInfo, savedInfo.context);
}
if (drawsOutline)
paintOutline(childPaintInfo.context, static_cast<int>(boundingBox.x()), static_cast<int>(boundingBox.y()),
static_cast<int>(boundingBox.width()), static_cast<int>(boundingBox.height()));
childPaintInfo.context->restore();
}
}
// This method is called from inside paintOutline() since we call paintOutline()
// while transformed to our coord system, return local coords
void RenderPath::addFocusRingRects(Vector<IntRect>& rects, int, int)
{
IntRect rect = enclosingIntRect(repaintRectInLocalCoordinates());
if (!rect.isEmpty())
rects.append(rect);
}
bool RenderPath::nodeAtFloatPoint(const HitTestRequest& request, HitTestResult& result, const FloatPoint& pointInParent, HitTestAction hitTestAction)
{
// We only draw in the forground phase, so we only hit-test then.
if (hitTestAction != HitTestForeground)
return false;
FloatPoint localPoint = m_localTransform.inverse().mapPoint(pointInParent);
if (!SVGRenderSupport::pointInClippingArea(this, localPoint))
return false;
PointerEventsHitRules hitRules(PointerEventsHitRules::SVG_PATH_HITTESTING, request, style()->pointerEvents());
bool isVisible = (style()->visibility() == VISIBLE);
if (isVisible || !hitRules.requireVisible) {
const SVGRenderStyle* svgStyle = style()->svgStyle();
WindRule fillRule = svgStyle->fillRule();
if (request.svgClipContent())
fillRule = svgStyle->clipRule();
if ((hitRules.canHitStroke && (svgStyle->hasStroke() || !hitRules.requireStroke) && strokeContains(localPoint, hitRules.requireStroke))
|| (hitRules.canHitFill && (svgStyle->hasFill() || !hitRules.requireFill) && fillContains(localPoint, hitRules.requireFill, fillRule))) {
updateHitTestResult(result, roundedIntPoint(localPoint));
return true;
}
}
return false;
}
FloatRect RenderPath::calculateMarkerBoundsIfNeeded()
{
Document* doc = document();
SVGElement* svgElement = static_cast<SVGElement*>(node());
ASSERT(svgElement && svgElement->document());
if (!svgElement->isStyled())
return FloatRect();
SVGStyledElement* styledElement = static_cast<SVGStyledElement*>(svgElement);
if (!styledElement->supportsMarkers())
return FloatRect();
const SVGRenderStyle* svgStyle = style()->svgStyle();
ASSERT(svgStyle->hasMarkers());
AtomicString startMarkerId(svgStyle->markerStartResource());
AtomicString midMarkerId(svgStyle->markerMidResource());
AtomicString endMarkerId(svgStyle->markerEndResource());
RenderSVGResourceMarker* startMarker = getRenderSVGResourceById<RenderSVGResourceMarker>(doc, startMarkerId);
RenderSVGResourceMarker* midMarker = getRenderSVGResourceById<RenderSVGResourceMarker>(doc, midMarkerId);
RenderSVGResourceMarker* endMarker = getRenderSVGResourceById<RenderSVGResourceMarker>(doc, endMarkerId);
if (!startMarker && !startMarkerId.isEmpty())
svgElement->document()->accessSVGExtensions()->addPendingResource(startMarkerId, styledElement);
else if (startMarker)
startMarker->addClient(this);
if (!midMarker && !midMarkerId.isEmpty())
svgElement->document()->accessSVGExtensions()->addPendingResource(midMarkerId, styledElement);
else if (midMarker)
midMarker->addClient(this);
if (!endMarker && !endMarkerId.isEmpty())
svgElement->document()->accessSVGExtensions()->addPendingResource(endMarkerId, styledElement);
else if (endMarker)
endMarker->addClient(this);
if (!startMarker && !midMarker && !endMarker)
return FloatRect();
float strokeWidth = SVGRenderStyle::cssPrimitiveToLength(this, svgStyle->strokeWidth(), 1.0f);
return m_markerLayoutInfo.calculateBoundaries(startMarker, midMarker, endMarker, strokeWidth, m_path);
}
void RenderPath::styleWillChange(StyleDifference diff, const RenderStyle* newStyle)
{
setNeedsBoundariesUpdate();
RenderSVGModelObject::styleWillChange(diff, newStyle);
}
void RenderPath::updateCachedBoundaries()
{
if (m_path.isEmpty()) {
m_fillBoundingBox = FloatRect();
m_strokeAndMarkerBoundingBox = FloatRect();
m_repaintBoundingBox = FloatRect();
return;
}
// Cache _unclipped_ fill bounding box, used for calculations in resources
m_fillBoundingBox = m_path.boundingRect();
// Cache _unclipped_ stroke bounding box, used for calculations in resources (includes marker boundaries)
m_strokeAndMarkerBoundingBox = m_fillBoundingBox;
const SVGRenderStyle* svgStyle = style()->svgStyle();
if (svgStyle->hasStroke()) {
BoundingRectStrokeStyleApplier strokeStyle(this, style());
m_strokeAndMarkerBoundingBox.unite(m_path.strokeBoundingRect(&strokeStyle));
}
if (svgStyle->hasMarkers()) {
FloatRect markerBounds = calculateMarkerBoundsIfNeeded();
if (!markerBounds.isEmpty())
m_strokeAndMarkerBoundingBox.unite(markerBounds);
}
// Cache smallest possible repaint rectangle
m_repaintBoundingBox = m_strokeAndMarkerBoundingBox;
SVGRenderSupport::intersectRepaintRectWithResources(this, m_repaintBoundingBox);
}
}
#endif // ENABLE(SVG)