diff -r 000000000000 -r 4f2f89ce4247 WebCore/rendering/RenderPath.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/WebCore/rendering/RenderPath.cpp Fri Sep 17 09:02:29 2010 +0300 @@ -0,0 +1,321 @@ +/* + Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann + 2004, 2005, 2008 Rob Buis + 2005, 2007 Eric Seidel + 2009 Google, Inc. + 2009 Dirk Schulze + Copyright (C) Research In Motion Limited 2010. All rights reserved. + 2009 Jeff Schiller + + 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 + +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(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(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(boundingBox.x()), static_cast(boundingBox.y()), + static_cast(boundingBox.width()), static_cast(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& 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(node()); + ASSERT(svgElement && svgElement->document()); + if (!svgElement->isStyled()) + return FloatRect(); + + SVGStyledElement* styledElement = static_cast(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(doc, startMarkerId); + RenderSVGResourceMarker* midMarker = getRenderSVGResourceById(doc, midMarkerId); + RenderSVGResourceMarker* endMarker = getRenderSVGResourceById(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)