Source/WebCore/rendering/svg/RenderSVGResourcePattern.cpp

   1 /*
   2  * Copyright (C) 2006 Nikolas Zimmermann <zimmermann@kde.org>
   3  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public License
  16  * along with this library; see the file COPYING.LIB.  If not, write to
  17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 #include "config.h"
  22 #include "RenderSVGResourcePattern.h"
  23
  24 #include "ElementIterator.h"
  25 #include "FrameView.h"
  26 #include "GraphicsContext.h"
  27 #include "RenderSVGRoot.h"
  28 #include "SVGFitToViewBox.h"
  29 #include "SVGRenderingContext.h"
  30
  31 namespace WebCore {
  32
  33 RenderSVGResourcePattern::RenderSVGResourcePattern(SVGPatternElement& element, Ref<RenderStyle>&& style)
  34     : RenderSVGResourceContainer(element, WTF::move(style))
  35     , m_shouldCollectPatternAttributes(true)
  36 {
  37 }
  38
  39 SVGPatternElement& RenderSVGResourcePattern::patternElement() const
  40 {
  41     return downcast<SVGPatternElement>(RenderSVGResourceContainer::element());
  42 }
  43
  44 void RenderSVGResourcePattern::removeAllClientsFromCache(bool markForInvalidation)
  45 {
  46     m_patternMap.clear();
  47     m_shouldCollectPatternAttributes = true;
  48     markAllClientsForInvalidation(markForInvalidation ? RepaintInvalidation : ParentOnlyInvalidation);
  49 }
  50
  51 void RenderSVGResourcePattern::removeClientFromCache(RenderElement& client, bool markForInvalidation)
  52 {
  53     m_patternMap.remove(&client);
  54     markClientForInvalidation(client, markForInvalidation ? RepaintInvalidation : ParentOnlyInvalidation);
  55 }
  56
  57 PatternData* RenderSVGResourcePattern::buildPattern(RenderElement& renderer, unsigned short resourceMode)
  58 {
  59     PatternData* currentData = m_patternMap.get(&renderer);
  60     if (currentData && currentData->pattern)
  61         return currentData;
  62
  63     if (m_shouldCollectPatternAttributes) {
  64         patternElement().synchronizeAnimatedSVGAttribute(anyQName());
  65
  66         m_attributes = PatternAttributes();
  67         patternElement().collectPatternAttributes(m_attributes);
  68         m_shouldCollectPatternAttributes = false;
  69     }
  70
  71     // If we couldn't determine the pattern content element root, stop here.
  72     if (!m_attributes.patternContentElement())
  73         return nullptr;
  74
  75     // An empty viewBox disables rendering.
  76     if (m_attributes.hasViewBox() && m_attributes.viewBox().isEmpty())
  77         return nullptr;
  78
  79     // Compute all necessary transformations to build the tile image & the pattern.
  80     FloatRect tileBoundaries;
  81     AffineTransform tileImageTransform;
  82     if (!buildTileImageTransform(renderer, m_attributes, patternElement(), tileBoundaries, tileImageTransform))
  83         return nullptr;
  84
  85     AffineTransform absoluteTransformIgnoringRotation = SVGRenderingContext::calculateTransformationToOutermostCoordinateSystem(renderer);
  86
  87     // Ignore 2D rotation, as it doesn't affect the size of the tile.
  88     SVGRenderingContext::clear2DRotation(absoluteTransformIgnoringRotation);
  89     FloatRect absoluteTileBoundaries = absoluteTransformIgnoringRotation.mapRect(tileBoundaries);
  90     FloatRect clampedAbsoluteTileBoundaries;
  91
  92     // Scale the tile size to match the scale level of the patternTransform.
  93     absoluteTileBoundaries.scale(static_cast<float>(m_attributes.patternTransform().xScale()),
  94         static_cast<float>(m_attributes.patternTransform().yScale()));
  95
  96     // Build tile image.
  97     auto tileImage = createTileImage(m_attributes, tileBoundaries, absoluteTileBoundaries, tileImageTransform, clampedAbsoluteTileBoundaries);
  98     if (!tileImage)
  99         return nullptr;
 100
 101     RefPtr<Image> copiedImage = tileImage->copyImage(CopyBackingStore);
 102     if (!copiedImage)
 103         return nullptr;
 104
 105     // Build pattern.
 106     auto patternData = std::make_unique<PatternData>();
 107     patternData->pattern = Pattern::create(copiedImage, true, true);
 108
 109     // Compute pattern space transformation.
 110     const IntSize tileImageSize = tileImage->logicalSize();
 111     patternData->transform.translate(tileBoundaries.x(), tileBoundaries.y());
 112     patternData->transform.scale(tileBoundaries.width() / tileImageSize.width(), tileBoundaries.height() / tileImageSize.height());
 113
 114     AffineTransform patternTransform = m_attributes.patternTransform();
 115     if (!patternTransform.isIdentity())
 116         patternData->transform = patternTransform * patternData->transform;
 117
 118     // Account for text drawing resetting the context to non-scaled, see SVGInlineTextBox::paintTextWithShadows.
 119     if (resourceMode & ApplyToTextMode) {
 120         AffineTransform additionalTextTransformation;
 121         if (shouldTransformOnTextPainting(renderer, additionalTextTransformation))
 122             patternData->transform *= additionalTextTransformation;
 123     }
 124     patternData->pattern->setPatternSpaceTransform(patternData->transform);
 125
 126     // Various calls above may trigger invalidations in some fringe cases (ImageBuffer allocation
 127     // failures in the SVG image cache for example). To avoid having our PatternData deleted by
 128     // removeAllClientsFromCache(), we only make it visible in the cache at the very end.
 129     return m_patternMap.set(&renderer, WTF::move(patternData)).iterator->value.get();
 130 }
 131
 132 bool RenderSVGResourcePattern::applyResource(RenderElement& renderer, const RenderStyle& style, GraphicsContext*& context, unsigned short resourceMode)
 133 {
 134     ASSERT(context);
 135     ASSERT(resourceMode != ApplyToDefaultMode);
 136
 137     // Spec: When the geometry of the applicable element has no width or height and objectBoundingBox is specified,
 138     // then the given effect (e.g. a gradient or a filter) will be ignored.
 139     FloatRect objectBoundingBox = renderer.objectBoundingBox();
 140     if (m_attributes.patternUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX && objectBoundingBox.isEmpty())
 141         return false;
 142
 143     PatternData* patternData = buildPattern(renderer, resourceMode);
 144     if (!patternData)
 145         return false;
 146
 147     // Draw pattern
 148     context->save();
 149
 150     const SVGRenderStyle& svgStyle = style.svgStyle();
 151
 152     if (resourceMode & ApplyToFillMode) {
 153         context->setAlpha(svgStyle.fillOpacity());
 154         context->setFillPattern(*patternData->pattern);
 155         context->setFillRule(svgStyle.fillRule());
 156     } else if (resourceMode & ApplyToStrokeMode) {
 157         if (svgStyle.vectorEffect() == VE_NON_SCALING_STROKE)
 158             patternData->pattern->setPatternSpaceTransform(transformOnNonScalingStroke(&renderer, patternData->transform));
 159         context->setAlpha(svgStyle.strokeOpacity());
 160         context->setStrokePattern(*patternData->pattern);
 161         SVGRenderSupport::applyStrokeStyleToContext(context, style, renderer);
 162     }
 163
 164     if (resourceMode & ApplyToTextMode) {
 165         if (resourceMode & ApplyToFillMode) {
 166             context->setTextDrawingMode(TextModeFill);
 167
 168 #if USE(CG)
 169             context->applyFillPattern();
 170 #endif
 171         } else if (resourceMode & ApplyToStrokeMode) {
 172             context->setTextDrawingMode(TextModeStroke);
 173
 174 #if USE(CG)
 175             context->applyStrokePattern();
 176 #endif
 177         }
 178     }
 179
 180     return true;
 181 }
 182
 183 void RenderSVGResourcePattern::postApplyResource(RenderElement&, GraphicsContext*& context, unsigned short resourceMode, const Path* path, const RenderSVGShape* shape)
 184 {
 185     ASSERT(context);
 186     ASSERT(resourceMode != ApplyToDefaultMode);
 187
 188     if (resourceMode & ApplyToFillMode) {
 189         if (path)
 190             context->fillPath(*path);
 191         else if (shape)
 192             shape->fillShape(context);
 193     }
 194     if (resourceMode & ApplyToStrokeMode) {
 195         if (path)
 196             context->strokePath(*path);
 197         else if (shape)
 198             shape->strokeShape(context);
 199     }
 200
 201     context->restore();
 202 }
 203
 204 static inline FloatRect calculatePatternBoundaries(const PatternAttributes& attributes,
 205                                                    const FloatRect& objectBoundingBox,
 206                                                    const SVGPatternElement& patternElement)
 207 {
 208     return SVGLengthContext::resolveRectangle(&patternElement, attributes.patternUnits(), objectBoundingBox, attributes.x(), attributes.y(), attributes.width(), attributes.height());
 209 }
 210
 211 bool RenderSVGResourcePattern::buildTileImageTransform(RenderElement& renderer,
 212                                                        const PatternAttributes& attributes,
 213                                                        const SVGPatternElement& patternElement,
 214                                                        FloatRect& patternBoundaries,
 215                                                        AffineTransform& tileImageTransform) const
 216 {
 217     FloatRect objectBoundingBox = renderer.objectBoundingBox();
 218     patternBoundaries = calculatePatternBoundaries(attributes, objectBoundingBox, patternElement);
 219     if (patternBoundaries.width() <= 0 || patternBoundaries.height() <= 0)
 220         return false;
 221
 222     AffineTransform viewBoxCTM = SVGFitToViewBox::viewBoxToViewTransform(attributes.viewBox(), attributes.preserveAspectRatio(), patternBoundaries.width(), patternBoundaries.height());
 223
 224     // Apply viewBox/objectBoundingBox transformations.
 225     if (!viewBoxCTM.isIdentity())
 226         tileImageTransform = viewBoxCTM;
 227     else if (attributes.patternContentUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
 228         tileImageTransform.scale(objectBoundingBox.width(), objectBoundingBox.height());
 229
 230     return true;
 231 }
 232
 233 std::unique_ptr<ImageBuffer> RenderSVGResourcePattern::createTileImage(const PatternAttributes& attributes, const FloatRect& tileBoundaries, const FloatRect& absoluteTileBoundaries, const AffineTransform& tileImageTransform, FloatRect& clampedAbsoluteTileBoundaries) const
 234 {
 235     clampedAbsoluteTileBoundaries = ImageBuffer::clampedRect(absoluteTileBoundaries);
 236     auto tileImage = SVGRenderingContext::createImageBuffer(absoluteTileBoundaries, clampedAbsoluteTileBoundaries, ColorSpaceDeviceRGB, Unaccelerated);
 237     if (!tileImage)
 238         return nullptr;
 239
 240     GraphicsContext* tileImageContext = tileImage->context();
 241     ASSERT(tileImageContext);
 242
 243     // The image buffer represents the final rendered size, so the content has to be scaled (to avoid pixelation).
 244     tileImageContext->scale(FloatSize(clampedAbsoluteTileBoundaries.width() / tileBoundaries.width(),
 245                                       clampedAbsoluteTileBoundaries.height() / tileBoundaries.height()));
 246
 247     // Apply tile image transformations.
 248     if (!tileImageTransform.isIdentity())
 249         tileImageContext->concatCTM(tileImageTransform);
 250
 251     AffineTransform contentTransformation;
 252     if (attributes.patternContentUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
 253         contentTransformation = tileImageTransform;
 254
 255     // Draw the content into the ImageBuffer.
 256     for (auto& child : childrenOfType<SVGElement>(*attributes.patternContentElement())) {
 257         if (!child.renderer())
 258             continue;
 259         if (child.renderer()->needsLayout())
 260             return nullptr;
 261         SVGRenderingContext::renderSubtreeToImageBuffer(tileImage.get(), *child.renderer(), contentTransformation);
 262     }
 263
 264     return tileImage;
 265 }
 266
 267 }