Add new renderer for SVGRectElement.
[WebKit.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 "LayoutRepainter.h"
33 #include "RenderPart.h"
34 #include "RenderSVGContainer.h"
35 #include "RenderSVGResource.h"
36 #include "RenderView.h"
37 #include "SVGLength.h"
38 #include "SVGRenderSupport.h"
39 #include "SVGResources.h"
40 #include "SVGSVGElement.h"
41 #include "SVGStyledElement.h"
42 #include "SVGViewSpec.h"
43 #include "TransformState.h"
44
45 #if ENABLE(FILTERS)
46 #include "RenderSVGResourceFilter.h"
47 #endif
48
49 using namespace std;
50
51 namespace WebCore {
52
53 RenderSVGRoot::RenderSVGRoot(SVGStyledElement* node)
54     : RenderBox(node)
55     , m_isLayoutSizeChanged(false)
56     , m_needsBoundariesOrTransformUpdate(true)
57     , m_needsSizeNegotiationWithHostDocument(false)
58 {
59     setReplaced(true);
60 }
61
62 RenderSVGRoot::~RenderSVGRoot()
63 {
64 }
65
66 void RenderSVGRoot::computeIntrinsicRatioInformation(FloatSize& intrinsicRatio, bool& isPercentageIntrinsicSize) const
67 {
68     // Spec: http://dev.w3.org/SVG/profiles/1.1F2/publish/coords.html#IntrinsicSizing
69     // The intrinsic aspect ratio of the viewport of SVG content is necessary for example, when including
70     // SVG from an ‘object’ element in HTML styled with CSS. It is possible (indeed, common) for an SVG
71     // graphic to have an intrinsic aspect ratio but not to have an intrinsic width or height.
72     // The intrinsic aspect ratio must be calculated based upon the following rules:
73     // The aspect ratio is calculated by dividing a width by a height.
74
75     // If the ‘width’ and ‘height’ of the rootmost ‘svg’ element are both specified with unit identifiers
76     // (in, mm, cm, pt, pc, px, em, ex) or in user units, then the aspect ratio is calculated from the
77     // ‘width’ and ‘height’ attributes after resolving both values to user units.
78     isPercentageIntrinsicSize = false;
79     if (style()->width().isFixed() && style()->height().isFixed()) {
80         intrinsicRatio = FloatSize(width(), height());
81         return;
82     }
83
84     // If either/both of the ‘width’ and ‘height’ of the rootmost ‘svg’ element are in percentage units (or omitted),
85     // the aspect ratio is calculated from the width and height values of the ‘viewBox’ specified for the current SVG
86     // document fragment. If the ‘viewBox’ is not correctly specified, or set to 'none', the intrinsic aspect ratio
87     // cannot be calculated and is considered unspecified.
88     intrinsicRatio = static_cast<SVGSVGElement*>(node())->currentViewBoxRect().size();
89
90     // Compatibility with authors expectations and Firefox/Opera: when percentage units are used, take them into
91     // account for certain cases of the intrinsic width/height calculation in RenderPart::computeReplacedLogicalWidth/Height.
92     if (intrinsicRatio.isEmpty() && style()->width().isPercent() && style()->height().isPercent()) {
93         isPercentageIntrinsicSize = true;
94         intrinsicRatio = FloatSize(style()->width().percent(), style()->height().percent());
95     }
96 }
97
98 void RenderSVGRoot::computePreferredLogicalWidths()
99 {
100     ASSERT(preferredLogicalWidthsDirty());
101
102     LayoutUnit borderAndPadding = borderAndPaddingWidth();
103     LayoutUnit width = computeReplacedLogicalWidth(false) + borderAndPadding;
104
105     if (style()->maxWidth().isFixed())
106         width = min(width, style()->maxWidth().value() + (style()->boxSizing() == CONTENT_BOX ? borderAndPadding : 0));
107
108     if (style()->width().isPercent() || (style()->width().isAuto() && style()->height().isPercent())) {
109         m_minPreferredLogicalWidth = 0;
110         m_maxPreferredLogicalWidth = width;
111     } else
112         m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = width;
113
114     setPreferredLogicalWidthsDirty(false);
115 }
116
117 LayoutUnit RenderSVGRoot::computeIntrinsicWidth(LayoutUnit replacedWidth) const
118 {
119     if (!style()->width().isPercent())
120         return replacedWidth;
121     // FIXME: Remove unnecessary rounding when layout is off ints: webkit.org/b/63656
122     return static_cast<int>(ceilf(replacedWidth * style()->effectiveZoom()));
123 }
124
125 LayoutUnit RenderSVGRoot::computeIntrinsicHeight(LayoutUnit replacedHeight) const
126 {
127     if (!style()->height().isPercent())
128         return replacedHeight;
129     // FIXME: Remove unnecessary rounding when layout is off ints: webkit.org/b/63656
130     return static_cast<int>(ceilf(replacedHeight * style()->effectiveZoom()));
131 }
132
133 LayoutUnit RenderSVGRoot::computeReplacedLogicalWidth(bool includeMaxWidth) const
134 {
135     LayoutUnit replacedWidth = RenderBox::computeReplacedLogicalWidth(includeMaxWidth);
136     Frame* frame = node() && node()->document() ? node()->document()->frame() : 0;
137     if (!frame)
138         return computeIntrinsicWidth(replacedWidth);
139
140     // If our frame has an owner renderer, we're embedded through eg. object/embed.
141     RenderPart* ownerRenderer = frame->ownerRenderer();
142     if (!ownerRenderer)
143         return computeIntrinsicWidth(replacedWidth);
144
145     RenderStyle* ownerRendererStyle = ownerRenderer->style();
146     ASSERT(ownerRendererStyle);
147     ASSERT(frame->contentRenderer());
148
149     Length ownerWidth = ownerRendererStyle->width();
150     if (ownerWidth.isAuto())
151         return replacedWidth;
152
153     // Spec: http://dev.w3.org/SVG/profiles/1.1F2/publish/coords.html#ViewportSpace
154     // The SVG user agent negotiates with its parent user agent to determine the viewport into which the SVG user agent can render
155     // the document. In some circumstances, SVG content will be embedded (by reference or inline) within a containing document.
156     // This containing document might include attributes, properties and/or other parameters (explicit or implicit) which specify
157     // or provide hints about the dimensions of the viewport for the SVG content. SVG content itself optionally can provide
158     // information about the appropriate viewport region for the content via the ‘width’ and ‘height’ XML attributes on the
159     // outermost svg element. The negotiation process uses any information provided by the containing document and the SVG
160     // content itself to choose the viewport location and size.
161
162     // The ‘width’ attribute on the outermost svg element establishes the viewport's width, unless the following conditions are met:
163     // * the SVG content is a separately stored resource that is embedded by reference (such as the ‘object’ element in XHTML [XHTML]),
164     //   or the SVG content is embedded inline within a containing document;
165     // * and the referencing element or containing document is styled using CSS [CSS2] or XSL [XSL];
166     // * and there are CSS-compatible positioning properties ([CSS2], section 9.3) specified on the referencing element
167     //   (e.g., the ‘object’ element) or on the containing document's outermost svg element that are sufficient to establish
168     //   the width of the viewport.
169     //
170     // Under these conditions, the positioning properties establish the viewport's width.
171     return ownerRenderer->computeReplacedLogicalWidthRespectingMinMaxWidth(ownerRenderer->computeReplacedLogicalWidthUsing(ownerWidth), includeMaxWidth);
172 }
173
174 LayoutUnit RenderSVGRoot::computeReplacedLogicalHeight() const
175 {
176     LayoutUnit replacedHeight = RenderBox::computeReplacedLogicalHeight();
177
178     Frame* frame = node() && node()->document() ? node()->document()->frame() : 0;
179     if (!frame)
180         return computeIntrinsicHeight(replacedHeight);
181
182     // If our frame has an owner renderer, we're embedded through eg. object/embed.
183     RenderPart* ownerRenderer = frame->ownerRenderer();
184     if (!ownerRenderer)
185         return computeIntrinsicHeight(replacedHeight);
186
187     RenderStyle* ownerRendererStyle = ownerRenderer->style();
188     ASSERT(ownerRendererStyle);
189     ASSERT(frame->contentRenderer());
190
191     Length ownerHeight = ownerRendererStyle->height();
192     if (ownerHeight.isAuto())
193         return replacedHeight;
194
195     // Spec: http://dev.w3.org/SVG/profiles/1.1F2/publish/coords.html#ViewportSpace
196     // See comment in RenderSVGRoot::computeReplacedLogicalWidth().
197     // Similarly, if there are positioning properties specified on the referencing element or on the outermost svg element that
198     // are sufficient to establish the height of the viewport, then these positioning properties establish the viewport's height;
199     // otherwise, the ‘height’ attribute on the outermost svg element establishes the viewport's height.
200     return ownerRenderer->computeReplacedLogicalHeightRespectingMinMaxHeight(ownerRenderer->computeReplacedLogicalHeightUsing(ownerHeight));
201 }
202
203 void RenderSVGRoot::layout()
204 {
205     ASSERT(needsLayout());
206
207     // Arbitrary affine transforms are incompatible with LayoutState.
208     LayoutStateDisabler layoutStateDisabler(view());
209
210     bool needsLayout = selfNeedsLayout();
211     LayoutRepainter repainter(*this, checkForRepaintDuringLayout() && needsLayout);
212
213     LayoutSize oldSize(width(), height());
214     computeLogicalWidth();
215     computeLogicalHeight();
216     calcViewport();
217
218     SVGSVGElement* svg = static_cast<SVGSVGElement*>(node());
219     m_isLayoutSizeChanged = svg->hasRelativeLengths() && oldSize != size();
220  
221     if (view() && view()->frameView() && view()->frameView()->embeddedContentBox()) {
222         if (!m_needsSizeNegotiationWithHostDocument)
223             m_needsSizeNegotiationWithHostDocument = !m_everHadLayout || oldSize != size();
224     } else
225         ASSERT(!m_needsSizeNegotiationWithHostDocument);
226
227     SVGRenderSupport::layoutChildren(this, needsLayout);
228     m_isLayoutSizeChanged = false;
229
230     // At this point LayoutRepainter already grabbed the old bounds,
231     // recalculate them now so repaintAfterLayout() uses the new bounds.
232     if (m_needsBoundariesOrTransformUpdate) {
233         updateCachedBoundaries();
234         m_needsBoundariesOrTransformUpdate = false;
235     }
236
237     repainter.repaintAfterLayout();
238
239     setNeedsLayout(false);
240 }
241
242 bool RenderSVGRoot::selfWillPaint()
243 {
244 #if ENABLE(FILTERS)
245     SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(this);
246     return resources && resources->filter();
247 #else
248     return false;
249 #endif
250 }
251
252 void RenderSVGRoot::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
253 {
254     if (paintInfo.context->paintingDisabled())
255         return;
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, paintInfo.renderRegion));
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)