Home | History | Annotate | Download | only in svg 
      1 /*
      2  * Copyright (C) 2004, 2005, 2007, 2008 Nikolas Zimmermann <zimmermann (at) kde.org>
      3  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Rob Buis <buis (at) kde.org>
      4  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
      5  *
      6  * This library is free software; you can redistribute it and/or
      7  * modify it under the terms of the GNU Library General Public
      8  * License as published by the Free Software Foundation; either
      9  * version 2 of the License, or (at your option) any later version.
     10  *
     11  * This library is distributed in the hope that it will be useful,
     12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
     13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     14  * Library General Public License for more details.
     15  *
     16  * You should have received a copy of the GNU Library General Public License
     17  * along with this library; see the file COPYING.LIB.  If not, write to
     18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     19  * Boston, MA 02110-1301, USA.
     20  */
     21 
     22 #include "config.h"
     23 
     24 #if ENABLE(SVG)
     25 #include "RenderSVGResourceClipper.h"
     26 
     27 #include "AffineTransform.h"
     28 #include "FloatRect.h"
     29 #include "GraphicsContext.h"
     30 #include "HitTestRequest.h"
     31 #include "HitTestResult.h"
     32 #include "ImageBuffer.h"
     33 #include "IntRect.h"
     34 #include "RenderObject.h"
     35 #include "RenderSVGResource.h"
     36 #include "RenderStyle.h"
     37 #include "SVGClipPathElement.h"
     38 #include "SVGElement.h"
     39 #include "SVGImageBufferTools.h"
     40 #include "SVGNames.h"
     41 #include "SVGRenderSupport.h"
     42 #include "SVGResources.h"
     43 #include "SVGStyledElement.h"
     44 #include "SVGStyledTransformableElement.h"
     45 #include "SVGUnitTypes.h"
     46 #include "SVGUseElement.h"
     47 #include <wtf/UnusedParam.h>
     48 
     49 namespace WebCore {
     50 
     51 RenderSVGResourceType RenderSVGResourceClipper::s_resourceType = ClipperResourceType;
     52 
     53 RenderSVGResourceClipper::RenderSVGResourceClipper(SVGClipPathElement* node)
     54     : RenderSVGResourceContainer(node)
     55     , m_invalidationBlocked(false)
     56 {
     57 }
     58 
     59 RenderSVGResourceClipper::~RenderSVGResourceClipper()
     60 {
     61     if (m_clipper.isEmpty())
     62         return;
     63 
     64     deleteAllValues(m_clipper);
     65     m_clipper.clear();
     66 }
     67 
     68 void RenderSVGResourceClipper::removeAllClientsFromCache(bool markForInvalidation)
     69 {
     70     if (m_invalidationBlocked)
     71         return;
     72 
     73     m_clipBoundaries = FloatRect();
     74     if (!m_clipper.isEmpty()) {
     75         deleteAllValues(m_clipper);
     76         m_clipper.clear();
     77     }
     78 
     79     markAllClientsForInvalidation(markForInvalidation ? LayoutAndBoundariesInvalidation : ParentOnlyInvalidation);
     80 }
     81 
     82 void RenderSVGResourceClipper::removeClientFromCache(RenderObject* client, bool markForInvalidation)
     83 {
     84     ASSERT(client);
     85     if (m_invalidationBlocked)
     86         return;
     87 
     88     if (m_clipper.contains(client))
     89         delete m_clipper.take(client);
     90 
     91     markClientForInvalidation(client, markForInvalidation ? BoundariesInvalidation : ParentOnlyInvalidation);
     92 }
     93 
     94 bool RenderSVGResourceClipper::applyResource(RenderObject* object, RenderStyle*, GraphicsContext*& context, unsigned short resourceMode)
     95 {
     96     ASSERT(object);
     97     ASSERT(context);
     98 #ifndef NDEBUG
     99     ASSERT(resourceMode == ApplyToDefaultMode);
    100 #else
    101     UNUSED_PARAM(resourceMode);
    102 #endif
    103 
    104     return applyClippingToContext(object, object->objectBoundingBox(), object->repaintRectInLocalCoordinates(), context);
    105 }
    106 
    107 bool RenderSVGResourceClipper::pathOnlyClipping(GraphicsContext* context, const FloatRect& objectBoundingBox)
    108 {
    109     // If the current clip-path gets clipped itself, we have to fallback to masking.
    110     if (!style()->svgStyle()->clipperResource().isEmpty())
    111         return false;
    112     WindRule clipRule = RULE_NONZERO;
    113     Path clipPath = Path();
    114 
    115     // If clip-path only contains one visible shape or path, we can use path-based clipping. Invisible
    116     // shapes don't affect the clipping and can be ignored. If clip-path contains more than one
    117     // visible shape, the additive clipping may not work, caused by the clipRule. EvenOdd
    118     // as well as NonZero can cause self-clipping of the elements.
    119     // See also http://www.w3.org/TR/SVG/painting.html#FillRuleProperty
    120     for (Node* childNode = node()->firstChild(); childNode; childNode = childNode->nextSibling()) {
    121         RenderObject* renderer = childNode->renderer();
    122         if (!renderer)
    123             continue;
    124         // Only shapes or paths are supported for direct clipping. We need to fallback to masking for texts.
    125         if (renderer->isSVGText())
    126             return false;
    127         if (!childNode->isSVGElement() || !static_cast<SVGElement*>(childNode)->isStyledTransformable())
    128             continue;
    129         SVGStyledTransformableElement* styled = static_cast<SVGStyledTransformableElement*>(childNode);
    130         RenderStyle* style = renderer->style();
    131         if (!style || style->display() == NONE || style->visibility() != VISIBLE)
    132              continue;
    133         const SVGRenderStyle* svgStyle = style->svgStyle();
    134         // Current shape in clip-path gets clipped too. Fallback to masking.
    135         if (!svgStyle->clipperResource().isEmpty())
    136             return false;
    137         // Fallback to masking, if there is more than one clipping path.
    138         if (clipPath.isEmpty()) {
    139             styled->toClipPath(clipPath);
    140             clipRule = svgStyle->clipRule();
    141         } else
    142             return false;
    143     }
    144     // Only one visible shape/path was found. Directly continue clipping and transform the content to userspace if necessary.
    145     if (static_cast<SVGClipPathElement*>(node())->clipPathUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX) {
    146         AffineTransform transform;
    147         transform.translate(objectBoundingBox.x(), objectBoundingBox.y());
    148         transform.scaleNonUniform(objectBoundingBox.width(), objectBoundingBox.height());
    149         clipPath.transform(transform);
    150     }
    151     // The SVG specification wants us to clip everything, if clip-path doesn't have a child.
    152     if (clipPath.isEmpty())
    153         clipPath.addRect(FloatRect());
    154     context->clipPath(clipPath, clipRule);
    155     return true;
    156 }
    157 
    158 bool RenderSVGResourceClipper::applyClippingToContext(RenderObject* object, const FloatRect& objectBoundingBox,
    159                                                       const FloatRect& repaintRect, GraphicsContext* context)
    160 {
    161     if (!m_clipper.contains(object))
    162         m_clipper.set(object, new ClipperData);
    163 
    164     bool shouldCreateClipData = false;
    165     ClipperData* clipperData = m_clipper.get(object);
    166     if (!clipperData->clipMaskImage) {
    167         if (pathOnlyClipping(context, objectBoundingBox))
    168             return true;
    169         shouldCreateClipData = true;
    170     }
    171 
    172     AffineTransform absoluteTransform;
    173     SVGImageBufferTools::calculateTransformationToOutermostSVGCoordinateSystem(object, absoluteTransform);
    174 
    175     FloatRect absoluteTargetRect = absoluteTransform.mapRect(repaintRect);
    176     FloatRect clampedAbsoluteTargetRect = SVGImageBufferTools::clampedAbsoluteTargetRectForRenderer(object, absoluteTargetRect);
    177 
    178     if (shouldCreateClipData && !clampedAbsoluteTargetRect.isEmpty()) {
    179         if (!SVGImageBufferTools::createImageBuffer(absoluteTargetRect, clampedAbsoluteTargetRect, clipperData->clipMaskImage, ColorSpaceDeviceRGB))
    180             return false;
    181 
    182         GraphicsContext* maskContext = clipperData->clipMaskImage->context();
    183         ASSERT(maskContext);
    184 
    185         // The save/restore pair is needed for clipToImageBuffer - it doesn't work without it on non-Cg platforms.
    186         maskContext->save();
    187         maskContext->translate(-clampedAbsoluteTargetRect.x(), -clampedAbsoluteTargetRect.y());
    188         maskContext->concatCTM(absoluteTransform);
    189 
    190         // clipPath can also be clipped by another clipPath.
    191         if (SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(this)) {
    192             if (RenderSVGResourceClipper* clipper = resources->clipper()) {
    193                 if (!clipper->applyClippingToContext(this, objectBoundingBox, repaintRect, maskContext)) {
    194                     maskContext->restore();
    195                     return false;
    196                 }
    197             }
    198         }
    199 
    200         drawContentIntoMaskImage(clipperData, objectBoundingBox);
    201         maskContext->restore();
    202     }
    203 
    204     if (!clipperData->clipMaskImage)
    205         return false;
    206 
    207     SVGImageBufferTools::clipToImageBuffer(context, absoluteTransform, clampedAbsoluteTargetRect, clipperData->clipMaskImage);
    208     return true;
    209 }
    210 
    211 bool RenderSVGResourceClipper::drawContentIntoMaskImage(ClipperData* clipperData, const FloatRect& objectBoundingBox)
    212 {
    213     ASSERT(clipperData);
    214     ASSERT(clipperData->clipMaskImage);
    215 
    216     GraphicsContext* maskContext = clipperData->clipMaskImage->context();
    217     ASSERT(maskContext);
    218 
    219     AffineTransform maskContentTransformation;
    220     SVGClipPathElement* clipPath = static_cast<SVGClipPathElement*>(node());
    221     if (clipPath->clipPathUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX) {
    222         maskContentTransformation.translate(objectBoundingBox.x(), objectBoundingBox.y());
    223         maskContentTransformation.scaleNonUniform(objectBoundingBox.width(), objectBoundingBox.height());
    224         maskContext->concatCTM(maskContentTransformation);
    225     }
    226 
    227     // Draw all clipPath children into a global mask.
    228     for (Node* childNode = node()->firstChild(); childNode; childNode = childNode->nextSibling()) {
    229         RenderObject* renderer = childNode->renderer();
    230         if (!childNode->isSVGElement() || !static_cast<SVGElement*>(childNode)->isStyled() || !renderer)
    231             continue;
    232         RenderStyle* style = renderer->style();
    233         if (!style || style->display() == NONE || style->visibility() != VISIBLE)
    234             continue;
    235 
    236         WindRule newClipRule = style->svgStyle()->clipRule();
    237         bool isUseElement = renderer->isSVGShadowTreeRootContainer();
    238         if (isUseElement) {
    239             SVGUseElement* useElement = static_cast<SVGUseElement*>(childNode);
    240             renderer = useElement->rendererClipChild();
    241             if (!renderer)
    242                 continue;
    243             if (!useElement->hasAttribute(SVGNames::clip_ruleAttr))
    244                 newClipRule = renderer->style()->svgStyle()->clipRule();
    245         }
    246 
    247         // Only shapes, paths and texts are allowed for clipping.
    248         if (!renderer->isSVGPath() && !renderer->isSVGText())
    249             continue;
    250 
    251         // Save the old RenderStyle of the current object for restoring after drawing
    252         // it to the MaskImage. The new intermediate RenderStyle needs to inherit from
    253         // the old one.
    254         RefPtr<RenderStyle> oldRenderStyle = renderer->style();
    255         RefPtr<RenderStyle> newRenderStyle = RenderStyle::clone(oldRenderStyle.get());
    256         SVGRenderStyle* svgStyle = newRenderStyle.get()->accessSVGStyle();
    257         svgStyle->setFillPaint(SVGPaint::defaultFill());
    258         svgStyle->setStrokePaint(SVGPaint::defaultStroke());
    259         svgStyle->setFillRule(newClipRule);
    260         newRenderStyle.get()->setOpacity(1.0f);
    261         svgStyle->setFillOpacity(1.0f);
    262         svgStyle->setStrokeOpacity(1.0f);
    263         svgStyle->setFilterResource(String());
    264         svgStyle->setMaskerResource(String());
    265 
    266         // The setStyle() call results in a styleDidChange() call, which in turn invalidations the resources.
    267         // As we're mutating the resource on purpose, block updates until we've resetted the style again.
    268         m_invalidationBlocked = true;
    269         renderer->setStyle(newRenderStyle.release());
    270 
    271         // In the case of a <use> element, we obtained its renderere above, to retrieve its clipRule.
    272         // We have to pass the <use> renderer itself to renderSubtreeToImageBuffer() to apply it's x/y/transform/etc. values when rendering.
    273         // So if isUseElement is true, refetch the childNode->renderer(), as renderer got overriden above.
    274         SVGImageBufferTools::renderSubtreeToImageBuffer(clipperData->clipMaskImage.get(), isUseElement ? childNode->renderer() : renderer, maskContentTransformation);
    275 
    276         renderer->setStyle(oldRenderStyle.release());
    277         m_invalidationBlocked = false;
    278     }
    279 
    280     return true;
    281 }
    282 
    283 void RenderSVGResourceClipper::calculateClipContentRepaintRect()
    284 {
    285     // This is a rough heuristic to appraise the clip size and doesn't consider clip on clip.
    286     for (Node* childNode = node()->firstChild(); childNode; childNode = childNode->nextSibling()) {
    287         RenderObject* renderer = childNode->renderer();
    288         if (!childNode->isSVGElement() || !static_cast<SVGElement*>(childNode)->isStyled() || !renderer)
    289             continue;
    290         if (!renderer->isSVGPath() && !renderer->isSVGText() && !renderer->isSVGShadowTreeRootContainer())
    291             continue;
    292         RenderStyle* style = renderer->style();
    293         if (!style || style->display() == NONE || style->visibility() != VISIBLE)
    294              continue;
    295         m_clipBoundaries.unite(renderer->localToParentTransform().mapRect(renderer->repaintRectInLocalCoordinates()));
    296     }
    297 }
    298 
    299 bool RenderSVGResourceClipper::hitTestClipContent(const FloatRect& objectBoundingBox, const FloatPoint& nodeAtPoint)
    300 {
    301     FloatPoint point = nodeAtPoint;
    302     if (!SVGRenderSupport::pointInClippingArea(this, point))
    303         return false;
    304 
    305     if (static_cast<SVGClipPathElement*>(node())->clipPathUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX) {
    306         AffineTransform transform;
    307         transform.translate(objectBoundingBox.x(), objectBoundingBox.y());
    308         transform.scaleNonUniform(objectBoundingBox.width(), objectBoundingBox.height());
    309         point = transform.inverse().mapPoint(point);
    310     }
    311 
    312     for (Node* childNode = node()->firstChild(); childNode; childNode = childNode->nextSibling()) {
    313         RenderObject* renderer = childNode->renderer();
    314         if (!childNode->isSVGElement() || !static_cast<SVGElement*>(childNode)->isStyled() || !renderer)
    315             continue;
    316         if (!renderer->isSVGPath() && !renderer->isSVGText() && !renderer->isSVGShadowTreeRootContainer())
    317             continue;
    318         IntPoint hitPoint;
    319         HitTestResult result(hitPoint);
    320         if (renderer->nodeAtFloatPoint(HitTestRequest(HitTestRequest::SVGClipContent), result, point, HitTestForeground))
    321             return true;
    322     }
    323 
    324     return false;
    325 }
    326 
    327 FloatRect RenderSVGResourceClipper::resourceBoundingBox(RenderObject* object)
    328 {
    329     // Resource was not layouted yet. Give back the boundingBox of the object.
    330     if (selfNeedsLayout())
    331         return object->objectBoundingBox();
    332 
    333     if (m_clipBoundaries.isEmpty())
    334         calculateClipContentRepaintRect();
    335 
    336     if (static_cast<SVGClipPathElement*>(node())->clipPathUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX) {
    337         FloatRect objectBoundingBox = object->objectBoundingBox();
    338         AffineTransform transform;
    339         transform.translate(objectBoundingBox.x(), objectBoundingBox.y());
    340         transform.scaleNonUniform(objectBoundingBox.width(), objectBoundingBox.height());
    341         return transform.mapRect(m_clipBoundaries);
    342     }
    343 
    344     return m_clipBoundaries;
    345 }
    346 
    347 }
    348 
    349 #endif // ENABLE(SVG)
    350