nagai/fune
3
0
Fork 0
forked from mirrors/gecko-dev
Code Pull requests Activity
fune/layout/tables/nsTableWrapperFrame.cpp
Emilio Cobos Álvarez a8cfb8a96f Bug 1472602 - Sticky/relative position fixes in nsTableWrapperFrame. r=dholbert 
Captions should be relatively-positioned (other browsers support this as
well). This ensures we correctly save their normal positions and thus
that the sticky scroll container knows how to reposition them correctly.

Avoid registering inner table frames with the sticky scroll container to
make the assertion sound in cases of sticky-positioned tables.

Differential Revision: https://phabricator.services.mozilla.com/D147092
2022-05-23 23:40:42 +00:00

1077 lines
43 KiB
C++
Raw Blame History

/* -*- 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 "mozilla/ComputedStyle.h"
#include "mozilla/PresShell.h"
#include "nsFrameManager.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;
/* virtual */
nscoord nsTableWrapperFrame::GetLogicalBaseline(
WritingMode aWritingMode) const {
if (StyleDisplay()->IsContainLayout()) {
// We have no baseline. Fall back to the inherited impl which is
// appropriate for this situation.
return nsContainerFrame::GetLogicalBaseline(aWritingMode);
}
nsIFrame* kid = mFrames.FirstChild();
if (!kid) {
MOZ_ASSERT_UNREACHABLE("no inner table");
return nsContainerFrame::GetLogicalBaseline(aWritingMode);
}
return kid->GetLogicalBaseline(aWritingMode) +
kid->BStart(aWritingMode, mRect.Size());
}
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::DestroyFrom(nsIFrame* aDestructRoot,
PostDestroyData& aPostDestroyData) {
DestroyAbsoluteFrames(aDestructRoot, aPostDestroyData);
mCaptionFrames.DestroyFramesFrom(aDestructRoot, aPostDestroyData);
nsContainerFrame::DestroyFrom(aDestructRoot, aPostDestroyData);
}
const nsFrameList& nsTableWrapperFrame::GetChildList(
ChildListID aListID) const {
if (aListID == kCaptionList) {
return mCaptionFrames;
}
return nsContainerFrame::GetChildList(aListID);
}
void nsTableWrapperFrame::GetChildLists(nsTArray<ChildList>* aLists) const {
nsContainerFrame::GetChildLists(aLists);
mCaptionFrames.AppendIfNonempty(aLists, kCaptionList);
}
void nsTableWrapperFrame::SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList) {
if (kCaptionList == aListID) {
#ifdef DEBUG
nsIFrame::VerifyDirtyBitSet(aChildList);
for (nsIFrame* f : aChildList) {
MOZ_ASSERT(f->GetParent() == this, "Unexpected parent");
}
#endif
// the frame constructor already checked for table-caption display type
MOZ_ASSERT(mCaptionFrames.IsEmpty(),
"already have child frames in CaptionList");
mCaptionFrames.SetFrames(aChildList);
} else {
MOZ_ASSERT(kPrincipalList != aListID ||
(aChildList.FirstChild() &&
aChildList.FirstChild() == aChildList.LastChild() &&
aChildList.FirstChild()->IsTableFrame()),
"expected a single table frame in principal child list");
nsContainerFrame::SetInitialChildList(aListID, aChildList);
}
}
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(kCaptionList == aListID, "unexpected child list");
MOZ_ASSERT(aFrameList.IsEmpty() || aFrameList.FirstChild()->IsTableCaption(),
"appending non-caption frame to captionList");
mCaptionFrames.AppendFrames(nullptr, aFrameList);
// Reflow the new caption frame. It's already marked dirty, so
// just tell the pres shell.
PresShell()->FrameNeedsReflow(this, IntrinsicDirty::TreeChange,
NS_FRAME_HAS_DIRTY_CHILDREN);
// 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(kCaptionList == aListID, "unexpected child list");
MOZ_ASSERT(aFrameList.IsEmpty() || aFrameList.FirstChild()->IsTableCaption(),
"inserting non-caption frame into captionList");
MOZ_ASSERT(!aPrevFrame || aPrevFrame->GetParent() == this,
"inserting after sibling frame with different parent");
mCaptionFrames.InsertFrames(nullptr, aPrevFrame, aFrameList);
// Reflow the new caption frame. It's already marked dirty, so
// just tell the pres shell.
PresShell()->FrameNeedsReflow(this, IntrinsicDirty::TreeChange,
NS_FRAME_HAS_DIRTY_CHILDREN);
MarkNeedsDisplayItemRebuild();
}
void nsTableWrapperFrame::RemoveFrame(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(kCaptionList == aListID, "can't remove inner frame");
if (HasSideCaption()) {
// The old caption isize had an effect on the inner table isize, so
// we're going to need to reflow it. Mark it dirty
InnerTableFrame()->MarkSubtreeDirty();
}
// Remove the frame and destroy it
mCaptionFrames.DestroyFrame(aOldFrame);
PresShell()->FrameNeedsReflow(this, IntrinsicDirty::TreeChange,
NS_FRAME_HAS_DIRTY_CHILDREN);
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 (mCaptionFrames.IsEmpty()) {
BuildDisplayListForInnerTable(aBuilder, aLists);
DisplayOutline(aBuilder, aLists);
return;
}
nsDisplayListCollection set(aBuilder);
BuildDisplayListForInnerTable(aBuilder, set);
nsDisplayListSet captionSet(set, set.BlockBorderBackgrounds());
BuildDisplayListForChild(aBuilder, mCaptionFrames.FirstChild(), captionSet);
// 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);
}
void nsTableWrapperFrame::BuildDisplayListForInnerTable(
nsDisplayListBuilder* aBuilder, const nsDisplayListSet& aLists) {
// Just paint the regular children, but the children's background is our
// true background (there should only be one, the real table)
nsIFrame* kid = mFrames.FirstChild();
// The children should be in content order
while (kid) {
BuildDisplayListForChild(aBuilder, kid, aLists);
kid = kid->GetNextSibling();
}
}
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();
}
static nsSize GetContainingBlockSize(const ReflowInput& aOuterRI) {
nsSize size(0, 0);
const ReflowInput* containRS = aOuterRI.mCBReflowInput;
if (containRS) {
size.width = containRS->ComputedWidth();
if (NS_UNCONSTRAINEDSIZE == size.width) {
size.width = 0;
}
size.height = containRS->ComputedHeight();
if (NS_UNCONSTRAINEDSIZE == size.height) {
size.height = 0;
}
}
return size;
}
/* virtual */
nscoord nsTableWrapperFrame::GetMinISize(gfxContext* aRenderingContext) {
nscoord iSize = nsLayoutUtils::IntrinsicForContainer(
aRenderingContext, InnerTableFrame(), IntrinsicISizeType::MinISize);
DISPLAY_MIN_INLINE_SIZE(this, iSize);
if (mCaptionFrames.NotEmpty()) {
nscoord capISize = nsLayoutUtils::IntrinsicForContainer(
aRenderingContext, mCaptionFrames.FirstChild(),
IntrinsicISizeType::MinISize);
if (HasSideCaption()) {
iSize += capISize;
} else {
if (capISize > iSize) {
iSize = capISize;
}
}
}
return iSize;
}
/* virtual */
nscoord nsTableWrapperFrame::GetPrefISize(gfxContext* aRenderingContext) {
nscoord maxISize;
DISPLAY_PREF_INLINE_SIZE(this, maxISize);
maxISize = nsLayoutUtils::IntrinsicForContainer(
aRenderingContext, InnerTableFrame(), IntrinsicISizeType::PrefISize);
if (Maybe<StyleCaptionSide> captionSide = GetCaptionSide()) {
switch (*captionSide) {
case StyleCaptionSide::Left:
case StyleCaptionSide::Right: {
nscoord capMin = nsLayoutUtils::IntrinsicForContainer(
aRenderingContext, mCaptionFrames.FirstChild(),
IntrinsicISizeType::MinISize);
maxISize += capMin;
} break;
default: {
IntrinsicISizeType iwt;
if (*captionSide == StyleCaptionSide::Top ||
*captionSide == StyleCaptionSide::Bottom) {
// Don't let the caption's pref isize expand the table's pref
// isize.
iwt = IntrinsicISizeType::MinISize;
} else {
MOZ_ASSERT(*captionSide == StyleCaptionSide::TopOutside ||
*captionSide == StyleCaptionSide::BottomOutside,
"unexpected caption side");
iwt = IntrinsicISizeType::PrefISize;
}
nscoord capPref = nsLayoutUtils::IntrinsicForContainer(
aRenderingContext, mCaptionFrames.FirstChild(), iwt);
maxISize = std::max(maxISize, capPref);
} break;
}
}
return maxISize;
}
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().
const LogicalSize areaOccupiedByCaption(aWM);
StyleSizeOverrides innerOverrides = ComputeSizeOverridesForInnerTable(
aTableFrame, aSizeOverrides, bpSize, areaOccupiedByCaption);
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 == mCaptionFrames.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,
const LogicalSize& aAreaOccupiedByCaption) 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 = aAreaOccupiedByCaption;
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.
// Shrink-wrap aChildFrame by default, except if we're a stretched grid item.
ComputeSizeFlags flags(ComputeSizeFlag::ShrinkWrap);
if (MOZ_UNLIKELY(IsGridItem()) && !StyleMargin()->HasInlineAxisAuto(aWM)) {
const auto* parent = GetParent();
auto inlineAxisAlignment =
aWM.IsOrthogonalTo(parent->GetWritingMode())
? StylePosition()->UsedAlignSelf(parent->Style())._0
: StylePosition()->UsedJustifySelf(parent->Style())._0;
if (inlineAxisAlignment == StyleAlignFlags::NORMAL ||
inlineAxisAlignment == StyleAlignFlags::STRETCH) {
flags -= ComputeSizeFlag::ShrinkWrap;
}
}
// Match the availableISize logic in Reflow.
Maybe<StyleCaptionSide> captionSide = GetCaptionSide();
// The result.ISize() is unconditionally set to a meaningful value in the
// logic that follows, but the unconstrained BSize() value might be used for
// cases where either BSize is indeed unconstrained).
LogicalSize result(aWM, 0, NS_UNCONSTRAINEDSIZE);
if (!captionSide) {
result = InnerTableShrinkWrapSize(aRenderingContext, InnerTableFrame(), aWM,
aCBSize, kidAvailableISize,
aSizeOverrides, flags);
} else if (*captionSide == StyleCaptionSide::Left ||
*captionSide == StyleCaptionSide::Right) {
const LogicalSize captionSize =
CaptionShrinkWrapSize(aRenderingContext, mCaptionFrames.FirstChild(),
aWM, aCBSize, kidAvailableISize, flags);
const LogicalSize innerTableSize = InnerTableShrinkWrapSize(
aRenderingContext, InnerTableFrame(), aWM, aCBSize,
kidAvailableISize - captionSize.ISize(aWM), aSizeOverrides, flags);
result.ISize(aWM) = captionSize.ISize(aWM) + innerTableSize.ISize(aWM);
if (captionSize.BSize(aWM) != NS_UNCONSTRAINEDSIZE &&
innerTableSize.BSize(aWM) != NS_UNCONSTRAINEDSIZE) {
result.BSize(aWM) =
std::max(captionSize.BSize(aWM), innerTableSize.BSize(aWM));
}
} else if (*captionSide == StyleCaptionSide::Top ||
*captionSide == StyleCaptionSide::Bottom) {
const LogicalSize innerTableSize = InnerTableShrinkWrapSize(
aRenderingContext, InnerTableFrame(), aWM, aCBSize, kidAvailableISize,
aSizeOverrides, flags);
const LogicalSize captionSize =
CaptionShrinkWrapSize(aRenderingContext, mCaptionFrames.FirstChild(),
aWM, aCBSize, innerTableSize.ISize(aWM), flags);
result.ISize(aWM) =
std::max(innerTableSize.ISize(aWM), captionSize.ISize(aWM));
if (innerTableSize.BSize(aWM) != NS_UNCONSTRAINEDSIZE &&
captionSize.BSize(aWM) != NS_UNCONSTRAINEDSIZE) {
result.BSize(aWM) = innerTableSize.BSize(aWM) + captionSize.BSize(aWM);
}
} else {
MOZ_ASSERT(*captionSide == StyleCaptionSide::TopOutside ||
*captionSide == StyleCaptionSide::BottomOutside,
"unexpected caption-side");
const LogicalSize innerTableSize = InnerTableShrinkWrapSize(
aRenderingContext, InnerTableFrame(), aWM, aCBSize, kidAvailableISize,
aSizeOverrides, flags);
const LogicalSize captionSize =
CaptionShrinkWrapSize(aRenderingContext, mCaptionFrames.FirstChild(),
aWM, aCBSize, kidAvailableISize, flags);
result.ISize(aWM) =
std::max(innerTableSize.ISize(aWM), captionSize.ISize(aWM));
if (innerTableSize.BSize(aWM) != NS_UNCONSTRAINEDSIZE &&
captionSize.BSize(aWM) != NS_UNCONSTRAINEDSIZE) {
result.BSize(aWM) = innerTableSize.BSize(aWM) + captionSize.BSize(aWM);
}
}
return result;
}
Maybe<StyleCaptionSide> nsTableWrapperFrame::GetCaptionSide() const {
if (mCaptionFrames.IsEmpty()) {
return Nothing();
}
return Some(mCaptionFrames.FirstChild()->StyleTableBorder()->mCaptionSide);
}
StyleVerticalAlignKeyword nsTableWrapperFrame::GetCaptionVerticalAlign() const {
const auto& va = mCaptionFrames.FirstChild()->StyleDisplay()->mVerticalAlign;
return va.IsKeyword() ? va.AsKeyword() : StyleVerticalAlignKeyword::Top;
}
nscoord nsTableWrapperFrame::ComputeFinalBSize(
const MaybeCaptionSide& aCaptionSide, const LogicalSize& aInnerSize,
const LogicalSize& aCaptionSize, const LogicalMargin& aCaptionMargin,
const WritingMode aWM) const {
nscoord bSize = aInnerSize.BSize(aWM);
// compute the overall block-size
if (aCaptionSide) {
switch (*aCaptionSide) {
case StyleCaptionSide::Top:
case StyleCaptionSide::TopOutside:
case StyleCaptionSide::Bottom:
case StyleCaptionSide::BottomOutside:
bSize = aInnerSize.BSize(aWM) +
std::max(
0, aCaptionSize.BSize(aWM) + aCaptionMargin.BStartEnd(aWM));
break;
case StyleCaptionSide::Left:
case StyleCaptionSide::Right:
bSize = std::max(aInnerSize.BSize(aWM),
aCaptionSize.BSize(aWM) + aCaptionMargin.BEnd(aWM));
break;
}
}
// negative sizes can upset overflow-area code
return std::max(bSize, 0);
}
nsresult nsTableWrapperFrame::GetCaptionOrigin(
StyleCaptionSide aCaptionSide, const LogicalSize& aContainBlockSize,
const LogicalSize& aInnerSize, const LogicalSize& aCaptionSize,
LogicalMargin& aCaptionMargin, LogicalPoint& aOrigin, WritingMode aWM) {
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 NS_OK;
}
if (mCaptionFrames.IsEmpty()) {
return NS_OK;
}
NS_ASSERTION(NS_AUTOMARGIN != aCaptionMargin.IStart(aWM) &&
NS_AUTOMARGIN != aCaptionMargin.BStart(aWM) &&
NS_AUTOMARGIN != aCaptionMargin.BEnd(aWM),
"The computed caption margin is auto?");
// inline-dir computation
switch (aCaptionSide) {
case StyleCaptionSide::Top:
case StyleCaptionSide::TopOutside:
case StyleCaptionSide::Bottom:
case StyleCaptionSide::BottomOutside:
aOrigin.I(aWM) = aCaptionMargin.IStart(aWM);
break;
case StyleCaptionSide::Left:
case StyleCaptionSide::Right:
aOrigin.I(aWM) = aCaptionMargin.IStart(aWM);
if (aWM.IsBidiLTR() == (aCaptionSide == StyleCaptionSide::Right)) {
aOrigin.I(aWM) += aInnerSize.ISize(aWM);
}
break;
}
// block-dir computation
switch (aCaptionSide) {
case StyleCaptionSide::Right:
case StyleCaptionSide::Left:
aOrigin.B(aWM) = 0;
switch (GetCaptionVerticalAlign()) {
case StyleVerticalAlignKeyword::Middle:
aOrigin.B(aWM) = std::max(
0, (aInnerSize.BSize(aWM) - aCaptionSize.BSize(aWM)) / 2);
break;
case StyleVerticalAlignKeyword::Bottom:
aOrigin.B(aWM) =
std::max(0, aInnerSize.BSize(aWM) - aCaptionSize.BSize(aWM));
break;
default:
break;
}
break;
case StyleCaptionSide::BottomOutside:
case StyleCaptionSide::Bottom:
aOrigin.B(aWM) = aInnerSize.BSize(aWM) + aCaptionMargin.BStart(aWM);
break;
case StyleCaptionSide::TopOutside:
case StyleCaptionSide::Top:
aOrigin.B(aWM) = aCaptionMargin.BStart(aWM);
break;
}
return NS_OK;
}
nsresult nsTableWrapperFrame::GetInnerOrigin(
const MaybeCaptionSide& aCaptionSide, const LogicalSize& aContainBlockSize,
const LogicalSize& aCaptionSize, const LogicalMargin& aCaptionMargin,
const LogicalSize& aInnerSize, LogicalPoint& aOrigin, WritingMode aWM) {
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 NS_OK;
}
nscoord minCapISize = aCaptionSize.ISize(aWM) + aCaptionMargin.IStartEnd(aWM);
// inline-dir computation
if (aCaptionSide && IsSideCaption(*aCaptionSide)) {
aOrigin.I(aWM) =
(aWM.IsBidiLTR() == (*aCaptionSide == StyleCaptionSide::Left))
? minCapISize
: 0;
}
// block-dir computation
if (aCaptionSide) {
switch (*aCaptionSide) {
case StyleCaptionSide::Bottom:
case StyleCaptionSide::BottomOutside:
// Leave at zero.
break;
case StyleCaptionSide::Left:
case StyleCaptionSide::Right:
switch (GetCaptionVerticalAlign()) {
case StyleVerticalAlignKeyword::Middle:
aOrigin.B(aWM) = std::max(
0, (aCaptionSize.BSize(aWM) - aInnerSize.BSize(aWM)) / 2);
break;
case StyleVerticalAlignKeyword::Bottom:
aOrigin.B(aWM) =
std::max(0, aCaptionSize.BSize(aWM) - aInnerSize.BSize(aWM));
break;
default:
// Leave at zero.
break;
}
break;
case StyleCaptionSide::TopOutside:
case StyleCaptionSide::Top:
aOrigin.B(aWM) =
aCaptionSize.BSize(aWM) + aCaptionMargin.BStartEnd(aWM);
break;
}
}
return NS_OK;
}
LogicalSize nsTableWrapperFrame::GetAreaOccupiedByCaption(
StyleCaptionSide aCaptionSide,
const mozilla::LogicalSize& aCaptionMarginBoxSize) const {
const WritingMode wm = GetWritingMode();
LogicalSize area(wm);
switch (aCaptionSide) {
case StyleCaptionSide::Top:
case StyleCaptionSide::Bottom:
case StyleCaptionSide::TopOutside:
case StyleCaptionSide::BottomOutside:
area.BSize(wm) = aCaptionMarginBoxSize.BSize(wm);
break;
case StyleCaptionSide::Left:
case StyleCaptionSide::Right:
area.ISize(wm) = aCaptionMarginBoxSize.ISize(wm);
break;
}
return area;
}
void nsTableWrapperFrame::CreateReflowInputForInnerTable(
nsPresContext* aPresContext, nsTableFrame* aTableFrame,
const ReflowInput& aOuterRI, Maybe<ReflowInput>& aChildRI,
const nscoord aAvailISize,
const Maybe<LogicalSize>& aAreaOccupiedByCaption) const {
MOZ_ASSERT(InnerTableFrame() == aTableFrame);
const WritingMode wm = aTableFrame->GetWritingMode();
const LogicalSize areaOccupiedByCaption =
aAreaOccupiedByCaption ? *aAreaOccupiedByCaption : LogicalSize(wm);
// 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 - areaOccupiedByCaption.BSize(wm));
}
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) -
areaOccupiedByCaption.ISize(wm));
if (cbSize->BSize(wm) != NS_UNCONSTRAINEDSIZE) {
cbSize->BSize(wm) = std::max(0, cbSize->BSize(wm) - margin.BStartEnd(wm) -
areaOccupiedByCaption.BSize(wm));
}
}
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);
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),
areaOccupiedByCaption);
aChildRI.emplace(aPresContext, aOuterRI, aTableFrame, availSize, Nothing(),
ReflowInput::InitFlag::CallerWillInit, innerOverrides);
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 == mCaptionFrames.FirstChild());
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 ||
*captionSide == StyleCaptionSide::BottomOutside) {
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();
ConsiderChildOverflow(aMet.mOverflowAreas, InnerTableFrame());
if (mCaptionFrames.NotEmpty()) {
ConsiderChildOverflow(aMet.mOverflowAreas, mCaptionFrames.FirstChild());
}
}
void nsTableWrapperFrame::Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aOuterRI,
nsReflowStatus& aStatus) {
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsTableWrapperFrame");
DISPLAY_REFLOW(aPresContext, this, aOuterRI, aDesiredSize, aStatus);
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 (mCaptionFrames.NotEmpty()) {
origCaptionRect = mCaptionFrames.FirstChild()->GetRect();
origCaptionInkOverflow = mCaptionFrames.FirstChild()->InkOverflowRect();
captionFirstReflow =
mCaptionFrames.FirstChild()->HasAnyStateBits(NS_FRAME_FIRST_REFLOW);
}
// ComputeAutoSize has to match this logic.
WritingMode wm = aOuterRI.GetWritingMode();
Maybe<StyleCaptionSide> captionSide = GetCaptionSide();
WritingMode captionWM = wm; // will be changed below if necessary
const nscoord contentBoxISize = aOuterRI.ComputedSize(wm).ISize(wm);
MOZ_ASSERT(mCaptionFrames.NotEmpty() == captionSide.isSome());
if (!captionSide) {
// We don't have a caption.
CreateReflowInputForInnerTable(aPresContext, InnerTableFrame(), aOuterRI,
innerRI, contentBoxISize);
} else if (*captionSide == StyleCaptionSide::Left ||
*captionSide == StyleCaptionSide::Right) {
// ComputeAutoSize takes care of making side captions small. Compute
// the caption's size first, and tell the table to fit in what's left.
CreateReflowInputForCaption(aPresContext, mCaptionFrames.FirstChild(),
aOuterRI, captionRI, contentBoxISize);
captionWM = captionRI->GetWritingMode();
nscoord innerAvailISize =
contentBoxISize -
captionRI->ComputedSizeWithMarginBorderPadding(wm).ISize(wm);
CreateReflowInputForInnerTable(aPresContext, InnerTableFrame(), aOuterRI,
innerRI, innerAvailISize);
} else if (*captionSide == StyleCaptionSide::Top ||
*captionSide == StyleCaptionSide::Bottom) {
// 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);
// 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, mCaptionFrames.FirstChild(),
aOuterRI, captionRI, innerBorderISize);
captionWM = captionRI->GetWritingMode();
} else {
MOZ_ASSERT(*captionSide == StyleCaptionSide::TopOutside ||
*captionSide == StyleCaptionSide::BottomOutside,
"unexpected caption-side");
// Size the table and the caption independently.
captionWM = mCaptionFrames.FirstChild()->GetWritingMode();
CreateReflowInputForCaption(
aPresContext, mCaptionFrames.FirstChild(), aOuterRI, captionRI,
aOuterRI.ComputedSize(captionWM).ISize(captionWM));
CreateReflowInputForInnerTable(aPresContext, InnerTableFrame(), aOuterRI,
innerRI, contentBoxISize);
}
// First reflow the caption.
Maybe<ReflowOutput> captionMet;
LogicalSize captionSize(wm);
LogicalMargin captionMargin(wm);
Maybe<LogicalSize> areaOccupiedByCaption;
if (captionSide) {
captionMet.emplace(wm);
// We intentionally don't merge capStatus into aStatus, since we currently
// can't handle caption continuations, but we probably should.
nsReflowStatus capStatus;
ReflowChild(aPresContext, mCaptionFrames.FirstChild(), *captionRI,
*captionMet, capStatus);
captionSize = captionMet->Size(wm);
captionMargin = captionRI->ComputedLogicalMargin(wm);
areaOccupiedByCaption.emplace(GetAreaOccupiedByCaption(
*captionSide, captionSize + captionMargin.Size(wm)));
if (!areaOccupiedByCaption->IsAllZero()) {
// 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,
areaOccupiedByCaption);
}
}
// Then, now that we know how much to reduce the isize of the inner
// table to account for side captions, reflow the inner table.
ReflowOutput innerMet(innerRI->GetWritingMode());
ReflowChild(aPresContext, InnerTableFrame(), *innerRI, innerMet, aStatus);
LogicalSize innerSize(wm, innerMet.ISize(wm), innerMet.BSize(wm));
LogicalSize containSize(wm, GetContainingBlockSize(aOuterRI));
// Now that we've reflowed both we can place them.
// XXXldb Most of the input variables here are now uninitialized!
// XXX Need to recompute inner table's auto margins for the case of side
// captions. (Caption's are broken too, but that should be fixed earlier.)
// 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(captionSide, innerSize, captionSize, captionMargin, wm);
aDesiredSize.SetSize(wm, desiredSize);
nsSize containerSize = aDesiredSize.PhysicalSize();
// XXX It's possible for this to be NS_UNCONSTRAINEDSIZE, which will result
// in assertions from FinishReflowChild.
MOZ_ASSERT(mCaptionFrames.NotEmpty() == captionSide.isSome());
if (mCaptionFrames.NotEmpty()) {
LogicalPoint captionOrigin(wm);
GetCaptionOrigin(*captionSide, containSize, innerSize, captionSize,
captionMargin, captionOrigin, wm);
FinishReflowChild(mCaptionFrames.FirstChild(), 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, containSize, 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 (mCaptionFrames.NotEmpty()) {
nsTableFrame::InvalidateTableFrame(mCaptionFrames.FirstChild(),
origCaptionRect, origCaptionInkOverflow,
captionFirstReflow);
}
UpdateOverflowAreas(aDesiredSize);
if (GetPrevInFlow()) {
ReflowOverflowContainerChildren(aPresContext, aOuterRI,
aDesiredSize.mOverflowAreas,
ReflowChildFlags::Default, aStatus);
}
FinishReflowWithAbsoluteFrames(aPresContext, aDesiredSize, aOuterRI, aStatus);
// Return our desired rect
NS_FRAME_SET_TRUNCATION(aStatus, aOuterRI, aDesiredSize);
}
/* ----- 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
View git blame Copy permalink