| /* |
| * Copyright (C) 2018 Apple Inc. 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 APPLE INC. AND ITS CONTRIBUTORS ``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 APPLE INC. OR ITS CONTRIBUTORS |
| * 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. |
| */ |
| |
| #pragma once |
| |
| #if ENABLE(LAYOUT_FORMATTING_CONTEXT) |
| |
| #include "DisplayRect.h" |
| #include "LayoutUnits.h" |
| #include <wtf/IsoMalloc.h> |
| |
| namespace WebCore { |
| namespace Display { |
| |
| class Box { |
| WTF_MAKE_ISO_ALLOCATED(Box); |
| public: |
| Box(const Box&); |
| Box() = default; |
| ~Box(); |
| |
| LayoutUnit top() const; |
| LayoutUnit left() const; |
| LayoutUnit bottom() const { return top() + height(); } |
| LayoutUnit right() const { return left() + width(); } |
| |
| LayoutPoint topLeft() const; |
| LayoutPoint bottomRight() const { return { right(), bottom() }; } |
| |
| LayoutSize size() const { return { width(), height() }; } |
| LayoutUnit width() const { return borderLeft() + paddingBoxWidth() + borderRight(); } |
| LayoutUnit height() const { return borderTop() + paddingBoxHeight() + borderBottom(); } |
| bool isEmpty() const { return size().isEmpty(); } |
| Rect rect() const { return { top(), left(), width(), height() }; } |
| Rect rectWithMargin() const; |
| |
| Layout::UsedVerticalMargin verticalMargin() const; |
| Layout::UsedHorizontalMargin horizontalMargin() const; |
| LayoutUnit marginBefore() const; |
| LayoutUnit marginStart() const; |
| LayoutUnit marginAfter() const; |
| LayoutUnit marginEnd() const; |
| bool hasCollapsedThroughMargin() const { return m_verticalMargin.isCollapsedThrough(); } |
| bool hasClearance() const { return m_hasClearance; } |
| |
| LayoutUnit nonCollapsedMarginBefore() const; |
| LayoutUnit nonCollapsedMarginAfter() const; |
| Optional<LayoutUnit> computedMarginStart() const; |
| Optional<LayoutUnit> computedMarginEnd() const; |
| |
| LayoutUnit borderTop() const; |
| LayoutUnit borderLeft() const; |
| LayoutUnit borderBottom() const; |
| LayoutUnit borderRight() const; |
| LayoutUnit verticalBorder() const { return borderTop() + borderBottom(); } |
| LayoutUnit horizontalBorder() const { return borderLeft() + borderRight(); } |
| |
| Optional<LayoutUnit> paddingTop() const; |
| Optional<LayoutUnit> paddingLeft() const; |
| Optional<LayoutUnit> paddingBottom() const; |
| Optional<LayoutUnit> paddingRight() const; |
| Optional<LayoutUnit> verticalPadding() const; |
| Optional<LayoutUnit> horizontalPadding() const; |
| |
| LayoutUnit contentBoxTop() const { return paddingBoxTop() + paddingTop().valueOr(0); } |
| LayoutUnit contentBoxLeft() const { return paddingBoxLeft() + paddingLeft().valueOr(0); } |
| LayoutUnit contentBoxBottom() const { return contentBoxTop() + contentBoxHeight(); } |
| LayoutUnit contentBoxRight() const { return contentBoxLeft() + contentBoxWidth(); } |
| LayoutUnit contentBoxHeight() const; |
| LayoutUnit contentBoxWidth() const; |
| |
| LayoutUnit paddingBoxTop() const { return borderTop(); } |
| LayoutUnit paddingBoxLeft() const { return borderLeft(); } |
| LayoutUnit paddingBoxBottom() const { return paddingBoxTop() + paddingBoxHeight(); } |
| LayoutUnit paddingBoxRight() const { return paddingBoxLeft() + paddingBoxWidth(); } |
| LayoutUnit paddingBoxHeight() const { return paddingTop().valueOr(0) + contentBoxHeight() + paddingBottom().valueOr(0); } |
| LayoutUnit paddingBoxWidth() const { return paddingLeft().valueOr(0) + contentBoxWidth() + paddingRight().valueOr(0); } |
| |
| LayoutUnit borderBoxHeight() const { return borderTop() + paddingBoxHeight() + borderBottom(); } |
| LayoutUnit borderBoxWidth() const { return borderLeft() + paddingBoxWidth() + borderRight(); } |
| LayoutUnit marginBoxHeight() const { return marginBefore() + borderBoxHeight() + marginAfter(); } |
| LayoutUnit marginBoxWidth() const { return marginStart() + borderBoxWidth() + marginEnd(); } |
| |
| LayoutUnit verticalMarginBorderAndPadding() const { return marginBefore() + verticalBorder() + verticalPadding().valueOr(0) + marginAfter(); } |
| LayoutUnit horizontalMarginBorderAndPadding() const { return marginStart() + horizontalBorder() + horizontalPadding().valueOr(0) + marginEnd(); } |
| |
| Rect marginBox() const; |
| Rect nonCollapsedMarginBox() const; |
| |
| Rect borderBox() const; |
| Rect paddingBox() const; |
| Rect contentBox() const; |
| |
| #if ASSERT_ENABLED |
| void setHasPrecomputedMarginBefore() { m_hasPrecomputedMarginBefore = true; } |
| #endif |
| |
| void setTopLeft(const LayoutPoint&); |
| void setTop(LayoutUnit); |
| void setLeft(LayoutUnit); |
| void moveHorizontally(LayoutUnit offset) { m_topLeft.move(offset, 0_lu); } |
| void moveVertically(LayoutUnit offset) { m_topLeft.move(0_lu, offset); } |
| void move(const LayoutSize& size) { m_topLeft.move(size); } |
| void moveBy(LayoutPoint offset) { m_topLeft.moveBy(offset); } |
| |
| void setContentBoxHeight(LayoutUnit); |
| void setContentBoxWidth(LayoutUnit); |
| |
| void setHorizontalMargin(Layout::UsedHorizontalMargin); |
| void setVerticalMargin(Layout::UsedVerticalMargin); |
| void setHorizontalComputedMargin(Layout::ComputedHorizontalMargin); |
| void setHasClearance() { m_hasClearance = true; } |
| |
| void setBorder(Layout::Edges); |
| |
| void setVerticalPadding(Layout::VerticalEdges); |
| void setPadding(Optional<Layout::Edges>); |
| |
| private: |
| #if ASSERT_ENABLED |
| void invalidateMargin(); |
| void invalidateBorder() { m_hasValidBorder = false; } |
| void invalidatePadding() { m_hasValidPadding = false; } |
| void invalidatePrecomputedMarginBefore() { m_hasPrecomputedMarginBefore = false; } |
| |
| void setHasValidTop() { m_hasValidTop = true; } |
| void setHasValidLeft() { m_hasValidLeft = true; } |
| void setHasValidVerticalMargin() { m_hasValidVerticalMargin = true; } |
| void setHasValidVerticalNonCollapsedMargin() { m_hasValidVerticalNonCollapsedMargin = true; } |
| void setHasValidHorizontalComputedMargin() { m_hasValidHorizontalComputedMargin = true; } |
| void setHasValidHorizontalMargin() { m_hasValidHorizontalMargin = true; } |
| |
| void setHasValidBorder() { m_hasValidBorder = true; } |
| void setHasValidPadding() { m_hasValidPadding = true; } |
| |
| void setHasValidContentHeight() { m_hasValidContentHeight = true; } |
| void setHasValidContentWidth() { m_hasValidContentWidth = true; } |
| #endif // ASSERT_ENABLED |
| |
| LayoutPoint m_topLeft; |
| LayoutUnit m_contentWidth; |
| LayoutUnit m_contentHeight; |
| |
| Layout::UsedHorizontalMargin m_horizontalMargin; |
| Layout::UsedVerticalMargin m_verticalMargin; |
| Layout::ComputedHorizontalMargin m_horizontalComputedMargin; |
| bool m_hasClearance { false }; |
| |
| Layout::Edges m_border; |
| Optional<Layout::Edges> m_padding; |
| |
| #if ASSERT_ENABLED |
| bool m_hasValidTop { false }; |
| bool m_hasValidLeft { false }; |
| bool m_hasValidHorizontalMargin { false }; |
| bool m_hasValidVerticalMargin { false }; |
| bool m_hasValidVerticalNonCollapsedMargin { false }; |
| bool m_hasValidHorizontalComputedMargin { false }; |
| bool m_hasValidBorder { false }; |
| bool m_hasValidPadding { false }; |
| bool m_hasValidContentHeight { false }; |
| bool m_hasValidContentWidth { false }; |
| bool m_hasPrecomputedMarginBefore { false }; |
| #endif // ASSERT_ENABLED |
| }; |
| |
| #if ASSERT_ENABLED |
| inline void Box::invalidateMargin() |
| { |
| m_hasValidHorizontalMargin = false; |
| m_hasValidVerticalMargin = false; |
| } |
| #endif |
| |
| inline LayoutUnit Box::top() const |
| { |
| ASSERT(m_hasValidTop && (m_hasPrecomputedMarginBefore || m_hasValidVerticalMargin)); |
| return m_topLeft.y(); |
| } |
| |
| inline LayoutUnit Box::left() const |
| { |
| ASSERT(m_hasValidLeft && m_hasValidHorizontalMargin); |
| return m_topLeft.x(); |
| } |
| |
| inline LayoutPoint Box::topLeft() const |
| { |
| ASSERT(m_hasValidTop && (m_hasPrecomputedMarginBefore || m_hasValidVerticalMargin)); |
| ASSERT(m_hasValidLeft && m_hasValidHorizontalMargin); |
| return m_topLeft; |
| } |
| |
| inline void Box::setTopLeft(const LayoutPoint& topLeft) |
| { |
| #if ASSERT_ENABLED |
| setHasValidTop(); |
| setHasValidLeft(); |
| #endif |
| m_topLeft = topLeft; |
| } |
| |
| inline void Box::setTop(LayoutUnit top) |
| { |
| #if ASSERT_ENABLED |
| setHasValidTop(); |
| #endif |
| m_topLeft.setY(top); |
| } |
| |
| inline void Box::setLeft(LayoutUnit left) |
| { |
| #if ASSERT_ENABLED |
| setHasValidLeft(); |
| #endif |
| m_topLeft.setX(left); |
| } |
| |
| inline void Box::setContentBoxHeight(LayoutUnit height) |
| { |
| #if ASSERT_ENABLED |
| setHasValidContentHeight(); |
| #endif |
| m_contentHeight = height; |
| } |
| |
| inline void Box::setContentBoxWidth(LayoutUnit width) |
| { |
| #if ASSERT_ENABLED |
| setHasValidContentWidth(); |
| #endif |
| m_contentWidth = width; |
| } |
| |
| inline LayoutUnit Box::contentBoxHeight() const |
| { |
| ASSERT(m_hasValidContentHeight); |
| return m_contentHeight; |
| } |
| |
| inline LayoutUnit Box::contentBoxWidth() const |
| { |
| ASSERT(m_hasValidContentWidth); |
| return m_contentWidth; |
| } |
| |
| inline void Box::setHorizontalMargin(Layout::UsedHorizontalMargin margin) |
| { |
| #if ASSERT_ENABLED |
| setHasValidHorizontalMargin(); |
| #endif |
| m_horizontalMargin = margin; |
| } |
| |
| inline void Box::setVerticalMargin(Layout::UsedVerticalMargin margin) |
| { |
| #if ASSERT_ENABLED |
| setHasValidVerticalMargin(); |
| setHasValidVerticalNonCollapsedMargin(); |
| invalidatePrecomputedMarginBefore(); |
| #endif |
| m_verticalMargin = margin; |
| } |
| |
| inline void Box::setHorizontalComputedMargin(Layout::ComputedHorizontalMargin margin) |
| { |
| #if ASSERT_ENABLED |
| setHasValidHorizontalComputedMargin(); |
| #endif |
| m_horizontalComputedMargin = margin; |
| } |
| |
| inline void Box::setBorder(Layout::Edges border) |
| { |
| #if ASSERT_ENABLED |
| setHasValidBorder(); |
| #endif |
| m_border = border; |
| } |
| |
| inline void Box::setPadding(Optional<Layout::Edges> padding) |
| { |
| #if ASSERT_ENABLED |
| setHasValidPadding(); |
| #endif |
| m_padding = padding; |
| } |
| |
| inline void Box::setVerticalPadding(Layout::VerticalEdges verticalPadding) |
| { |
| #if ASSERT_ENABLED |
| setHasValidPadding(); |
| #endif |
| m_padding = Layout::Edges { m_padding ? m_padding->horizontal : Layout::HorizontalEdges(), verticalPadding }; |
| } |
| |
| inline Rect Box::rectWithMargin() const |
| { |
| auto marginAfter = this->marginAfter(); |
| if (m_verticalMargin.collapsedValues().isCollapsedThrough) |
| marginAfter = 0; |
| return { top() - marginBefore(), left() - marginStart(), marginStart() + width() + marginEnd(), marginBefore() + height() + marginAfter }; |
| } |
| |
| inline Layout::UsedVerticalMargin Box::verticalMargin() const |
| { |
| ASSERT(m_hasValidVerticalMargin); |
| return m_verticalMargin; |
| } |
| |
| inline Layout::UsedHorizontalMargin Box::horizontalMargin() const |
| { |
| ASSERT(m_hasValidHorizontalMargin); |
| return m_horizontalMargin; |
| } |
| |
| inline LayoutUnit Box::marginBefore() const |
| { |
| ASSERT(m_hasValidVerticalMargin); |
| return m_verticalMargin.before(); |
| } |
| |
| inline LayoutUnit Box::marginStart() const |
| { |
| ASSERT(m_hasValidHorizontalMargin); |
| return m_horizontalMargin.start; |
| } |
| |
| inline LayoutUnit Box::marginAfter() const |
| { |
| ASSERT(m_hasValidVerticalMargin); |
| return m_verticalMargin.after(); |
| } |
| |
| inline LayoutUnit Box::marginEnd() const |
| { |
| ASSERT(m_hasValidHorizontalMargin); |
| return m_horizontalMargin.end; |
| } |
| |
| inline LayoutUnit Box::nonCollapsedMarginBefore() const |
| { |
| ASSERT(m_hasValidVerticalNonCollapsedMargin); |
| return m_verticalMargin.nonCollapsedValues().before; |
| } |
| |
| inline LayoutUnit Box::nonCollapsedMarginAfter() const |
| { |
| ASSERT(m_hasValidVerticalNonCollapsedMargin); |
| return m_verticalMargin.nonCollapsedValues().after; |
| } |
| |
| inline Optional<LayoutUnit> Box::computedMarginStart() const |
| { |
| ASSERT(m_hasValidHorizontalComputedMargin); |
| return m_horizontalComputedMargin.start; |
| } |
| |
| inline Optional<LayoutUnit> Box::computedMarginEnd() const |
| { |
| ASSERT(m_hasValidHorizontalComputedMargin); |
| return m_horizontalComputedMargin.end; |
| } |
| |
| inline Optional<LayoutUnit> Box::paddingTop() const |
| { |
| ASSERT(m_hasValidPadding); |
| if (!m_padding) |
| return { }; |
| return m_padding->vertical.top; |
| } |
| |
| inline Optional<LayoutUnit> Box::paddingLeft() const |
| { |
| ASSERT(m_hasValidPadding); |
| if (!m_padding) |
| return { }; |
| return m_padding->horizontal.left; |
| } |
| |
| inline Optional<LayoutUnit> Box::paddingBottom() const |
| { |
| ASSERT(m_hasValidPadding); |
| if (!m_padding) |
| return { }; |
| return m_padding->vertical.bottom; |
| } |
| |
| inline Optional<LayoutUnit> Box::paddingRight() const |
| { |
| ASSERT(m_hasValidPadding); |
| if (!m_padding) |
| return { }; |
| return m_padding->horizontal.right; |
| } |
| |
| inline Optional<LayoutUnit> Box::verticalPadding() const |
| { |
| auto paddingTop = this->paddingTop(); |
| auto paddingBottom = this->paddingBottom(); |
| if (!paddingTop && !paddingBottom) |
| return { }; |
| return paddingTop.valueOr(0) + paddingBottom.valueOr(0); |
| } |
| |
| inline Optional<LayoutUnit> Box::horizontalPadding() const |
| { |
| auto paddingLeft = this->paddingLeft(); |
| auto paddingRight = this->paddingRight(); |
| if (!paddingLeft && !paddingRight) |
| return { }; |
| return paddingLeft.valueOr(0) + paddingRight.valueOr(0); |
| } |
| |
| inline LayoutUnit Box::borderTop() const |
| { |
| ASSERT(m_hasValidBorder); |
| return m_border.vertical.top; |
| } |
| |
| inline LayoutUnit Box::borderLeft() const |
| { |
| ASSERT(m_hasValidBorder); |
| return m_border.horizontal.left; |
| } |
| |
| inline LayoutUnit Box::borderBottom() const |
| { |
| ASSERT(m_hasValidBorder); |
| return m_border.vertical.bottom; |
| } |
| |
| inline LayoutUnit Box::borderRight() const |
| { |
| ASSERT(m_hasValidBorder); |
| return m_border.horizontal.right; |
| } |
| |
| } |
| } |
| #endif |