This source file includes following definitions.
- computePreferredLogicalWidths
- layoutSpecialExcludedChild
- findLegend
- paintBoxDecorations
- paintMask
#include "config.h"
#include "core/rendering/RenderFieldset.h"
#include "CSSPropertyNames.h"
#include "HTMLNames.h"
#include "core/html/HTMLLegendElement.h"
#include "core/rendering/PaintInfo.h"
#include "platform/graphics/GraphicsContextStateSaver.h"
using std::min;
using std::max;
namespace WebCore {
using namespace HTMLNames;
RenderFieldset::RenderFieldset(Element* element)
: RenderBlockFlow(element)
{
}
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 = max(m_minPreferredLogicalWidth, legendMinWidth + borderAndPaddingWidth());
}
}
RenderObject* RenderFieldset::layoutSpecialExcludedChild(bool relayoutChildren, SubtreeLayoutScope&)
{
RenderBox* legend = findLegend();
if (legend) {
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 = 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) const
{
for (RenderObject* legend = firstChild(); legend; legend = legend->nextSibling()) {
if (option == IgnoreFloatingOrOutOfFlow && legend->isFloatingOrOutOfFlowPositioned())
continue;
if (isHTMLLegendElement(legend->node()))
return toRenderBox(legend);
}
return 0;
}
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(determineBackgroundBleedAvoidance(paintInfo.context)))
paintBoxShadow(paintInfo, paintRect, style(), Normal);
paintFillLayers(paintInfo, resolveColor(CSSPropertyBackgroundColor), style()->backgroundLayers(), paintRect);
paintBoxShadow(paintInfo, paintRect, style(), Inset);
if (!style()->hasBorder())
return;
GraphicsContext* graphicsContext = paintInfo.context;
GraphicsContextStateSaver stateSaver(*graphicsContext);
if (style()->isHorizontalWritingMode()) {
LayoutUnit clipTop = paintRect.y();
LayoutUnit clipHeight = max(static_cast<LayoutUnit>(style()->borderTopWidth()), legend->height() - ((legend->height() - borderTop()) / 2));
graphicsContext->clipOut(pixelSnappedIntRect(paintRect.x() + legend->x(), clipTop, legend->width(), clipHeight));
} else {
LayoutUnit clipLeft = paintRect.x();
LayoutUnit clipWidth = max(static_cast<LayoutUnit>(style()->borderLeftWidth()), legend->width());
graphicsContext->clipOut(pixelSnappedIntRect(clipLeft, paintRect.y() + legend->y(), clipWidth, legend->height()));
}
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);
}
}