| /* |
| * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer. |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, |
| * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR |
| * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF |
| * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| */ |
| |
| #include "core/layout/shapes/ShapeOutsideInfo.h" |
| |
| #include "core/inspector/ConsoleMessage.h" |
| #include "core/layout/FloatingObjects.h" |
| #include "core/layout/LayoutBlockFlow.h" |
| #include "core/layout/LayoutBox.h" |
| #include "core/layout/LayoutImage.h" |
| #include "core/layout/api/LineLayoutBlockFlow.h" |
| #include "platform/LengthFunctions.h" |
| #include "public/platform/Platform.h" |
| #include "wtf/AutoReset.h" |
| #include <memory> |
| |
| namespace blink { |
| |
| CSSBoxType referenceBox(const ShapeValue& shapeValue) { |
| if (shapeValue.cssBox() == BoxMissing) |
| return MarginBox; |
| return shapeValue.cssBox(); |
| } |
| |
| void ShapeOutsideInfo::setReferenceBoxLogicalSize( |
| LayoutSize newReferenceBoxLogicalSize) { |
| bool isHorizontalWritingMode = |
| m_layoutBox.containingBlock()->style()->isHorizontalWritingMode(); |
| switch (referenceBox(*m_layoutBox.style()->shapeOutside())) { |
| case MarginBox: |
| if (isHorizontalWritingMode) |
| newReferenceBoxLogicalSize.expand(m_layoutBox.marginWidth(), |
| m_layoutBox.marginHeight()); |
| else |
| newReferenceBoxLogicalSize.expand(m_layoutBox.marginHeight(), |
| m_layoutBox.marginWidth()); |
| break; |
| case BorderBox: |
| break; |
| case PaddingBox: |
| if (isHorizontalWritingMode) |
| newReferenceBoxLogicalSize.shrink(m_layoutBox.borderWidth(), |
| m_layoutBox.borderHeight()); |
| else |
| newReferenceBoxLogicalSize.shrink(m_layoutBox.borderHeight(), |
| m_layoutBox.borderWidth()); |
| break; |
| case ContentBox: |
| if (isHorizontalWritingMode) |
| newReferenceBoxLogicalSize.shrink(m_layoutBox.borderAndPaddingWidth(), |
| m_layoutBox.borderAndPaddingHeight()); |
| else |
| newReferenceBoxLogicalSize.shrink(m_layoutBox.borderAndPaddingHeight(), |
| m_layoutBox.borderAndPaddingWidth()); |
| break; |
| case BoxMissing: |
| ASSERT_NOT_REACHED(); |
| break; |
| } |
| |
| newReferenceBoxLogicalSize.clampNegativeToZero(); |
| |
| if (m_referenceBoxLogicalSize == newReferenceBoxLogicalSize) |
| return; |
| markShapeAsDirty(); |
| m_referenceBoxLogicalSize = newReferenceBoxLogicalSize; |
| } |
| |
| static bool checkShapeImageOrigin(Document& document, |
| const StyleImage& styleImage) { |
| if (styleImage.isGeneratedImage()) |
| return true; |
| |
| ASSERT(styleImage.cachedImage()); |
| ImageResourceContent& imageResource = *(styleImage.cachedImage()); |
| if (imageResource.isAccessAllowed(document.getSecurityOrigin())) |
| return true; |
| |
| const KURL& url = imageResource.url(); |
| String urlString = url.isNull() ? "''" : url.elidedString(); |
| document.addConsoleMessage( |
| ConsoleMessage::create(SecurityMessageSource, ErrorMessageLevel, |
| "Unsafe attempt to load URL " + urlString + ".")); |
| |
| return false; |
| } |
| |
| static LayoutRect getShapeImageMarginRect( |
| const LayoutBox& layoutBox, |
| const LayoutSize& referenceBoxLogicalSize) { |
| LayoutPoint marginBoxOrigin( |
| -layoutBox.marginLogicalLeft() - layoutBox.borderAndPaddingLogicalLeft(), |
| -layoutBox.marginBefore() - layoutBox.borderBefore() - |
| layoutBox.paddingBefore()); |
| LayoutSize marginBoxSizeDelta( |
| layoutBox.marginLogicalWidth() + layoutBox.borderAndPaddingLogicalWidth(), |
| layoutBox.marginLogicalHeight() + |
| layoutBox.borderAndPaddingLogicalHeight()); |
| LayoutSize marginRectSize(referenceBoxLogicalSize + marginBoxSizeDelta); |
| marginRectSize.clampNegativeToZero(); |
| return LayoutRect(marginBoxOrigin, marginRectSize); |
| } |
| |
| static bool isValidRasterShapeRect(const LayoutRect& rect) { |
| static double maxImageSizeBytes = 0; |
| if (!maxImageSizeBytes) { |
| size_t size32MaxBytes = |
| 0xFFFFFFFF / 4; // Some platforms don't limit maxDecodedImageBytes. |
| maxImageSizeBytes = |
| std::min(size32MaxBytes, Platform::current()->maxDecodedImageBytes()); |
| } |
| return (rect.width().toFloat() * rect.height().toFloat() * 4.0) < |
| maxImageSizeBytes; |
| } |
| |
| std::unique_ptr<Shape> ShapeOutsideInfo::createShapeForImage( |
| StyleImage* styleImage, |
| float shapeImageThreshold, |
| WritingMode writingMode, |
| float margin) const { |
| const LayoutSize& imageSize = |
| styleImage->imageSize(m_layoutBox, m_layoutBox.style()->effectiveZoom(), |
| m_referenceBoxLogicalSize); |
| |
| const LayoutRect& marginRect = |
| getShapeImageMarginRect(m_layoutBox, m_referenceBoxLogicalSize); |
| const LayoutRect& imageRect = |
| (m_layoutBox.isLayoutImage()) |
| ? toLayoutImage(m_layoutBox).replacedContentRect() |
| : LayoutRect(LayoutPoint(), imageSize); |
| |
| if (!isValidRasterShapeRect(marginRect) || |
| !isValidRasterShapeRect(imageRect)) { |
| m_layoutBox.document().addConsoleMessage( |
| ConsoleMessage::create(RenderingMessageSource, ErrorMessageLevel, |
| "The shape-outside image is too large.")); |
| return Shape::createEmptyRasterShape(writingMode, margin); |
| } |
| |
| ASSERT(!styleImage->isPendingImage()); |
| RefPtr<Image> image = |
| styleImage->image(m_layoutBox, flooredIntSize(imageSize), |
| m_layoutBox.style()->effectiveZoom()); |
| |
| return Shape::createRasterShape(image.get(), shapeImageThreshold, imageRect, |
| marginRect, writingMode, margin); |
| } |
| |
| const Shape& ShapeOutsideInfo::computedShape() const { |
| if (Shape* shape = m_shape.get()) |
| return *shape; |
| |
| AutoReset<bool> isInComputingShape(&m_isComputingShape, true); |
| |
| const ComputedStyle& style = *m_layoutBox.style(); |
| ASSERT(m_layoutBox.containingBlock()); |
| const ComputedStyle& containingBlockStyle = |
| *m_layoutBox.containingBlock()->style(); |
| |
| WritingMode writingMode = containingBlockStyle.getWritingMode(); |
| // Make sure contentWidth is not negative. This can happen when containing |
| // block has a vertical scrollbar and its content is smaller than the |
| // scrollbar width. |
| LayoutUnit maximumValue = |
| m_layoutBox.containingBlock() |
| ? std::max(LayoutUnit(), |
| m_layoutBox.containingBlock()->contentWidth()) |
| : LayoutUnit(); |
| float margin = floatValueForLength(m_layoutBox.style()->shapeMargin(), |
| maximumValue.toFloat()); |
| |
| float shapeImageThreshold = style.shapeImageThreshold(); |
| ASSERT(style.shapeOutside()); |
| const ShapeValue& shapeValue = *style.shapeOutside(); |
| |
| switch (shapeValue.type()) { |
| case ShapeValue::Shape: |
| ASSERT(shapeValue.shape()); |
| m_shape = Shape::createShape( |
| shapeValue.shape(), m_referenceBoxLogicalSize, writingMode, margin); |
| break; |
| case ShapeValue::Image: |
| ASSERT(shapeValue.isImageValid()); |
| m_shape = createShapeForImage(shapeValue.image(), shapeImageThreshold, |
| writingMode, margin); |
| break; |
| case ShapeValue::Box: { |
| const FloatRoundedRect& shapeRect = style.getRoundedBorderFor( |
| LayoutRect(LayoutPoint(), m_referenceBoxLogicalSize), |
| m_layoutBox.view()); |
| m_shape = Shape::createLayoutBoxShape(shapeRect, writingMode, margin); |
| break; |
| } |
| } |
| |
| ASSERT(m_shape); |
| return *m_shape; |
| } |
| |
| inline LayoutUnit borderBeforeInWritingMode(const LayoutBox& layoutBox, |
| WritingMode writingMode) { |
| switch (writingMode) { |
| case WritingMode::HorizontalTb: |
| return LayoutUnit(layoutBox.borderTop()); |
| case WritingMode::VerticalLr: |
| return LayoutUnit(layoutBox.borderLeft()); |
| case WritingMode::VerticalRl: |
| return LayoutUnit(layoutBox.borderRight()); |
| } |
| |
| ASSERT_NOT_REACHED(); |
| return LayoutUnit(layoutBox.borderBefore()); |
| } |
| |
| inline LayoutUnit borderAndPaddingBeforeInWritingMode( |
| const LayoutBox& layoutBox, |
| WritingMode writingMode) { |
| switch (writingMode) { |
| case WritingMode::HorizontalTb: |
| return layoutBox.borderTop() + layoutBox.paddingTop(); |
| case WritingMode::VerticalLr: |
| return layoutBox.borderLeft() + layoutBox.paddingLeft(); |
| case WritingMode::VerticalRl: |
| return layoutBox.borderRight() + layoutBox.paddingRight(); |
| } |
| |
| ASSERT_NOT_REACHED(); |
| return layoutBox.borderAndPaddingBefore(); |
| } |
| |
| LayoutUnit ShapeOutsideInfo::logicalTopOffset() const { |
| switch (referenceBox(*m_layoutBox.style()->shapeOutside())) { |
| case MarginBox: |
| return -m_layoutBox.marginBefore(m_layoutBox.containingBlock()->style()); |
| case BorderBox: |
| return LayoutUnit(); |
| case PaddingBox: |
| return borderBeforeInWritingMode( |
| m_layoutBox, |
| m_layoutBox.containingBlock()->style()->getWritingMode()); |
| case ContentBox: |
| return borderAndPaddingBeforeInWritingMode( |
| m_layoutBox, |
| m_layoutBox.containingBlock()->style()->getWritingMode()); |
| case BoxMissing: |
| break; |
| } |
| |
| ASSERT_NOT_REACHED(); |
| return LayoutUnit(); |
| } |
| |
| inline LayoutUnit borderStartWithStyleForWritingMode( |
| const LayoutBox& layoutBox, |
| const ComputedStyle* style) { |
| if (style->isHorizontalWritingMode()) { |
| if (style->isLeftToRightDirection()) |
| return LayoutUnit(layoutBox.borderLeft()); |
| |
| return LayoutUnit(layoutBox.borderRight()); |
| } |
| if (style->isLeftToRightDirection()) |
| return LayoutUnit(layoutBox.borderTop()); |
| |
| return LayoutUnit(layoutBox.borderBottom()); |
| } |
| |
| inline LayoutUnit borderAndPaddingStartWithStyleForWritingMode( |
| const LayoutBox& layoutBox, |
| const ComputedStyle* style) { |
| if (style->isHorizontalWritingMode()) { |
| if (style->isLeftToRightDirection()) |
| return layoutBox.borderLeft() + layoutBox.paddingLeft(); |
| |
| return layoutBox.borderRight() + layoutBox.paddingRight(); |
| } |
| if (style->isLeftToRightDirection()) |
| return layoutBox.borderTop() + layoutBox.paddingTop(); |
| |
| return layoutBox.borderBottom() + layoutBox.paddingBottom(); |
| } |
| |
| LayoutUnit ShapeOutsideInfo::logicalLeftOffset() const { |
| switch (referenceBox(*m_layoutBox.style()->shapeOutside())) { |
| case MarginBox: |
| return -m_layoutBox.marginStart(m_layoutBox.containingBlock()->style()); |
| case BorderBox: |
| return LayoutUnit(); |
| case PaddingBox: |
| return borderStartWithStyleForWritingMode( |
| m_layoutBox, m_layoutBox.containingBlock()->style()); |
| case ContentBox: |
| return borderAndPaddingStartWithStyleForWritingMode( |
| m_layoutBox, m_layoutBox.containingBlock()->style()); |
| case BoxMissing: |
| break; |
| } |
| |
| ASSERT_NOT_REACHED(); |
| return LayoutUnit(); |
| } |
| |
| bool ShapeOutsideInfo::isEnabledFor(const LayoutBox& box) { |
| ShapeValue* shapeValue = box.style()->shapeOutside(); |
| if (!box.isFloating() || !shapeValue) |
| return false; |
| |
| switch (shapeValue->type()) { |
| case ShapeValue::Shape: |
| return shapeValue->shape(); |
| case ShapeValue::Image: |
| return shapeValue->isImageValid() && |
| checkShapeImageOrigin(box.document(), *(shapeValue->image())); |
| case ShapeValue::Box: |
| return true; |
| } |
| |
| return false; |
| } |
| |
| ShapeOutsideDeltas ShapeOutsideInfo::computeDeltasForContainingBlockLine( |
| const LineLayoutBlockFlow& containingBlock, |
| const FloatingObject& floatingObject, |
| LayoutUnit lineTop, |
| LayoutUnit lineHeight) { |
| ASSERT(lineHeight >= 0); |
| |
| LayoutUnit borderBoxTop = containingBlock.logicalTopForFloat(floatingObject) + |
| containingBlock.marginBeforeForChild(m_layoutBox); |
| LayoutUnit borderBoxLineTop = lineTop - borderBoxTop; |
| |
| if (isShapeDirty() || |
| !m_shapeOutsideDeltas.isForLine(borderBoxLineTop, lineHeight)) { |
| LayoutUnit referenceBoxLineTop = borderBoxLineTop - logicalTopOffset(); |
| LayoutUnit floatMarginBoxWidth = std::max( |
| containingBlock.logicalWidthForFloat(floatingObject), LayoutUnit()); |
| |
| if (computedShape().lineOverlapsShapeMarginBounds(referenceBoxLineTop, |
| lineHeight)) { |
| LineSegment segment = computedShape().getExcludedInterval( |
| (borderBoxLineTop - logicalTopOffset()), |
| std::min(lineHeight, shapeLogicalBottom() - borderBoxLineTop)); |
| if (segment.isValid) { |
| LayoutUnit logicalLeftMargin = |
| containingBlock.style()->isLeftToRightDirection() |
| ? containingBlock.marginStartForChild(m_layoutBox) |
| : containingBlock.marginEndForChild(m_layoutBox); |
| LayoutUnit rawLeftMarginBoxDelta( |
| segment.logicalLeft + logicalLeftOffset() + logicalLeftMargin); |
| LayoutUnit leftMarginBoxDelta = clampTo<LayoutUnit>( |
| rawLeftMarginBoxDelta, LayoutUnit(), floatMarginBoxWidth); |
| |
| LayoutUnit logicalRightMargin = |
| containingBlock.style()->isLeftToRightDirection() |
| ? containingBlock.marginEndForChild(m_layoutBox) |
| : containingBlock.marginStartForChild(m_layoutBox); |
| LayoutUnit rawRightMarginBoxDelta( |
| segment.logicalRight + logicalLeftOffset() - |
| containingBlock.logicalWidthForChild(m_layoutBox) - |
| logicalRightMargin); |
| LayoutUnit rightMarginBoxDelta = clampTo<LayoutUnit>( |
| rawRightMarginBoxDelta, -floatMarginBoxWidth, LayoutUnit()); |
| |
| m_shapeOutsideDeltas = |
| ShapeOutsideDeltas(leftMarginBoxDelta, rightMarginBoxDelta, true, |
| borderBoxLineTop, lineHeight); |
| return m_shapeOutsideDeltas; |
| } |
| } |
| |
| // Lines that do not overlap the shape should act as if the float |
| // wasn't there for layout purposes. So we set the deltas to remove the |
| // entire width of the float. |
| m_shapeOutsideDeltas = |
| ShapeOutsideDeltas(floatMarginBoxWidth, -floatMarginBoxWidth, false, |
| borderBoxLineTop, lineHeight); |
| } |
| |
| return m_shapeOutsideDeltas; |
| } |
| |
| LayoutRect ShapeOutsideInfo::computedShapePhysicalBoundingBox() const { |
| LayoutRect physicalBoundingBox = |
| computedShape().shapeMarginLogicalBoundingBox(); |
| physicalBoundingBox.setX(physicalBoundingBox.x() + logicalLeftOffset()); |
| |
| if (m_layoutBox.style()->isFlippedBlocksWritingMode()) |
| physicalBoundingBox.setY(m_layoutBox.logicalHeight() - |
| physicalBoundingBox.maxY()); |
| else |
| physicalBoundingBox.setY(physicalBoundingBox.y() + logicalTopOffset()); |
| |
| if (!m_layoutBox.style()->isHorizontalWritingMode()) |
| physicalBoundingBox = physicalBoundingBox.transposedRect(); |
| else |
| physicalBoundingBox.setY(physicalBoundingBox.y() + logicalTopOffset()); |
| |
| return physicalBoundingBox; |
| } |
| |
| FloatPoint ShapeOutsideInfo::shapeToLayoutObjectPoint(FloatPoint point) const { |
| FloatPoint result = FloatPoint(point.x() + logicalLeftOffset(), |
| point.y() + logicalTopOffset()); |
| if (m_layoutBox.style()->isFlippedBlocksWritingMode()) |
| result.setY(m_layoutBox.logicalHeight() - result.y()); |
| if (!m_layoutBox.style()->isHorizontalWritingMode()) |
| result = result.transposedPoint(); |
| return result; |
| } |
| |
| FloatSize ShapeOutsideInfo::shapeToLayoutObjectSize(FloatSize size) const { |
| if (!m_layoutBox.style()->isHorizontalWritingMode()) |
| return size.transposedSize(); |
| return size; |
| } |
| |
| } // namespace blink |
