#include "config.h"
#include "FloatingState.h"
#if ENABLE(LAYOUT_FORMATTING_CONTEXT)
#include "FormattingContext.h"
#include "LayoutBox.h"
#include "LayoutContainer.h"
#include "LayoutState.h"
#include <wtf/IsoMallocInlines.h>
namespace WebCore {
namespace Layout {
WTF_MAKE_ISO_ALLOCATED_IMPL(FloatingState);
FloatingState::FloatItem::FloatItem(const Box& layoutBox, const FloatingState& floatingState)
: m_layoutBox(makeWeakPtr(layoutBox))
, m_absoluteDisplayBox(FormattingContext::mapBoxToAncestor(floatingState.layoutState(), layoutBox, downcast<Container>(floatingState.root())))
{
}
FloatingState::FloatingState(LayoutState& layoutState, const Box& formattingContextRoot)
: m_layoutState(layoutState)
, m_formattingContextRoot(makeWeakPtr(formattingContextRoot))
{
}
#ifndef NDEBUG
static bool belongsToThisFloatingContext(const Box& layoutBox, const Box& floatingStateRoot)
{
auto& formattingContextRoot = layoutBox.formattingContextRoot();
if (&formattingContextRoot == &floatingStateRoot)
return true;
if (!formattingContextRoot.establishesInlineFormattingContext())
return false;
return &formattingContextRoot.formattingContextRoot() == &floatingStateRoot;
}
#endif
void FloatingState::remove(const Box& layoutBox)
{
for (size_t index = 0; index < m_floats.size(); ++index) {
if (m_floats[index] == layoutBox) {
m_floats.remove(index);
return;
}
}
ASSERT_NOT_REACHED();
}
void FloatingState::append(const Box& layoutBox)
{
ASSERT(is<Container>(*m_formattingContextRoot));
ASSERT(belongsToThisFloatingContext(layoutBox, *m_formattingContextRoot));
ASSERT(is<Container>(*m_formattingContextRoot));
m_floats.append({ layoutBox, *this });
}
FloatingState::Constraints FloatingState::constraints(PositionInContextRoot verticalPosition, const Box& formattingContextRoot) const
{
if (isEmpty())
return { };
auto coordinateMappingIsRequired = &root() != &formattingContextRoot;
auto adjustedPosition = Point { 0, verticalPosition };
if (coordinateMappingIsRequired)
adjustedPosition = FormattingContext::mapCoordinateToAncestor(m_layoutState, adjustedPosition, downcast<Container>(formattingContextRoot), downcast<Container>(root()));
Constraints constraints;
for (int index = m_floats.size() - 1; index >= 0; --index) {
auto& floatItem = m_floats[index];
if (constraints.left && floatItem.isLeftPositioned())
continue;
if (constraints.right && !floatItem.isLeftPositioned())
continue;
auto rect = floatItem.rectWithMargin();
if (!(rect.top() <= adjustedPosition.y && adjustedPosition.y < rect.bottom()))
continue;
if (floatItem.isLeftPositioned())
constraints.left = PositionInContextRoot { rect.right() };
else
constraints.right = PositionInContextRoot { rect.left() };
if (constraints.left && constraints.right)
break;
}
if (coordinateMappingIsRequired) {
if (constraints.left)
constraints.left = PositionInContextRoot { *constraints.left - adjustedPosition.x };
if (constraints.right)
constraints.right = PositionInContextRoot { *constraints.right - adjustedPosition.x };
}
return constraints;
}
Optional<PositionInContextRoot> FloatingState::bottom(const Box& formattingContextRoot, Clear type) const
{
if (m_floats.isEmpty())
return { };
Optional<PositionInContextRoot> bottom;
for (auto& floatItem : m_floats) {
if (!floatItem.inFormattingContext(formattingContextRoot))
continue;
if ((type == Clear::Left && !floatItem.isLeftPositioned())
|| (type == Clear::Right && floatItem.isLeftPositioned()))
continue;
auto floatsBottom = floatItem.rectWithMargin().bottom();
if (bottom) {
bottom = std::max<PositionInContextRoot>(*bottom, { floatsBottom });
continue;
}
bottom = PositionInContextRoot { floatsBottom };
}
return bottom;
}
}
}
#endif