Switch remaining SVG Rendering methods to LayoutUnits
[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 "Frame.h"
30 #include "GraphicsContext.h"
31 #include "HitTestResult.h"
32 #include "RenderPart.h"
33 #include "RenderSVGContainer.h"
34 #include "RenderSVGResource.h"
35 #include "RenderView.h"
36 #include "SVGLength.h"
37 #include "SVGRenderSupport.h"
38 #include "SVGResources.h"
39 #include "SVGSVGElement.h"
40 #include "SVGStyledElement.h"
41 #include "SVGViewSpec.h"
42 #include "TransformState.h"
43
44 #if ENABLE(FILTERS)
45 #include "RenderSVGResourceFilter.h"
46 #endif
47
48 using namespace std;
49
50 namespace WebCore {
51
52 RenderSVGRoot::RenderSVGRoot(SVGStyledElement* node)
53     : RenderBox(node)
54     , m_isLayoutSizeChanged(false)
55     , m_needsBoundariesOrTransformUpdate(true)
56     , m_needsSizeNegotiationWithHostDocument(false)
57 {
58     setReplaced(true);
59 }
60
61 RenderSVGRoot::~RenderSVGRoot()
62 {
63 }
64
65 void RenderSVGRoot::computeIntrinsicRatioInformation(FloatSize& intrinsicRatio, bool& isPercentageIntrinsicSize) const
66 {
67     // Spec: http://dev.w3.org/SVG/profiles/1.1F2/publish/coords.html#IntrinsicSizing
68     // The intrinsic aspect ratio of the viewport of SVG content is necessary for example, when including
69     // SVG from an ‘object’ element in HTML styled with CSS. It is possible (indeed, common) for an SVG
70     // graphic to have an intrinsic aspect ratio but not to have an intrinsic width or height.
71     // The intrinsic aspect ratio must be calculated based upon the following rules:
72     // The aspect ratio is calculated by dividing a width by a height.
73
74     // If the ‘width’ and ‘height’ of the rootmost ‘svg’ element are both specified with unit identifiers
75     // (in, mm, cm, pt, pc, px, em, ex) or in user units, then the aspect ratio is calculated from the
76     // ‘width’ and ‘height’ attributes after resolving both values to user units.
77     isPercentageIntrinsicSize = false;
78     if (style()->width().isFixed() && style()->height().isFixed()) {
79         intrinsicRatio = FloatSize(width(), height());
80         return;
81     }
82
83     // If either/both of the ‘width’ and ‘height’ of the rootmost ‘svg’ element are in percentage units (or omitted),
84     // the aspect ratio is calculated from the width and height values of the ‘viewBox’ specified for the current SVG
85     // document fragment. If the ‘viewBox’ is not correctly specified, or set to 'none', the intrinsic aspect ratio
86     // cannot be calculated and is considered unspecified.
87     intrinsicRatio = static_cast<SVGSVGElement*>(node())->currentViewBoxRect().size();
88
89     // Compatibility with authors expectations and Firefox/Opera: when percentage units are used, take them into
90     // account for certain cases of the intrinsic width/height calculation in RenderPart::computeReplacedLogicalWidth/Height.
91     if (intrinsicRatio.isEmpty() && style()->width().isPercent() && style()->height().isPercent()) {
92         isPercentageIntrinsicSize = true;
93         intrinsicRatio = FloatSize(style()->width().percent(), style()->height().percent());
94     }
95 }
96
97 void RenderSVGRoot::computePreferredLogicalWidths()
98 {
99     ASSERT(preferredLogicalWidthsDirty());
100
101     LayoutUnit borderAndPadding = borderAndPaddingWidth();
102     LayoutUnit width = computeReplacedLogicalWidth(false) + borderAndPadding;
103
104     if (style()->maxWidth().isFixed() && style()->maxWidth().value() != undefinedLength)
105         width = min(width, style()->maxWidth().value() + (style()->boxSizing() == CONTENT_BOX ? borderAndPadding : 0));
106
107     if (style()->width().isPercent() || (style()->width().isAuto() && style()->height().isPercent())) {
108         m_minPreferredLogicalWidth = 0;
109         m_maxPreferredLogicalWidth = width;
110     } else
111         m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = width;
112
113     setPreferredLogicalWidthsDirty(false);
114 }
115
116 LayoutUnit RenderSVGRoot::computeIntrinsicWidth(LayoutUnit replacedWidth) const
117 {
118     if (!style()->width().isPercent())
119         return replacedWidth;
120     // FIXME: Remove unnecessary rounding when layout is off ints: webkit.org/b/63656
121     return static_cast<int>(ceilf(replacedWidth * style()->effectiveZoom()));
122 }
123
124 LayoutUnit RenderSVGRoot::computeIntrinsicHeight(LayoutUnit replacedHeight) const
125 {
126     if (!style()->height().isPercent())
127         return replacedHeight;
128     // FIXME: Remove unnecessary rounding when layout is off ints: webkit.org/b/63656
129     return static_cast<int>(ceilf(replacedHeight * style()->effectiveZoom()));
130 }
131
132 LayoutUnit RenderSVGRoot::computeReplacedLogicalWidth(bool includeMaxWidth) const
133 {
134     LayoutUnit replacedWidth = RenderBox::computeReplacedLogicalWidth(includeMaxWidth);
135     Frame* frame = node() && node()->document() ? node()->document()->frame() : 0;
136     if (!frame)
137         return computeIntrinsicWidth(replacedWidth);
138
139     // If our frame has an owner renderer, we're embedded through eg. object/embed.
140     RenderPart* ownerRenderer = frame->ownerRenderer();
141     if (!ownerRenderer)
142         return computeIntrinsicWidth(replacedWidth);
143
144     RenderStyle* ownerRendererStyle = ownerRenderer->style();
145     ASSERT(ownerRendererStyle);
146     ASSERT(frame->contentRenderer());
147
148     Length ownerWidth = ownerRendererStyle->width();
149     if (ownerWidth.isAuto())
150         return replacedWidth;
151
152     // Spec: http://dev.w3.org/SVG/profiles/1.1F2/publish/coords.html#ViewportSpace
153     // The SVG user agent negotiates with its parent user agent to determine the viewport into which the SVG user agent can render
154     // the document. In some circumstances, SVG content will be embedded (by reference or inline) within a containing document.
155     // This containing document might include attributes, properties and/or other parameters (explicit or implicit) which specify
156     // or provide hints about the dimensions of the viewport for the SVG content. SVG content itself optionally can provide
157     // information about the appropriate viewport region for the content via the ‘width’ and ‘height’ XML attributes on the
158     // outermost svg element. The negotiation process uses any information provided by the containing document and the SVG
159     // content itself to choose the viewport location and size.
160
161     // The ‘width’ attribute on the outermost svg element establishes the viewport's width, unless the following conditions are met:
162     // * the SVG content is a separately stored resource that is embedded by reference (such as the ‘object’ element in XHTML [XHTML]),
163     //   or the SVG content is embedded inline within a containing document;
164     // * and the referencing element or containing document is styled using CSS [CSS2] or XSL [XSL];
165     // * and there are CSS-compatible positioning properties ([CSS2], section 9.3) specified on the referencing element
166     //   (e.g., the ‘object’ element) or on the containing document's outermost svg element that are sufficient to establish
167     //   the width of the viewport.
168     //
169     // Under these conditions, the positioning properties establish the viewport's width.
170     return ownerRenderer->computeReplacedLogicalWidthRespectingMinMaxWidth(ownerRenderer->computeReplacedLogicalWidthUsing(ownerWidth), includeMaxWidth);
171 }
172
173 LayoutUnit RenderSVGRoot::computeReplacedLogicalHeight() const
174 {
175     LayoutUnit replacedHeight = RenderBox::computeReplacedLogicalHeight();
176
177     Frame* frame = node() && node()->document() ? node()->document()->frame() : 0;
178     if (!frame)
179         return computeIntrinsicHeight(replacedHeight);
180
181     // If our frame has an owner renderer, we're embedded through eg. object/embed.
182     RenderPart* ownerRenderer = frame->ownerRenderer();
183     if (!ownerRenderer)
184         return computeIntrinsicHeight(replacedHeight);
185
186     RenderStyle* ownerRendererStyle = ownerRenderer->style();
187     ASSERT(ownerRendererStyle);
188     ASSERT(frame->contentRenderer());
189
190     Length ownerHeight = ownerRendererStyle->height();
191     if (ownerHeight.isAuto())
192         return replacedHeight;
193
194     // Spec: http://dev.w3.org/SVG/profiles/1.1F2/publish/coords.html#ViewportSpace
195     // See comment in RenderSVGRoot::computeReplacedLogicalWidth().
196     // Similarly, if there are positioning properties specified on the referencing element or on the outermost svg element that
197     // are sufficient to establish the height of the viewport, then these positioning properties establish the viewport's height;
198     // otherwise, the ‘height’ attribute on the outermost svg element establishes the viewport's height.
199     return ownerRenderer->computeReplacedLogicalHeightRespectingMinMaxHeight(ownerRenderer->computeReplacedLogicalHeightUsing(ownerHeight));
200 }
201
202 void RenderSVGRoot::layout()
203 {
204     ASSERT(needsLayout());
205
206     // Arbitrary affine transforms are incompatible with LayoutState.
207     LayoutStateDisabler layoutStateDisabler(view());
208
209     bool needsLayout = selfNeedsLayout();
210     LayoutRepainter repainter(*this, checkForRepaintDuringLayout() && needsLayout);
211
212     LayoutSize oldSize(width(), height());
213     computeLogicalWidth();
214     computeLogicalHeight();
215     calcViewport();
216
217     SVGSVGElement* svg = static_cast<SVGSVGElement*>(node());
218     m_isLayoutSizeChanged = svg->hasRelativeLengths() && oldSize != size();
219  
220     if (view() && view()->frameView() && view()->frameView()->embeddedContentBox()) {
221         if (!m_needsSizeNegotiationWithHostDocument)
222             m_needsSizeNegotiationWithHostDocument = !m_everHadLayout || oldSize != size();
223     } else
224         ASSERT(!m_needsSizeNegotiationWithHostDocument);
225
226     SVGRenderSupport::layoutChildren(this, needsLayout);
227     m_isLayoutSizeChanged = false;
228
229     // At this point LayoutRepainter already grabbed the old bounds,
230     // recalculate them now so repaintAfterLayout() uses the new bounds.
231     if (m_needsBoundariesOrTransformUpdate) {
232         updateCachedBoundaries();
233         m_needsBoundariesOrTransformUpdate = false;
234     }
235
236     repainter.repaintAfterLayout();
237
238     setNeedsLayout(false);
239 }
240
241 bool RenderSVGRoot::selfWillPaint()
242 {
243 #if ENABLE(FILTERS)
244     SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(this);
245     return resources && resources->filter();
246 #else
247     return false;
248 #endif
249 }
250
251 void RenderSVGRoot::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
252 {
253     if (paintInfo.context->paintingDisabled())
254         return;
255
256     bool isVisible = style()->visibility() == VISIBLE;
257     LayoutPoint borderBoxOriginInContainer = paintOffset + parentOriginToBorderBox();
258
259     if (hasBoxDecorations() && (paintInfo.phase == PaintPhaseBlockBackground || paintInfo.phase == PaintPhaseChildBlockBackground) && isVisible)
260         paintBoxDecorations(paintInfo, borderBoxOriginInContainer);
261
262     if (paintInfo.phase == PaintPhaseBlockBackground)
263         return;
264
265     // An empty viewport disables rendering.  FIXME: Should we still render filters?
266     if (m_viewportSize.isEmpty())
267         return;
268
269     // Don't paint if we don't have kids, except if we have filters we should paint those.
270     if (!firstChild() && !selfWillPaint())
271         return;
272
273     // Make a copy of the PaintInfo because applyTransform will modify the damage rect.
274     PaintInfo childPaintInfo(paintInfo);
275     childPaintInfo.context->save();
276
277     // Apply initial viewport clip - not affected by overflow handling
278     childPaintInfo.context->clip(overflowClipRect(borderBoxOriginInContainer));
279
280     // Convert from container offsets (html renderers) to a relative transform (svg renderers).
281     // Transform from our paint container's coordinate system to our local coords.
282     childPaintInfo.applyTransform(localToRepaintContainerTransform(paintOffset));
283
284     bool continueRendering = true;
285     if (childPaintInfo.phase == PaintPhaseForeground)
286         continueRendering = SVGRenderSupport::prepareToRenderSVGContent(this, childPaintInfo);
287
288     if (continueRendering)
289         RenderBox::paint(childPaintInfo, LayoutPoint());
290
291     if (childPaintInfo.phase == PaintPhaseForeground)
292         SVGRenderSupport::finishRenderSVGContent(this, childPaintInfo, paintInfo.context);
293
294     childPaintInfo.context->restore();
295
296     if ((paintInfo.phase == PaintPhaseOutline || paintInfo.phase == PaintPhaseSelfOutline) && style()->outlineWidth() && isVisible)
297         paintOutline(paintInfo.context, LayoutRect(borderBoxOriginInContainer, size()));
298 }
299
300 void RenderSVGRoot::willBeDestroyed()
301 {
302     SVGResourcesCache::clientDestroyed(this);
303     RenderBox::willBeDestroyed();
304 }
305
306 void RenderSVGRoot::styleWillChange(StyleDifference diff, const RenderStyle* newStyle)
307 {
308     if (diff == StyleDifferenceLayout)
309         setNeedsBoundariesUpdate();
310     RenderBox::styleWillChange(diff, newStyle);
311 }
312
313 void RenderSVGRoot::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
314 {
315     RenderBox::styleDidChange(diff, oldStyle);
316     SVGResourcesCache::clientStyleChanged(this, diff, style());
317 }
318
319 void RenderSVGRoot::updateFromElement()
320 {
321     RenderBox::updateFromElement();
322     SVGResourcesCache::clientUpdatedFromElement(this, style());
323 }
324
325 void RenderSVGRoot::calcViewport()
326 {
327     SVGSVGElement* svg = static_cast<SVGSVGElement*>(node());
328
329     if (!svg->hasSetContainerSize()) {
330         // In the normal case of <svg> being stand-alone or in a CSSBoxModel object we use
331         // RenderBox::width()/height() (which pulls data from RenderStyle)
332         m_viewportSize = FloatSize(width(), height());
333         return;
334     }
335
336     // In the SVGImage case grab the SVGLength values off of SVGSVGElement and use
337     // the special relativeWidthValue accessors which respect the specified containerSize
338     // FIXME: Check how SVGImage + zooming is supposed to be handled?
339     SVGLength width = svg->width();
340     SVGLength height = svg->height();
341     m_viewportSize = FloatSize(width.unitType() == LengthTypePercentage ? svg->relativeWidthValue() : width.value(svg),
342                                height.unitType() == LengthTypePercentage ? svg->relativeHeightValue() : height.value(svg));
343 }
344
345 // RenderBox methods will expect coordinates w/o any transforms in coordinates
346 // relative to our borderBox origin.  This method gives us exactly that.
347 AffineTransform RenderSVGRoot::localToBorderBoxTransform() const
348 {
349     LayoutSize borderAndPadding = borderOriginToContentBox();
350     SVGSVGElement* svg = static_cast<SVGSVGElement*>(node());
351     float scale = style()->effectiveZoom();
352     FloatPoint translate = svg->currentTranslate();
353     AffineTransform ctm(scale, 0, 0, scale, borderAndPadding.width() + translate.x(), borderAndPadding.height() + translate.y());
354     return ctm * svg->viewBoxToViewTransform(width() / scale, height() / scale);
355 }
356
357 LayoutSize RenderSVGRoot::parentOriginToBorderBox() const
358 {
359     return locationOffset();
360 }
361
362 LayoutSize RenderSVGRoot::borderOriginToContentBox() const
363 {
364     return LayoutSize(borderLeft() + paddingLeft(), borderTop() + paddingTop());
365 }
366
367 AffineTransform RenderSVGRoot::localToRepaintContainerTransform(const LayoutPoint& parentOriginInContainer) const
368 {
369     return AffineTransform::translation(parentOriginInContainer.x(), parentOriginInContainer.y()) * localToParentTransform();
370 }
371
372 const AffineTransform& RenderSVGRoot::localToParentTransform() const
373 {
374     LayoutSize parentToBorderBoxOffset = parentOriginToBorderBox();
375
376     m_localToParentTransform = AffineTransform::translation(parentToBorderBoxOffset.width(), parentToBorderBoxOffset.height()) * localToBorderBoxTransform();
377
378     return m_localToParentTransform;
379 }
380
381 LayoutRect RenderSVGRoot::clippedOverflowRectForRepaint(RenderBoxModelObject* repaintContainer) const
382 {
383     return SVGRenderSupport::clippedOverflowRectForRepaint(this, repaintContainer);
384 }
385
386 void RenderSVGRoot::computeRectForRepaint(RenderBoxModelObject* repaintContainer, LayoutRect& repaintRect, bool fixed) const
387 {
388     // Apply our local transforms (except for x/y translation), then our shadow, 
389     // and then call RenderBox's method to handle all the normal CSS Box model bits
390     repaintRect = localToBorderBoxTransform().mapRect(repaintRect);
391
392     // Apply initial viewport clip - not affected by overflow settings    
393     repaintRect.intersect(enclosingLayoutRect(FloatRect(FloatPoint(), m_viewportSize)));
394
395     const SVGRenderStyle* svgStyle = style()->svgStyle();
396     if (const ShadowData* shadow = svgStyle->shadow())
397         shadow->adjustRectForShadow(repaintRect);
398
399     RenderBox::computeRectForRepaint(repaintContainer, repaintRect, fixed);
400 }
401
402 void RenderSVGRoot::mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool fixed, bool useTransforms, TransformState& transformState, bool* wasFixed) const
403 {
404     ASSERT(!fixed); // We should have no fixed content in the SVG rendering tree.
405     ASSERT(useTransforms); // mapping a point through SVG w/o respecting trasnforms is useless.
406
407     // Transform to our border box and let RenderBox transform the rest of the way.
408     transformState.applyTransform(localToBorderBoxTransform());
409     RenderBox::mapLocalToContainer(repaintContainer, fixed, useTransforms, transformState, wasFixed);
410 }
411
412 void RenderSVGRoot::updateCachedBoundaries()
413 {
414     m_objectBoundingBox = FloatRect();
415     m_strokeBoundingBox = FloatRect();
416     m_repaintBoundingBox = FloatRect();
417
418     SVGRenderSupport::computeContainerBoundingBoxes(this, m_objectBoundingBox, m_strokeBoundingBox, m_repaintBoundingBox);
419     SVGRenderSupport::intersectRepaintRectWithResources(this, m_repaintBoundingBox);
420     m_repaintBoundingBox.inflate(borderAndPaddingWidth());
421 }
422
423 bool RenderSVGRoot::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
424 {
425     LayoutPoint pointInParent = pointInContainer - toLayoutSize(accumulatedOffset);
426     LayoutPoint pointInBorderBox = pointInParent - parentOriginToBorderBox();
427
428     // Note: For now, we're ignoring hits to border and padding for <svg>
429     LayoutPoint pointInContentBox = pointInBorderBox - borderOriginToContentBox();
430     if (!contentBoxRect().contains(pointInContentBox))
431         return false;
432
433     LayoutPoint localPoint = localToParentTransform().inverse().mapPoint(pointInParent);
434
435     for (RenderObject* child = lastChild(); child; child = child->previousSibling()) {
436         if (child->nodeAtFloatPoint(request, result, localPoint, hitTestAction)) {
437             // FIXME: CSS/HTML assumes the local point is relative to the border box, right?
438             updateHitTestResult(result, pointInBorderBox);
439             // FIXME: nodeAtFloatPoint() doesn't handle rect-based hit tests yet.
440             result.addNodeToRectBasedTestResult(child->node(), pointInContainer);
441             return true;
442         }
443     }
444
445     // 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.
446     if (hitTestAction == HitTestBlockBackground && style()->pointerEvents() != PE_NONE) {
447         // Only return true here, if the last hit testing phase 'BlockBackground' is executed. If we'd return true in the 'Foreground' phase,
448         // hit testing would stop immediately. For SVG only trees this doesn't matter. Though when we have a <foreignObject> subtree we need
449         // 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 
450         // to detect these hits anymore.
451         updateHitTestResult(result, roundedLayoutPoint(localPoint));
452         return true;
453     }
454
455     return false;
456 }
457
458 }
459
460 #endif // ENABLE(SVG)