#include "core/rendering/svg/RenderSVGRoot.h"
-#include "core/frame/Frame.h"
+#include "core/frame/LocalFrame.h"
#include "core/rendering/HitTestResult.h"
-#include "core/rendering/LayoutRectRecorder.h"
-#include "core/rendering/LayoutRepainter.h"
+#include "core/rendering/RenderLayer.h"
#include "core/rendering/RenderPart.h"
#include "core/rendering/RenderView.h"
#include "core/rendering/svg/RenderSVGResourceContainer.h"
+#include "core/rendering/svg/SVGRenderSupport.h"
#include "core/rendering/svg/SVGRenderingContext.h"
#include "core/rendering/svg/SVGResources.h"
#include "core/rendering/svg/SVGResourcesCache.h"
#include "platform/LengthFunctions.h"
#include "platform/graphics/GraphicsContext.h"
-using namespace std;
-
-namespace WebCore {
+namespace blink {
RenderSVGRoot::RenderSVGRoot(SVGElement* node)
: RenderReplaced(node)
, m_objectBoundingBoxValid(false)
, m_isLayoutSizeChanged(false)
, m_needsBoundariesOrTransformUpdate(true)
+ , m_hasBoxDecorationBackground(false)
{
}
{
}
-void RenderSVGRoot::computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio, bool& isPercentageIntrinsicSize) const
+void RenderSVGRoot::trace(Visitor* visitor)
+{
+ visitor->trace(m_children);
+ RenderReplaced::trace(visitor);
+}
+
+void RenderSVGRoot::computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio) const
{
// Spec: http://www.w3.org/TR/SVG/coords.html#IntrinsicSizing
// SVG needs to specify how to calculate some intrinsic sizing properties to enable inclusion within other languages.
// The intrinsic width and height of the viewport of SVG content must be determined from the ‘width’ and ‘height’ attributes.
- // If either of these are not specified, a value of '100%' must be assumed. Note: the ‘width’ and ‘height’ attributes are not
- // the same as the CSS width and height properties. Specifically, percentage values do not provide an intrinsic width or height,
- // and do not indicate a percentage of the containing block. Rather, once the viewport is established, they indicate the portion
- // of the viewport that is actually covered by image data.
SVGSVGElement* svg = toSVGSVGElement(node());
ASSERT(svg);
- Length intrinsicWidthAttribute = svg->intrinsicWidth(SVGSVGElement::IgnoreCSSProperties);
- Length intrinsicHeightAttribute = svg->intrinsicHeight(SVGSVGElement::IgnoreCSSProperties);
// The intrinsic aspect ratio of the viewport of SVG content is necessary for example, when including SVG from an ‘object’
// element in HTML styled with CSS. It is possible (indeed, common) for an SVG graphic to have an intrinsic aspect ratio but
// - If the ‘width’ and ‘height’ of the rootmost ‘svg’ element are both specified with unit identifiers (in, mm, cm, pt, pc,
// px, em, ex) or in user units, then the aspect ratio is calculated from the ‘width’ and ‘height’ attributes after
// resolving both values to user units.
- if (intrinsicWidthAttribute.isFixed() || intrinsicHeightAttribute.isFixed()) {
- if (intrinsicWidthAttribute.isFixed())
- intrinsicSize.setWidth(floatValueForLength(intrinsicWidthAttribute, 0));
- if (intrinsicHeightAttribute.isFixed())
- intrinsicSize.setHeight(floatValueForLength(intrinsicHeightAttribute, 0));
- if (!intrinsicSize.isEmpty())
- intrinsicRatio = intrinsicSize.width() / static_cast<double>(intrinsicSize.height());
- return;
- }
+ intrinsicSize.setWidth(floatValueForLength(svg->intrinsicWidth(), 0));
+ intrinsicSize.setHeight(floatValueForLength(svg->intrinsicHeight(), 0));
- // - If either/both of the ‘width’ and ‘height’ of the rootmost ‘svg’ element are in percentage units (or omitted), the
- // aspect ratio is calculated from the width and height values of the ‘viewBox’ specified for the current SVG document
- // fragment. If the ‘viewBox’ is not correctly specified, or set to 'none', the intrinsic aspect ratio cannot be
- // calculated and is considered unspecified.
- intrinsicSize = svg->viewBox()->currentValue()->value().size();
if (!intrinsicSize.isEmpty()) {
- // The viewBox can only yield an intrinsic ratio, not an intrinsic size.
intrinsicRatio = intrinsicSize.width() / static_cast<double>(intrinsicSize.height());
- intrinsicSize = FloatSize();
- return;
- }
-
- // If our intrinsic size is in percentage units, return those to the caller through the intrinsicSize. Notify the caller
- // about the special situation, by setting isPercentageIntrinsicSize=true, so it knows how to interpret the return values.
- if (intrinsicWidthAttribute.isPercent() && intrinsicHeightAttribute.isPercent()) {
- isPercentageIntrinsicSize = true;
- intrinsicSize = FloatSize(intrinsicWidthAttribute.percent(), intrinsicHeightAttribute.percent());
+ } else {
+ // - If either/both of the ‘width’ and ‘height’ of the rootmost ‘svg’ element are in percentage units (or omitted), the
+ // aspect ratio is calculated from the width and height values of the ‘viewBox’ specified for the current SVG document
+ // fragment. If the ‘viewBox’ is not correctly specified, or set to 'none', the intrinsic aspect ratio cannot be
+ // calculated and is considered unspecified.
+ FloatSize viewBoxSize = svg->viewBox()->currentValue()->value().size();
+ if (!viewBoxSize.isEmpty()) {
+ // The viewBox can only yield an intrinsic ratio, not an intrinsic size.
+ intrinsicRatio = viewBoxSize.width() / static_cast<double>(viewBoxSize.height());
+ }
}
}
if (!node())
return false;
- Frame* frame = node()->document().frame();
+ LocalFrame* frame = node()->document().frame();
if (!frame)
return false;
// If our frame has an owner renderer, we're embedded through eg. object/embed/iframe,
- // but we only negotiate if we're in an SVG document.
- if (!frame->ownerRenderer())
+ // but we only negotiate if we're in an SVG document inside a embedded object (object/embed).
+ if (!frame->ownerRenderer() || !frame->ownerRenderer()->isEmbeddedObject())
return false;
return frame->document()->isSVGDocument();
}
if (!m_containerSize.isEmpty())
return m_containerSize.width();
+ if (isEmbeddedThroughFrameContainingSVGDocument())
+ return containingBlock()->availableLogicalWidth();
+
if (style()->logicalWidth().isSpecified() || style()->logicalMaxWidth().isSpecified())
return RenderReplaced::computeReplacedLogicalWidth(shouldComputePreferred);
- if (svg->widthAttributeEstablishesViewport())
- return resolveLengthAttributeForSVG(svg->intrinsicWidth(SVGSVGElement::IgnoreCSSProperties), style()->effectiveZoom(), containingBlock()->availableLogicalWidth());
-
- // SVG embedded through object/embed/iframe.
- if (isEmbeddedThroughFrameContainingSVGDocument())
- return document().frame()->ownerRenderer()->availableLogicalWidth();
+ if (svg->hasIntrinsicWidth())
+ return resolveLengthAttributeForSVG(svg->intrinsicWidth(), style()->effectiveZoom(), containingBlock()->availableLogicalWidth().toFloat());
// SVG embedded via SVGImage (background-image/border-image/etc) / Inline SVG.
return RenderReplaced::computeReplacedLogicalWidth(shouldComputePreferred);
if (!m_containerSize.isEmpty())
return m_containerSize.height();
+ if (isEmbeddedThroughFrameContainingSVGDocument())
+ return containingBlock()->availableLogicalHeight(IncludeMarginBorderPadding);
+
if (style()->logicalHeight().isSpecified() || style()->logicalMaxHeight().isSpecified())
return RenderReplaced::computeReplacedLogicalHeight();
- if (svg->heightAttributeEstablishesViewport()) {
- Length height = svg->intrinsicHeight(SVGSVGElement::IgnoreCSSProperties);
- if (height.isPercent()) {
- RenderBlock* cb = containingBlock();
- ASSERT(cb);
- while (cb->isAnonymous()) {
- cb = cb->containingBlock();
- cb->addPercentHeightDescendant(const_cast<RenderSVGRoot*>(this));
- }
- } else
- RenderBlock::removePercentHeightDescendant(const_cast<RenderSVGRoot*>(this));
-
- return resolveLengthAttributeForSVG(height, style()->effectiveZoom(), containingBlock()->availableLogicalHeight(IncludeMarginBorderPadding));
- }
-
- // SVG embedded through object/embed/iframe.
- if (isEmbeddedThroughFrameContainingSVGDocument())
- return document().frame()->ownerRenderer()->availableLogicalHeight(IncludeMarginBorderPadding);
+ if (svg->hasIntrinsicHeight())
+ return resolveLengthAttributeForSVG(svg->intrinsicHeight(), style()->effectiveZoom(), containingBlock()->availableLogicalHeight(IncludeMarginBorderPadding).toFloat());
// SVG embedded via SVGImage (background-image/border-image/etc) / Inline SVG.
return RenderReplaced::computeReplacedLogicalHeight();
{
ASSERT(needsLayout());
- LayoutRectRecorder recorder(*this);
-
- // Arbitrary affine transforms are incompatible with LayoutState.
- LayoutStateDisabler layoutStateDisabler(view());
-
bool needsLayout = selfNeedsLayout();
- LayoutRepainter repainter(*this, checkForRepaintDuringLayout() && needsLayout);
LayoutSize oldSize = size();
updateLogicalWidth();
m_isLayoutSizeChanged = needsLayout || (svg->hasRelativeLengths() && oldSize != size());
SVGRenderSupport::layoutChildren(this, needsLayout || SVGRenderSupport::filtersForceContainerLayout(this));
- // At this point LayoutRepainter already grabbed the old bounds,
- // recalculate them now so repaintAfterLayout() uses the new bounds.
if (m_needsBoundariesOrTransformUpdate) {
updateCachedBoundaries();
m_needsBoundariesOrTransformUpdate = false;
}
- updateLayerTransform();
+ m_overflow.clear();
+ addVisualEffectOverflow();
+
+ if (!shouldApplyViewportClip()) {
+ FloatRect contentPaintInvalidationRect = paintInvalidationRectInLocalCoordinates();
+ contentPaintInvalidationRect = m_localToBorderBoxTransform.mapRect(contentPaintInvalidationRect);
+ addVisualOverflow(enclosingLayoutRect(contentPaintInvalidationRect));
+ }
- repainter.repaintAfterLayout();
+ updateLayerTransformAfterLayout();
+ m_hasBoxDecorationBackground = isDocumentElement() ? calculateHasBoxDecorations() : hasBoxDecorationBackground();
+ invalidateBackgroundObscurationStatus();
clearNeedsLayout();
}
+bool RenderSVGRoot::shouldApplyViewportClip() const
+{
+ // the outermost svg is clipped if auto, and svg document roots are always clipped
+ // When the svg is stand-alone (isDocumentElement() == true) the viewport clipping should always
+ // be applied, noting that the window scrollbars should be hidden if overflow=hidden.
+ return style()->overflowX() == OHIDDEN
+ || style()->overflowX() == OAUTO
+ || style()->overflowX() == OSCROLL
+ || this->isDocumentElement();
+}
+
void RenderSVGRoot::paintReplaced(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
{
// An empty viewport disables rendering.
if (pixelSnappedBorderBoxRect().isEmpty())
return;
- // Don't paint, if the context explicitly disabled it.
- if (paintInfo.context->paintingDisabled())
+ // SVG outlines are painted during PaintPhaseForeground.
+ if (paintInfo.phase == PaintPhaseOutline || paintInfo.phase == PaintPhaseSelfOutline)
return;
// An empty viewBox also disables rendering.
PaintInfo childPaintInfo(paintInfo);
childPaintInfo.context->save();
- // Apply initial viewport clip - not affected by overflow handling
- childPaintInfo.context->clip(pixelSnappedIntRect(overflowClipRect(paintOffset)));
+ // Apply initial viewport clip
+ if (shouldApplyViewportClip())
+ childPaintInfo.context->clip(pixelSnappedIntRect(overflowClipRect(paintOffset)));
// Convert from container offsets (html renderers) to a relative transform (svg renderers).
// Transform from our paint container's coordinate system to our local coords.
void RenderSVGRoot::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
{
- if (diff == StyleDifferenceLayout)
+ if (diff.needsFullLayout())
setNeedsBoundariesUpdate();
+ if (diff.needsPaintInvalidation()) {
+ // Box decorations may have appeared/disappeared - recompute status.
+ m_hasBoxDecorationBackground = calculateHasBoxDecorations();
+ }
RenderReplaced::styleDidChange(diff, oldStyle);
SVGResourcesCache::clientStyleChanged(this, diff, style());
FloatPoint translate = svg->currentTranslate();
LayoutSize borderAndPadding(borderLeft() + paddingLeft(), borderTop() + paddingTop());
m_localToBorderBoxTransform = svg->viewBoxToViewTransform(contentWidth() / scale, contentHeight() / scale);
- if (borderAndPadding.isEmpty() && scale == 1 && translate == FloatPoint::zero())
+ AffineTransform viewToBorderBoxTransform(scale, 0, 0, scale, borderAndPadding.width() + translate.x(), borderAndPadding.height() + translate.y());
+ if (viewToBorderBoxTransform.isIdentity())
return;
- m_localToBorderBoxTransform = AffineTransform(scale, 0, 0, scale, borderAndPadding.width() + translate.x(), borderAndPadding.height() + translate.y()) * m_localToBorderBoxTransform;
+ m_localToBorderBoxTransform = viewToBorderBoxTransform * m_localToBorderBoxTransform;
}
const AffineTransform& RenderSVGRoot::localToParentTransform() const
return m_localToParentTransform;
}
-LayoutRect RenderSVGRoot::clippedOverflowRectForRepaint(const RenderLayerModelObject* repaintContainer) const
+LayoutRect RenderSVGRoot::clippedOverflowRectForPaintInvalidation(const RenderLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState) const
{
- return SVGRenderSupport::clippedOverflowRectForRepaint(this, repaintContainer);
+ // This is an open-coded aggregate of SVGRenderSupport::clippedOverflowRectForPaintInvalidation,
+ // RenderSVGRoot::computeFloatRectForPaintInvalidation and RenderReplaced::clippedOverflowRectForPaintInvalidation.
+ // The reason for this is to optimize/minimize the paint invalidation rect when the box is not "decorated"
+ // (does not have background/border/etc.)
+
+ // Return early for any cases where we don't actually paint.
+ if (style()->visibility() != VISIBLE && !enclosingLayer()->hasVisibleContent())
+ return LayoutRect();
+
+ // Compute the paint invalidation rect of the content of the SVG in the border-box coordinate space.
+ FloatRect contentPaintInvalidationRect = paintInvalidationRectInLocalCoordinates();
+ contentPaintInvalidationRect = m_localToBorderBoxTransform.mapRect(contentPaintInvalidationRect);
+
+ // Apply initial viewport clip, overflow:visible content is added to visualOverflow
+ // but the most common case is that overflow is hidden, so always intersect.
+ contentPaintInvalidationRect.intersect(pixelSnappedBorderBoxRect());
+
+ LayoutRect paintInvalidationRect = enclosingLayoutRect(contentPaintInvalidationRect);
+ // If the box is decorated or is overflowing, extend it to include the border-box and overflow.
+ if (m_hasBoxDecorationBackground || hasRenderOverflow()) {
+ // The selectionRect can project outside of the overflowRect, so take their union
+ // for paint invalidation to avoid selection painting glitches.
+ LayoutRect decoratedPaintInvalidationRect = unionRect(localSelectionRect(false), visualOverflowRect());
+ paintInvalidationRect.unite(decoratedPaintInvalidationRect);
+ }
+
+ // Compute the paint invalidation rect in the parent coordinate space.
+ LayoutRect rect = enclosingIntRect(paintInvalidationRect);
+ RenderReplaced::mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, ViewportConstraintDoesNotMatter, paintInvalidationState);
+ return rect;
}
-void RenderSVGRoot::computeFloatRectForRepaint(const RenderLayerModelObject* repaintContainer, FloatRect& repaintRect, bool fixed) const
+void RenderSVGRoot::computeFloatRectForPaintInvalidation(const RenderLayerModelObject* paintInvalidationContainer, FloatRect& paintInvalidationRect, const PaintInvalidationState* paintInvalidationState) const
{
// Apply our local transforms (except for x/y translation), then our shadow,
// and then call RenderBox's method to handle all the normal CSS Box model bits
- repaintRect = m_localToBorderBoxTransform.mapRect(repaintRect);
+ paintInvalidationRect = m_localToBorderBoxTransform.mapRect(paintInvalidationRect);
- // Apply initial viewport clip - not affected by overflow settings
- repaintRect.intersect(pixelSnappedBorderBoxRect());
+ // Apply initial viewport clip
+ if (shouldApplyViewportClip())
+ paintInvalidationRect.intersect(pixelSnappedBorderBoxRect());
- LayoutRect rect = enclosingIntRect(repaintRect);
- RenderReplaced::computeRectForRepaint(repaintContainer, rect, fixed);
- repaintRect = rect;
+ LayoutRect rect = enclosingIntRect(paintInvalidationRect);
+ RenderReplaced::mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, ViewportConstraintDoesNotMatter, paintInvalidationState);
+ paintInvalidationRect = rect;
}
// This method expects local CSS box coordinates.
// Callers with local SVG viewport coordinates should first apply the localToBorderBoxTransform
// to convert from SVG viewport coordinates to local CSS box coordinates.
-void RenderSVGRoot::mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed) const
+void RenderSVGRoot::mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed, const PaintInvalidationState* paintInvalidationState) const
{
ASSERT(mode & ~IsFixed); // We should have no fixed content in the SVG rendering tree.
- ASSERT(mode & UseTransforms); // mapping a point through SVG w/o respecting trasnforms is useless.
+ // We used to have this ASSERT here, but we removed it when enabling layer squashing.
+ // See http://crbug.com/364901
+ // ASSERT(mode & UseTransforms); // mapping a point through SVG w/o respecting trasnforms is useless.
- RenderReplaced::mapLocalToContainer(repaintContainer, transformState, mode | ApplyContainerFlip, wasFixed);
+ RenderReplaced::mapLocalToContainer(paintInvalidationContainer, transformState, mode | ApplyContainerFlip, wasFixed, paintInvalidationState);
}
const RenderObject* RenderSVGRoot::pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
void RenderSVGRoot::updateCachedBoundaries()
{
- SVGRenderSupport::computeContainerBoundingBoxes(this, m_objectBoundingBox, m_objectBoundingBoxValid, m_strokeBoundingBox, m_repaintBoundingBox);
- SVGRenderSupport::intersectRepaintRectWithResources(this, m_repaintBoundingBox);
- m_repaintBoundingBox.inflate(borderAndPaddingWidth());
+ SVGRenderSupport::computeContainerBoundingBoxes(this, m_objectBoundingBox, m_objectBoundingBoxValid, m_strokeBoundingBox, m_paintInvalidationBoundingBox);
+ SVGRenderSupport::intersectPaintInvalidationRectWithResources(this, m_paintInvalidationBoundingBox);
}
bool RenderSVGRoot::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
LayoutPoint pointInParent = locationInContainer.point() - toLayoutSize(accumulatedOffset);
LayoutPoint pointInBorderBox = pointInParent - toLayoutSize(location());
- // Only test SVG content if the point is in our content box.
+ // Only test SVG content if the point is in our content box, or in case we
+ // don't clip to the viewport, the visual overflow rect.
// FIXME: This should be an intersection when rect-based hit tests are supported by nodeAtFloatPoint.
- if (contentBoxRect().contains(pointInBorderBox)) {
- FloatPoint localPoint = localToParentTransform().inverse().mapPoint(FloatPoint(pointInParent));
-
- for (RenderObject* child = lastChild(); child; child = child->previousSibling()) {
- // FIXME: nodeAtFloatPoint() doesn't handle rect-based hit tests yet.
- if (child->nodeAtFloatPoint(request, result, localPoint, hitTestAction)) {
- updateHitTestResult(result, pointInBorderBox);
- if (!result.addNodeToRectBasedTestResult(child->node(), request, locationInContainer))
- return true;
+ if (contentBoxRect().contains(pointInBorderBox) || (!shouldApplyViewportClip() && visualOverflowRect().contains(pointInBorderBox))) {
+ const AffineTransform& localToParentTransform = this->localToParentTransform();
+ if (localToParentTransform.isInvertible()) {
+ FloatPoint localPoint = localToParentTransform.inverse().mapPoint(FloatPoint(pointInParent));
+
+ for (RenderObject* child = lastChild(); child; child = child->previousSibling()) {
+ // FIXME: nodeAtFloatPoint() doesn't handle rect-based hit tests yet.
+ if (child->nodeAtFloatPoint(request, result, localPoint, hitTestAction)) {
+ updateHitTestResult(result, pointInBorderBox);
+ if (!result.addNodeToRectBasedTestResult(child->node(), request, locationInContainer))
+ return true;
+ }
}
}
}
// 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.
- if (hitTestAction == HitTestBlockBackground && visibleToHitTestRequest(request)) {
- // Only return true here, if the last hit testing phase 'BlockBackground' is executed. If we'd return true in the 'Foreground' phase,
- // hit testing would stop immediately. For SVG only trees this doesn't matter. Though when we have a <foreignObject> subtree we need
- // 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
- // to detect these hits anymore.
+ if ((hitTestAction == HitTestBlockBackground || hitTestAction == HitTestChildBlockBackground) && visibleToHitTestRequest(request)) {
+ // Only return true here, if the last hit testing phase 'BlockBackground' (or 'ChildBlockBackground' - depending on context) is executed.
+ // If we'd return true in the 'Foreground' phase, hit testing would stop immediately. For SVG only trees this doesn't matter.
+ // Though when we have a <foreignObject> subtree we need 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 to detect these hits anymore.
LayoutRect boundsRect(accumulatedOffset + location(), size());
if (locationInContainer.intersects(boundsRect)) {
updateHitTestResult(result, pointInBorderBox);
return false;
}
-bool RenderSVGRoot::hasRelativeIntrinsicLogicalWidth() const
-{
- SVGSVGElement* svg = toSVGSVGElement(node());
- ASSERT(svg);
- return svg->intrinsicWidth(SVGSVGElement::IgnoreCSSProperties).isPercent();
-}
-
-bool RenderSVGRoot::hasRelativeLogicalHeight() const
-{
- SVGSVGElement* svg = toSVGSVGElement(node());
- ASSERT(svg);
-
- return svg->intrinsicHeight(SVGSVGElement::IgnoreCSSProperties).isPercent();
-}
-
}
projects / platform / framework / web / crosswalk.git / blobdiff