RenderSVGPath.cpp

 * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>

 * Copyright (C) Research In Motion Limited 2010. All rights reserved.

 * Copyright (C) 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

#if ENABLE(SVG)

#include "RenderSVGPath.h"

#include "FloatPoint.h"

#include "FloatQuad.h"

#include "GraphicsContext.h"

#include "HitTestRequest.h"

#include "PointerEventsHitRules.h"

#include "RenderSVGContainer.h"

#include "RenderSVGResourceMarker.h"

#include "RenderSVGResourceSolidColor.h"

#include "SVGRenderSupport.h"

#include "SVGResources.h"

33#include "SVGPathElement.h"

4134#include "SVGStyledTransformableElement.h"

#include "SVGTransformList.h"

#include "SVGURIReference.h"

#include "StrokeStyleApplier.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;

};

6938RenderSVGPath::RenderSVGPath(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

39 : RenderSVGShape(node)

{

}

@@RenderSVGPath::~RenderSVGPath()

{

}

bool RenderSVGPath::fillContains(const FloatPoint& point, bool requiresFill, WindRule fillRule)

{

    if (!m_fillBoundingBox.contains(point))

        return false;

    Color fallbackColor;

    if (requiresFill && !RenderSVGResource::fillPaintingResource(this, style(), fallbackColor))

        return false;

    return m_path.contains(point, fillRule);

}

bool RenderSVGPath::strokeContains(const FloatPoint& point, bool requiresStroke)

{

    if (!m_strokeAndMarkerBoundingBox.contains(point))

        return false;

    Color fallbackColor;

    if (requiresStroke && !RenderSVGResource::strokePaintingResource(this, style(), fallbackColor))

        return false;

    if (shouldStrokeZeroLengthSubpath())

        return zeroLengthSubpathRect().contains(point);

    BoundingRectStrokeStyleApplier strokeStyle(this, style());

    return m_path.strokeContains(&strokeStyle, point);

}

void RenderSVGPath::layout()

{

    LayoutRepainter repainter(*this, checkForRepaintDuringLayout() && selfNeedsLayout());

    SVGStyledTransformableElement* element = static_cast<SVGStyledTransformableElement*>(node());

    bool updateCachedBoundariesInParents = false;

    bool needsPathUpdate = m_needsPathUpdate;

    if (needsPathUpdate) {

        m_path.clear();

        element->toPathData(m_path);

        m_needsPathUpdate = false;

        updateCachedBoundariesInParents = true;

    }

    if (m_needsTransformUpdate) {

        m_localTransform = element->animatedLocalTransform();

        m_needsTransformUpdate = false;

        updateCachedBoundariesInParents = true;

    }

    if (m_needsBoundariesUpdate)

        updateCachedBoundariesInParents = true;

    // Invalidate all resources of this client if our layout changed.

    if (m_everHadLayout && selfNeedsLayout()) {

        SVGResourcesCache::clientLayoutChanged(this);

        m_markerLayoutInfo.clear();

    }

    // 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;

    }

    // If our bounds changed, notify the parents.

    if (updateCachedBoundariesInParents)

        RenderSVGModelObject::setNeedsBoundariesUpdate();

    repainter.repaintAfterLayout();

    setNeedsLayout(false);

}

bool RenderSVGPath::shouldStrokeZeroLengthSubpath() const

{

    // Spec(11.4): Any zero length subpath shall not be stroked if the ‘stroke-linecap’ property has a value of butt

    // but shall be stroked if the ‘stroke-linecap’ property has a value of round or square

    return style()->svgStyle()->hasStroke() && style()->svgStyle()->capStyle() != ButtCap && !m_fillBoundingBox.width() && !m_fillBoundingBox.height();

}

FloatRect RenderSVGPath::zeroLengthSubpathRect() const

{

    SVGElement* svgElement = static_cast<SVGElement*>(node());

    float strokeWidth = style()->svgStyle()->strokeWidth().value(svgElement);

    return FloatRect(m_fillBoundingBox.x() - strokeWidth / 2, m_fillBoundingBox.y() - strokeWidth / 2, strokeWidth, strokeWidth);

}

void RenderSVGPath::setupSquareCapPath(Path*& usePath, int& applyMode)

{

    // Spec(11.4): Any zero length subpath shall not be stroked if the ‘stroke-linecap’ property has a value of butt

    // but shall be stroked if the ‘stroke-linecap’ property has a value of round or square

    DEFINE_STATIC_LOCAL(Path, tempPath, ());

    applyMode = ApplyToFillMode;

    usePath = &tempPath;

    usePath->clear();

    if (style()->svgStyle()->capStyle() == SquareCap)

        usePath->addRect(zeroLengthSubpathRect());

    else

        usePath->addEllipse(zeroLengthSubpathRect());

}

bool RenderSVGPath::setupNonScalingStrokePath(Path*& usePath, GraphicsContextStateSaver& stateSaver)

{

    DEFINE_STATIC_LOCAL(Path, tempPath, ());

    SVGStyledTransformableElement* element = static_cast<SVGStyledTransformableElement*>(node());

    AffineTransform nonScalingStrokeTransform = element->getScreenCTM(SVGLocatable::DisallowStyleUpdate);

    if (!nonScalingStrokeTransform.isInvertible())

        return false;

    tempPath = m_path;

    usePath = &tempPath;

    tempPath.transform(nonScalingStrokeTransform);

    stateSaver.save();

    stateSaver.context()->concatCTM(nonScalingStrokeTransform.inverse());

    return true;

}

void RenderSVGPath::fillAndStrokePath(GraphicsContext* context)

{

    RenderStyle* style = this->style();

    Color fallbackColor;

    if (RenderSVGResource* fillPaintingResource = RenderSVGResource::fillPaintingResource(this, style, fallbackColor)) {

        if (fillPaintingResource->applyResource(this, style, context, ApplyToFillMode))

            fillPaintingResource->postApplyResource(this, context, ApplyToFillMode, &m_path);

        else if (fallbackColor.isValid()) {

            RenderSVGResourceSolidColor* fallbackResource = RenderSVGResource::sharedSolidPaintingResource();

            fallbackResource->setColor(fallbackColor);

            if (fallbackResource->applyResource(this, style, context, ApplyToFillMode))

                fallbackResource->postApplyResource(this, context, ApplyToFillMode, &m_path);

        }

    }

    fallbackColor = Color();

    RenderSVGResource* strokePaintingResource = RenderSVGResource::strokePaintingResource(this, style, fallbackColor);

    if (!strokePaintingResource)

        return;

    Path* usePath = &m_path;

    int applyMode = ApplyToStrokeMode;

    bool nonScalingStroke = style->svgStyle()->vectorEffect() == VE_NON_SCALING_STROKE;

    GraphicsContextStateSaver stateSaver(*context, false);

    // Spec(11.4): Any zero length subpath shall not be stroked if the ‘stroke-linecap’ property has a value of butt

    // but shall be stroked if the ‘stroke-linecap’ property has a value of round or square

    // FIXME: this does not work for zero-length subpaths, only when total path is zero-length

    if (shouldStrokeZeroLengthSubpath())

        setupSquareCapPath(usePath, applyMode);

    else if (nonScalingStroke) {

       if (!setupNonScalingStrokePath(usePath, stateSaver))

           return;

    }

    if (strokePaintingResource->applyResource(this, style, context, applyMode))

        strokePaintingResource->postApplyResource(this, context, applyMode, usePath);

    else if (fallbackColor.isValid()) {

        RenderSVGResourceSolidColor* fallbackResource = RenderSVGResource::sharedSolidPaintingResource();

        fallbackResource->setColor(fallbackColor);

        if (fallbackResource->applyResource(this, style, context, applyMode))

            fallbackResource->postApplyResource(this, context, applyMode, usePath);

    }

}

void RenderSVGPath::paint(PaintInfo& paintInfo, const LayoutPoint&)

{

    if (paintInfo.context->paintingDisabled() || style()->visibility() == HIDDEN || m_path.isEmpty())

        return;

    FloatRect boundingBox = repaintRectInLocalCoordinates();

    if (!SVGRenderSupport::paintInfoIntersectsRepaintRect(boundingBox, m_localTransform, paintInfo))

        return;

    PaintInfo childPaintInfo(paintInfo);

    bool drawsOutline = style()->outlineWidth() && (childPaintInfo.phase == PaintPhaseOutline || childPaintInfo.phase == PaintPhaseSelfOutline);

    if (drawsOutline || childPaintInfo.phase == PaintPhaseForeground) {

        GraphicsContextStateSaver stateSaver(*childPaintInfo.context);

        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(childPaintInfo.context);

                if (svgStyle->hasMarkers())

                    m_markerLayoutInfo.drawMarkers(childPaintInfo);

            }

            SVGRenderSupport::finishRenderSVGContent(this, childPaintInfo, savedInfo.context);

        }

        if (drawsOutline)

            paintOutline(childPaintInfo.context, IntRect(boundingBox));

    }

}

// This method is called from inside paintOutline() since we call paintOutline()

// while transformed to our coord system, return local coords

void RenderSVGPath::addFocusRingRects(Vector<LayoutRect>& rects, const LayoutPoint&) 

{

    LayoutRect rect = enclosingLayoutRect(repaintRectInLocalCoordinates());

    if (!rect.isEmpty())

        rects.append(rect);

}

bool RenderSVGPath::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, roundedLayoutPoint(localPoint));

            return true;

        }

    }

    return false;

}

FloatRect RenderSVGPath::calculateMarkerBoundsIfNeeded()

{

    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());

    SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(this);

    if (!resources)

        return FloatRect();

    RenderSVGResourceMarker* markerStart = resources->markerStart();

    RenderSVGResourceMarker* markerMid = resources->markerMid();

    RenderSVGResourceMarker* markerEnd = resources->markerEnd();

    if (!markerStart && !markerMid && !markerEnd)

        return FloatRect();

    return m_markerLayoutInfo.calculateBoundaries(markerStart, markerMid, markerEnd, svgStyle->strokeWidth().value(svgElement), m_path);

}

void RenderSVGPath::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();

    // Spec(11.4): Any zero length subpath shall not be stroked if the ‘stroke-linecap’ property has a value of butt

    // but shall be stroked if the ‘stroke-linecap’ property has a value of round or square

    if (shouldStrokeZeroLengthSubpath()) {

        m_strokeAndMarkerBoundingBox = zeroLengthSubpathRect();

        // Cache smallest possible repaint rectangle

        m_repaintBoundingBox = m_strokeAndMarkerBoundingBox;

        SVGRenderSupport::intersectRepaintRectWithResources(this, m_repaintBoundingBox);

        return;

    }

    // 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)

Source/WebCore/rendering/svg/RenderSVGPath.h

 * Copyright (C) 2005 Eric Seidel <eric@webkit.org>

 * Copyright (C) 2006 Apple Computer, Inc

 * Copyright (C) 2009 Google, Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

#define RenderSVGPath_h

#if ENABLE(SVG)

#include "AffineTransform.h"

#include "FloatRect.h"

#include "RenderSVGModelObject.h"

#include "SVGMarkerLayoutInfo.h"

30#include "RenderSVGShape.h"

namespace WebCore {

class FloatPoint;

class GraphicsContextStateSaver;

class RenderSVGContainer;

class SVGStyledTransformableElement;

class RenderSVGPath : public RenderSVGModelObject {

34class RenderSVGPath : public RenderSVGShape {

4135public:

42 ~~explicit~~ RenderSVGPath(SVGStyledTransformableElement*);

36 RenderSVGPath(SVGStyledTransformableElement*);

4337 virtual ~RenderSVGPath();

4438

    const Path& path() const { return m_path; }

    void setNeedsPathUpdate() { m_needsPathUpdate = true; }

    virtual void setNeedsBoundariesUpdate() { m_needsBoundariesUpdate = true; }

    virtual void setNeedsTransformUpdate() { m_needsTransformUpdate = true; }

5039private:

    // Hit-detection seperated for the fill and the stroke

    bool fillContains(const FloatPoint&, bool requiresFill = true, WindRule fillRule = RULE_NONZERO);

    bool strokeContains(const FloatPoint&, bool requiresStroke = true);

    virtual FloatRect objectBoundingBox() const { return m_fillBoundingBox; }

    virtual FloatRect strokeBoundingBox() const { return m_strokeAndMarkerBoundingBox; }

    virtual FloatRect repaintRectInLocalCoordinates() const { return m_repaintBoundingBox; }

    virtual const AffineTransform& localToParentTransform() const { return m_localTransform; }

6040 virtual bool isSVGPath() const { return true; }

6141 virtual const char* renderName() const { return "RenderSVGPath"; }

    virtual void layout();

    virtual void paint(PaintInfo&, const LayoutPoint&);

    virtual void addFocusRingRects(Vector<LayoutRect>&, const LayoutPoint&);

    virtual bool nodeAtFloatPoint(const HitTestRequest&, HitTestResult&, const FloatPoint& pointInParent, HitTestAction);

    FloatRect calculateMarkerBoundsIfNeeded();

    void updateCachedBoundaries();

    void setupSquareCapPath(Path*& usePath, int& applyMode);

    bool setupNonScalingStrokePath(Path*& usePath, GraphicsContextStateSaver&);

    bool shouldStrokeZeroLengthSubpath() const;

    FloatRect zeroLengthSubpathRect() const;

private:

    virtual AffineTransform localTransform() const { return m_localTransform; }

    void fillAndStrokePath(GraphicsContext*);

    bool m_needsBoundariesUpdate : 1;

    bool m_needsPathUpdate : 1;

    bool m_needsTransformUpdate : 1;

    mutable Path m_path;

    FloatRect m_fillBoundingBox;

    FloatRect m_strokeAndMarkerBoundingBox;

    FloatRect m_repaintBoundingBox;

    SVGMarkerLayoutInfo m_markerLayoutInfo;

    AffineTransform m_localTransform;

9142};

9243

inline RenderSVGPath* toRenderSVGPath(RenderObject* object)

{

    ASSERT(!object || object->isSVGPath());

    return static_cast<RenderSVGPath*>(object);

}

inline const RenderSVGPath* toRenderSVGPath(const RenderObject* object)

{

    ASSERT(!object || object->isSVGPath());

    return static_cast<const RenderSVGPath*>(object);

}

// This will catch anyone doing an unnecessary cast.

void toRenderSVGPath(const RenderSVGPath*);

}

#endif // ENABLE(SVG)

Source/WebCore/rendering/svg/RenderSVGRect.cpp

/*

 * Copyright (C) 2011 University of Szeged

 * Copyright (C) 2011 Renata Hodovan (reni@webkit.org)

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY UNIVERSITY OF SZEGED ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL UNIVERSITY OF SZEGED OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#if ENABLE(SVG)

#include "RenderSVGRect.h"

#include "SVGNames.h"

#include "SVGRectElement.h"

namespace WebCore {

RenderSVGRect::RenderSVGRect(SVGStyledTransformableElement* node)

    : RenderSVGShape(node)

{

}

RenderSVGRect::~RenderSVGRect()

{

}

void RenderSVGRect::createShape()

{

    // Clear m_rect.

    m_rect = FloatRect();

    SVGRectElement* rect = static_cast<SVGRectElement*>(node());

    bool m_hasRx = rect->hasAttribute(SVGNames::rxAttr);

    bool m_hasRy = rect->hasAttribute(SVGNames::ryAttr);

    // Fallback to the parent if rect has special features.

    if (m_hasRx || m_hasRy || !style()->svgStyle()->strokeDashArray().isEmpty()) {

       RenderSVGShape::createShape();

       return;

    }

    float widthValue = rect->width().value(rect);

    if (widthValue <= 0)

        return;

    float heightValue = rect->height().value(rect);

    if (heightValue <= 0)

        return;

    float xValue = rect->x().value(rect);

    float yValue = rect->y().value(rect);

    m_rect = FloatRect(xValue, yValue, widthValue, heightValue);

}

FloatRect RenderSVGRect::objectBoundingBox() const

{

    if (hasPath())

        return RenderSVGShape::objectBoundingBox();

    return m_rect;

}

FloatRect RenderSVGRect::strokeBoundingBox()

{

    if (hasPath())

        return RenderSVGShape::strokeBoundingBox();

    // If we inflate the m_rect with the half size strokeWidth, we get the strokeBoundingBox in non-fallback path mode.

    BoundingRectStrokeStyleApplier strokeStyle(this, style());

    FloatRect strokeRect = m_rect;

    strokeRect.inflate(this->strokeWidth() / 2);

    return strokeRect;

}

void RenderSVGRect::fillShape(GraphicsContext* context)

{

    if (hasPath())

        RenderSVGShape::fillShape(context);

    else

        context->fillRect(m_rect);

}

void RenderSVGRect::strokeShape(GraphicsContext* context)

{

    if (hasPath()) {

        RenderSVGShape::strokeShape(context);

        return;

    }

    context->strokeRect(m_rect, this->strokeWidth());

}

bool RenderSVGRect::strokeContainsSlowCase(const FloatPoint& point)

{

    if (hasPath())

        return RenderSVGShape::strokeContainsSlowCase(point);

    // To deceide the stroke containing we create two rects which represent the inner and

    // the outer stroke borders. The containing exists, if the point is between them.

    float strokeWidth = this->strokeWidth();

    FloatRect innerStrokeRect = m_rect;

    FloatRect outerStrokeRect = m_rect;

    innerStrokeRect.inflate(-strokeWidth / 2);

    outerStrokeRect.inflate(strokeWidth / 2);

    return (determinePointLocation(point, innerStrokeRect) != InsideShape

            && determinePointLocation(point, outerStrokeRect) != OutsideShape) ?  true : false;

}

bool RenderSVGRect::fillContainsSlowCase(const FloatPoint& point, const WindRule&) const

{

    return (determinePointLocation(point, m_rect) != OutsideShape) ? true : false;

}

PointLocation RenderSVGRect::determinePointLocation(const FloatPoint& point, const FloatRect& rect) const

{

    // Test whether the rect contains the certain point or not

    if (!rect.contains(point))

        return OutsideShape;

    return (rect.x() < point.x() && rect.maxX() > point.x() && rect.y() < point.y() && rect.maxY() > point.y()) ? InsideShape : OnStroke;

}

}

#endif // ENABLE(SVG)

Source/WebCore/rendering/svg/RenderSVGRect.h

/*

 * Copyright (C) 2011 University of Szeged

 * Copyright (C) 2011 Renata Hodovan (reni@webkit.org)

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY UNIVERSITY OF SZEGED ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL UNIVERSITY OF SZEGED OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#ifndef RenderSVGRect_h

#define RenderSVGRect_h

#if ENABLE(SVG)

#include "RenderSVGPath.h"

namespace WebCore {

class RenderSVGRect : public RenderSVGShape {

public:

    explicit RenderSVGRect(SVGStyledTransformableElement*);

    virtual ~RenderSVGRect();

private:

    virtual bool isSVGRect() const { return true; }

    virtual const char* renderName() const { return "RenderSVGRect"; }

    void createShape();

    bool isEmpty() const { return hasPath() ? RenderSVGShape::isEmpty() : m_rect.isEmpty(); };

    void fillShape(GraphicsContext*);

    FloatRect objectBoundingBox() const;

    FloatRect strokeBoundingBox();

    void strokeShape(GraphicsContext*);

    bool strokeContainsSlowCase(const FloatPoint&);

    bool fillContainsSlowCase(const FloatPoint&, const WindRule&) const;

    PointLocation determinePointLocation(const FloatPoint&, const FloatRect&) const;

private:

    FloatRect m_rect;

};

}

#endif // ENABLE(SVG)

#endif

Source/WebCore/rendering/svg/RenderSVGResourceClipper.cpp

@@bool RenderSVGResourceClipper::drawContentIntoMaskImage(ClipperData* clipperData

        }

        // Only shapes, paths and texts are allowed for clipping.

245 if (!renderer->isSVGP~~ath~~() && !renderer->isSVGText())

245 if (!renderer->isSVGShape() && !renderer->isSVGText())

            continue;

        // Save the old RenderStyle of the current object for restoring after drawing

@@void RenderSVGResourceClipper::calculateClipContentRepaintRect()

        RenderObject* renderer = childNode->renderer();

        if (!childNode->isSVGElement() || !static_cast<SVGElement*>(childNode)->isStyled() || !renderer)

            continue;

287 if (!renderer->isSVGP~~ath~~() && !renderer->isSVGText() && !renderer->isSVGShadowTreeRootContainer())

287 if (!renderer->isSVGShape() && !renderer->isSVGText() && !renderer->isSVGShadowTreeRootContainer())

            continue;

        RenderStyle* style = renderer->style();

        if (!style || style->display() == NONE || style->visibility() != VISIBLE)

@@bool RenderSVGResourceClipper::hitTestClipContent(const FloatRect& objectBoundin

        RenderObject* renderer = childNode->renderer();

        if (!childNode->isSVGElement() || !static_cast<SVGElement*>(childNode)->isStyled() || !renderer)

            continue;

313 if (!renderer->isSVGP~~ath~~() && !renderer->isSVGText() && !renderer->isSVGShadowTreeRootContainer())

313 if (!renderer->isSVGShape() && !renderer->isSVGText() && !renderer->isSVGShadowTreeRootContainer())

            continue;

        IntPoint hitPoint;

        HitTestResult result(hitPoint);

Source/WebCore/rendering/svg/RenderSVGResourceContainer.cpp

@@void RenderSVGResourceContainer::registerResource()

// FIXME: This does not belong here.

AffineTransform RenderSVGResourceContainer::transformOnNonScalingStroke(RenderObject* object, const AffineTransform& resourceTransform)

{

183 if (!object->isSVGP~~ath~~())

183 if (!object->isSVGShape())

        return resourceTransform;

    SVGStyledTransformableElement* element = static_cast<SVGStyledTransformableElement*>(object->node());

Source/WebCore/rendering/svg/RenderSVGShape.cpp

/*

 * Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>

 * Copyright (C) 2004, 2005, 2008 Rob Buis <buis@kde.org>

 * Copyright (C) 2005, 2007 Eric Seidel <eric@webkit.org>

 * Copyright (C) 2009 Google, Inc.

 * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>

 * Copyright (C) Research In Motion Limited 2010. All rights reserved.

 * Copyright (C) 2009 Jeff Schiller <codedread@gmail.com>

 * Copyright (C) 2011 Renata Hodovan <reni@webkit.org>

 * Copyright (C) 2011 University of Szeged

 *

 * 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

 * along 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 "RenderSVGShape.h"

#include "FloatPoint.h"

#include "FloatQuad.h"

#include "GraphicsContext.h"

#include "HitTestRequest.h"

#include "PointerEventsHitRules.h"

#include "RenderSVGContainer.h"

#include "RenderSVGResourceMarker.h"

#include "RenderSVGResourceSolidColor.h"

#include "SVGPathElement.h"

#include "SVGRenderSupport.h"

#include "SVGResources.h"

#include "SVGStyledTransformableElement.h"

#include "SVGTransformList.h"

#include "SVGURIReference.h"

#include "StrokeStyleApplier.h"

#include <wtf/MathExtras.h>

namespace WebCore {

RenderSVGShape::RenderSVGShape(SVGStyledTransformableElement* node)

    : RenderSVGModelObject(node)

    , m_needsBoundariesUpdate(false) // default is false, the cached rects are empty from the beginning

    , m_needsShapeUpdate(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

{

}

RenderSVGShape::~RenderSVGShape()

{

}

void RenderSVGShape::createShape()

{

    m_path = adoptPtr(new Path);

    ASSERT(isEmpty());

    SVGPathElement* element = static_cast<SVGPathElement*>(node());

    element->toPathData(path());

}

bool RenderSVGShape::isEmpty() const

{

    return path().isEmpty();

}

void RenderSVGShape::fillShape(GraphicsContext* context)

{

    context->fillPath(path());

}

FloatRect RenderSVGShape::objectBoundingBox() const

{

    return m_path->boundingRect();

}

FloatRect RenderSVGShape::strokeBoundingBox()

{

    BoundingRectStrokeStyleApplier strokeStyle(this, style());

    return path().strokeBoundingRect(&strokeStyle);

}

void RenderSVGShape::strokeShape(GraphicsContext* context)

{

    context->strokePath(path());

}

bool RenderSVGShape::strokeContainsSlowCase(const FloatPoint& point)

{

    BoundingRectStrokeStyleApplier applier(this, style());

    return path().strokeContains(&applier, point);

}

bool RenderSVGShape::fillContainsSlowCase(const FloatPoint& point, const WindRule& fillRule) const

{

    return path().contains(point, fillRule);

}

bool RenderSVGShape::fillContains(const FloatPoint& point, bool requiresFill, WindRule fillRule)

{

    if (!m_fillBoundingBox.contains(point))

        return false;

    Color fallbackColor;

    if (requiresFill && !RenderSVGResource::fillPaintingResource(this, style(), fallbackColor))

        return false;

    return fillContainsSlowCase(point, fillRule);

}

bool RenderSVGShape::strokeContains(const FloatPoint& point, bool requiresStroke)

{

    if (!m_strokeAndMarkerBoundingBox.contains(point))

        return false;

    Color fallbackColor;

    if (requiresStroke && !RenderSVGResource::strokePaintingResource(this, style(), fallbackColor))

        return false;

    if (shouldStrokeZeroLengthSubpath())

        return zeroLengthSubpathRect().contains(point);

    return strokeContainsSlowCase(point);

}

void RenderSVGShape::layout()

{

    LayoutRepainter repainter(*this, checkForRepaintDuringLayout() && selfNeedsLayout());

    SVGStyledTransformableElement* element = static_cast<SVGStyledTransformableElement*>(node());

    bool updateCachedBoundariesInParents = false;

    bool needsShapeUpdate = m_needsShapeUpdate;

    if (needsShapeUpdate) {;

        createShape();

        m_needsShapeUpdate = false;

        updateCachedBoundariesInParents = true;

    }

    if (m_needsTransformUpdate) {

        m_localTransform = element->animatedLocalTransform();

        m_needsTransformUpdate = false;

        updateCachedBoundariesInParents = true;

    }

    if (m_needsBoundariesUpdate)

        updateCachedBoundariesInParents = true;

    // Invalidate all resources of this client if our layout changed.

    if (m_everHadLayout && selfNeedsLayout()) {

        SVGResourcesCache::clientLayoutChanged(this);

        m_markerLayoutInfo.clear();

    }

    // At this point LayoutRepainter already grabbed the old bounds,

    // recalculate them now so repaintAfterLayout() uses the new bounds.

    if (needsShapeUpdate || m_needsBoundariesUpdate) {

        updateCachedBoundaries();

        m_needsBoundariesUpdate = false;

    }

    // If our bounds changed, notify the parents.

    if (updateCachedBoundariesInParents)

        RenderSVGModelObject::setNeedsBoundariesUpdate();

    repainter.repaintAfterLayout();

    setNeedsLayout(false);

}

bool RenderSVGShape::shouldStrokeZeroLengthSubpath() const

{

    // Spec(11.4): Any zero length subpath shall not be stroked if the ‘stroke-linecap’ property has a value of butt

    // but shall be stroked if the ‘stroke-linecap’ property has a value of round or square

    return style()->svgStyle()->hasStroke() && style()->svgStyle()->capStyle() != ButtCap && !m_fillBoundingBox.width() && !m_fillBoundingBox.height();

}

FloatRect RenderSVGShape::zeroLengthSubpathRect() const

{

    float strokeWidth = this->strokeWidth();

    return FloatRect(m_fillBoundingBox.x() - strokeWidth / 2, m_fillBoundingBox.y() - strokeWidth / 2, strokeWidth, strokeWidth);

}

void RenderSVGShape::setupSquareCapPath(Path*& usePath, int& applyMode)

{

    // Spec(11.4): Any zero length subpath shall not be stroked if the ‘stroke-linecap’ property has a value of butt

    // but shall be stroked if the ‘stroke-linecap’ property has a value of round or square

    DEFINE_STATIC_LOCAL(Path, tempPath, ());

    applyMode = ApplyToFillMode;

    usePath = &tempPath;

    usePath->clear();

    if (style()->svgStyle()->capStyle() == SquareCap)

        usePath->addRect(zeroLengthSubpathRect());

    else

        usePath->addEllipse(zeroLengthSubpathRect());

}

bool RenderSVGShape::setupNonScalingStrokePath(Path*& usePath, GraphicsContextStateSaver& stateSaver)

{

    DEFINE_STATIC_LOCAL(Path, tempPath, ());

    SVGStyledTransformableElement* element = static_cast<SVGStyledTransformableElement*>(node());

    AffineTransform nonScalingStrokeTransform = element->getScreenCTM(SVGLocatable::DisallowStyleUpdate);

    if (!nonScalingStrokeTransform.isInvertible())

        return false;

    tempPath = *m_path;

    usePath = &tempPath;

    tempPath.transform(nonScalingStrokeTransform);

    stateSaver.save();

    stateSaver.context()->concatCTM(nonScalingStrokeTransform.inverse());

    return true;

}

void RenderSVGShape::fillAndStrokePath(GraphicsContext* context)

{

    RenderStyle* style = this->style();

    Color fallbackColor;

    if (RenderSVGResource* fillPaintingResource = RenderSVGResource::fillPaintingResource(this, style, fallbackColor)) {

        if (fillPaintingResource->applyResource(this, style, context, ApplyToFillMode)) {

            fillShape(context);

        } else if (fallbackColor.isValid()) {

            RenderSVGResourceSolidColor* fallbackResource = RenderSVGResource::sharedSolidPaintingResource();

            fallbackResource->setColor(fallbackColor);

            if (fallbackResource->applyResource(this, style, context, ApplyToFillMode))

                fillShape(context);

        }

    }

    fallbackColor = Color();

    RenderSVGResource* strokePaintingResource = RenderSVGResource::strokePaintingResource(this, style, fallbackColor);

    if (!strokePaintingResource)

        return;

    Path* usePath;

    int applyMode = ApplyToStrokeMode;

    bool nonScalingStroke = style->svgStyle()->vectorEffect() == VE_NON_SCALING_STROKE;

    GraphicsContextStateSaver stateSaver(*context, false);

    // Spec(11.4): Any zero length subpath shall not be stroked if the ‘stroke-linecap’ property has a value of butt

    // but shall be stroked if the ‘stroke-linecap’ property has a value of round or square

    // FIXME: this does not work for zero-length subpaths, only when total path is zero-length

    if (shouldStrokeZeroLengthSubpath()) {

        RenderSVGShape::createShape();

        usePath = m_path.get();

        setupSquareCapPath(usePath, applyMode);

    } else if (nonScalingStroke) {

        RenderSVGShape::createShape();

        usePath = m_path.get();

        if (!setupNonScalingStrokePath(usePath, stateSaver))

            return;

    }

    if (strokePaintingResource->applyResource(this, style, context, applyMode)) {

        strokeShape(context);

        return;

    }

    if (!fallbackColor.isValid())

        return;

    RenderSVGResourceSolidColor* fallbackResource = RenderSVGResource::sharedSolidPaintingResource();

    fallbackResource->setColor(fallbackColor);

    if (fallbackResource->applyResource(this, style, context, applyMode))

        strokeShape(context);

}

void RenderSVGShape::paint(PaintInfo& paintInfo, const IntPoint&)

{

    if (paintInfo.context->paintingDisabled() || style()->visibility() == HIDDEN || isEmpty())

        return;

    FloatRect boundingBox = repaintRectInLocalCoordinates();

    if (!SVGRenderSupport::paintInfoIntersectsRepaintRect(boundingBox, m_localTransform, paintInfo))

        return;

    PaintInfo childPaintInfo(paintInfo);

    bool drawsOutline = style()->outlineWidth() && (childPaintInfo.phase == PaintPhaseOutline || childPaintInfo.phase == PaintPhaseSelfOutline);

    if (drawsOutline || childPaintInfo.phase == PaintPhaseForeground) {

        GraphicsContextStateSaver stateSaver(*childPaintInfo.context);

        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(childPaintInfo.context);

                if (svgStyle->hasMarkers())

                    m_markerLayoutInfo.drawMarkers(childPaintInfo);

            }

            SVGRenderSupport::finishRenderSVGContent(this, childPaintInfo, savedInfo.context);

        }

        if (drawsOutline)

            paintOutline(childPaintInfo.context, IntRect(boundingBox));

    }

}

// This method is called from inside paintOutline() since we call paintOutline()

// while transformed to our coord system, return local coords

void RenderSVGShape::addFocusRingRects(Vector<LayoutRect>& rects, const LayoutPoint&)

{

    LayoutRect rect = enclosingLayoutRect(repaintRectInLocalCoordinates());

    if (!rect.isEmpty())

        rects.append(rect);

}

bool RenderSVGShape::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, roundedLayoutPoint(localPoint));

            return true;

        }

    }

    return false;

}

FloatRect RenderSVGShape::calculateMarkerBoundsIfNeeded()

{

    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();

    ASSERT(style()->svgStyle()->hasMarkers());

    SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(this);

    if (!resources)

        return FloatRect();

    RenderSVGResourceMarker* markerStart = resources->markerStart();

    RenderSVGResourceMarker* markerMid = resources->markerMid();

    RenderSVGResourceMarker* markerEnd = resources->markerEnd();

    if (!markerStart && !markerMid && !markerEnd)

        return FloatRect();

    return m_markerLayoutInfo.calculateBoundaries(markerStart, markerMid, markerEnd, strokeWidth(), path());

}

void RenderSVGShape::updateCachedBoundaries()

{

    if (isEmpty()) {

        m_fillBoundingBox = FloatRect();

        m_strokeAndMarkerBoundingBox = FloatRect();

        m_repaintBoundingBox = FloatRect();

        return;

    }

    // Cache _unclipped_ fill bounding box, used for calculations in resources

    m_fillBoundingBox = objectBoundingBox();

    // Spec(11.4): Any zero length subpath shall not be stroked if the ‘stroke-linecap’ property has a value of butt

    // but shall be stroked if the ‘stroke-linecap’ property has a value of round or square

    if (shouldStrokeZeroLengthSubpath()) {

        m_strokeAndMarkerBoundingBox = zeroLengthSubpathRect();

        // Cache smallest possible repaint rectangle

        m_repaintBoundingBox = m_strokeAndMarkerBoundingBox;

        SVGRenderSupport::intersectRepaintRectWithResources(this, m_repaintBoundingBox);

        return;

    }

    // 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())

        m_strokeAndMarkerBoundingBox.unite(strokeBoundingBox());

    if (isSVGPath()) {

        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);

}

float RenderSVGShape::strokeWidth() const

{

    SVGElement* svgElement = static_cast<SVGElement*>(node());

    return style()->svgStyle()->strokeWidth().value(svgElement);

}

}

Source/WebCore/rendering/svg/RenderSVGShape.h

/*

 * Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>

 * Copyright (C) 2004, 2005 Rob Buis <buis@kde.org>

 * Copyright (C) 2005 Eric Seidel <eric@webkit.org>

 * Copyright (C) 2006 Apple Computer, Inc

 * Copyright (C) 2009 Google, Inc.

 * Copyright (C) 2011 Renata Hodovan <reni@webkit.org>

 * Copyright (C) 2011 University of Szeged

 *

 * 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

 * along 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.

 */

#ifndef RenderSVGShape_h

#define RenderSVGShape_h

#if ENABLE(SVG)

#include "AffineTransform.h"

#include "FloatRect.h"

#include "RenderSVGModelObject.h"

#include "SVGMarkerLayoutInfo.h"

#include "StrokeStyleApplier.h"

#include <wtf/OwnPtr.h>

namespace WebCore {

class FloatPoint;

class GraphicsContextStateSaver;

class RenderSVGContainer;

class RenderSVGPath;

class SVGStyledTransformableElement;

enum PointLocation {

    InsideShape,

    OutsideShape,

    OnStroke

};

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;

};

class RenderSVGShape : public RenderSVGModelObject {

public:

    explicit RenderSVGShape(SVGStyledTransformableElement*);

    virtual ~RenderSVGShape();

    void setNeedsShapeUpdate() { m_needsShapeUpdate = true; }

    virtual void setNeedsBoundariesUpdate() { m_needsBoundariesUpdate = true; }

    virtual void setNeedsTransformUpdate() { m_needsTransformUpdate = true; }

private:

    // Hit-detection seperated for the fill and the stroke

    bool fillContains(const FloatPoint&, bool requiresFill = true, WindRule fillRule = RULE_NONZERO);

    bool strokeContains(const FloatPoint&, bool requiresStroke = true);

    virtual FloatRect strokeBoundingBox() const { return m_strokeAndMarkerBoundingBox; }

    virtual FloatRect repaintRectInLocalCoordinates() const { return m_repaintBoundingBox; }

    virtual const AffineTransform& localToParentTransform() const { return m_localTransform; }

    virtual bool isSVGShape() const { return true; }

    virtual const char* renderName() const { return "RenderSVGShape"; }

    virtual void layout();

    virtual void paint(PaintInfo&, const LayoutPoint&);

    virtual void addFocusRingRects(Vector<LayoutRect>&, const LayoutPoint&);

    virtual bool nodeAtFloatPoint(const HitTestRequest&, HitTestResult&, const FloatPoint& pointInParent, HitTestAction);

    FloatRect calculateMarkerBoundsIfNeeded();

    void updateCachedBoundaries();

    void setupSquareCapPath(Path*& usePath, int& applyMode);

    bool setupNonScalingStrokePath(Path*& usePath, GraphicsContextStateSaver&);

    bool shouldStrokeZeroLengthSubpath() const;

    FloatRect zeroLengthSubpathRect() const;

protected:

    virtual void createShape();

    virtual bool isEmpty() const;

    virtual void fillShape(GraphicsContext*);

    virtual FloatRect objectBoundingBox() const;

    virtual FloatRect strokeBoundingBox();

    virtual void strokeShape(GraphicsContext*);

    virtual bool strokeContainsSlowCase(const FloatPoint&);

    virtual bool fillContainsSlowCase(const FloatPoint&, const WindRule&) const;

    float strokeWidth() const;

    Path& path() const

    {

        ASSERT(m_path.get());

        return *m_path;

    }

    Path* pathPtr() const

    {

        ASSERT(m_path.get());

        return m_path.get();

    };

    bool hasPath() const { return m_path.get(); }

private:

    virtual AffineTransform localTransform() const { return m_localTransform; }

    void fillAndStrokePath(GraphicsContext*);

    bool m_needsBoundariesUpdate : 1;

    bool m_needsShapeUpdate : 1;

    bool m_needsTransformUpdate : 1;

    FloatRect m_fillBoundingBox;

    FloatRect m_strokeAndMarkerBoundingBox;

    FloatRect m_repaintBoundingBox;

    SVGMarkerLayoutInfo m_markerLayoutInfo;

    AffineTransform m_localTransform;

    OwnPtr<Path> m_path;

};

inline RenderSVGShape* toRenderSVGShape(RenderObject* object)

{

    ASSERT(!object || object->isSVGShape());

    return static_cast<RenderSVGShape*>(object);

}

inline const RenderSVGShape* toRenderSVGShape(const RenderObject* object)

{

    ASSERT(!object || object->isSVGShape());

    return static_cast<const RenderSVGShape*>(object);

}

// This will catch anyone doing an unnecessary cast.

void toRenderSVGShape(const RenderSVGShape*);

}

Source/WebCore/rendering/svg/SVGRenderSupport.cpp

@@void SVGRenderSupport::layoutChildren(RenderObject* start, bool selfNeedsLayout)

            // When selfNeedsLayout is false and the layout size changed, we have to check whether this child uses relative lengths

            if (SVGElement* element = child->node()->isSVGElement() ? static_cast<SVGElement*>(child->node()) : 0) {

                if (element->isStyled() && static_cast<SVGStyledElement*>(element)->hasRelativeLengths()) {

                    // When the layout size changed and when using relative values tell the RenderSVGPath to update its Path object

                    if (child->isSVGPath())

                        toRenderSVGPath(child)->setNeedsPathUpdate();

                    // When the layout size changed and when using relative values tell the RenderSVGShape to update its shape object

                    if (child->isSVGShape())

                        toRenderSVGShape(child)->setNeedsShapeUpdate();

                    needsLayout = true;

                }

Source/WebCore/rendering/svg/SVGRenderTreeAsText.cpp

#include "RenderSVGResourceRadialGradient.h"

#include "RenderSVGResourceSolidColor.h"

#include "RenderSVGRoot.h"

58#include "RenderSVGShape.h"

#include "RenderSVGText.h"

#include "RenderTreeAsText.h"

#include "SVGCircleElement.h"

@@static void writeStyle(TextStream& ts, const RenderObject& object)

        writeNameValuePair(ts, "transform", object.localTransform());

    writeIfNotDefault(ts, "image rendering", style->imageRendering(), RenderStyle::initialImageRendering());

    writeIfNotDefault(ts, "opacity", style->opacity(), RenderStyle::initialOpacity());

    if (object.isSVGPath()) {

        const RenderSVGPath& path = static_cast<const RenderSVGPath&>(object);

        ASSERT(path.node());

        ASSERT(path.node()->isSVGElement());

    if (object.isSVGShape()) {

        const RenderSVGShape& shape = static_cast<const RenderSVGShape&>(object);

        ASSERT(shape.node());

        ASSERT(shape.node()->isSVGElement());

296297

297298 Color fallbackColor;

298 if (RenderSVGResource* strokePaintingResource = RenderSVGResource::strokePaintingResource(const_cast<RenderSVGP~~ath~~*>(&~~path~~), ~~path~~.style(), fallbackColor)) {

299 if (RenderSVGResource* strokePaintingResource = RenderSVGResource::strokePaintingResource(const_cast<RenderSVGShape*>(&shape), shape.style(), fallbackColor)) {

            TextStreamSeparator s(" ");

            ts << " [stroke={" << s;

            writeSVGPaintingResource(ts, strokePaintingResource);

303 SVGElement* element = static_cast<SVGElement*>(~~path~~.node());

304 SVGElement* element = static_cast<SVGElement*>(shape.node());

            double dashOffset = svgStyle->strokeDashOffset().value(element);

            double strokeWidth = svgStyle->strokeWidth().value(element);

            const Vector<SVGLength>& dashes = svgStyle->strokeDashArray();

@@static void writeStyle(TextStream& ts, const RenderObject& object)

            ts << "}]";

        }

325 if (RenderSVGResource* fillPaintingResource = RenderSVGResource::fillPaintingResource(const_cast<RenderSVGP~~ath~~*>(&~~path~~), ~~path~~.style(), fallbackColor)) {

326 if (RenderSVGResource* fillPaintingResource = RenderSVGResource::fillPaintingResource(const_cast<RenderSVGShape*>(&shape), shape.style(), fallbackColor)) {

            TextStreamSeparator s(" ");

            ts << " [fill={" << s;

            writeSVGPaintingResource(ts, fillPaintingResource);

@@static TextStream& writePositionAndStyle(TextStream& ts, const RenderObject& obj

    return ts;

}

349 static TextStream& operator<<(TextStream& ts, const RenderSVGP~~ath~~& ~~path~~)

350static TextStream& operator<<(TextStream& ts, const RenderSVGShape& shape)

350351{

351 writePositionAndStyle(ts, ~~path~~);

352 writePositionAndStyle(ts, shape);

352353

353 ASSERT(~~path~~.node()->isSVGElement());

354 SVGElement* svgElement = static_cast<SVGElement*>(~~path~~.node());

354 ASSERT(shape.node()->isSVGElement());

355 SVGElement* svgElement = static_cast<SVGElement*>(shape.node());

    if (svgElement->hasTagName(SVGNames::rectTag)) {

        SVGRectElement* element = static_cast<SVGRectElement*>(svgElement);

@@void writeSVGImage(TextStream& ts, const RenderSVGImage& image, int indent)

    writeResources(ts, image, indent);

}

656 void write(TextStream& ts, const RenderSVGP~~ath~~& ~~path~~, int indent)

657void write(TextStream& ts, const RenderSVGShape& shape, int indent)

657658{

    writeStandardPrefix(ts, path, indent);

    ts << path << "\n";

    writeResources(ts, path, indent);

    writeStandardPrefix(ts, shape, indent);

    ts << shape << "\n";

    writeResources(ts, shape, indent);

}

void writeSVGGradientStop(TextStream& ts, const RenderSVGGradientStop& stop, int indent)

COMMIT_MESSAGE

Source/WebCore/CMakeLists.txt

Source/WebCore/GNUmakefile.list.am

Source/WebCore/WebCore.gypi

Source/WebCore/WebCore.pro

Source/WebCore/WebCore.xcodeproj/project.pbxproj

Source/WebCore/rendering/RenderObject.h

Source/WebCore/rendering/RenderTreeAsText.cpp

Source/WebCore/rendering/svg/RenderSVGPath.cpp

Source/WebCore/rendering/svg/RenderSVGPath.h

Source/WebCore/rendering/svg/RenderSVGRect.cpp

Source/WebCore/rendering/svg/RenderSVGRect.h

Source/WebCore/rendering/svg/RenderSVGResourceClipper.cpp

Source/WebCore/rendering/svg/RenderSVGResourceContainer.cpp

Source/WebCore/rendering/svg/RenderSVGShape.cpp

Source/WebCore/rendering/svg/RenderSVGShape.h

Source/WebCore/rendering/svg/SVGRenderSupport.cpp

Source/WebCore/rendering/svg/SVGRenderTreeAsText.cpp

Source/WebCore/rendering/svg/SVGRenderTreeAsText.h

Source/WebCore/svg/SVGCircleElement.cpp

Source/WebCore/svg/SVGEllipseElement.cpp

Source/WebCore/svg/SVGLineElement.cpp

Source/WebCore/svg/SVGPathElement.cpp

Source/WebCore/svg/SVGPathElement.h

Source/WebCore/svg/SVGPolyElement.cpp

Source/WebCore/svg/SVGRectElement.cpp

Source/WebCore/svg/SVGRectElement.h