037039ecfc
This fixes the issue by moving the table captions to the principal child list. It also paves the way to fix bug 144517, but it doesn't fix it as that requires extra layout changes to nsTableWrapper frame (mostly to reserve the multiple caption block sizes). Test courtesy of Masayuki in D246407 (with minor tweaks). Differential Revision: https://phabricator.services.mozilla.com/D246468
799 lines
33 KiB
C++
799 lines
33 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "nsTableWrapperFrame.h"
|
|
|
|
#include "LayoutConstants.h"
|
|
#include "mozilla/ComputedStyle.h"
|
|
#include "mozilla/PresShell.h"
|
|
#include "nsFrameManager.h"
|
|
#include "nsGridContainerFrame.h"
|
|
#include "nsTableFrame.h"
|
|
#include "nsTableCellFrame.h"
|
|
#include "nsStyleConsts.h"
|
|
#include "nsPresContext.h"
|
|
#include "nsCSSRendering.h"
|
|
#include "nsIContent.h"
|
|
#include "prinrval.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsHTMLParts.h"
|
|
#include "nsDisplayList.h"
|
|
#include "nsLayoutUtils.h"
|
|
#include "nsIFrameInlines.h"
|
|
#include <algorithm>
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::layout;
|
|
|
|
nscoord nsTableWrapperFrame::SynthesizeFallbackBaseline(
|
|
mozilla::WritingMode aWM, BaselineSharingGroup aBaselineGroup) const {
|
|
const auto marginBlockEnd = GetLogicalUsedMargin(aWM).BEnd(aWM);
|
|
if (aWM.IsCentralBaseline()) {
|
|
return (BSize(aWM) + marginBlockEnd) / 2;
|
|
}
|
|
// Our fallback baseline is the block-end margin-edge, with respect to the
|
|
// given writing mode.
|
|
if (aBaselineGroup == BaselineSharingGroup::Last) {
|
|
return -marginBlockEnd;
|
|
}
|
|
return BSize(aWM) + marginBlockEnd;
|
|
}
|
|
|
|
Maybe<nscoord> nsTableWrapperFrame::GetNaturalBaselineBOffset(
|
|
WritingMode aWM, BaselineSharingGroup aBaselineGroup,
|
|
BaselineExportContext aExportContext) const {
|
|
// Baseline is determined by row
|
|
// (https://drafts.csswg.org/css-align-3/#baseline-export). If the row
|
|
// direction is going to be orthogonal to the parent's writing mode, the
|
|
// resulting baseline wouldn't be valid, so we use the fallback baseline
|
|
// instead.
|
|
if (StyleDisplay()->IsContainLayout() ||
|
|
GetWritingMode().IsOrthogonalTo(aWM)) {
|
|
return Nothing{};
|
|
}
|
|
auto* innerTable = InnerTableFrame();
|
|
return innerTable
|
|
->GetNaturalBaselineBOffset(aWM, aBaselineGroup, aExportContext)
|
|
.map([this, aWM, aBaselineGroup, innerTable](nscoord aBaseline) {
|
|
auto bStart = innerTable->BStart(aWM, mRect.Size());
|
|
if (aBaselineGroup == BaselineSharingGroup::First) {
|
|
return aBaseline + bStart;
|
|
}
|
|
auto bEnd = bStart + innerTable->BSize(aWM);
|
|
return BSize(aWM) - (bEnd - aBaseline);
|
|
});
|
|
}
|
|
|
|
nsTableWrapperFrame::nsTableWrapperFrame(ComputedStyle* aStyle,
|
|
nsPresContext* aPresContext,
|
|
ClassID aID)
|
|
: nsContainerFrame(aStyle, aPresContext, aID) {}
|
|
|
|
nsTableWrapperFrame::~nsTableWrapperFrame() = default;
|
|
|
|
NS_QUERYFRAME_HEAD(nsTableWrapperFrame)
|
|
NS_QUERYFRAME_ENTRY(nsTableWrapperFrame)
|
|
NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
|
|
|
|
#ifdef ACCESSIBILITY
|
|
a11y::AccType nsTableWrapperFrame::AccessibleType() {
|
|
return a11y::eHTMLTableType;
|
|
}
|
|
#endif
|
|
|
|
void nsTableWrapperFrame::Destroy(DestroyContext& aContext) {
|
|
DestroyAbsoluteFrames(aContext);
|
|
nsContainerFrame::Destroy(aContext);
|
|
}
|
|
|
|
void nsTableWrapperFrame::AppendFrames(ChildListID aListID,
|
|
nsFrameList&& aFrameList) {
|
|
// We only have two child frames: the inner table and a caption frame.
|
|
// The inner frame is provided when we're initialized, and it cannot change
|
|
MOZ_ASSERT(FrameChildListID::Principal == aListID, "unexpected child list");
|
|
MOZ_ASSERT(aFrameList.IsEmpty() || aFrameList.FirstChild()->IsTableCaption(),
|
|
"appending non-caption frame to captionList");
|
|
nsContainerFrame::AppendFrames(aListID, std::move(aFrameList));
|
|
// The presence of caption frames makes us sort our display list differently,
|
|
// so mark us as changed for the new ordering.
|
|
MarkNeedsDisplayItemRebuild();
|
|
}
|
|
|
|
void nsTableWrapperFrame::InsertFrames(
|
|
ChildListID aListID, nsIFrame* aPrevFrame,
|
|
const nsLineList::iterator* aPrevFrameLine, nsFrameList&& aFrameList) {
|
|
MOZ_ASSERT(FrameChildListID::Principal == aListID, "unexpected child list");
|
|
MOZ_ASSERT(aFrameList.IsEmpty() || aFrameList.FirstChild()->IsTableCaption(),
|
|
"inserting non-caption frame");
|
|
MOZ_ASSERT(!aPrevFrame || aPrevFrame->GetParent() == this,
|
|
"inserting after sibling frame with different parent");
|
|
nsContainerFrame::InsertFrames(aListID, aPrevFrame, aPrevFrameLine,
|
|
std::move(aFrameList));
|
|
MarkNeedsDisplayItemRebuild();
|
|
}
|
|
|
|
void nsTableWrapperFrame::RemoveFrame(DestroyContext& aContext,
|
|
ChildListID aListID,
|
|
nsIFrame* aOldFrame) {
|
|
// We only have two child frames: the inner table and one caption frame.
|
|
// The inner frame can't be removed so this should be the caption
|
|
MOZ_ASSERT(aOldFrame->IsTableCaption(), "can't remove inner frame");
|
|
nsContainerFrame::RemoveFrame(aContext, aListID, aOldFrame);
|
|
MarkNeedsDisplayItemRebuild();
|
|
}
|
|
|
|
void nsTableWrapperFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
|
const nsDisplayListSet& aLists) {
|
|
// No border or background is painted because they belong to the inner table.
|
|
// The outline belongs to the wrapper frame so it can contain the caption.
|
|
|
|
// If there's no caption, take a short cut to avoid having to create
|
|
// the special display list set and then sort it.
|
|
if (nsIFrame* inner = mFrames.OnlyChild()) {
|
|
BuildDisplayListForChild(aBuilder, inner, aLists);
|
|
DisplayOutline(aBuilder, aLists);
|
|
return;
|
|
}
|
|
|
|
MOZ_ASSERT(mFrames.FirstChild());
|
|
MOZ_ASSERT(mFrames.FirstChild()->IsTableFrame());
|
|
|
|
nsDisplayListCollection set(aBuilder);
|
|
nsDisplayListSet captionSet(set, set.BlockBorderBackgrounds());
|
|
for (auto* frame : mFrames) {
|
|
const bool isTable = frame->IsTableFrame();
|
|
auto& setForFrame = isTable ? set : captionSet;
|
|
BuildDisplayListForChild(aBuilder, frame, setForFrame);
|
|
if (!isTable) {
|
|
// FIXME(emilio, bug 144517): Historically we haven't displayed / laid
|
|
// out multiple captions. This preserves that behavior.
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Now we have to sort everything by content order, since the caption
|
|
// may be somewhere inside the table.
|
|
// We don't sort BlockBorderBackgrounds and BorderBackgrounds because the
|
|
// display items in those lists should stay out of content order in order to
|
|
// follow the rules in https://www.w3.org/TR/CSS21/zindex.html#painting-order
|
|
// and paint the caption background after all of the rest.
|
|
set.Floats()->SortByContentOrder(GetContent());
|
|
set.Content()->SortByContentOrder(GetContent());
|
|
set.PositionedDescendants()->SortByContentOrder(GetContent());
|
|
set.Outlines()->SortByContentOrder(GetContent());
|
|
set.MoveTo(aLists);
|
|
|
|
DisplayOutline(aBuilder, aLists);
|
|
}
|
|
|
|
ComputedStyle* nsTableWrapperFrame::GetParentComputedStyle(
|
|
nsIFrame** aProviderFrame) const {
|
|
// The table wrapper frame and the (inner) table frame split the style
|
|
// data by giving the table frame the ComputedStyle associated with
|
|
// the table content node and creating a ComputedStyle for the wrapper
|
|
// frame that is a *child* of the table frame's ComputedStyle,
|
|
// matching the ::-moz-table-wrapper pseudo-element. html.css has a
|
|
// rule that causes that pseudo-element (and thus the wrapper table)
|
|
// to inherit *some* style properties from the table frame. The
|
|
// children of the table inherit directly from the inner table, and
|
|
// the table wrapper's ComputedStyle is a leaf.
|
|
|
|
return (*aProviderFrame = InnerTableFrame())->Style();
|
|
}
|
|
|
|
nscoord nsTableWrapperFrame::IntrinsicISize(const IntrinsicSizeInput& aInput,
|
|
IntrinsicISizeType aType) {
|
|
nscoord iSize = nsLayoutUtils::IntrinsicForContainer(
|
|
aInput.mContext, InnerTableFrame(), aType);
|
|
|
|
{
|
|
// If aFrame is a container for font size inflation, then shrink
|
|
// wrapping inside of it should not apply font size inflation.
|
|
AutoMaybeDisableFontInflation an(this);
|
|
|
|
// Tables can't shrink smaller than their intrinsic minimum inline size,
|
|
// no matter what.
|
|
const IntrinsicSizeInput input(aInput.mContext, Nothing(), Nothing());
|
|
|
|
// GetMinISize() returns a content-box inline size, but we need the
|
|
// margin-box inline size as the contribution in the inline axis.
|
|
const IntrinsicSizeOffsetData offset =
|
|
InnerTableFrame()->IntrinsicISizeOffsets();
|
|
const nscoord innerTableMinISize =
|
|
InnerTableFrame()->GetMinISize(input) + offset.MarginBorderPadding();
|
|
iSize = std::max(iSize, innerTableMinISize);
|
|
}
|
|
|
|
if (nsIFrame* caption = GetCaption()) {
|
|
// The table wrapper's intrinsic inline size should be as least as large as
|
|
// caption's min inline size.
|
|
const nscoord capMinISize = nsLayoutUtils::IntrinsicForContainer(
|
|
aInput.mContext, caption, IntrinsicISizeType::MinISize);
|
|
iSize = std::max(iSize, capMinISize);
|
|
}
|
|
return iSize;
|
|
}
|
|
|
|
LogicalSize nsTableWrapperFrame::InnerTableShrinkWrapSize(
|
|
gfxContext* aRenderingContext, nsTableFrame* aTableFrame, WritingMode aWM,
|
|
const LogicalSize& aCBSize, nscoord aAvailableISize,
|
|
const StyleSizeOverrides& aSizeOverrides, ComputeSizeFlags aFlags) const {
|
|
MOZ_ASSERT(InnerTableFrame() == aTableFrame);
|
|
|
|
AutoMaybeDisableFontInflation an(aTableFrame);
|
|
|
|
Maybe<LogicalMargin> collapseBorder;
|
|
Maybe<LogicalMargin> collapsePadding;
|
|
aTableFrame->GetCollapsedBorderPadding(collapseBorder, collapsePadding);
|
|
|
|
SizeComputationInput input(aTableFrame, aRenderingContext, aWM,
|
|
aCBSize.ISize(aWM), collapseBorder,
|
|
collapsePadding);
|
|
LogicalSize marginSize(aWM); // Inner table doesn't have any margin
|
|
LogicalSize bpSize = input.ComputedLogicalBorderPadding(aWM).Size(aWM);
|
|
|
|
// Note that we pass an empty caption-area here (rather than the caption's
|
|
// actual size). This is fine because:
|
|
//
|
|
// 1) nsTableWrapperFrame::ComputeSize() only uses the size returned by this
|
|
// method (indirectly via calling nsTableWrapperFrame::ComputeAutoSize())
|
|
// if it get a aSizeOverrides arg containing any size overrides with
|
|
// mApplyOverridesVerbatim=true. The aSizeOverrides arg is passed to this
|
|
// method without any modifications.
|
|
//
|
|
// 2) With 1), that means the aSizeOverrides passing into this method should
|
|
// be applied to the inner table directly, so we don't need to subtract
|
|
// caption-area when preparing innerOverrides for
|
|
// nsTableFrame::ComputeSize().
|
|
StyleSizeOverrides innerOverrides = ComputeSizeOverridesForInnerTable(
|
|
aTableFrame, aSizeOverrides, bpSize, /* aBSizeOccupiedByCaption = */ 0);
|
|
auto size =
|
|
aTableFrame
|
|
->ComputeSize(aRenderingContext, aWM, aCBSize, aAvailableISize,
|
|
marginSize, bpSize, innerOverrides, aFlags)
|
|
.mLogicalSize;
|
|
size.ISize(aWM) += bpSize.ISize(aWM);
|
|
if (size.BSize(aWM) != NS_UNCONSTRAINEDSIZE) {
|
|
size.BSize(aWM) += bpSize.BSize(aWM);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
LogicalSize nsTableWrapperFrame::CaptionShrinkWrapSize(
|
|
gfxContext* aRenderingContext, nsIFrame* aCaptionFrame, WritingMode aWM,
|
|
const LogicalSize& aCBSize, nscoord aAvailableISize,
|
|
ComputeSizeFlags aFlags) const {
|
|
MOZ_ASSERT(aCaptionFrame != mFrames.FirstChild());
|
|
|
|
AutoMaybeDisableFontInflation an(aCaptionFrame);
|
|
|
|
SizeComputationInput input(aCaptionFrame, aRenderingContext, aWM,
|
|
aCBSize.ISize(aWM));
|
|
LogicalSize marginSize = input.ComputedLogicalMargin(aWM).Size(aWM);
|
|
LogicalSize bpSize = input.ComputedLogicalBorderPadding(aWM).Size(aWM);
|
|
|
|
auto size = aCaptionFrame
|
|
->ComputeSize(aRenderingContext, aWM, aCBSize,
|
|
aAvailableISize, marginSize, bpSize, {}, aFlags)
|
|
.mLogicalSize;
|
|
size.ISize(aWM) += (marginSize.ISize(aWM) + bpSize.ISize(aWM));
|
|
if (size.BSize(aWM) != NS_UNCONSTRAINEDSIZE) {
|
|
size.BSize(aWM) += (marginSize.BSize(aWM) + bpSize.BSize(aWM));
|
|
}
|
|
return size;
|
|
}
|
|
|
|
StyleSize nsTableWrapperFrame::ReduceStyleSizeBy(
|
|
const StyleSize& aStyleSize, const nscoord aAmountToReduce) const {
|
|
MOZ_ASSERT(aStyleSize.ConvertsToLength(), "Only handles 'Length' StyleSize!");
|
|
const nscoord size = std::max(0, aStyleSize.ToLength() - aAmountToReduce);
|
|
return StyleSize::LengthPercentage(LengthPercentage::FromAppUnits(size));
|
|
}
|
|
|
|
StyleSizeOverrides nsTableWrapperFrame::ComputeSizeOverridesForInnerTable(
|
|
const nsTableFrame* aTableFrame,
|
|
const StyleSizeOverrides& aWrapperSizeOverrides,
|
|
const LogicalSize& aBorderPadding, nscoord aBSizeOccupiedByCaption) const {
|
|
if (aWrapperSizeOverrides.mApplyOverridesVerbatim ||
|
|
!aWrapperSizeOverrides.HasAnyLengthOverrides()) {
|
|
// We are asked to apply the size overrides directly to the inner table, or
|
|
// there's no 'Length' size overrides. No need to tweak the size overrides.
|
|
return aWrapperSizeOverrides;
|
|
}
|
|
|
|
const auto wm = aTableFrame->GetWritingMode();
|
|
LogicalSize areaOccupied(wm, 0, aBSizeOccupiedByCaption);
|
|
if (aTableFrame->StylePosition()->mBoxSizing == StyleBoxSizing::Content) {
|
|
// If the inner table frame has 'box-sizing: content', enlarge the occupied
|
|
// area by adding border & padding because they should also be subtracted
|
|
// from the size overrides.
|
|
areaOccupied += aBorderPadding;
|
|
}
|
|
|
|
StyleSizeOverrides innerSizeOverrides;
|
|
const auto& wrapperISize = aWrapperSizeOverrides.mStyleISize;
|
|
if (wrapperISize) {
|
|
MOZ_ASSERT(!wrapperISize->HasPercent(),
|
|
"Table doesn't support size overrides containing percentages!");
|
|
innerSizeOverrides.mStyleISize.emplace(
|
|
wrapperISize->ConvertsToLength()
|
|
? ReduceStyleSizeBy(*wrapperISize, areaOccupied.ISize(wm))
|
|
: *wrapperISize);
|
|
}
|
|
|
|
const auto& wrapperBSize = aWrapperSizeOverrides.mStyleBSize;
|
|
if (wrapperBSize) {
|
|
MOZ_ASSERT(!wrapperBSize->HasPercent(),
|
|
"Table doesn't support size overrides containing percentages!");
|
|
innerSizeOverrides.mStyleBSize.emplace(
|
|
wrapperBSize->ConvertsToLength()
|
|
? ReduceStyleSizeBy(*wrapperBSize, areaOccupied.BSize(wm))
|
|
: *wrapperBSize);
|
|
}
|
|
|
|
return innerSizeOverrides;
|
|
}
|
|
|
|
/* virtual */
|
|
nsIFrame::SizeComputationResult nsTableWrapperFrame::ComputeSize(
|
|
gfxContext* aRenderingContext, WritingMode aWM, const LogicalSize& aCBSize,
|
|
nscoord aAvailableISize, const LogicalSize& aMargin,
|
|
const LogicalSize& aBorderPadding, const StyleSizeOverrides& aSizeOverrides,
|
|
ComputeSizeFlags aFlags) {
|
|
auto result = nsContainerFrame::ComputeSize(
|
|
aRenderingContext, aWM, aCBSize, aAvailableISize, aMargin, aBorderPadding,
|
|
aSizeOverrides, aFlags);
|
|
|
|
if (aSizeOverrides.mApplyOverridesVerbatim &&
|
|
aSizeOverrides.HasAnyOverrides()) {
|
|
// We are asked to apply the size overrides directly to the inner table, but
|
|
// we still want ourselves to remain 'auto'-sized and shrink-wrapping our
|
|
// children's sizes. (Table wrapper frames always have 'auto' inline-size
|
|
// and block-size, since we don't inherit those properties from inner table,
|
|
// and authors can't target them with styling.)
|
|
auto size =
|
|
ComputeAutoSize(aRenderingContext, aWM, aCBSize, aAvailableISize,
|
|
aMargin, aBorderPadding, aSizeOverrides, aFlags);
|
|
result.mLogicalSize = size;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* virtual */
|
|
LogicalSize nsTableWrapperFrame::ComputeAutoSize(
|
|
gfxContext* aRenderingContext, WritingMode aWM, const LogicalSize& aCBSize,
|
|
nscoord aAvailableISize, const LogicalSize& aMargin,
|
|
const LogicalSize& aBorderPadding, const StyleSizeOverrides& aSizeOverrides,
|
|
ComputeSizeFlags aFlags) {
|
|
nscoord kidAvailableISize = aAvailableISize - aMargin.ISize(aWM);
|
|
NS_ASSERTION(aBorderPadding.IsAllZero(),
|
|
"Table wrapper frames cannot have borders or paddings");
|
|
|
|
// When we're shrink-wrapping, our auto size needs to wrap around the
|
|
// actual size of the table, which (if it is specified as a percent)
|
|
// could be something that is not reflected in our GetMinISize and
|
|
// GetPrefISize. See bug 349457 for an example.
|
|
const ComputeSizeFlags flags = CreateComputeSizeFlagsForChild();
|
|
|
|
// Match the logic in Reflow() that sets aside space for the caption.
|
|
Maybe<StyleCaptionSide> captionSide = GetCaptionSide();
|
|
|
|
const LogicalSize innerTableSize = InnerTableShrinkWrapSize(
|
|
aRenderingContext, InnerTableFrame(), aWM, aCBSize, kidAvailableISize,
|
|
aSizeOverrides, flags);
|
|
if (!captionSide) {
|
|
return innerTableSize;
|
|
}
|
|
const LogicalSize captionSize =
|
|
CaptionShrinkWrapSize(aRenderingContext, GetCaption(), aWM, aCBSize,
|
|
innerTableSize.ISize(aWM), flags);
|
|
const nscoord iSize =
|
|
std::max(innerTableSize.ISize(aWM), captionSize.ISize(aWM));
|
|
nscoord bSize = NS_UNCONSTRAINEDSIZE;
|
|
if (innerTableSize.BSize(aWM) != NS_UNCONSTRAINEDSIZE &&
|
|
captionSize.BSize(aWM) != NS_UNCONSTRAINEDSIZE) {
|
|
bSize = innerTableSize.BSize(aWM) + captionSize.BSize(aWM);
|
|
}
|
|
return LogicalSize(aWM, iSize, bSize);
|
|
}
|
|
|
|
Maybe<StyleCaptionSide> nsTableWrapperFrame::GetCaptionSide() const {
|
|
if (!HasCaption()) {
|
|
return Nothing();
|
|
}
|
|
return Some(GetCaption()->StyleTableBorder()->mCaptionSide);
|
|
}
|
|
|
|
StyleVerticalAlignKeyword nsTableWrapperFrame::GetCaptionVerticalAlign() const {
|
|
const auto& va = GetCaption()->StyleDisplay()->mVerticalAlign;
|
|
return va.IsKeyword() ? va.AsKeyword() : StyleVerticalAlignKeyword::Top;
|
|
}
|
|
|
|
nscoord nsTableWrapperFrame::ComputeFinalBSize(
|
|
const LogicalSize& aInnerSize, const LogicalSize& aCaptionSize,
|
|
const LogicalMargin& aCaptionMargin, const WritingMode aWM) const {
|
|
// negative sizes can upset overflow-area code
|
|
return std::max(0, aInnerSize.BSize(aWM) +
|
|
std::max(0, aCaptionSize.BSize(aWM) +
|
|
aCaptionMargin.BStartEnd(aWM)));
|
|
}
|
|
|
|
void nsTableWrapperFrame::GetCaptionOrigin(StyleCaptionSide aCaptionSide,
|
|
const LogicalSize& aInnerSize,
|
|
const LogicalSize& aCaptionSize,
|
|
LogicalMargin& aCaptionMargin,
|
|
LogicalPoint& aOrigin,
|
|
WritingMode aWM) const {
|
|
aOrigin.I(aWM) = aOrigin.B(aWM) = 0;
|
|
if ((NS_UNCONSTRAINEDSIZE == aInnerSize.ISize(aWM)) ||
|
|
(NS_UNCONSTRAINEDSIZE == aInnerSize.BSize(aWM)) ||
|
|
(NS_UNCONSTRAINEDSIZE == aCaptionSize.ISize(aWM)) ||
|
|
(NS_UNCONSTRAINEDSIZE == aCaptionSize.BSize(aWM))) {
|
|
return;
|
|
}
|
|
if (!HasCaption()) {
|
|
return;
|
|
}
|
|
|
|
NS_ASSERTION(NS_AUTOMARGIN != aCaptionMargin.IStart(aWM) &&
|
|
NS_AUTOMARGIN != aCaptionMargin.BStart(aWM) &&
|
|
NS_AUTOMARGIN != aCaptionMargin.BEnd(aWM),
|
|
"The computed caption margin is auto?");
|
|
|
|
aOrigin.I(aWM) = aCaptionMargin.IStart(aWM);
|
|
|
|
// block-dir computation
|
|
switch (aCaptionSide) {
|
|
case StyleCaptionSide::Bottom:
|
|
aOrigin.B(aWM) = aInnerSize.BSize(aWM) + aCaptionMargin.BStart(aWM);
|
|
break;
|
|
case StyleCaptionSide::Top:
|
|
aOrigin.B(aWM) = aCaptionMargin.BStart(aWM);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void nsTableWrapperFrame::GetInnerOrigin(const MaybeCaptionSide& aCaptionSide,
|
|
const LogicalSize& aCaptionSize,
|
|
const LogicalMargin& aCaptionMargin,
|
|
const LogicalSize& aInnerSize,
|
|
LogicalPoint& aOrigin,
|
|
WritingMode aWM) const {
|
|
NS_ASSERTION(NS_AUTOMARGIN != aCaptionMargin.IStart(aWM) &&
|
|
NS_AUTOMARGIN != aCaptionMargin.IEnd(aWM),
|
|
"The computed caption margin is auto?");
|
|
|
|
aOrigin.I(aWM) = aOrigin.B(aWM) = 0;
|
|
if ((NS_UNCONSTRAINEDSIZE == aInnerSize.ISize(aWM)) ||
|
|
(NS_UNCONSTRAINEDSIZE == aInnerSize.BSize(aWM)) ||
|
|
(NS_UNCONSTRAINEDSIZE == aCaptionSize.ISize(aWM)) ||
|
|
(NS_UNCONSTRAINEDSIZE == aCaptionSize.BSize(aWM))) {
|
|
return;
|
|
}
|
|
|
|
// block-dir computation
|
|
if (aCaptionSide) {
|
|
switch (*aCaptionSide) {
|
|
case StyleCaptionSide::Bottom:
|
|
// Leave at zero.
|
|
break;
|
|
case StyleCaptionSide::Top:
|
|
aOrigin.B(aWM) =
|
|
aCaptionSize.BSize(aWM) + aCaptionMargin.BStartEnd(aWM);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
ComputeSizeFlags nsTableWrapperFrame::CreateComputeSizeFlagsForChild() const {
|
|
// Shrink-wrap child frames by default, except if we're a stretched grid item.
|
|
if (MOZ_UNLIKELY(IsGridItem())) {
|
|
auto* gridContainer = static_cast<nsGridContainerFrame*>(GetParent());
|
|
if (gridContainer->GridItemShouldStretch(this, LogicalAxis::Inline)) {
|
|
return {};
|
|
}
|
|
}
|
|
return {ComputeSizeFlag::ShrinkWrap};
|
|
}
|
|
|
|
void nsTableWrapperFrame::CreateReflowInputForInnerTable(
|
|
nsPresContext* aPresContext, nsTableFrame* aTableFrame,
|
|
const ReflowInput& aOuterRI, Maybe<ReflowInput>& aChildRI,
|
|
const nscoord aAvailISize, nscoord aBSizeOccupiedByCaption) const {
|
|
MOZ_ASSERT(InnerTableFrame() == aTableFrame);
|
|
|
|
const WritingMode wm = aTableFrame->GetWritingMode();
|
|
// If we have a caption occupied our content-box area, reduce the available
|
|
// block-size by the amount.
|
|
nscoord availBSize = aOuterRI.AvailableBSize();
|
|
if (availBSize != NS_UNCONSTRAINEDSIZE) {
|
|
availBSize = std::max(0, availBSize - aBSizeOccupiedByCaption);
|
|
}
|
|
const LogicalSize availSize(wm, aAvailISize, availBSize);
|
|
|
|
// For inner table frames, the containing block is the same as for the outer
|
|
// table frame.
|
|
Maybe<LogicalSize> cbSize = Some(aOuterRI.mContainingBlockSize);
|
|
|
|
// However, if we are a grid item, the CB size needs to subtract our margins
|
|
// and the area occupied by the caption.
|
|
//
|
|
// Note that inner table computed margins are always zero, they're inherited
|
|
// by the table wrapper, so we need to get our margin from aOuterRI.
|
|
if (IsGridItem()) {
|
|
const LogicalMargin margin = aOuterRI.ComputedLogicalMargin(wm);
|
|
cbSize->ISize(wm) = std::max(0, cbSize->ISize(wm) - margin.IStartEnd(wm));
|
|
if (cbSize->BSize(wm) != NS_UNCONSTRAINEDSIZE) {
|
|
cbSize->BSize(wm) = std::max(0, cbSize->BSize(wm) - margin.BStartEnd(wm) -
|
|
aBSizeOccupiedByCaption);
|
|
}
|
|
}
|
|
|
|
ComputeSizeFlags csFlags = CreateComputeSizeFlagsForChild();
|
|
if (!aTableFrame->IsBorderCollapse() &&
|
|
!aOuterRI.mStyleSizeOverrides.HasAnyOverrides()) {
|
|
// We are not border-collapsed and not given any size overrides. It's
|
|
// sufficient to call the standard ReflowInput constructor.
|
|
aChildRI.emplace(aPresContext, aOuterRI, aTableFrame, availSize, cbSize,
|
|
ReflowInput::InitFlags{}, StyleSizeOverrides{}, csFlags);
|
|
return;
|
|
}
|
|
|
|
Maybe<LogicalMargin> borderPadding;
|
|
Maybe<LogicalMargin> padding;
|
|
{
|
|
// Compute inner table frame's border & padding because we may need to
|
|
// reduce the size for inner table's size overrides. We won't waste time if
|
|
// they are not used, because we can use them directly by passing them into
|
|
// ReflowInput::Init().
|
|
Maybe<LogicalMargin> collapseBorder;
|
|
Maybe<LogicalMargin> collapsePadding;
|
|
aTableFrame->GetCollapsedBorderPadding(collapseBorder, collapsePadding);
|
|
SizeComputationInput input(aTableFrame, aOuterRI.mRenderingContext, wm,
|
|
cbSize->ISize(wm), collapseBorder,
|
|
collapsePadding);
|
|
borderPadding.emplace(input.ComputedLogicalBorderPadding(wm));
|
|
padding.emplace(input.ComputedLogicalPadding(wm));
|
|
}
|
|
|
|
StyleSizeOverrides innerOverrides = ComputeSizeOverridesForInnerTable(
|
|
aTableFrame, aOuterRI.mStyleSizeOverrides, borderPadding->Size(wm),
|
|
aBSizeOccupiedByCaption);
|
|
|
|
aChildRI.emplace(aPresContext, aOuterRI, aTableFrame, availSize, Nothing(),
|
|
ReflowInput::InitFlag::CallerWillInit, innerOverrides,
|
|
csFlags);
|
|
aChildRI->Init(aPresContext, cbSize, Some(*borderPadding - *padding),
|
|
padding);
|
|
}
|
|
|
|
void nsTableWrapperFrame::CreateReflowInputForCaption(
|
|
nsPresContext* aPresContext, nsIFrame* aCaptionFrame,
|
|
const ReflowInput& aOuterRI, Maybe<ReflowInput>& aChildRI,
|
|
const nscoord aAvailISize) const {
|
|
MOZ_ASSERT(aCaptionFrame == GetCaption());
|
|
|
|
const WritingMode wm = aCaptionFrame->GetWritingMode();
|
|
|
|
// Use unconstrained available block-size so that the caption is always
|
|
// fully-complete.
|
|
const LogicalSize availSize(wm, aAvailISize, NS_UNCONSTRAINEDSIZE);
|
|
aChildRI.emplace(aPresContext, aOuterRI, aCaptionFrame, availSize);
|
|
|
|
// See if we need to reset mIsTopOfPage flag.
|
|
if (aChildRI->mFlags.mIsTopOfPage) {
|
|
if (auto captionSide = GetCaptionSide()) {
|
|
if (*captionSide == StyleCaptionSide::Bottom) {
|
|
aChildRI->mFlags.mIsTopOfPage = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void nsTableWrapperFrame::ReflowChild(nsPresContext* aPresContext,
|
|
nsIFrame* aChildFrame,
|
|
const ReflowInput& aChildRI,
|
|
ReflowOutput& aMetrics,
|
|
nsReflowStatus& aStatus) {
|
|
// Using zero as containerSize here because we want consistency between
|
|
// the GetLogicalPosition and ReflowChild calls, to avoid unnecessarily
|
|
// changing the frame's coordinates; but we don't yet know its final
|
|
// position anyway so the actual value is unimportant.
|
|
const nsSize zeroCSize;
|
|
WritingMode wm = aChildRI.GetWritingMode();
|
|
|
|
// Use the current position as a best guess for placement.
|
|
LogicalPoint childPt = aChildFrame->GetLogicalPosition(wm, zeroCSize);
|
|
ReflowChildFlags flags = ReflowChildFlags::NoMoveFrame;
|
|
|
|
// We don't want to delete our next-in-flow's child if it's an inner table
|
|
// frame, because table wrapper frames always assume that their inner table
|
|
// frames don't go away. If a table wrapper frame is removed because it is
|
|
// a next-in-flow of an already complete table wrapper frame, then it will
|
|
// take care of removing it's inner table frame.
|
|
if (aChildFrame == InnerTableFrame()) {
|
|
flags |= ReflowChildFlags::NoDeleteNextInFlowChild;
|
|
}
|
|
|
|
nsContainerFrame::ReflowChild(aChildFrame, aPresContext, aMetrics, aChildRI,
|
|
wm, childPt, zeroCSize, flags, aStatus);
|
|
}
|
|
|
|
void nsTableWrapperFrame::UpdateOverflowAreas(ReflowOutput& aMet) {
|
|
aMet.SetOverflowAreasToDesiredBounds();
|
|
for (auto* frame : mFrames) {
|
|
ConsiderChildOverflow(aMet.mOverflowAreas, frame);
|
|
}
|
|
}
|
|
|
|
void nsTableWrapperFrame::Reflow(nsPresContext* aPresContext,
|
|
ReflowOutput& aDesiredSize,
|
|
const ReflowInput& aOuterRI,
|
|
nsReflowStatus& aStatus) {
|
|
MarkInReflow();
|
|
DO_GLOBAL_REFLOW_COUNT("nsTableWrapperFrame");
|
|
MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
|
|
|
|
// Initialize out parameters
|
|
aDesiredSize.ClearSize();
|
|
|
|
if (!HasAnyStateBits(NS_FRAME_FIRST_REFLOW)) {
|
|
// Set up our kids. They're already present, on an overflow list,
|
|
// or there are none so we'll create them now
|
|
MoveOverflowToChildList();
|
|
}
|
|
|
|
Maybe<ReflowInput> captionRI;
|
|
Maybe<ReflowInput> innerRI;
|
|
|
|
nsRect origCaptionRect;
|
|
nsRect origCaptionInkOverflow;
|
|
bool captionFirstReflow = false;
|
|
if (nsIFrame* caption = GetCaption()) {
|
|
origCaptionRect = caption->GetRect();
|
|
origCaptionInkOverflow = caption->InkOverflowRect();
|
|
captionFirstReflow = caption->HasAnyStateBits(NS_FRAME_FIRST_REFLOW);
|
|
}
|
|
|
|
// ComputeAutoSize has to match this logic.
|
|
WritingMode wm = aOuterRI.GetWritingMode();
|
|
Maybe<StyleCaptionSide> captionSide = GetCaptionSide();
|
|
const nscoord contentBoxISize = aOuterRI.ComputedSize(wm).ISize(wm);
|
|
|
|
MOZ_ASSERT(HasCaption() == captionSide.isSome());
|
|
|
|
// Compute the table's size first, and then prevent the caption from
|
|
// being larger in the inline dir unless it has to be.
|
|
//
|
|
// Note that CSS 2.1 (but not 2.0) says:
|
|
// The width of the anonymous box is the border-edge width of the
|
|
// table box inside it
|
|
// We don't actually make our anonymous box that isize (if we did,
|
|
// it would break 'auto' margins), but this effectively does that.
|
|
CreateReflowInputForInnerTable(aPresContext, InnerTableFrame(), aOuterRI,
|
|
innerRI, contentBoxISize);
|
|
|
|
// First reflow the caption.
|
|
ReflowOutput captionMet(wm);
|
|
LogicalSize captionSize(wm);
|
|
LogicalMargin captionMargin(wm);
|
|
if (captionSide) {
|
|
// It's good that CSS 2.1 says not to include margins, since we can't, since
|
|
// they already been converted so they exactly fill the available isize
|
|
// (ignoring the margin on one side if neither are auto). (We take
|
|
// advantage of that later when we call GetCaptionOrigin, though.)
|
|
nscoord innerBorderISize =
|
|
innerRI->ComputedSizeWithBorderPadding(wm).ISize(wm);
|
|
CreateReflowInputForCaption(aPresContext, GetCaption(), aOuterRI, captionRI,
|
|
innerBorderISize);
|
|
|
|
// We intentionally don't merge capStatus into aStatus, since we currently
|
|
// can't handle caption continuations, but we probably should.
|
|
nsReflowStatus capStatus;
|
|
ReflowChild(aPresContext, GetCaption(), *captionRI, captionMet, capStatus);
|
|
captionSize = captionMet.Size(wm);
|
|
captionMargin = captionRI->ComputedLogicalMargin(wm);
|
|
nscoord bSizeOccupiedByCaption =
|
|
captionSize.BSize(wm) + captionMargin.BStartEnd(wm);
|
|
if (bSizeOccupiedByCaption) {
|
|
// Reset the inner table's ReflowInput to reduce various sizes because of
|
|
// the area occupied by caption.
|
|
innerRI.reset();
|
|
CreateReflowInputForInnerTable(aPresContext, InnerTableFrame(), aOuterRI,
|
|
innerRI, contentBoxISize,
|
|
bSizeOccupiedByCaption);
|
|
}
|
|
}
|
|
|
|
// Now we know how much to reduce the block-size for the inner table to
|
|
// account for captions. Reflow the inner table.
|
|
ReflowOutput innerMet(innerRI->GetWritingMode());
|
|
ReflowChild(aPresContext, InnerTableFrame(), *innerRI, innerMet, aStatus);
|
|
LogicalSize innerSize(wm, innerMet.ISize(wm), innerMet.BSize(wm));
|
|
|
|
// Now that we've reflowed both we can place them.
|
|
// Compute the desiredSize so that we can use it as the containerSize
|
|
// for the FinishReflowChild calls below.
|
|
LogicalSize desiredSize(wm);
|
|
|
|
// We have zero border and padding, so content-box inline-size is our desired
|
|
// border-box inline-size.
|
|
desiredSize.ISize(wm) = contentBoxISize;
|
|
desiredSize.BSize(wm) =
|
|
ComputeFinalBSize(innerSize, captionSize, captionMargin, wm);
|
|
|
|
aDesiredSize.SetSize(wm, desiredSize);
|
|
nsSize containerSize = aDesiredSize.PhysicalSize();
|
|
|
|
MOZ_ASSERT(HasCaption() == captionSide.isSome());
|
|
if (nsIFrame* caption = GetCaption()) {
|
|
LogicalPoint captionOrigin(wm);
|
|
GetCaptionOrigin(*captionSide, innerSize, captionSize, captionMargin,
|
|
captionOrigin, wm);
|
|
FinishReflowChild(caption, aPresContext, captionMet, captionRI.ptr(), wm,
|
|
captionOrigin, containerSize,
|
|
ReflowChildFlags::ApplyRelativePositioning);
|
|
captionRI.reset();
|
|
}
|
|
// XXX If the bsize is constrained then we need to check whether
|
|
// everything still fits...
|
|
|
|
LogicalPoint innerOrigin(wm);
|
|
GetInnerOrigin(captionSide, captionSize, captionMargin, innerSize,
|
|
innerOrigin, wm);
|
|
// NOTE: Relative positioning on the table applies to the whole table wrapper.
|
|
FinishReflowChild(InnerTableFrame(), aPresContext, innerMet, innerRI.ptr(),
|
|
wm, innerOrigin, containerSize, ReflowChildFlags::Default);
|
|
innerRI.reset();
|
|
|
|
if (HasCaption()) {
|
|
nsTableFrame::InvalidateTableFrame(GetCaption(), origCaptionRect,
|
|
origCaptionInkOverflow,
|
|
captionFirstReflow);
|
|
}
|
|
|
|
UpdateOverflowAreas(aDesiredSize);
|
|
|
|
if (GetPrevInFlow()) {
|
|
ReflowOverflowContainerChildren(aPresContext, aOuterRI,
|
|
aDesiredSize.mOverflowAreas,
|
|
ReflowChildFlags::Default, aStatus);
|
|
}
|
|
|
|
FinishReflowWithAbsoluteFrames(aPresContext, aDesiredSize, aOuterRI, aStatus);
|
|
}
|
|
|
|
/* ----- global methods ----- */
|
|
|
|
nsIContent* nsTableWrapperFrame::GetCellAt(uint32_t aRowIdx,
|
|
uint32_t aColIdx) const {
|
|
nsTableCellMap* cellMap = InnerTableFrame()->GetCellMap();
|
|
if (!cellMap) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsTableCellFrame* cell = cellMap->GetCellInfoAt(aRowIdx, aColIdx);
|
|
if (!cell) {
|
|
return nullptr;
|
|
}
|
|
|
|
return cell->GetContent();
|
|
}
|
|
|
|
nsTableWrapperFrame* NS_NewTableWrapperFrame(PresShell* aPresShell,
|
|
ComputedStyle* aStyle) {
|
|
return new (aPresShell)
|
|
nsTableWrapperFrame(aStyle, aPresShell->GetPresContext());
|
|
}
|
|
|
|
NS_IMPL_FRAMEARENA_HELPERS(nsTableWrapperFrame)
|
|
|
|
#ifdef DEBUG_FRAME_DUMP
|
|
nsresult nsTableWrapperFrame::GetFrameName(nsAString& aResult) const {
|
|
return MakeFrameName(u"TableWrapper"_ns, aResult);
|
|
}
|
|
#endif
|