| /* |
| * 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. ``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 |
| * 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. |
| */ |
| |
| /* |
| class FloatingContext { |
| public: |
| void computePosition(Layout::Box&); |
| LayoutUnit left(LayoutUnit verticalPosition); |
| LayoutUnit right(LayoutUnit verticalPosition); |
| LayoutUnit bottom(); |
| |
| private: |
| LayoutPoint positionForFloating(const Layout::Box&); |
| LayoutPoint positionForClear(const Layout::Box&); |
| LayoutPoint computePositionToAvoidIntrudingFloats(const Layout::Box&); |
| }; |
| */ |
| // All geometry here is absolute to the formatting context's root. |
| class FloatingContext { |
| constructor(floatingState) { |
| this.m_floatingState = floatingState; |
| } |
| |
| computePosition(layoutBox) { |
| if (layoutBox.isOutOfFlowPositioned()) |
| return; |
| let displayBox = this._formattingState().displayBox(layoutBox); |
| if (layoutBox.isFloatingPositioned()) { |
| displayBox.setTopLeft(this._positionForFloating(layoutBox)); |
| this._addFloatingBox(layoutBox); |
| return; |
| } |
| if (Utils.hasClear(layoutBox)) |
| return displayBox.setTopLeft(this._positionForClear(layoutBox)); |
| // Intruding floats might force this box move. |
| displayBox.setTopLeft(this._computePositionToAvoidIntrudingFloats(layoutBox)); |
| } |
| |
| left(verticalPosition) { |
| // Relative to the formatting context's root. |
| let leftFloating = this._findFloatingAtVerticalPosition(verticalPosition, this._leftFloatings()); |
| if (!leftFloating) |
| return Number.NaN; |
| return this._mapDisplayMarginBoxToFormattingRoot(leftFloating).right(); |
| } |
| |
| right(verticalPosition) { |
| // Relative to the formatting context's root. |
| let rightFloating = this._findFloatingAtVerticalPosition(verticalPosition, this._rightFloatings()); |
| if (!rightFloating) |
| return Number.NaN; |
| return this._mapDisplayMarginBoxToFormattingRoot(rightFloating).left(); |
| } |
| |
| bottom() { |
| let leftBottom = this._bottom(this._leftFloatings()); |
| let rightBottom = this._bottom(this._rightFloatings()); |
| if (Number.isNaN(leftBottom) && Number.isNaN(rightBottom)) |
| return Number.NaN; |
| if (!Number.isNaN(leftBottom) && !Number.isNaN(rightBottom)) |
| return Math.max(leftBottom, rightBottom); |
| if (!Number.isNaN(leftBottom)) |
| return leftBottom; |
| return rightBottom; |
| } |
| |
| _positionForFloating(floatingBox) { |
| let absoluteFloatingBox = this._mapMarginBoxToFormattingRoot(floatingBox); |
| if (this._isEmpty()) |
| return this._adjustedFloatingPosition(floatingBox, absoluteFloatingBox.top()); |
| let verticalPosition = Math.max(absoluteFloatingBox.top(), this._mapDisplayMarginBoxToFormattingRoot(this._lastFloating()).top()); |
| let spaceNeeded = absoluteFloatingBox.width(); |
| while (true) { |
| let floatingPair = this._findInnerMostLeftAndRight(verticalPosition); |
| if (this._availableSpace(floatingBox.containingBlock(), floatingPair) >= spaceNeeded) |
| return this._adjustedFloatingPosition(floatingBox, verticalPosition, floatingPair); |
| verticalPosition = this._moveToNextVerticalPosition(floatingPair); |
| } |
| return Math.Nan; |
| } |
| |
| _positionForClear(layoutBox) { |
| ASSERT(Utils.hasClear(layoutBox)); |
| let displayBox = this._formattingState().displayBox(layoutBox); |
| if (this._isEmpty()) |
| return displayBox.topLeft(); |
| |
| let leftBottom = Number.NaN; |
| let rightBottom = Number.NaN; |
| if (Utils.hasClearLeft(layoutBox) || Utils.hasClearBoth(layoutBox)) |
| leftBottom = this._bottom(this._leftFloatings()); |
| if (Utils.hasClearRight(layoutBox) || Utils.hasClearBoth(layoutBox)) |
| rightBottom = this._bottom(this._rightFloatings()); |
| |
| if (!Number.isNaN(leftBottom) && !Number.isNaN(rightBottom)) |
| return new LayoutPoint(Math.max(leftBottom, rightBottom), displayBox.left()); |
| if (!Number.isNaN(leftBottom)) |
| return new LayoutPoint(leftBottom, displayBox.left()); |
| if (!Number.isNaN(rightBottom)) |
| return new LayoutPoint(rightBottom, displayBox.left()); |
| return displayBox.topLeft(); |
| } |
| |
| _computePositionToAvoidIntrudingFloats(layoutBox) { |
| if (!layoutBox.establishesBlockFormattingContext() || this._isEmpty()) |
| return this._formattingState().displayBox(layoutBox).topLeft(); |
| // The border box of a table, a block-level replaced element, or an element in the normal flow that establishes |
| // a new block formatting context (such as an element with 'overflow' other than 'visible') must not overlap the |
| // margin box of any floats in the same block formatting context as the element itself. |
| // For some reason, we position this as if it was floating left. |
| return this._positionForFloating(layoutBox); |
| } |
| |
| _findInnerMostLeftAndRight(verticalPosition) { |
| let leftFloating = this._findFloatingAtVerticalPosition(verticalPosition, this._leftFloatings()); |
| let rightFloating = this._findFloatingAtVerticalPosition(verticalPosition, this._rightFloatings()); |
| return { left: leftFloating, right: rightFloating }; |
| } |
| |
| _moveToNextVerticalPosition(floatingPair) { |
| if (!floatingPair.left && !floatingPair.right) |
| return Math.NaN; |
| let leftBottom = Number.POSITIVE_INFINITY; |
| let rightBottom = Number.POSITIVE_INFINITY; |
| if (floatingPair.left) |
| leftBottom = this._mapDisplayMarginBoxToFormattingRoot(floatingPair.left).bottom(); |
| if (floatingPair.right) |
| rightBottom = this._mapDisplayMarginBoxToFormattingRoot(floatingPair.right).bottom(); |
| return Math.min(leftBottom, rightBottom); |
| } |
| |
| _availableSpace(containingBlock, floatingPair) { |
| let containingBlockContentBox = this._formattingState().displayBox(containingBlock); |
| if (floatingPair.left && floatingPair.right) |
| return floatingPair.right.left() - floatingPair.left.right(); |
| if (floatingPair.left) { |
| return containingBlockContentBox.width() - (this._mapDisplayMarginBoxToFormattingRoot(floatingPair.left).right() - this._mapBorderBoxToFormattingRoot(containingBlock).left()); |
| } |
| if (floatingPair.right) |
| return this._mapDisplayMarginBoxToFormattingRoot(floatingPair.right).left(); |
| return containingBlockContentBox.width(); |
| } |
| |
| _findFloatingAtVerticalPosition(verticalPosition, floatingStack) { |
| let index = floatingStack.length; |
| while (--index >= 0 && this._mapDisplayMarginBoxToFormattingRoot(floatingStack[index]).bottom() <= verticalPosition); |
| return index >= 0 ? floatingStack[index] : null; |
| } |
| |
| _isEmpty() { |
| return !this._leftFloatings().length && !this._rightFloatings().length; |
| } |
| |
| _adjustedFloatingPosition(floatingBox, verticalPosition, leftRightFloatings) { |
| let containingBlock = floatingBox.containingBlock(); |
| // Convert all coordinates relative to formatting context's root. |
| let left = this._mapContentBoxToFormattingRoot(containingBlock).left(); |
| let right = this._mapContentBoxToFormattingRoot(containingBlock).right(); |
| if (leftRightFloatings) { |
| if (leftRightFloatings.left) { |
| let floatingBoxRight = this._mapDisplayMarginBoxToFormattingRoot(leftRightFloatings.left).right(); |
| if (floatingBoxRight > left) |
| left = floatingBoxRight; |
| } |
| |
| if (leftRightFloatings.right) { |
| let floatingBoxLeft = this._mapDisplayMarginBoxToFormattingRoot(leftRightFloatings.right).left(); |
| if (floatingBoxLeft < right) |
| right = floatingBoxLeft; |
| } |
| } |
| let floatingDisplayBox = this._formattingState().displayBox(floatingBox); |
| left += floatingDisplayBox.marginLeft(); |
| right -= floatingDisplayBox.marginRight(); |
| verticalPosition += floatingDisplayBox.marginTop(); |
| // No convert them back relative to the floatingBox's containing block. |
| let containingBlockLeft = this._mapBorderBoxToFormattingRoot(containingBlock).left(); |
| let containingBlockTop = this._mapBorderBoxToFormattingRoot(containingBlock).top(); |
| left -= containingBlockLeft; |
| right -= containingBlockLeft; |
| verticalPosition -= containingBlockTop; |
| |
| if (Utils.isFloatingLeft(floatingBox) || !Utils.isFloatingPositioned(floatingBox)) |
| return new LayoutPoint(verticalPosition, left); |
| return new LayoutPoint(verticalPosition, right - floatingDisplayBox.rect().width()); |
| } |
| |
| _bottom(floatingStack) { |
| if (!floatingStack || !floatingStack.length) |
| return Number.NaN; |
| let max = Number.NEGATIVE_INFINITY; |
| for (let i = 0; i < floatingStack.length; ++i) |
| max = Math.max(this._mapDisplayMarginBoxToFormattingRoot(floatingStack[i]).bottom(), max); |
| return max; |
| } |
| |
| _addFloatingBox(layoutBox) { |
| this._floatingState().addFloating(this._formattingState().displayBox(layoutBox), Utils.isFloatingLeft(layoutBox)); |
| } |
| |
| _mapMarginBoxToFormattingRoot(layoutBox) { |
| ASSERT(layoutBox instanceof Layout.Box); |
| return this._mapDisplayMarginBoxToFormattingRoot(this._formattingState().displayBox(layoutBox)); |
| } |
| |
| _mapDisplayMarginBoxToFormattingRoot(displayBox) { |
| ASSERT(displayBox instanceof Display.Box); |
| return Utils.marginBox(displayBox, this._formattingState().displayBox(this.formattingRoot())); |
| } |
| |
| _mapBorderBoxToFormattingRoot(layoutBox) { |
| let displayBox = this._formattingState().displayBox(layoutBox); |
| let rootDisplayBox = this._formattingState().displayBox(this.formattingRoot()); |
| return Utils.borderBox(displayBox, rootDisplayBox); |
| } |
| |
| _mapContentBoxToFormattingRoot(layoutBox) { |
| let displayBox = this._formattingState().displayBox(layoutBox); |
| let rootDisplayBox = this._formattingState().displayBox(this.formattingRoot()); |
| return Utils.contentBox(displayBox, rootDisplayBox); |
| } |
| |
| formattingRoot() { |
| return this._formattingState().formattingRoot(); |
| } |
| |
| _floatingState() { |
| return this.m_floatingState; |
| } |
| |
| _formattingState() { |
| return this._floatingState().formattingState(); |
| } |
| |
| _lastFloating() { |
| return this._floatingState().lastFloating(); |
| } |
| |
| _leftFloatings() { |
| return this._floatingState().leftFloatingStack(); |
| } |
| |
| _rightFloatings() { |
| return this._floatingState().rightFloatingStack(); |
| } |
| } |
