1/*
2 * Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>
3 * Copyright (C) 2004, 2005, 2007, 2008, 2009 Rob Buis <buis@kde.org>
4 * Copyright (C) 2007 Eric Seidel <eric@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
44namespace blink {
45
46RenderSVGRoot::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
55RenderSVGRoot::~RenderSVGRoot()
56{
57}
58
59void RenderSVGRoot::trace(Visitor* visitor)
60{
61    visitor->trace(m_children);
62    RenderReplaced::trace(visitor);
63}
64
65void 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
98bool RenderSVGRoot::isEmbeddedThroughSVGImage() const
99{
100    return SVGImage::isInSVGImage(toSVGSVGElement(node()));
101}
102
103bool 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
119static 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
124LayoutUnit 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
146LayoutUnit 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
168void 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
207bool 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
218void 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
265void RenderSVGRoot::willBeDestroyed()
266{
267    RenderBlock::removePercentHeightDescendant(const_cast<RenderSVGRoot*>(this));
268
269    SVGResourcesCache::clientDestroyed(this);
270    RenderReplaced::willBeDestroyed();
271}
272
273void 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
286bool RenderSVGRoot::isChildAllowed(RenderObject* child, RenderStyle*) const
287{
288    return child->isSVG() && !(child->isSVGInline() || child->isSVGInlineText());
289}
290
291void RenderSVGRoot::addChild(RenderObject* child, RenderObject* beforeChild)
292{
293    RenderReplaced::addChild(child, beforeChild);
294    SVGResourcesCache::clientWasAddedToTree(child, child->style());
295}
296
297void RenderSVGRoot::removeChild(RenderObject* child)
298{
299    SVGResourcesCache::clientWillBeRemovedFromTree(child);
300    RenderReplaced::removeChild(child);
301}
302
303void RenderSVGRoot::insertedIntoTree()
304{
305    RenderReplaced::insertedIntoTree();
306    SVGResourcesCache::clientWasAddedToTree(this, style());
307}
308
309void 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.
317void 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
331const 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
342LayoutRect 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
376void 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.
394void 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
404const RenderObject* RenderSVGRoot::pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
405{
406    return RenderReplaced::pushMappingToContainer(ancestorToStopAt, geometryMap);
407}
408
409void RenderSVGRoot::updateCachedBoundaries()
410{
411    SVGRenderSupport::computeContainerBoundingBoxes(this, m_objectBoundingBox, m_objectBoundingBoxValid, m_strokeBoundingBox, m_paintInvalidationBoundingBox);
412    SVGRenderSupport::intersectPaintInvalidationRectWithResources(this, m_paintInvalidationBoundingBox);
413}
414
415bool 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