Avoid updateFromElement() usage in SVG
[WebKit-https.git] / Source / WebCore / rendering / svg / RenderSVGRoot.cpp
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 #if ENABLE(SVG)
27 #include "RenderSVGRoot.h"
28
29 #include "Chrome.h"
30 #include "ChromeClient.h"
31 #include "Frame.h"
32 #include "GraphicsContext.h"
33 #include "HitTestResult.h"
34 #include "LayoutRepainter.h"
35 #include "Page.h"
36 #include "RenderPart.h"
37 #include "RenderSVGContainer.h"
38 #include "RenderSVGResource.h"
39 #include "RenderSVGResourceContainer.h"
40 #include "RenderView.h"
41 #include "SVGLength.h"
42 #include "SVGRenderingContext.h"
43 #include "SVGResources.h"
44 #include "SVGResourcesCache.h"
45 #include "SVGSVGElement.h"
46 #include "SVGStyledElement.h"
47 #include "SVGViewSpec.h"
48 #include "TransformState.h"
49
50 #if ENABLE(FILTERS)
51 #include "RenderSVGResourceFilter.h"
52 #endif
53
54 using namespace std;
55
56 namespace WebCore {
57
58 RenderSVGRoot::RenderSVGRoot(SVGStyledElement* node)
59     : RenderReplaced(node)
60     , m_objectBoundingBoxValid(false)
61     , m_isLayoutSizeChanged(false)
62     , m_needsBoundariesOrTransformUpdate(true)
63 {
64 }
65
66 RenderSVGRoot::~RenderSVGRoot()
67 {
68 }
69
70 void RenderSVGRoot::computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio, bool& isPercentageIntrinsicSize) const
71 {
72     // Spec: http://www.w3.org/TR/SVG/coords.html#IntrinsicSizing
73     // SVG needs to specify how to calculate some intrinsic sizing properties to enable inclusion within other languages.
74     // The intrinsic width and height of the viewport of SVG content must be determined from the ‘width’ and ‘height’ attributes.
75     // If either of these are not specified, a value of '100%' must be assumed. Note: the ‘width’ and ‘height’ attributes are not
76     // the same as the CSS width and height properties. Specifically, percentage values do not provide an intrinsic width or height,
77     // and do not indicate a percentage of the containing block. Rather, once the viewport is established, they indicate the portion
78     // of the viewport that is actually covered by image data.
79     SVGSVGElement* svg = static_cast<SVGSVGElement*>(node());
80     Length intrinsicWidthAttribute = svg->intrinsicWidth(SVGSVGElement::IgnoreCSSProperties);
81     Length intrinsicHeightAttribute = svg->intrinsicHeight(SVGSVGElement::IgnoreCSSProperties);
82
83     // The intrinsic aspect ratio of the viewport of SVG content is necessary for example, when including SVG from an ‘object’
84     // element in HTML styled with CSS. It is possible (indeed, common) for an SVG graphic to have an intrinsic aspect ratio but
85     // not to have an intrinsic width or height. The intrinsic aspect ratio must be calculated based upon the following rules:
86     // - The aspect ratio is calculated by dividing a width by a height.
87     // - If the ‘width’ and ‘height’ of the rootmost ‘svg’ element are both specified with unit identifiers (in, mm, cm, pt, pc,
88     //   px, em, ex) or in user units, then the aspect ratio is calculated from the ‘width’ and ‘height’ attributes after
89     //   resolving both values to user units.
90     if (intrinsicWidthAttribute.isFixed() || intrinsicHeightAttribute.isFixed()) {
91         if (intrinsicWidthAttribute.isFixed())
92             intrinsicSize.setWidth(floatValueForLength(intrinsicWidthAttribute, 0));
93         if (intrinsicHeightAttribute.isFixed())
94             intrinsicSize.setHeight(floatValueForLength(intrinsicHeightAttribute, 0));
95         if (!intrinsicSize.isEmpty())
96             intrinsicRatio = intrinsicSize.width() / static_cast<double>(intrinsicSize.height());
97         return;
98     }
99
100     // - If either/both of the ‘width’ and ‘height’ of the rootmost ‘svg’ element are in percentage units (or omitted), the
101     //   aspect ratio is calculated from the width and height values of the ‘viewBox’ specified for the current SVG document
102     //   fragment. If the ‘viewBox’ is not correctly specified, or set to 'none', the intrinsic aspect ratio cannot be
103     //   calculated and is considered unspecified.
104     intrinsicSize = svg->viewBox().size();
105     if (!intrinsicSize.isEmpty()) {
106         // The viewBox can only yield an intrinsic ratio, not an intrinsic size.
107         intrinsicRatio = intrinsicSize.width() / static_cast<double>(intrinsicSize.height());
108         intrinsicSize = FloatSize();
109         return;
110     }
111
112     // If our intrinsic size is in percentage units, return those to the caller through the intrinsicSize. Notify the caller
113     // about the special situation, by setting isPercentageIntrinsicSize=true, so it knows how to interpret the return values.
114     if (intrinsicWidthAttribute.isPercent() && intrinsicHeightAttribute.isPercent()) {
115         isPercentageIntrinsicSize = true;
116         intrinsicSize = FloatSize(intrinsicWidthAttribute.percent(), intrinsicHeightAttribute.percent());
117     }
118 }
119
120 bool RenderSVGRoot::isEmbeddedThroughSVGImage() const
121 {
122     if (!node())
123         return false;
124
125     Frame* frame = node()->document()->frame();
126     if (!frame)
127         return false;
128
129     // Test whether we're embedded through an img.
130     if (!frame->page() || !frame->page()->chrome())
131         return false;
132
133     ChromeClient* chromeClient = frame->page()->chrome()->client();
134     if (!chromeClient || !chromeClient->isSVGImageChromeClient())
135         return false;
136
137     return true;
138 }
139
140 bool RenderSVGRoot::isEmbeddedThroughFrameContainingSVGDocument() const
141 {
142     if (!node())
143         return false;
144
145     Frame* frame = node()->document()->frame();
146     if (!frame)
147         return false;
148
149     // If our frame has an owner renderer, we're embedded through eg. object/embed/iframe,
150     // but we only negotiate if we're in an SVG document.
151     if (!frame->ownerRenderer())
152         return false;
153     return frame->document()->isSVGDocument();
154 }
155
156 static inline LayoutUnit resolveLengthAttributeForSVG(const Length& length, float scale, float maxSize, RenderView* renderView)
157 {
158     return static_cast<LayoutUnit>(valueForLength(length, maxSize, renderView) * (length.isFixed() ? scale : 1));
159 }
160
161 LayoutUnit RenderSVGRoot::computeReplacedLogicalWidth(bool includeMaxWidth) const
162 {
163     SVGSVGElement* svg = static_cast<SVGSVGElement*>(node());
164     ASSERT(svg);
165
166     // When we're embedded through SVGImage (border-image/background-image/<html:img>/...) we're forced to resize to a specific size.
167     if (!m_containerSize.isEmpty())
168         return m_containerSize.width();
169
170     if (style()->logicalWidth().isSpecified() || style()->logicalMaxWidth().isSpecified())
171         return RenderReplaced::computeReplacedLogicalWidth(includeMaxWidth);
172
173     if (svg->widthAttributeEstablishesViewport())
174         return resolveLengthAttributeForSVG(svg->intrinsicWidth(SVGSVGElement::IgnoreCSSProperties), style()->effectiveZoom(), containingBlock()->availableLogicalWidth(), view());
175
176     // Only SVGs embedded in <object> reach this point.
177     ASSERT(isEmbeddedThroughFrameContainingSVGDocument());
178     return document()->frame()->ownerRenderer()->availableLogicalWidth();
179 }
180
181 LayoutUnit RenderSVGRoot::computeReplacedLogicalHeight() const
182 {
183     SVGSVGElement* svg = static_cast<SVGSVGElement*>(node());
184     ASSERT(svg);
185
186     // When we're embedded through SVGImage (border-image/background-image/<html:img>/...) we're forced to resize to a specific size.
187     if (!m_containerSize.isEmpty())
188         return m_containerSize.height();
189
190     if (style()->logicalHeight().isSpecified() || style()->logicalMaxHeight().isSpecified())
191         return RenderReplaced::computeReplacedLogicalHeight();
192
193     if (svg->heightAttributeEstablishesViewport()) {
194         Length height = svg->intrinsicHeight(SVGSVGElement::IgnoreCSSProperties);
195         if (height.isPercent()) {
196             RenderBlock* cb = containingBlock();
197             ASSERT(cb);
198             while (cb->isAnonymous()) {
199                 cb = cb->containingBlock();
200                 cb->addPercentHeightDescendant(const_cast<RenderSVGRoot*>(this));
201             }
202         } else
203             RenderBlock::removePercentHeightDescendant(const_cast<RenderSVGRoot*>(this));
204
205         return resolveLengthAttributeForSVG(height, style()->effectiveZoom(), containingBlock()->availableLogicalHeight(), view());
206     }
207
208     // Only SVGs embedded in <object> reach this point.
209     ASSERT(isEmbeddedThroughFrameContainingSVGDocument());
210     return document()->frame()->ownerRenderer()->availableLogicalHeight();
211 }
212
213 void RenderSVGRoot::layout()
214 {
215     ASSERT(needsLayout());
216
217     m_resourcesNeedingToInvalidateClients.clear();
218
219     // Arbitrary affine transforms are incompatible with LayoutState.
220     LayoutStateDisabler layoutStateDisabler(view());
221
222     bool needsLayout = selfNeedsLayout();
223     LayoutRepainter repainter(*this, checkForRepaintDuringLayout() && needsLayout);
224
225     LayoutSize oldSize = size();
226     computeLogicalWidth();
227     computeLogicalHeight();
228     buildLocalToBorderBoxTransform();
229
230     SVGSVGElement* svg = static_cast<SVGSVGElement*>(node());
231     m_isLayoutSizeChanged = needsLayout || (svg->hasRelativeLengths() && oldSize != size());
232     SVGRenderSupport::layoutChildren(this, needsLayout || SVGRenderSupport::filtersForceContainerLayout(this));
233
234     if (!m_resourcesNeedingToInvalidateClients.isEmpty()) {
235         // Invalidate resource clients, which may mark some nodes for layout.
236         HashSet<RenderSVGResourceContainer*>::iterator end = m_resourcesNeedingToInvalidateClients.end();
237         for (HashSet<RenderSVGResourceContainer*>::iterator it = m_resourcesNeedingToInvalidateClients.begin(); it != end; ++it)
238             (*it)->removeAllClientsFromCache();
239
240         m_isLayoutSizeChanged = false;
241         SVGRenderSupport::layoutChildren(this, false);
242     }
243
244     // At this point LayoutRepainter already grabbed the old bounds,
245     // recalculate them now so repaintAfterLayout() uses the new bounds.
246     if (m_needsBoundariesOrTransformUpdate) {
247         updateCachedBoundaries();
248         m_needsBoundariesOrTransformUpdate = false;
249     }
250
251     repainter.repaintAfterLayout();
252
253     setNeedsLayout(false);
254 }
255
256 void RenderSVGRoot::paintReplaced(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
257 {
258     // An empty viewport disables rendering.
259     if (pixelSnappedBorderBoxRect().isEmpty())
260         return;
261
262     // Don't paint, if the context explicitely disabled it.
263     if (paintInfo.context->paintingDisabled())
264         return;
265
266     Page* page = 0;
267     if (Frame* frame = this->frame())
268         page = frame->page();
269
270     // Don't paint if we don't have kids, except if we have filters we should paint those.
271     if (!firstChild()) {
272         SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(this);
273         if (!resources || !resources->filter()) {
274             if (page && paintInfo.phase == PaintPhaseForeground)
275                 page->addRelevantUnpaintedObject(this, visualOverflowRect());
276             return;
277         }
278     }
279
280     if (page && paintInfo.phase == PaintPhaseForeground)
281         page->addRelevantRepaintedObject(this, visualOverflowRect());
282
283     // Make a copy of the PaintInfo because applyTransform will modify the damage rect.
284     PaintInfo childPaintInfo(paintInfo);
285     childPaintInfo.context->save();
286
287     // Apply initial viewport clip - not affected by overflow handling
288     childPaintInfo.context->clip(pixelSnappedIntRect(overflowClipRect(paintOffset, paintInfo.renderRegion)));
289
290     // Convert from container offsets (html renderers) to a relative transform (svg renderers).
291     // Transform from our paint container's coordinate system to our local coords.
292     IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset);
293     childPaintInfo.applyTransform(AffineTransform::translation(adjustedPaintOffset.x() - x(), adjustedPaintOffset.y() - y()) * localToParentTransform());
294
295     SVGRenderingContext renderingContext;
296     bool continueRendering = true;
297     if (childPaintInfo.phase == PaintPhaseForeground) {
298         renderingContext.prepareToRenderSVGContent(this, childPaintInfo);
299         continueRendering = renderingContext.isRenderingPrepared();
300     }
301
302     if (continueRendering)
303         RenderBox::paint(childPaintInfo, LayoutPoint());
304
305     childPaintInfo.context->restore();
306 }
307
308 void RenderSVGRoot::willBeDestroyed()
309 {
310     RenderBlock::removePercentHeightDescendant(const_cast<RenderSVGRoot*>(this));
311
312     SVGResourcesCache::clientDestroyed(this);
313     RenderReplaced::willBeDestroyed();
314 }
315
316 void RenderSVGRoot::styleWillChange(StyleDifference diff, const RenderStyle* newStyle)
317 {
318     if (diff == StyleDifferenceLayout)
319         setNeedsBoundariesUpdate();
320     RenderReplaced::styleWillChange(diff, newStyle);
321 }
322
323 void RenderSVGRoot::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
324 {
325     RenderReplaced::styleDidChange(diff, oldStyle);
326     SVGResourcesCache::clientStyleChanged(this, diff, style());
327 }
328
329 void RenderSVGRoot::addChild(RenderObject* child, RenderObject* beforeChild)
330 {
331     RenderReplaced::addChild(child, beforeChild);
332     SVGResourcesCache::clientWasAddedToTree(child, child->style());
333 }
334
335 void RenderSVGRoot::removeChild(RenderObject* child)
336 {
337     SVGResourcesCache::clientWillBeRemovedFromTree(child);
338     RenderReplaced::removeChild(child);
339 }
340
341 // RenderBox methods will expect coordinates w/o any transforms in coordinates
342 // relative to our borderBox origin.  This method gives us exactly that.
343 void RenderSVGRoot::buildLocalToBorderBoxTransform()
344 {
345     SVGSVGElement* svg = static_cast<SVGSVGElement*>(node());
346     float scale = style()->effectiveZoom();
347     FloatPoint translate = svg->currentTranslate();
348     LayoutSize borderAndPadding(borderLeft() + paddingLeft(), borderTop() + paddingTop());
349     m_localToBorderBoxTransform = svg->viewBoxToViewTransform(contentWidth() / scale, contentHeight() / scale);
350     if (borderAndPadding.isEmpty() && scale == 1 && translate == FloatPoint::zero())
351         return;
352     m_localToBorderBoxTransform = AffineTransform(scale, 0, 0, scale, borderAndPadding.width() + translate.x(), borderAndPadding.height() + translate.y()) * m_localToBorderBoxTransform;
353 }
354
355 const AffineTransform& RenderSVGRoot::localToParentTransform() const
356 {
357     // Slightly optimized version of m_localToParentTransform = AffineTransform::translation(x(), y()) * m_localToBorderBoxTransform;
358     m_localToParentTransform = m_localToBorderBoxTransform;
359     if (x())
360         m_localToParentTransform.setE(m_localToParentTransform.e() + roundToInt(x()));
361     if (y())
362         m_localToParentTransform.setF(m_localToParentTransform.f() + roundToInt(y()));
363     return m_localToParentTransform;
364 }
365
366 LayoutRect RenderSVGRoot::clippedOverflowRectForRepaint(RenderBoxModelObject* repaintContainer) const
367 {
368     return SVGRenderSupport::clippedOverflowRectForRepaint(this, repaintContainer);
369 }
370
371 void RenderSVGRoot::computeFloatRectForRepaint(RenderBoxModelObject* repaintContainer, FloatRect& repaintRect, bool fixed) const
372 {
373     // Apply our local transforms (except for x/y translation), then our shadow, 
374     // and then call RenderBox's method to handle all the normal CSS Box model bits
375     repaintRect = m_localToBorderBoxTransform.mapRect(repaintRect);
376
377     // Apply initial viewport clip - not affected by overflow settings    
378     repaintRect.intersect(pixelSnappedBorderBoxRect());
379
380     const SVGRenderStyle* svgStyle = style()->svgStyle();
381     if (const ShadowData* shadow = svgStyle->shadow())
382         shadow->adjustRectForShadow(repaintRect);
383
384     LayoutRect rect = enclosingIntRect(repaintRect);
385     RenderReplaced::computeRectForRepaint(repaintContainer, rect, fixed);
386     repaintRect = rect;
387 }
388
389 // This method expects local CSS box coordinates.
390 // Callers with local SVG viewport coordinates should first apply the localToBorderBoxTransform
391 // to convert from SVG viewport coordinates to local CSS box coordinates.
392 void RenderSVGRoot::mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool fixed, bool useTransforms, TransformState& transformState, ApplyContainerFlipOrNot, bool* wasFixed) const
393 {
394     ASSERT(!fixed); // We should have no fixed content in the SVG rendering tree.
395     ASSERT(useTransforms); // mapping a point through SVG w/o respecting trasnforms is useless.
396
397     RenderReplaced::mapLocalToContainer(repaintContainer, fixed, useTransforms, transformState, ApplyContainerFlip, wasFixed);
398 }
399
400 const RenderObject* RenderSVGRoot::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
401 {
402     return RenderReplaced::pushMappingToContainer(ancestorToStopAt, geometryMap);
403 }
404
405 void RenderSVGRoot::updateCachedBoundaries()
406 {
407     m_objectBoundingBox = FloatRect();
408     m_objectBoundingBoxValid = false;
409     m_strokeBoundingBox = FloatRect();
410     m_repaintBoundingBox = FloatRect();
411
412     SVGRenderSupport::computeContainerBoundingBoxes(this, m_objectBoundingBox, m_objectBoundingBoxValid, m_strokeBoundingBox, m_repaintBoundingBox);
413     SVGRenderSupport::intersectRepaintRectWithResources(this, m_repaintBoundingBox);
414     m_repaintBoundingBox.inflate(borderAndPaddingWidth());
415 }
416
417 bool RenderSVGRoot::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
418 {
419     LayoutPoint pointInParent = pointInContainer - toLayoutSize(accumulatedOffset);
420     LayoutPoint pointInBorderBox(pointInParent.x() - x(), pointInParent.y() - y());
421
422     // Note: For now, we're ignoring hits to border and padding for <svg>
423     if (!contentBoxRect().contains(pointInBorderBox))
424         return false;
425
426     FloatPoint localPoint = localToParentTransform().inverse().mapPoint(FloatPoint(pointInParent));
427
428     for (RenderObject* child = lastChild(); child; child = child->previousSibling()) {
429         if (child->nodeAtFloatPoint(request, result, localPoint, hitTestAction)) {
430             // FIXME: CSS/HTML assumes the local point is relative to the border box, right?
431             updateHitTestResult(result, pointInBorderBox);
432             // FIXME: nodeAtFloatPoint() doesn't handle rect-based hit tests yet.
433             result.addNodeToRectBasedTestResult(child->node(), pointInContainer);
434             return true;
435         }
436     }
437
438     // 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.
439     if (hitTestAction == HitTestBlockBackground && style()->pointerEvents() != PE_NONE) {
440         // Only return true here, if the last hit testing phase 'BlockBackground' is executed. If we'd return true in the 'Foreground' phase,
441         // hit testing would stop immediately. For SVG only trees this doesn't matter. Though when we have a <foreignObject> subtree we need
442         // to be able to detect hits on the background of a <div> element. If we'd return true here in the 'Foreground' phase, we are not able 
443         // to detect these hits anymore.
444         updateHitTestResult(result, roundedLayoutPoint(localPoint));
445         return true;
446     }
447
448     return false;
449 }
450
451 bool RenderSVGRoot::hasRelativeDimensions() const
452 {
453     SVGSVGElement* svg = static_cast<SVGSVGElement*>(node());
454     ASSERT(svg);
455
456     return svg->intrinsicHeight(SVGSVGElement::IgnoreCSSProperties).isPercent() || svg->intrinsicWidth(SVGSVGElement::IgnoreCSSProperties).isPercent();
457 }
458
459 bool RenderSVGRoot::hasRelativeLogicalHeight() const
460 {
461     SVGSVGElement* svg = static_cast<SVGSVGElement*>(node());
462     ASSERT(svg);
463
464     return svg->intrinsicHeight(SVGSVGElement::IgnoreCSSProperties).isPercent();
465 }
466
467 void RenderSVGRoot::addResourceForClientInvalidation(RenderSVGResourceContainer* resource)
468 {
469     RenderObject* svgRoot = resource->parent();
470     while (svgRoot && !svgRoot->isSVGRoot())
471         svgRoot = svgRoot->parent();
472     if (!svgRoot)
473         return;
474     static_cast<RenderSVGRoot*>(svgRoot)->m_resourcesNeedingToInvalidateClients.add(resource);
475 }
476
477 }
478
479 #endif // ENABLE(SVG)