RenderFieldset.cpp [plain text]
#include "config.h"
#include "RenderFieldset.h"
#include "CSSPropertyNames.h"
#include "GraphicsContext.h"
#include "HTMLFieldSetElement.h"
#include "HTMLLegendElement.h"
#include "HTMLNames.h"
#include "PaintInfo.h"
#include "RenderChildIterator.h"
namespace WebCore {
using namespace HTMLNames;
RenderFieldset::RenderFieldset(HTMLFieldSetElement& element, RenderStyle&& style)
: RenderBlockFlow(element, WTFMove(style))
{
}
void RenderFieldset::computePreferredLogicalWidths()
{
RenderBlockFlow::computePreferredLogicalWidths();
if (RenderBox* legend = findLegend()) {
int legendMinWidth = legend->minPreferredLogicalWidth();
Length legendMarginLeft = legend->style().marginLeft();
Length legendMarginRight = legend->style().marginLeft();
if (legendMarginLeft.isFixed())
legendMinWidth += legendMarginLeft.value();
if (legendMarginRight.isFixed())
legendMinWidth += legendMarginRight.value();
m_minPreferredLogicalWidth = std::max(m_minPreferredLogicalWidth, legendMinWidth + horizontalBorderAndPaddingExtent());
}
}
RenderObject* RenderFieldset::layoutSpecialExcludedChild(bool relayoutChildren)
{
RenderBox* box = findLegend();
if (!box)
return nullptr;
RenderBox& legend = *box;
if (relayoutChildren)
legend.setNeedsLayout();
legend.layoutIfNeeded();
LayoutUnit logicalLeft;
if (style().isLeftToRightDirection()) {
switch (legend.style().textAlign()) {
case CENTER:
logicalLeft = (logicalWidth() - logicalWidthForChild(legend)) / 2;
break;
case RIGHT:
logicalLeft = logicalWidth() - borderEnd() - paddingEnd() - logicalWidthForChild(legend);
break;
default:
logicalLeft = borderStart() + paddingStart() + marginStartForChild(legend);
break;
}
} else {
switch (legend.style().textAlign()) {
case LEFT:
logicalLeft = borderStart() + paddingStart();
break;
case CENTER: {
LayoutUnit centeredWidth = logicalWidth() - logicalWidthForChild(legend);
logicalLeft = centeredWidth - centeredWidth / 2;
break;
}
default:
logicalLeft = logicalWidth() - borderStart() - paddingStart() - marginStartForChild(legend) - logicalWidthForChild(legend);
break;
}
}
setLogicalLeftForChild(legend, logicalLeft);
LayoutUnit fieldsetBorderBefore = borderBefore();
LayoutUnit legendLogicalHeight = logicalHeightForChild(legend);
LayoutUnit legendLogicalTop;
LayoutUnit collapsedLegendExtent;
if (fieldsetBorderBefore > legendLogicalHeight) {
legendLogicalTop = (fieldsetBorderBefore - legendLogicalHeight) / 2;
collapsedLegendExtent = std::max<LayoutUnit>(fieldsetBorderBefore, legendLogicalTop + legendLogicalHeight + marginAfterForChild(legend));
} else
collapsedLegendExtent = legendLogicalHeight + marginAfterForChild(legend);
setLogicalTopForChild(legend, legendLogicalTop);
setLogicalHeight(paddingBefore() + collapsedLegendExtent);
return &legend;
}
RenderBox* RenderFieldset::findLegend(FindLegendOption option)
{
for (auto& legend : childrenOfType<RenderBox>(*this)) {
if (option == IgnoreFloatingOrOutOfFlow && legend.isFloatingOrOutOfFlowPositioned())
continue;
if (is<HTMLLegendElement>(legend.element()))
return &legend;
}
return nullptr;
}
void RenderFieldset::paintBoxDecorations(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
{
if (!paintInfo.shouldPaintWithinRoot(*this))
return;
LayoutRect paintRect(paintOffset, size());
RenderBox* legend = findLegend();
if (!legend)
return RenderBlockFlow::paintBoxDecorations(paintInfo, paintOffset);
if (style().isHorizontalWritingMode()) {
LayoutUnit yOff = (legend->y() > 0) ? LayoutUnit() : (legend->height() - borderTop()) / 2;
paintRect.setHeight(paintRect.height() - yOff);
paintRect.setY(paintRect.y() + yOff);
} else {
LayoutUnit xOff = (legend->x() > 0) ? LayoutUnit() : (legend->width() - borderLeft()) / 2;
paintRect.setWidth(paintRect.width() - xOff);
paintRect.setX(paintRect.x() + xOff);
}
if (!boxShadowShouldBeAppliedToBackground(paintRect.location(), determineBackgroundBleedAvoidance(paintInfo.context())))
paintBoxShadow(paintInfo, paintRect, style(), Normal);
paintFillLayers(paintInfo, style().visitedDependentColor(CSSPropertyBackgroundColor), style().backgroundLayers(), paintRect);
paintBoxShadow(paintInfo, paintRect, style(), Inset);
if (!style().hasBorder())
return;
GraphicsContext& graphicsContext = paintInfo.context();
GraphicsContextStateSaver stateSaver(graphicsContext);
LayoutRect clipRect;
if (style().isHorizontalWritingMode()) {
clipRect.setX(paintRect.x() + legend->x());
clipRect.setY(paintRect.y());
clipRect.setWidth(legend->width());
clipRect.setHeight(std::max<LayoutUnit>(style().borderTopWidth(), legend->height() - ((legend->height() - borderTop()) / 2)));
} else {
clipRect.setX(paintRect.x());
clipRect.setY(paintRect.y() + legend->y());
clipRect.setWidth(std::max<LayoutUnit>(style().borderLeftWidth(), legend->width()));
clipRect.setHeight(legend->height());
}
graphicsContext.clipOut(snapRectToDevicePixels(clipRect, document().deviceScaleFactor()));
paintBorder(paintInfo, paintRect, style());
}
void RenderFieldset::paintMask(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
{
if (style().visibility() != VISIBLE || paintInfo.phase != PaintPhaseMask)
return;
LayoutRect paintRect = LayoutRect(paintOffset, size());
RenderBox* legend = findLegend();
if (!legend)
return RenderBlockFlow::paintMask(paintInfo, paintOffset);
if (style().isHorizontalWritingMode()) {
LayoutUnit yOff = (legend->y() > 0) ? LayoutUnit() : (legend->height() - borderTop()) / 2;
paintRect.expand(0, -yOff);
paintRect.move(0, yOff);
} else {
LayoutUnit xOff = (legend->x() > 0) ? LayoutUnit() : (legend->width() - borderLeft()) / 2;
paintRect.expand(-xOff, 0);
paintRect.move(xOff, 0);
}
paintMaskImages(paintInfo, paintRect);
}
}