| // Copyright 2016 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef NGBlockLayoutAlgorithm_h |
| #define NGBlockLayoutAlgorithm_h |
| |
| #include "core/CoreExport.h" |
| #include "core/layout/ng/geometry/ng_margin_strut.h" |
| #include "core/layout/ng/ng_block_break_token.h" |
| #include "core/layout/ng/ng_block_node.h" |
| #include "core/layout/ng/ng_box_fragment.h" |
| #include "core/layout/ng/ng_constraint_space_builder.h" |
| #include "core/layout/ng/ng_layout_algorithm.h" |
| #include "platform/wtf/RefPtr.h" |
| |
| namespace blink { |
| |
| class NGConstraintSpace; |
| class NGLayoutResult; |
| |
| // Updates the fragment's BFC offset if it's not already set. |
| void MaybeUpdateFragmentBfcOffset(const NGConstraintSpace&, |
| const NGLogicalOffset&, |
| NGFragmentBuilder* builder); |
| |
| // Positions pending floats starting from {@origin_block_offset} and relative |
| // to container's BFC offset. |
| void PositionPendingFloats(LayoutUnit origin_block_offset, |
| NGFragmentBuilder* container_builder, |
| NGConstraintSpace* space); |
| |
| // A class for general block layout (e.g. a <div> with no special style). |
| // Lays out the children in sequence. |
| class CORE_EXPORT NGBlockLayoutAlgorithm |
| : public NGLayoutAlgorithm<NGBlockNode, NGBlockBreakToken> { |
| public: |
| // Default constructor. |
| // @param node The input node to perform layout upon. |
| // @param space The constraint space which the algorithm should generate a |
| // fragment within. |
| // @param break_token The break token from which the layout should start. |
| NGBlockLayoutAlgorithm(NGBlockNode* node, |
| NGConstraintSpace* space, |
| NGBlockBreakToken* break_token = nullptr); |
| |
| Optional<MinMaxContentSize> ComputeMinMaxContentSize() const override; |
| virtual RefPtr<NGLayoutResult> Layout() override; |
| |
| private: |
| NGBoxStrut CalculateMargins(NGLayoutInputNode* child, |
| const NGConstraintSpace& space); |
| |
| // Creates a new constraint space for the current child. |
| RefPtr<NGConstraintSpace> CreateConstraintSpaceForChild( |
| const NGLogicalOffset& child_bfc_offset, |
| NGLayoutInputNode*); |
| |
| // @return Estimated BFC offset for the "to be layout" child. |
| NGLogicalOffset PrepareChildLayout(NGLayoutInputNode*); |
| |
| void FinishChildLayout(const NGConstraintSpace*, NGLayoutResult*); |
| |
| // Positions the fragment that establishes a new formatting context. |
| // |
| // This uses Layout Opportunity iterator to position the fragment. |
| // That's because an element that establishes a new block formatting context |
| // must not overlap the margin box of any floats in the same block formatting |
| // context as the element itself. |
| // |
| // So if necessary, we clear the new BFC by placing it below any preceding |
| // floats or place it adjacent to such floats if there is sufficient space. |
| // |
| // Example: |
| // <div id="container"> |
| // <div id="float"></div> |
| // <div id="new-fc" style="margin-top: 20px;"></div> |
| // </div> |
| // 1) If #new-fc is small enough to fit the available space right from #float |
| // then it will be placed there and we collapse its margin. |
| // 2) If #new-fc is too big then we need to clear its position and place it |
| // below #float ignoring its vertical margin. |
| NGLogicalOffset PositionNewFc(const NGBoxFragment&, |
| const NGConstraintSpace& child_space); |
| |
| // Positions the fragment that knows its BFC offset. |
| NGLogicalOffset PositionWithBfcOffset(const NGBoxFragment&); |
| |
| // Positions using the parent BFC offset. |
| // Fragment doesn't know its offset but we can still calculate its BFC |
| // position because the parent fragment's BFC is known. |
| // Example: |
| // BFC Offset is known here because of the padding. |
| // <div style="padding: 1px"> |
| // <div id="empty-div" style="margins: 1px"></div> |
| NGLogicalOffset PositionWithParentBfc(); |
| |
| void FinishFloatChildLayout(const ComputedStyle&, |
| const NGConstraintSpace&, |
| const NGLayoutResult*); |
| |
| // Final adjustments before fragment creation. We need to prevent the |
| // fragment from crossing fragmentainer boundaries, and rather create a break |
| // token if we're out of space. |
| void FinalizeForFragmentation(); |
| |
| // Calculates logical offset for the current fragment using either |
| // {@code content_size_} when the fragment doesn't know it's offset |
| // or {@code known_fragment_offset} if the fragment knows it's offset |
| // @return Fragment's offset relative to the fragment's parent. |
| NGLogicalOffset CalculateLogicalOffset( |
| const WTF::Optional<NGLogicalOffset>& known_fragment_offset); |
| |
| NGConstraintSpaceBuilder space_builder_; |
| |
| NGBoxStrut border_and_padding_; |
| LayoutUnit content_size_; |
| LayoutUnit max_inline_size_; |
| // MarginStrut for the previous child. |
| NGMarginStrut curr_margin_strut_; |
| NGLogicalOffset curr_bfc_offset_; |
| NGBoxStrut curr_child_margins_; |
| }; |
| |
| } // namespace blink |
| |
| #endif // NGBlockLayoutAlgorithm_h |