FloatSize SVGSVGElement::currentViewportSize() const {
if (!layoutObject())
return FloatSize();
if (layoutObject()->isSVGRoot()) {
LayoutRect contentBoxRect =
toLayoutSVGRoot(layoutObject())->contentBoxRect();
return FloatSize(
contentBoxRect.width() / layoutObject()->style()->effectiveZoom(),
contentBoxRect.height() / layoutObject()->style()->effectiveZoom());
}
FloatRect viewportRect =
toLayoutSVGViewportContainer(layoutObject())->viewport();
return FloatSize(viewportRect.width(), viewportRect.height());
}
void PaintPropertyTreeBuilder::updateSvgLocalToBorderBoxTransform(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
{
if (!object.isSVGRoot())
return;
AffineTransform transform = AffineTransform::translation(context.paintOffset.x().toFloat(), context.paintOffset.y().toFloat());
transform *= toLayoutSVGRoot(object).localToBorderBoxTransform();
if (transform.isIdentity())
return;
RefPtr<TransformPaintPropertyNode> svgLocalToBorderBoxTransform = TransformPaintPropertyNode::create(
transform, FloatPoint3D(0, 0, 0), context.currentTransform);
context.currentTransform = svgLocalToBorderBoxTransform.get();
context.paintOffset = LayoutPoint();
object.getMutableForPainting().ensureObjectPaintProperties().setSvgLocalToBorderBoxTransform(svgLocalToBorderBoxTransform.release());
}
FloatRect SVGSVGElement::currentViewBoxRect() const
{
if (m_useCurrentView)
return m_viewSpec ? m_viewSpec->viewBox()->currentValue()->value() : FloatRect();
FloatRect useViewBox = viewBox()->currentValue()->value();
if (!useViewBox.isEmpty())
return useViewBox;
if (!layoutObject() || !layoutObject()->isSVGRoot())
return FloatRect();
if (!toLayoutSVGRoot(layoutObject())->isEmbeddedThroughSVGImage())
return FloatRect();
// If no viewBox is specified but non-relative width/height values, then we
// should always synthesize a viewBox if we're embedded through a SVGImage.
return FloatRect(FloatPoint(), FloatSize(floatValueForLength(intrinsicWidth(), 0), floatValueForLength(intrinsicHeight(), 0)));
}
AffineTransform SVGSVGElement::localCoordinateSpaceTransform(SVGElement::CTMScope mode) const
{
AffineTransform viewBoxTransform;
if (!hasEmptyViewBox()) {
FloatSize size = currentViewportSize();
viewBoxTransform = viewBoxToViewTransform(size.width(), size.height());
}
AffineTransform transform;
if (!isOutermostSVGSVGElement()) {
SVGLengthContext lengthContext(this);
transform.translate(m_x->currentValue()->value(lengthContext), m_y->currentValue()->value(lengthContext));
} else if (mode == SVGElement::ScreenScope) {
if (LayoutObject* layoutObject = this->layoutObject()) {
FloatPoint location;
float zoomFactor = 1;
// At the SVG/HTML boundary (aka LayoutSVGRoot), we apply the localToBorderBoxTransform
// to map an element from SVG viewport coordinates to CSS box coordinates.
// LayoutSVGRoot's localToAbsolute method expects CSS box coordinates.
// We also need to adjust for the zoom level factored into CSS coordinates (bug #96361).
if (layoutObject->isSVGRoot()) {
location = toLayoutSVGRoot(layoutObject)->localToBorderBoxTransform().mapPoint(location);
zoomFactor = 1 / layoutObject->style()->effectiveZoom();
}
// Translate in our CSS parent coordinate space
// FIXME: This doesn't work correctly with CSS transforms.
location = layoutObject->localToAbsolute(location, UseTransforms);
location.scale(zoomFactor, zoomFactor);
// Be careful here! localToBorderBoxTransform() included the x/y offset coming from the viewBoxToViewTransform(),
// so we have to subtract it here (original cause of bug #27183)
transform.translate(location.x() - viewBoxTransform.e(), location.y() - viewBoxTransform.f());
// Respect scroll offset.
if (FrameView* view = document().view()) {
LayoutSize scrollOffset(view->scrollOffset());
scrollOffset.scale(zoomFactor);
transform.translate(-scrollOffset.width(), -scrollOffset.height());
}
}
}
return transform.multiply(viewBoxTransform);
}
void SVGImage::setContainerSize(const IntSize& size)
{
if (!usesContainerSize())
return;
SVGSVGElement* rootElement = svgRootElement(m_page.get());
if (!rootElement)
return;
FrameView* view = frameView();
view->resize(this->containerSize());
LayoutSVGRoot* layoutObject = toLayoutSVGRoot(rootElement->layoutObject());
if (!layoutObject)
return;
layoutObject->setContainerSize(size);
}
void PaintPropertyTreeBuilder::updateOverflowClip(
const LayoutObject& object,
PaintPropertyTreeBuilderContext& context) {
if (!object.isBox())
return;
const LayoutBox& box = toLayoutBox(object);
// The <input> elements can't have contents thus CSS overflow property doesn't
// apply. However for layout purposes we do generate child layout objects for
// them, e.g. button label. We should clip the overflow from those children.
// This is called control clip and we technically treat them like overflow
// clip.
LayoutRect clipRect;
if (box.hasControlClip()) {
clipRect = box.controlClipRect(context.current.paintOffset);
} else if (box.hasOverflowClip() || box.styleRef().containsPaint() ||
(box.isSVGRoot() &&
toLayoutSVGRoot(box).shouldApplyViewportClip())) {
clipRect = box.overflowClipRect(context.current.paintOffset);
} else {
if (auto* properties = object.getMutableForPainting().paintProperties()) {
properties->clearInnerBorderRadiusClip();
properties->clearOverflowClip();
}
return;
}
if (box.styleRef().hasBorderRadius()) {
auto innerBorder = box.styleRef().getRoundedInnerBorderFor(
LayoutRect(context.current.paintOffset, box.size()));
context.current.clip =
object.getMutableForPainting()
.ensurePaintProperties()
.updateInnerBorderRadiusClip(
context.current.clip, context.current.transform, innerBorder);
} else if (auto* properties =
object.getMutableForPainting().paintProperties()) {
properties->clearInnerBorderRadiusClip();
}
context.current.clip =
object.getMutableForPainting().ensurePaintProperties().updateOverflowClip(
context.current.clip, context.current.transform,
FloatRoundedRect(FloatRect(clipRect)));
}
void SVGLayoutSupport::mapLocalToAncestor(const LayoutObject* object,
const LayoutBoxModelObject* ancestor,
TransformState& transformState,
MapCoordinatesFlags flags) {
transformState.applyTransform(object->localToSVGParentTransform());
LayoutObject* parent = object->parent();
// At the SVG/HTML boundary (aka LayoutSVGRoot), we apply the
// localToBorderBoxTransform to map an element from SVG viewport coordinates
// to CSS box coordinates.
// LayoutSVGRoot's mapLocalToAncestor method expects CSS box coordinates.
if (parent->isSVGRoot())
transformState.applyTransform(
toLayoutSVGRoot(parent)->localToBorderBoxTransform());
parent->mapLocalToAncestor(ancestor, transformState, flags);
}
const LayoutObject* SVGLayoutSupport::pushMappingToContainer(const LayoutObject* object, const LayoutBoxModelObject* ancestorToStopAt, LayoutGeometryMap& geometryMap)
{
ASSERT_UNUSED(ancestorToStopAt, ancestorToStopAt != object);
LayoutObject* parent = object->parent();
// At the SVG/HTML boundary (aka LayoutSVGRoot), we apply the localToBorderBoxTransform
// to map an element from SVG viewport coordinates to CSS box coordinates.
// LayoutSVGRoot's mapLocalToContainer method expects CSS box coordinates.
if (parent->isSVGRoot()) {
TransformationMatrix matrix(object->localToParentTransform());
matrix.multiply(toLayoutSVGRoot(parent)->localToBorderBoxTransform());
geometryMap.push(object, matrix);
} else {
geometryMap.push(object, object->localToParentTransform());
}
return parent;
}
IntSize SVGImage::containerSize() const
{
SVGSVGElement* rootElement = svgRootElement(m_page.get());
if (!rootElement)
return IntSize();
LayoutSVGRoot* layoutObject = toLayoutSVGRoot(rootElement->layoutObject());
if (!layoutObject)
return IntSize();
// If a container size is available it has precedence.
IntSize containerSize = layoutObject->containerSize();
if (!containerSize.isEmpty())
return containerSize;
// Assure that a container size is always given for a non-identity zoom level.
ASSERT(layoutObject->style()->effectiveZoom() == 1);
FloatSize intrinsicSize;
double intrinsicRatio = 0;
layoutObject->computeIntrinsicRatioInformation(intrinsicSize, intrinsicRatio);
if (intrinsicSize.isEmpty() && intrinsicRatio) {
if (!intrinsicSize.width() && intrinsicSize.height())
intrinsicSize.setWidth(intrinsicSize.height() * intrinsicRatio);
else if (intrinsicSize.width() && !intrinsicSize.height())
intrinsicSize.setHeight(intrinsicSize.width() / intrinsicRatio);
}
// TODO(davve): In order to maintain aspect ratio the intrinsic
// size is faked from the viewBox as a last resort. This may cause
// unwanted side effects. Preferably we should be able to signal
// the intrinsic ratio in another way.
if (intrinsicSize.isEmpty())
intrinsicSize = rootElement->currentViewBoxRect().size();
if (!intrinsicSize.isEmpty())
return expandedIntSize(intrinsicSize);
// As last resort, use CSS replaced element fallback size.
return IntSize(300, 150);
}
void SVGLayoutSupport::mapLocalToContainer(const LayoutObject* object, const LayoutBoxModelObject* paintInvalidationContainer, TransformState& transformState, bool* wasFixed, const PaintInvalidationState* paintInvalidationState)
{
transformState.applyTransform(object->localToParentTransform());
if (paintInvalidationState && paintInvalidationState->canMapToContainer(paintInvalidationContainer)) {
// |svgTransform| contains localToBorderBoxTransform mentioned below.
transformState.applyTransform(paintInvalidationState->svgTransform());
transformState.move(paintInvalidationState->paintOffset());
return;
}
LayoutObject* parent = object->parent();
// At the SVG/HTML boundary (aka LayoutSVGRoot), we apply the localToBorderBoxTransform
// to map an element from SVG viewport coordinates to CSS box coordinates.
// LayoutSVGRoot's mapLocalToContainer method expects CSS box coordinates.
if (parent->isSVGRoot())
transformState.applyTransform(toLayoutSVGRoot(parent)->localToBorderBoxTransform());
MapCoordinatesFlags mode = UseTransforms;
parent->mapLocalToContainer(paintInvalidationContainer, transformState, mode, wasFixed, paintInvalidationState);
}
void PaintLayerClipper::calculateClipRects(const ClipRectsContext& context,
ClipRects& clipRects) const {
const LayoutBoxModelObject& layoutObject = *m_layer.layoutObject();
if (!m_layer.parent() &&
!RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
// The root layer's clip rect is always infinite.
clipRects.reset(LayoutRect(LayoutRect::infiniteIntRect()));
return;
}
bool isClippingRoot = &m_layer == context.rootLayer;
// For transformed layers, the root layer was shifted to be us, so there is no
// need to examine the parent. We want to cache clip rects with us as the
// root.
PaintLayer* parentLayer = !isClippingRoot ? m_layer.parent() : nullptr;
// Ensure that our parent's clip has been calculated so that we can examine
// the values.
if (parentLayer) {
parentLayer->clipper().getOrCalculateClipRects(context, clipRects);
} else {
clipRects.reset(LayoutRect(LayoutRect::infiniteIntRect()));
}
adjustClipRectsForChildren(layoutObject, clipRects);
if (shouldClipOverflow(context) || layoutObject.hasClip() ||
(layoutObject.isSVGRoot() &&
toLayoutSVGRoot(&layoutObject)->shouldApplyViewportClip())) {
// This offset cannot use convertToLayerCoords, because sometimes our
// rootLayer may be across some transformed layer boundary, for example, in
// the PaintLayerCompositor overlapMap, where clipRects are needed in view
// space.
applyClipRects(context, layoutObject,
roundedLayoutPoint(layoutObject.localToAncestorPoint(
FloatPoint(), context.rootLayer->layoutObject())),
clipRects);
}
}
bool SVGSVGElement::shouldSynthesizeViewBox() const {
return layoutObject() && layoutObject()->isSVGRoot() &&
toLayoutSVGRoot(layoutObject())->isEmbeddedThroughSVGImage();
}
static bool shouldApplyViewportClip(const LayoutReplaced& layoutReplaced)
{
return !layoutReplaced.isSVGRoot() || toLayoutSVGRoot(&layoutReplaced)->shouldApplyViewportClip();
}
