FloatQuad RenderGeometryMap::mapToContainer(const FloatRect& rect, const RenderLayerModelObject* container) const
{
FloatRect result;
if (!hasFixedPositionStep() && !hasTransformStep() && !hasNonUniformStep() && (!container || (m_mapping.size() && container == m_mapping[0].m_renderer))) {
result = rect;
result.move(m_accumulatedOffset);
} else {
TransformState transformState(TransformState::ApplyTransformDirection, rect.center(), rect);
mapToContainer(transformState, container);
result = transformState.lastPlanarQuad().boundingBox();
}
#if !ASSERT_DISABLED
if (m_mapping.size() > 0) {
const RenderObject* lastRenderer = m_mapping.last().m_renderer;
const RenderLayer* layer = lastRenderer->enclosingLayer();
// Bounds for invisible layers are intentionally not calculated, and are
// therefore not necessarily expected to be correct here. This is ok,
// because they will be recomputed if the layer becomes visible.
if (!layer->subtreeIsInvisible() && lastRenderer->style()->visibility() == VISIBLE) {
FloatRect rendererMappedResult = lastRenderer->localToContainerQuad(rect, container, m_mapCoordinatesFlags).boundingBox();
// Inspector creates renderers with negative width <https://bugs.webkit.org/show_bug.cgi?id=87194>.
// Taking FloatQuad bounds avoids spurious assertions because of that.
ASSERT(enclosingIntRect(rendererMappedResult) == enclosingIntRect(FloatQuad(result).boundingBox()));
}
}
#endif
return result;
}
FloatQuad LayoutGeometryMap::mapToAncestor(const FloatRect& rect, const LayoutBoxModelObject* ancestor) const
{
FloatQuad result;
if (!hasFixedPositionStep() && !hasTransformStep() && !hasNonUniformStep() && (!ancestor || (m_mapping.size() && ancestor == m_mapping[0].m_layoutObject))) {
result = rect;
result.move(m_accumulatedOffset);
} else {
TransformState transformState(TransformState::ApplyTransformDirection, rect.center(), rect);
mapToAncestor(transformState, ancestor);
result = transformState.lastPlanarQuad();
}
#if ENABLE(ASSERT)
if (m_mapping.size() > 0) {
const LayoutObject* lastLayoutObject = m_mapping.last().m_layoutObject;
FloatRect layoutObjectMappedResult = lastLayoutObject->localToAncestorQuad(rect, ancestor, m_mapCoordinatesFlags).boundingBox();
// Inspector creates layoutObjects with negative width <https://bugs.webkit.org/show_bug.cgi?id=87194>.
// Taking FloatQuad bounds avoids spurious assertions because of that.
ASSERT(enclosingIntRect(layoutObjectMappedResult) == enclosingIntRect(result.boundingBox())
|| layoutObjectMappedResult.mayNotHaveExactIntRectRepresentation()
|| result.boundingBox().mayNotHaveExactIntRectRepresentation());
}
#endif
return result;
}
FloatPoint RenderGeometryMap::mapToContainer(const FloatPoint& p, const RenderLayerModelObject* container) const
{
FloatPoint result;
if (!hasFixedPositionStep() && !hasTransformStep() && !hasNonUniformStep() && (!container || (m_mapping.size() && container == m_mapping[0].m_renderer)))
result = p + roundedIntSize(m_accumulatedOffset);
else {
TransformState transformState(TransformState::ApplyTransformDirection, p);
mapToContainer(transformState, container);
result = transformState.lastPlanarPoint();
}
#if !ASSERT_DISABLED
if (m_mapping.size() > 0) {
const RenderObject* lastRenderer = m_mapping.last().m_renderer;
const RenderLayer* layer = lastRenderer->enclosingLayer();
// Bounds for invisible layers are intentionally not calculated, and are
// therefore not necessarily expected to be correct here. This is ok,
// because they will be recomputed if the layer becomes visible.
if (!layer || !layer->subtreeIsInvisible()) {
FloatPoint rendererMappedResult = lastRenderer->localToAbsolute(p, m_mapCoordinatesFlags);
ASSERT(roundedIntPoint(rendererMappedResult) == roundedIntPoint(result));
}
}
#endif
return result;
}
void LayoutGeometryMap::mapToAncestor(TransformState& transformState, const LayoutBoxModelObject* ancestor) const
{
// If the mapping includes something like columns, we have to go via layoutObjects.
if (hasNonUniformStep()) {
m_mapping.last().m_layoutObject->mapLocalToAncestor(ancestor, transformState, ApplyContainerFlip | m_mapCoordinatesFlags);
transformState.flatten();
return;
}
bool inFixed = false;
#if ENABLE(ASSERT)
bool foundAncestor = !ancestor || (m_mapping.size() && m_mapping[0].m_layoutObject == ancestor);
#endif
for (int i = m_mapping.size() - 1; i >= 0; --i) {
const LayoutGeometryMapStep& currentStep = m_mapping[i];
// If container is the root LayoutView (step 0) we want to apply its fixed position offset.
if (i > 0 && currentStep.m_layoutObject == ancestor) {
#if ENABLE(ASSERT)
foundAncestor = true;
#endif
break;
}
// If this box has a transform, it acts as a fixed position container
// for fixed descendants, which prevents the propagation of 'fixed'
// unless the layer itself is also fixed position.
if (i && currentStep.m_flags & HasTransform && !(currentStep.m_flags & IsFixedPosition))
inFixed = false;
else if (currentStep.m_flags & IsFixedPosition)
inFixed = true;
ASSERT(!i == isTopmostLayoutView(currentStep.m_layoutObject));
if (!i) {
// A null container indicates mapping through the root LayoutView, so including its transform (the page scale).
if (!ancestor && currentStep.m_transform)
transformState.applyTransform(*currentStep.m_transform.get());
} else {
TransformState::TransformAccumulation accumulate = currentStep.m_flags & AccumulatingTransform ? TransformState::AccumulateTransform : TransformState::FlattenTransform;
if (currentStep.m_transform)
transformState.applyTransform(*currentStep.m_transform.get(), accumulate);
else
transformState.move(currentStep.m_offset.width(), currentStep.m_offset.height(), accumulate);
}
if (inFixed && !currentStep.m_offsetForFixedPosition.isZero()) {
ASSERT(currentStep.m_layoutObject->isLayoutView());
transformState.move(currentStep.m_offsetForFixedPosition);
}
}
ASSERT(foundAncestor);
transformState.flatten();
}
void RenderGeometryMap::mapToContainer(TransformState& transformState, const RenderLayerModelObject* container) const
{
// If the mapping includes something like columns, we have to go via renderers.
if (hasNonUniformStep()) {
m_mapping.last().m_renderer->mapLocalToContainer(container, transformState, ApplyContainerFlip | m_mapCoordinatesFlags);
transformState.flatten();
return;
}
bool inFixed = false;
#if !ASSERT_DISABLED
bool foundContainer = !container || (m_mapping.size() && m_mapping[0].m_renderer == container);
#endif
for (int i = m_mapping.size() - 1; i >= 0; --i) {
const RenderGeometryMapStep& currentStep = m_mapping[i];
// If container is the RenderView (step 0) we want to apply its scroll offset.
if (i > 0 && currentStep.m_renderer == container) {
#if !ASSERT_DISABLED
foundContainer = true;
#endif
break;
}
// If this box has a transform, it acts as a fixed position container
// for fixed descendants, which prevents the propagation of 'fixed'
// unless the layer itself is also fixed position.
if (i && currentStep.m_hasTransform && !currentStep.m_isFixedPosition)
inFixed = false;
else if (currentStep.m_isFixedPosition)
inFixed = true;
if (!i) {
// The root gets special treatment for fixed position
if (inFixed)
transformState.move(currentStep.m_offset.width(), currentStep.m_offset.height());
// A null container indicates mapping through the RenderView, so including its transform (the page scale).
if (!container && currentStep.m_transform)
transformState.applyTransform(*currentStep.m_transform.get());
} else {
TransformState::TransformAccumulation accumulate = currentStep.m_accumulatingTransform ? TransformState::AccumulateTransform : TransformState::FlattenTransform;
if (currentStep.m_transform)
transformState.applyTransform(*currentStep.m_transform.get(), accumulate);
else
transformState.move(currentStep.m_offset.width(), currentStep.m_offset.height(), accumulate);
}
}
ASSERT(foundContainer);
transformState.flatten();
}
void RenderGeometryMap::mapToContainer(TransformState& transformState,
const RenderBox* container) const {
// If the mapping includes something like columns, we have to go via
// renderers.
if (hasNonUniformStep()) {
m_mapping.last().m_renderer->mapLocalToContainer(
container, transformState, ApplyContainerFlip | m_mapCoordinatesFlags);
transformState.flatten();
return;
}
#if ENABLE(ASSERT)
bool foundContainer =
!container || (m_mapping.size() && m_mapping[0].m_renderer == container);
#endif
for (int i = m_mapping.size() - 1; i >= 0; --i) {
const RenderGeometryMapStep& currentStep = m_mapping[i];
// If container is the root RenderView (step 0) we want to apply its fixed
// position offset.
if (i > 0 && currentStep.m_renderer == container) {
#if ENABLE(ASSERT)
foundContainer = true;
#endif
break;
}
ASSERT(!i == isTopmostRenderView(currentStep.m_renderer));
if (!i) {
// A null container indicates mapping through the root RenderView, so
// including its transform (the page scale).
if (!container && currentStep.m_transform)
transformState.applyTransform(*currentStep.m_transform.get());
} else {
TransformState::TransformAccumulation accumulate =
currentStep.m_accumulatingTransform
? TransformState::AccumulateTransform
: TransformState::FlattenTransform;
if (currentStep.m_transform)
transformState.applyTransform(*currentStep.m_transform.get(),
accumulate);
else
transformState.move(currentStep.m_offset.width(),
currentStep.m_offset.height(), accumulate);
}
}
ASSERT(foundContainer);
transformState.flatten();
}
FloatQuad RenderGeometryMap::mapToContainer(const FloatRect& rect, const RenderLayerModelObject* container) const
{
FloatQuad result;
if (!hasFixedPositionStep() && !hasTransformStep() && !hasNonUniformStep() && (!container || (m_mapping.size() && container == m_mapping[0].m_renderer))) {
result = rect;
result.move(m_accumulatedOffset);
} else {
TransformState transformState(TransformState::ApplyTransformDirection, rect.center(), rect);
mapToContainer(transformState, container);
result = transformState.lastPlanarQuad();
}
return result;
}
FloatPoint RenderGeometryMap::absolutePoint(const FloatPoint& p) const
{
FloatPoint result;
if (!hasFixedPositionStep() && !hasTransformStep() && !hasNonUniformStep())
result = p + m_accumulatedOffset;
else {
TransformState transformState(TransformState::ApplyTransformDirection, p);
mapToAbsolute(transformState);
result = transformState.lastPlanarPoint();
}
#if !ASSERT_DISABLED
FloatPoint rendererMappedResult = m_mapping.last().m_renderer->localToAbsolute(p, false, true);
ASSERT(rendererMappedResult == result);
#endif
return result;
}
FloatPoint RenderGeometryMap::mapToContainer(const FloatPoint& p, const RenderLayerModelObject* container) const
{
FloatPoint result;
#if !ASSERT_DISABLED
FloatPoint rendererMappedResult = m_mapping.last().m_renderer->localToAbsolute(p, m_mapCoordinatesFlags);
#endif
if (!hasFixedPositionStep() && !hasTransformStep() && !hasNonUniformStep() && (!container || (m_mapping.size() && container == m_mapping[0].m_renderer))) {
result = p + roundedIntSize(m_accumulatedOffset);
// Should convert to a LayoutPoint because of the uniqueness of LayoutUnit::round
ASSERT(roundedIntPoint(LayoutPoint(rendererMappedResult)) == result);
} else {
TransformState transformState(TransformState::ApplyTransformDirection, p);
mapToContainer(transformState, container);
result = transformState.lastPlanarPoint();
ASSERT(areEssentiallyEqual(rendererMappedResult, result));
}
return result;
}
FloatPoint RenderGeometryMap::mapToContainer(const FloatPoint& p, const RenderLayerModelObject* container) const
{
FloatPoint result;
if (!hasFixedPositionStep() && !hasTransformStep() && !hasNonUniformStep() && (!container || (m_mapping.size() && container == m_mapping[0].m_renderer)))
result = p + roundedIntSize(m_accumulatedOffset);
else {
TransformState transformState(TransformState::ApplyTransformDirection, p);
mapToContainer(transformState, container);
result = transformState.lastPlanarPoint();
}
#if !ASSERT_DISABLED
FloatPoint rendererMappedResult = m_mapping.last().m_renderer->localToAbsolute(p, m_mapCoordinatesFlags);
ASSERT(roundedIntPoint(rendererMappedResult) == roundedIntPoint(result));
// if (roundedIntPoint(rendererMappedResult) != roundedIntPoint(result))
// fprintf(stderr, "Mismatched point\n");
#endif
return result;
}
void RenderGeometryMap::mapToAbsolute(TransformState& transformState) const
{
// If the mapping includes something like columns, we have to go via renderers.
if (hasNonUniformStep()) {
bool fixed = false;
m_mapping.last()->m_renderer->mapLocalToContainer(0, fixed, true, transformState, RenderObject::ApplyContainerFlip);
return;
}
bool inFixed = false;
for (int i = m_mapping.size() - 1; i >= 0; --i) {
const RenderGeometryMapStep* currStep = m_mapping[i].get();
// If this box has a transform, it acts as a fixed position container
// for fixed descendants, which prevents the propagation of 'fixed'
// unless the layer itself is also fixed position.
if (currStep->m_hasTransform && !currStep->m_isFixedPosition)
inFixed = false;
else if (currStep->m_isFixedPosition)
inFixed = true;
if (!i) {
if (currStep->m_transform)
transformState.applyTransform(*currStep->m_transform.get());
// The root gets special treatment for fixed position
if (inFixed)
transformState.move(currStep->m_offset.width(), currStep->m_offset.height());
} else {
TransformState::TransformAccumulation accumulate = currStep->m_accumulatingTransform ? TransformState::AccumulateTransform : TransformState::FlattenTransform;
if (currStep->m_transform)
transformState.applyTransform(*currStep->m_transform.get(), accumulate);
else
transformState.move(currStep->m_offset.width(), currStep->m_offset.height(), accumulate);
}
}
transformState.flatten();
}
FloatRect RenderGeometryMap::absoluteRect(const FloatRect& rect) const
{
FloatRect result;
if (!hasFixedPositionStep() && !hasTransformStep() && !hasNonUniformStep()) {
result = rect;
result.move(m_accumulatedOffset);
} else {
TransformState transformState(TransformState::ApplyTransformDirection, rect.center(), rect);
mapToAbsolute(transformState);
result = transformState.lastPlanarQuad().boundingBox();
}
#if !ASSERT_DISABLED
FloatRect rendererMappedResult = m_mapping.last().m_renderer->localToAbsoluteQuad(rect).boundingBox();
// Inspector creates renderers with negative width <https://bugs.webkit.org/show_bug.cgi?id=87194>.
// Taking FloatQuad bounds avoids spurious assertions because of that.
ASSERT(enclosingIntRect(rendererMappedResult) == enclosingIntRect(FloatQuad(result).boundingBox()));
#endif
return result;
}
FloatQuad RenderGeometryMap::mapToContainer(const FloatRect& rect, const RenderLayerModelObject* container) const
{
FloatRect result;
if (!hasFixedPositionStep() && !hasTransformStep() && !hasNonUniformStep() && (!container || (m_mapping.size() && container == m_mapping[0].m_renderer))) {
result = rect;
result.move(m_accumulatedOffset);
} else {
TransformState transformState(TransformState::ApplyTransformDirection, rect.center(), rect);
mapToContainer(transformState, container);
result = transformState.lastPlanarQuad().boundingBox();
}
#if !ASSERT_DISABLED
FloatRect rendererMappedResult = m_mapping.last().m_renderer->localToContainerQuad(rect, container, m_mapCoordinatesFlags).boundingBox();
// Inspector creates renderers with negative width <https://bugs.webkit.org/show_bug.cgi?id=87194>.
// Taking FloatQuad bounds avoids spurious assertions because of that.
ASSERT(enclosingIntRect(rendererMappedResult) == enclosingIntRect(FloatQuad(result).boundingBox()));
// if (enclosingIntRect(rendererMappedResult) != enclosingIntRect(FloatQuad(result).boundingBox()))
// fprintf(stderr, "Mismatched rects\n");
#endif
return result;
}
