Home | History | Annotate | Download | only in svg 
      1 /*
      2  * Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann (at) kde.org>
      3  * Copyright (C) 2004, 2005, 2007, 2008, 2009 Rob Buis <buis (at) kde.org>
      4  * Copyright (C) 2007 Eric Seidel <eric (at) webkit.org>
      5  * Copyright (C) 2009 Google, Inc.
      6  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
      7  *
      8  * This library is free software; you can redistribute it and/or
      9  * modify it under the terms of the GNU Library General Public
     10  * License as published by the Free Software Foundation; either
     11  * version 2 of the License, or (at your option) any later version.
     12  *
     13  * This library is distributed in the hope that it will be useful,
     14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
     15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     16  * Library General Public License for more details.
     17  *
     18  * You should have received a copy of the GNU Library General Public License
     19  * along with this library; see the file COPYING.LIB.  If not, write to
     20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     21  * Boston, MA 02110-1301, USA.
     22  */
     23 
     24 #include "config.h"
     25 
     26 #include "core/rendering/svg/RenderSVGRoot.h"
     27 
     28 #include "core/frame/LocalFrame.h"
     29 #include "core/rendering/HitTestResult.h"
     30 #include "core/rendering/RenderLayer.h"
     31 #include "core/rendering/RenderPart.h"
     32 #include "core/rendering/RenderView.h"
     33 #include "core/rendering/svg/RenderSVGResourceContainer.h"
     34 #include "core/rendering/svg/SVGRenderSupport.h"
     35 #include "core/rendering/svg/SVGRenderingContext.h"
     36 #include "core/rendering/svg/SVGResources.h"
     37 #include "core/rendering/svg/SVGResourcesCache.h"
     38 #include "core/svg/SVGElement.h"
     39 #include "core/svg/SVGSVGElement.h"
     40 #include "core/svg/graphics/SVGImage.h"
     41 #include "platform/LengthFunctions.h"
     42 #include "platform/graphics/GraphicsContext.h"
     43 
     44 namespace blink {
     45 
     46 RenderSVGRoot::RenderSVGRoot(SVGElement* node)
     47     : RenderReplaced(node)
     48     , m_objectBoundingBoxValid(false)
     49     , m_isLayoutSizeChanged(false)
     50     , m_needsBoundariesOrTransformUpdate(true)
     51     , m_hasBoxDecorationBackground(false)
     52 {
     53 }
     54 
     55 RenderSVGRoot::~RenderSVGRoot()
     56 {
     57 }
     58 
     59 void RenderSVGRoot::trace(Visitor* visitor)
     60 {
     61     visitor->trace(m_children);
     62     RenderReplaced::trace(visitor);
     63 }
     64 
     65 void RenderSVGRoot::computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio) const
     66 {
     67     // Spec: http://www.w3.org/TR/SVG/coords.html#IntrinsicSizing
     68     // SVG needs to specify how to calculate some intrinsic sizing properties to enable inclusion within other languages.
     69     // The intrinsic width and height of the viewport of SVG content must be determined from the width and height attributes.
     70     SVGSVGElement* svg = toSVGSVGElement(node());
     71     ASSERT(svg);
     72 
     73     // The intrinsic aspect ratio of the viewport of SVG content is necessary for example, when including SVG from an object
     74     // element in HTML styled with CSS. It is possible (indeed, common) for an SVG graphic to have an intrinsic aspect ratio but
     75     // not to have an intrinsic width or height. The intrinsic aspect ratio must be calculated based upon the following rules:
     76     // - The aspect ratio is calculated by dividing a width by a height.
     77     // - If the width and height of the rootmost svg element are both specified with unit identifiers (in, mm, cm, pt, pc,
     78     //   px, em, ex) or in user units, then the aspect ratio is calculated from the width and height attributes after
     79     //   resolving both values to user units.
     80     intrinsicSize.setWidth(floatValueForLength(svg->intrinsicWidth(), 0));
     81     intrinsicSize.setHeight(floatValueForLength(svg->intrinsicHeight(), 0));
     82 
     83     if (!intrinsicSize.isEmpty()) {
     84         intrinsicRatio = intrinsicSize.width() / static_cast<double>(intrinsicSize.height());
     85     } else {
     86         // - If either/both of the width and height of the rootmost svg element are in percentage units (or omitted), the
     87         //   aspect ratio is calculated from the width and height values of the viewBox specified for the current SVG document
     88         //   fragment. If the viewBox is not correctly specified, or set to 'none', the intrinsic aspect ratio cannot be
     89         //   calculated and is considered unspecified.
     90         FloatSize viewBoxSize = svg->viewBox()->currentValue()->value().size();
     91         if (!viewBoxSize.isEmpty()) {
     92             // The viewBox can only yield an intrinsic ratio, not an intrinsic size.
     93             intrinsicRatio = viewBoxSize.width() / static_cast<double>(viewBoxSize.height());
     94         }
     95     }
     96 }
     97 
     98 bool RenderSVGRoot::isEmbeddedThroughSVGImage() const
     99 {
    100     return SVGImage::isInSVGImage(toSVGSVGElement(node()));
    101 }
    102 
    103 bool RenderSVGRoot::isEmbeddedThroughFrameContainingSVGDocument() const
    104 {
    105     if (!node())
    106         return false;
    107 
    108     LocalFrame* frame = node()->document().frame();
    109     if (!frame)
    110         return false;
    111 
    112     // If our frame has an owner renderer, we're embedded through eg. object/embed/iframe,
    113     // but we only negotiate if we're in an SVG document inside a embedded object (object/embed).
    114     if (!frame->ownerRenderer() || !frame->ownerRenderer()->isEmbeddedObject())
    115         return false;
    116     return frame->document()->isSVGDocument();
    117 }
    118 
    119 static inline LayoutUnit resolveLengthAttributeForSVG(const Length& length, float scale, float maxSize)
    120 {
    121     return static_cast<LayoutUnit>(valueForLength(length, maxSize) * (length.isFixed() ? scale : 1));
    122 }
    123 
    124 LayoutUnit RenderSVGRoot::computeReplacedLogicalWidth(ShouldComputePreferred shouldComputePreferred) const
    125 {
    126     SVGSVGElement* svg = toSVGSVGElement(node());
    127     ASSERT(svg);
    128 
    129     // When we're embedded through SVGImage (border-image/background-image/<html:img>/...) we're forced to resize to a specific size.
    130     if (!m_containerSize.isEmpty())
    131         return m_containerSize.width();
    132 
    133     if (isEmbeddedThroughFrameContainingSVGDocument())
    134         return containingBlock()->availableLogicalWidth();
    135 
    136     if (style()->logicalWidth().isSpecified() || style()->logicalMaxWidth().isSpecified())
    137         return RenderReplaced::computeReplacedLogicalWidth(shouldComputePreferred);
    138 
    139     if (svg->hasIntrinsicWidth())
    140         return resolveLengthAttributeForSVG(svg->intrinsicWidth(), style()->effectiveZoom(), containingBlock()->availableLogicalWidth().toFloat());
    141 
    142     // SVG embedded via SVGImage (background-image/border-image/etc) / Inline SVG.
    143     return RenderReplaced::computeReplacedLogicalWidth(shouldComputePreferred);
    144 }
    145 
    146 LayoutUnit RenderSVGRoot::computeReplacedLogicalHeight() const
    147 {
    148     SVGSVGElement* svg = toSVGSVGElement(node());
    149     ASSERT(svg);
    150 
    151     // When we're embedded through SVGImage (border-image/background-image/<html:img>/...) we're forced to resize to a specific size.
    152     if (!m_containerSize.isEmpty())
    153         return m_containerSize.height();
    154 
    155     if (isEmbeddedThroughFrameContainingSVGDocument())
    156         return containingBlock()->availableLogicalHeight(IncludeMarginBorderPadding);
    157 
    158     if (style()->logicalHeight().isSpecified() || style()->logicalMaxHeight().isSpecified())
    159         return RenderReplaced::computeReplacedLogicalHeight();
    160 
    161     if (svg->hasIntrinsicHeight())
    162         return resolveLengthAttributeForSVG(svg->intrinsicHeight(), style()->effectiveZoom(), containingBlock()->availableLogicalHeight(IncludeMarginBorderPadding).toFloat());
    163 
    164     // SVG embedded via SVGImage (background-image/border-image/etc) / Inline SVG.
    165     return RenderReplaced::computeReplacedLogicalHeight();
    166 }
    167 
    168 void RenderSVGRoot::layout()
    169 {
    170     ASSERT(needsLayout());
    171 
    172     bool needsLayout = selfNeedsLayout();
    173 
    174     LayoutSize oldSize = size();
    175     updateLogicalWidth();
    176     updateLogicalHeight();
    177     buildLocalToBorderBoxTransform();
    178 
    179     SVGRenderSupport::layoutResourcesIfNeeded(this);
    180 
    181     SVGSVGElement* svg = toSVGSVGElement(node());
    182     ASSERT(svg);
    183     m_isLayoutSizeChanged = needsLayout || (svg->hasRelativeLengths() && oldSize != size());
    184     SVGRenderSupport::layoutChildren(this, needsLayout || SVGRenderSupport::filtersForceContainerLayout(this));
    185 
    186     if (m_needsBoundariesOrTransformUpdate) {
    187         updateCachedBoundaries();
    188         m_needsBoundariesOrTransformUpdate = false;
    189     }
    190 
    191     m_overflow.clear();
    192     addVisualEffectOverflow();
    193 
    194     if (!shouldApplyViewportClip()) {
    195         FloatRect contentPaintInvalidationRect = paintInvalidationRectInLocalCoordinates();
    196         contentPaintInvalidationRect = m_localToBorderBoxTransform.mapRect(contentPaintInvalidationRect);
    197         addVisualOverflow(enclosingLayoutRect(contentPaintInvalidationRect));
    198     }
    199 
    200     updateLayerTransformAfterLayout();
    201     m_hasBoxDecorationBackground = isDocumentElement() ? calculateHasBoxDecorations() : hasBoxDecorationBackground();
    202     invalidateBackgroundObscurationStatus();
    203 
    204     clearNeedsLayout();
    205 }
    206 
    207 bool RenderSVGRoot::shouldApplyViewportClip() const
    208 {
    209     // the outermost svg is clipped if auto, and svg document roots are always clipped
    210     // When the svg is stand-alone (isDocumentElement() == true) the viewport clipping should always
    211     // be applied, noting that the window scrollbars should be hidden if overflow=hidden.
    212     return style()->overflowX() == OHIDDEN
    213         || style()->overflowX() == OAUTO
    214         || style()->overflowX() == OSCROLL
    215         || this->isDocumentElement();
    216 }
    217 
    218 void RenderSVGRoot::paintReplaced(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
    219 {
    220     // An empty viewport disables rendering.
    221     if (pixelSnappedBorderBoxRect().isEmpty())
    222         return;
    223 
    224     // SVG outlines are painted during PaintPhaseForeground.
    225     if (paintInfo.phase == PaintPhaseOutline || paintInfo.phase == PaintPhaseSelfOutline)
    226         return;
    227 
    228     // An empty viewBox also disables rendering.
    229     // (http://www.w3.org/TR/SVG/coords.html#ViewBoxAttribute)
    230     SVGSVGElement* svg = toSVGSVGElement(node());
    231     ASSERT(svg);
    232     if (svg->hasEmptyViewBox())
    233         return;
    234 
    235     // Don't paint if we don't have kids, except if we have filters we should paint those.
    236     if (!firstChild()) {
    237         SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(this);
    238         if (!resources || !resources->filter())
    239             return;
    240     }
    241 
    242     // Make a copy of the PaintInfo because applyTransform will modify the damage rect.
    243     PaintInfo childPaintInfo(paintInfo);
    244     GraphicsContextStateSaver stateSaver(*childPaintInfo.context);
    245 
    246     // Apply initial viewport clip
    247     if (shouldApplyViewportClip())
    248         childPaintInfo.context->clip(pixelSnappedIntRect(overflowClipRect(paintOffset)));
    249 
    250     // Convert from container offsets (html renderers) to a relative transform (svg renderers).
    251     // Transform from our paint container's coordinate system to our local coords.
    252     IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset);
    253     childPaintInfo.applyTransform(AffineTransform::translation(adjustedPaintOffset.x(), adjustedPaintOffset.y()) * localToBorderBoxTransform());
    254 
    255     SVGRenderingContext renderingContext;
    256     if (childPaintInfo.phase == PaintPhaseForeground) {
    257         renderingContext.prepareToRenderSVGContent(this, childPaintInfo);
    258         if (!renderingContext.isRenderingPrepared())
    259             return;
    260     }
    261 
    262     RenderBox::paint(childPaintInfo, LayoutPoint());
    263 }
    264 
    265 void RenderSVGRoot::willBeDestroyed()
    266 {
    267     RenderBlock::removePercentHeightDescendant(const_cast<RenderSVGRoot*>(this));
    268 
    269     SVGResourcesCache::clientDestroyed(this);
    270     RenderReplaced::willBeDestroyed();
    271 }
    272 
    273 void RenderSVGRoot::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
    274 {
    275     if (diff.needsFullLayout())
    276         setNeedsBoundariesUpdate();
    277     if (diff.needsPaintInvalidation()) {
    278         // Box decorations may have appeared/disappeared - recompute status.
    279         m_hasBoxDecorationBackground = calculateHasBoxDecorations();
    280     }
    281 
    282     RenderReplaced::styleDidChange(diff, oldStyle);
    283     SVGResourcesCache::clientStyleChanged(this, diff, style());
    284 }
    285 
    286 bool RenderSVGRoot::isChildAllowed(RenderObject* child, RenderStyle*) const
    287 {
    288     return child->isSVG() && !(child->isSVGInline() || child->isSVGInlineText());
    289 }
    290 
    291 void RenderSVGRoot::addChild(RenderObject* child, RenderObject* beforeChild)
    292 {
    293     RenderReplaced::addChild(child, beforeChild);
    294     SVGResourcesCache::clientWasAddedToTree(child, child->style());
    295 }
    296 
    297 void RenderSVGRoot::removeChild(RenderObject* child)
    298 {
    299     SVGResourcesCache::clientWillBeRemovedFromTree(child);
    300     RenderReplaced::removeChild(child);
    301 }
    302 
    303 void RenderSVGRoot::insertedIntoTree()
    304 {
    305     RenderReplaced::insertedIntoTree();
    306     SVGResourcesCache::clientWasAddedToTree(this, style());
    307 }
    308 
    309 void RenderSVGRoot::willBeRemovedFromTree()
    310 {
    311     SVGResourcesCache::clientWillBeRemovedFromTree(this);
    312     RenderReplaced::willBeRemovedFromTree();
    313 }
    314 
    315 // RenderBox methods will expect coordinates w/o any transforms in coordinates
    316 // relative to our borderBox origin.  This method gives us exactly that.
    317 void RenderSVGRoot::buildLocalToBorderBoxTransform()
    318 {
    319     SVGSVGElement* svg = toSVGSVGElement(node());
    320     ASSERT(svg);
    321     float scale = style()->effectiveZoom();
    322     FloatPoint translate = svg->currentTranslate();
    323     LayoutSize borderAndPadding(borderLeft() + paddingLeft(), borderTop() + paddingTop());
    324     m_localToBorderBoxTransform = svg->viewBoxToViewTransform(contentWidth() / scale, contentHeight() / scale);
    325     AffineTransform viewToBorderBoxTransform(scale, 0, 0, scale, borderAndPadding.width() + translate.x(), borderAndPadding.height() + translate.y());
    326     if (viewToBorderBoxTransform.isIdentity())
    327         return;
    328     m_localToBorderBoxTransform = viewToBorderBoxTransform * m_localToBorderBoxTransform;
    329 }
    330 
    331 const AffineTransform& RenderSVGRoot::localToParentTransform() const
    332 {
    333     // Slightly optimized version of m_localToParentTransform = AffineTransform::translation(x(), y()) * m_localToBorderBoxTransform;
    334     m_localToParentTransform = m_localToBorderBoxTransform;
    335     if (x())
    336         m_localToParentTransform.setE(m_localToParentTransform.e() + roundToInt(x()));
    337     if (y())
    338         m_localToParentTransform.setF(m_localToParentTransform.f() + roundToInt(y()));
    339     return m_localToParentTransform;
    340 }
    341 
    342 LayoutRect RenderSVGRoot::clippedOverflowRectForPaintInvalidation(const RenderLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState) const
    343 {
    344     // This is an open-coded aggregate of SVGRenderSupport::clippedOverflowRectForPaintInvalidation,
    345     // RenderSVGRoot::computeFloatRectForPaintInvalidation and RenderReplaced::clippedOverflowRectForPaintInvalidation.
    346     // The reason for this is to optimize/minimize the paint invalidation rect when the box is not "decorated"
    347     // (does not have background/border/etc.)
    348 
    349     // Return early for any cases where we don't actually paint.
    350     if (style()->visibility() != VISIBLE && !enclosingLayer()->hasVisibleContent())
    351         return LayoutRect();
    352 
    353     // Compute the paint invalidation rect of the content of the SVG in the border-box coordinate space.
    354     FloatRect contentPaintInvalidationRect = paintInvalidationRectInLocalCoordinates();
    355     contentPaintInvalidationRect = m_localToBorderBoxTransform.mapRect(contentPaintInvalidationRect);
    356 
    357     // Apply initial viewport clip, overflow:visible content is added to visualOverflow
    358     // but the most common case is that overflow is hidden, so always intersect.
    359     contentPaintInvalidationRect.intersect(pixelSnappedBorderBoxRect());
    360 
    361     LayoutRect paintInvalidationRect = enclosingLayoutRect(contentPaintInvalidationRect);
    362     // If the box is decorated or is overflowing, extend it to include the border-box and overflow.
    363     if (m_hasBoxDecorationBackground || hasRenderOverflow()) {
    364         // The selectionRect can project outside of the overflowRect, so take their union
    365         // for paint invalidation to avoid selection painting glitches.
    366         LayoutRect decoratedPaintInvalidationRect = unionRect(localSelectionRect(false), visualOverflowRect());
    367         paintInvalidationRect.unite(decoratedPaintInvalidationRect);
    368     }
    369 
    370     // Compute the paint invalidation rect in the parent coordinate space.
    371     LayoutRect rect = enclosingIntRect(paintInvalidationRect);
    372     RenderReplaced::mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, paintInvalidationState);
    373     return rect;
    374 }
    375 
    376 void RenderSVGRoot::computeFloatRectForPaintInvalidation(const RenderLayerModelObject* paintInvalidationContainer, FloatRect& paintInvalidationRect, const PaintInvalidationState* paintInvalidationState) const
    377 {
    378     // Apply our local transforms (except for x/y translation), then our shadow,
    379     // and then call RenderBox's method to handle all the normal CSS Box model bits
    380     paintInvalidationRect = m_localToBorderBoxTransform.mapRect(paintInvalidationRect);
    381 
    382     // Apply initial viewport clip
    383     if (shouldApplyViewportClip())
    384         paintInvalidationRect.intersect(pixelSnappedBorderBoxRect());
    385 
    386     LayoutRect rect = enclosingIntRect(paintInvalidationRect);
    387     RenderReplaced::mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, paintInvalidationState);
    388     paintInvalidationRect = rect;
    389 }
    390 
    391 // This method expects local CSS box coordinates.
    392 // Callers with local SVG viewport coordinates should first apply the localToBorderBoxTransform
    393 // to convert from SVG viewport coordinates to local CSS box coordinates.
    394 void RenderSVGRoot::mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed, const PaintInvalidationState* paintInvalidationState) const
    395 {
    396     ASSERT(mode & ~IsFixed); // We should have no fixed content in the SVG rendering tree.
    397     // We used to have this ASSERT here, but we removed it when enabling layer squashing.
    398     // See http://crbug.com/364901
    399     // ASSERT(mode & UseTransforms); // mapping a point through SVG w/o respecting trasnforms is useless.
    400 
    401     RenderReplaced::mapLocalToContainer(paintInvalidationContainer, transformState, mode | ApplyContainerFlip, wasFixed, paintInvalidationState);
    402 }
    403 
    404 const RenderObject* RenderSVGRoot::pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
    405 {
    406     return RenderReplaced::pushMappingToContainer(ancestorToStopAt, geometryMap);
    407 }
    408 
    409 void RenderSVGRoot::updateCachedBoundaries()
    410 {
    411     SVGRenderSupport::computeContainerBoundingBoxes(this, m_objectBoundingBox, m_objectBoundingBoxValid, m_strokeBoundingBox, m_paintInvalidationBoundingBox);
    412     SVGRenderSupport::intersectPaintInvalidationRectWithResources(this, m_paintInvalidationBoundingBox);
    413 }
    414 
    415 bool RenderSVGRoot::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
    416 {
    417     LayoutPoint pointInParent = locationInContainer.point() - toLayoutSize(accumulatedOffset);
    418     LayoutPoint pointInBorderBox = pointInParent - toLayoutSize(location());
    419 
    420     // Only test SVG content if the point is in our content box, or in case we
    421     // don't clip to the viewport, the visual overflow rect.
    422     // FIXME: This should be an intersection when rect-based hit tests are supported by nodeAtFloatPoint.
    423     if (contentBoxRect().contains(pointInBorderBox) || (!shouldApplyViewportClip() && visualOverflowRect().contains(pointInBorderBox))) {
    424         const AffineTransform& localToParentTransform = this->localToParentTransform();
    425         if (localToParentTransform.isInvertible()) {
    426             FloatPoint localPoint = localToParentTransform.inverse().mapPoint(FloatPoint(pointInParent));
    427 
    428             for (RenderObject* child = lastChild(); child; child = child->previousSibling()) {
    429                 // FIXME: nodeAtFloatPoint() doesn't handle rect-based hit tests yet.
    430                 if (child->nodeAtFloatPoint(request, result, localPoint, hitTestAction)) {
    431                     updateHitTestResult(result, pointInBorderBox);
    432                     if (!result.addNodeToRectBasedTestResult(child->node(), request, locationInContainer))
    433                         return true;
    434                 }
    435             }
    436         }
    437     }
    438 
    439     // If we didn't early exit above, we've just hit the container <svg> element. Unlike SVG 1.1, 2nd Edition allows container elements to be hit.
    440     if ((hitTestAction == HitTestBlockBackground || hitTestAction == HitTestChildBlockBackground) && visibleToHitTestRequest(request)) {
    441         // Only return true here, if the last hit testing phase 'BlockBackground' (or 'ChildBlockBackground' - depending on context) is executed.
    442         // If we'd return true in the 'Foreground' phase, hit testing would stop immediately. For SVG only trees this doesn't matter.
    443         // Though when we have a <foreignObject> subtree we need to be able to detect hits on the background of a <div> element.
    444         // If we'd return true here in the 'Foreground' phase, we are not able to detect these hits anymore.
    445         LayoutRect boundsRect(accumulatedOffset + location(), size());
    446         if (locationInContainer.intersects(boundsRect)) {
    447             updateHitTestResult(result, pointInBorderBox);
    448             if (!result.addNodeToRectBasedTestResult(node(), request, locationInContainer, boundsRect))
    449                 return true;
    450         }
    451     }
    452 
    453     return false;
    454 }
    455 
    456 }
    457