summaryrefslogtreecommitdiffstats
path: root/layout/tables/nsTableRowFrame.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /layout/tables/nsTableRowFrame.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'layout/tables/nsTableRowFrame.cpp')
-rw-r--r--layout/tables/nsTableRowFrame.cpp1517
1 files changed, 1517 insertions, 0 deletions
diff --git a/layout/tables/nsTableRowFrame.cpp b/layout/tables/nsTableRowFrame.cpp
new file mode 100644
index 000000000..81b5d6699
--- /dev/null
+++ b/layout/tables/nsTableRowFrame.cpp
@@ -0,0 +1,1517 @@
+/* -*- 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 "mozilla/Maybe.h"
+
+#include "nsTableRowFrame.h"
+#include "nsTableRowGroupFrame.h"
+#include "nsIPresShell.h"
+#include "nsPresContext.h"
+#include "nsStyleContext.h"
+#include "nsStyleConsts.h"
+#include "nsGkAtoms.h"
+#include "nsIContent.h"
+#include "nsTableFrame.h"
+#include "nsTableCellFrame.h"
+#include "nsCSSRendering.h"
+#include "nsHTMLParts.h"
+#include "nsTableColGroupFrame.h"
+#include "nsTableColFrame.h"
+#include "nsCOMPtr.h"
+#include "nsDisplayList.h"
+#include "nsIFrameInlines.h"
+#include <algorithm>
+
+using namespace mozilla;
+
+namespace mozilla {
+
+struct TableCellReflowInput : public ReflowInput
+{
+ TableCellReflowInput(nsPresContext* aPresContext,
+ const ReflowInput& aParentReflowInput,
+ nsIFrame* aFrame,
+ const LogicalSize& aAvailableSpace,
+ uint32_t aFlags = 0)
+ : ReflowInput(aPresContext, aParentReflowInput, aFrame,
+ aAvailableSpace, nullptr, aFlags)
+ {
+ }
+
+ void FixUp(const LogicalSize& aAvailSpace);
+};
+
+} // namespace mozilla
+
+void TableCellReflowInput::FixUp(const LogicalSize& aAvailSpace)
+{
+ // fix the mComputed values during a pass 2 reflow since the cell can be a percentage base
+ NS_WARNING_ASSERTION(
+ NS_UNCONSTRAINEDSIZE != aAvailSpace.ISize(mWritingMode),
+ "have unconstrained inline-size; this should only result from very large "
+ "sizes, not attempts at intrinsic inline size calculation");
+ if (NS_UNCONSTRAINEDSIZE != ComputedISize()) {
+ nscoord computedISize = aAvailSpace.ISize(mWritingMode) -
+ ComputedLogicalBorderPadding().IStartEnd(mWritingMode);
+ computedISize = std::max(0, computedISize);
+ SetComputedISize(computedISize);
+ }
+ if (NS_UNCONSTRAINEDSIZE != ComputedBSize() &&
+ NS_UNCONSTRAINEDSIZE != aAvailSpace.BSize(mWritingMode)) {
+ nscoord computedBSize = aAvailSpace.BSize(mWritingMode) -
+ ComputedLogicalBorderPadding().BStartEnd(mWritingMode);
+ computedBSize = std::max(0, computedBSize);
+ SetComputedBSize(computedBSize);
+ }
+}
+
+void
+nsTableRowFrame::InitChildReflowInput(nsPresContext& aPresContext,
+ const LogicalSize& aAvailSize,
+ bool aBorderCollapse,
+ TableCellReflowInput& aReflowInput)
+{
+ nsMargin collapseBorder;
+ nsMargin* pCollapseBorder = nullptr;
+ if (aBorderCollapse) {
+ // we only reflow cells, so don't need to check frame type
+ nsBCTableCellFrame* bcCellFrame = (nsBCTableCellFrame*)aReflowInput.mFrame;
+ if (bcCellFrame) {
+ WritingMode wm = GetWritingMode();
+ collapseBorder = bcCellFrame->GetBorderWidth(wm).GetPhysicalMargin(wm);
+ pCollapseBorder = &collapseBorder;
+ }
+ }
+ aReflowInput.Init(&aPresContext, nullptr, pCollapseBorder);
+ aReflowInput.FixUp(aAvailSize);
+}
+
+void
+nsTableRowFrame::SetFixedBSize(nscoord aValue)
+{
+ nscoord bsize = std::max(0, aValue);
+ if (HasFixedBSize()) {
+ if (bsize > mStyleFixedBSize) {
+ mStyleFixedBSize = bsize;
+ }
+ }
+ else {
+ mStyleFixedBSize = bsize;
+ if (bsize > 0) {
+ SetHasFixedBSize(true);
+ }
+ }
+}
+
+void
+nsTableRowFrame::SetPctBSize(float aPctValue,
+ bool aForce)
+{
+ nscoord bsize = std::max(0, NSToCoordRound(aPctValue * 100.0f));
+ if (HasPctBSize()) {
+ if ((bsize > mStylePctBSize) || aForce) {
+ mStylePctBSize = bsize;
+ }
+ }
+ else {
+ mStylePctBSize = bsize;
+ if (bsize > 0) {
+ SetHasPctBSize(true);
+ }
+ }
+}
+
+/* ----------- nsTableRowFrame ---------- */
+
+NS_QUERYFRAME_HEAD(nsTableRowFrame)
+ NS_QUERYFRAME_ENTRY(nsTableRowFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
+
+nsTableRowFrame::nsTableRowFrame(nsStyleContext* aContext)
+ : nsContainerFrame(aContext)
+{
+ mBits.mRowIndex = mBits.mFirstInserted = 0;
+ ResetBSize(0);
+}
+
+nsTableRowFrame::~nsTableRowFrame()
+{
+}
+
+void
+nsTableRowFrame::Init(nsIContent* aContent,
+ nsContainerFrame* aParent,
+ nsIFrame* aPrevInFlow)
+{
+ // Let the base class do its initialization
+ nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
+
+ NS_ASSERTION(mozilla::StyleDisplay::TableRow == StyleDisplay()->mDisplay,
+ "wrong display on table row frame");
+
+ if (aPrevInFlow) {
+ // Set the row index
+ nsTableRowFrame* rowFrame = (nsTableRowFrame*)aPrevInFlow;
+
+ SetRowIndex(rowFrame->GetRowIndex());
+ }
+}
+
+void
+nsTableRowFrame::DestroyFrom(nsIFrame* aDestructRoot)
+{
+ if (HasAnyStateBits(NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN)) {
+ nsTableFrame::UnregisterPositionedTablePart(this, aDestructRoot);
+ }
+
+ nsContainerFrame::DestroyFrom(aDestructRoot);
+}
+
+/* virtual */ void
+nsTableRowFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)
+{
+ nsContainerFrame::DidSetStyleContext(aOldStyleContext);
+
+ if (!aOldStyleContext) //avoid this on init
+ return;
+
+ nsTableFrame* tableFrame = GetTableFrame();
+ if (tableFrame->IsBorderCollapse() &&
+ tableFrame->BCRecalcNeeded(aOldStyleContext, StyleContext())) {
+ TableArea damageArea(0, GetRowIndex(), tableFrame->GetColCount(), 1);
+ tableFrame->AddBCDamageArea(damageArea);
+ }
+}
+
+void
+nsTableRowFrame::AppendFrames(ChildListID aListID,
+ nsFrameList& aFrameList)
+{
+ NS_ASSERTION(aListID == kPrincipalList, "unexpected child list");
+
+ DrainSelfOverflowList(); // ensure the last frame is in mFrames
+ const nsFrameList::Slice& newCells = mFrames.AppendFrames(nullptr, aFrameList);
+
+ // Add the new cell frames to the table
+ nsTableFrame* tableFrame = GetTableFrame();
+ for (nsFrameList::Enumerator e(newCells) ; !e.AtEnd(); e.Next()) {
+ nsIFrame *childFrame = e.get();
+ NS_ASSERTION(IS_TABLE_CELL(childFrame->GetType()),
+ "Not a table cell frame/pseudo frame construction failure");
+ tableFrame->AppendCell(static_cast<nsTableCellFrame&>(*childFrame), GetRowIndex());
+ }
+
+ PresContext()->PresShell()->FrameNeedsReflow(this, nsIPresShell::eTreeChange,
+ NS_FRAME_HAS_DIRTY_CHILDREN);
+ tableFrame->SetGeometryDirty();
+}
+
+
+void
+nsTableRowFrame::InsertFrames(ChildListID aListID,
+ nsIFrame* aPrevFrame,
+ nsFrameList& aFrameList)
+{
+ NS_ASSERTION(aListID == kPrincipalList, "unexpected child list");
+ NS_ASSERTION(!aPrevFrame || aPrevFrame->GetParent() == this,
+ "inserting after sibling frame with different parent");
+ DrainSelfOverflowList(); // ensure aPrevFrame is in mFrames
+ //Insert Frames in the frame list
+ const nsFrameList::Slice& newCells = mFrames.InsertFrames(nullptr, aPrevFrame, aFrameList);
+
+ // Get the table frame
+ nsTableFrame* tableFrame = GetTableFrame();
+ nsIAtom* cellFrameType = tableFrame->IsBorderCollapse() ? nsGkAtoms::bcTableCellFrame : nsGkAtoms::tableCellFrame;
+ nsTableCellFrame* prevCellFrame = (nsTableCellFrame *)nsTableFrame::GetFrameAtOrBefore(this, aPrevFrame, cellFrameType);
+ nsTArray<nsTableCellFrame*> cellChildren;
+ for (nsFrameList::Enumerator e(newCells); !e.AtEnd(); e.Next()) {
+ nsIFrame *childFrame = e.get();
+ NS_ASSERTION(IS_TABLE_CELL(childFrame->GetType()),
+ "Not a table cell frame/pseudo frame construction failure");
+ cellChildren.AppendElement(static_cast<nsTableCellFrame*>(childFrame));
+ }
+ // insert the cells into the cell map
+ int32_t colIndex = -1;
+ if (prevCellFrame) {
+ prevCellFrame->GetColIndex(colIndex);
+ }
+ tableFrame->InsertCells(cellChildren, GetRowIndex(), colIndex);
+
+ PresContext()->PresShell()->FrameNeedsReflow(this, nsIPresShell::eTreeChange,
+ NS_FRAME_HAS_DIRTY_CHILDREN);
+ tableFrame->SetGeometryDirty();
+}
+
+void
+nsTableRowFrame::RemoveFrame(ChildListID aListID,
+ nsIFrame* aOldFrame)
+{
+ NS_ASSERTION(aListID == kPrincipalList, "unexpected child list");
+
+ MOZ_ASSERT((nsTableCellFrame*)do_QueryFrame(aOldFrame));
+ nsTableCellFrame* cellFrame = static_cast<nsTableCellFrame*>(aOldFrame);
+ // remove the cell from the cell map
+ nsTableFrame* tableFrame = GetTableFrame();
+ tableFrame->RemoveCell(cellFrame, GetRowIndex());
+
+ // Remove the frame and destroy it
+ mFrames.DestroyFrame(aOldFrame);
+
+ PresContext()->PresShell()->
+ FrameNeedsReflow(this, nsIPresShell::eTreeChange,
+ NS_FRAME_HAS_DIRTY_CHILDREN);
+
+ tableFrame->SetGeometryDirty();
+}
+
+/* virtual */ nsMargin
+nsTableRowFrame::GetUsedMargin() const
+{
+ return nsMargin(0,0,0,0);
+}
+
+/* virtual */ nsMargin
+nsTableRowFrame::GetUsedBorder() const
+{
+ return nsMargin(0,0,0,0);
+}
+
+/* virtual */ nsMargin
+nsTableRowFrame::GetUsedPadding() const
+{
+ return nsMargin(0,0,0,0);
+}
+
+nscoord
+GetBSizeOfRowsSpannedBelowFirst(nsTableCellFrame& aTableCellFrame,
+ nsTableFrame& aTableFrame,
+ const WritingMode aWM)
+{
+ nscoord bsize = 0;
+ int32_t rowSpan = aTableFrame.GetEffectiveRowSpan(aTableCellFrame);
+ // add in bsize of rows spanned beyond the 1st one
+ nsIFrame* nextRow = aTableCellFrame.GetParent()->GetNextSibling();
+ for (int32_t rowX = 1; ((rowX < rowSpan) && nextRow);) {
+ if (nsGkAtoms::tableRowFrame == nextRow->GetType()) {
+ bsize += nextRow->BSize(aWM);
+ rowX++;
+ }
+ bsize += aTableFrame.GetRowSpacing(rowX);
+ nextRow = nextRow->GetNextSibling();
+ }
+ return bsize;
+}
+
+nsTableCellFrame*
+nsTableRowFrame::GetFirstCell()
+{
+ for (nsIFrame* childFrame : mFrames) {
+ nsTableCellFrame *cellFrame = do_QueryFrame(childFrame);
+ if (cellFrame) {
+ return cellFrame;
+ }
+ }
+ return nullptr;
+}
+
+/**
+ * Post-reflow hook. This is where the table row does its post-processing
+ */
+void
+nsTableRowFrame::DidResize()
+{
+ // Resize and re-align the cell frames based on our row bsize
+ nsTableFrame* tableFrame = GetTableFrame();
+
+ WritingMode wm = GetWritingMode();
+ ReflowOutput desiredSize(wm);
+ desiredSize.SetSize(wm, GetLogicalSize(wm));
+ desiredSize.SetOverflowAreasToDesiredBounds();
+
+ nsSize containerSize = mRect.Size();
+
+ for (nsIFrame* childFrame : mFrames) {
+ nsTableCellFrame *cellFrame = do_QueryFrame(childFrame);
+ if (cellFrame) {
+ nscoord cellBSize = BSize(wm) +
+ GetBSizeOfRowsSpannedBelowFirst(*cellFrame, *tableFrame, wm);
+
+ // If the bsize for the cell has changed, we need to reset it;
+ // and in vertical-rl mode, we need to update the cell's block position
+ // to account for the containerSize, which may not have been known
+ // earlier, so we always apply it here.
+ LogicalSize cellSize = cellFrame->GetLogicalSize(wm);
+ if (cellSize.BSize(wm) != cellBSize || wm.IsVerticalRL()) {
+ nsRect cellOldRect = cellFrame->GetRect();
+ nsRect cellVisualOverflow = cellFrame->GetVisualOverflowRect();
+
+ if (wm.IsVerticalRL()) {
+ // Get the old position of the cell, as we want to preserve its
+ // inline coordinate.
+ LogicalPoint oldPos =
+ cellFrame->GetLogicalPosition(wm, containerSize);
+
+ // The cell should normally be aligned with the row's block-start,
+ // so set the B component of the position to zero:
+ LogicalPoint newPos(wm, oldPos.I(wm), 0);
+
+ // ...unless relative positioning is in effect, in which case the
+ // cell may have been moved away from the row's block-start
+ if (cellFrame->IsRelativelyPositioned()) {
+ // Find out where the cell would have been without relative
+ // positioning.
+ LogicalPoint oldNormalPos =
+ cellFrame->GetLogicalNormalPosition(wm, containerSize);
+ // The difference (if any) between oldPos and oldNormalPos reflects
+ // relative positioning that was applied to the cell, and which we
+ // need to incorporate when resetting the position.
+ newPos.B(wm) = oldPos.B(wm) - oldNormalPos.B(wm);
+ }
+
+ if (oldPos != newPos) {
+ cellFrame->SetPosition(wm, newPos, containerSize);
+ nsTableFrame::RePositionViews(cellFrame);
+ }
+ }
+
+ cellSize.BSize(wm) = cellBSize;
+ cellFrame->SetSize(wm, cellSize);
+ nsTableFrame::InvalidateTableFrame(cellFrame, cellOldRect,
+ cellVisualOverflow,
+ false);
+ }
+
+ // realign cell content based on the new bsize. We might be able to
+ // skip this if the bsize didn't change... maybe. Hard to tell.
+ cellFrame->BlockDirAlignChild(wm, mMaxCellAscent);
+
+ // Always store the overflow, even if the height didn't change, since
+ // we'll lose part of our overflow area otherwise.
+ ConsiderChildOverflow(desiredSize.mOverflowAreas, cellFrame);
+
+ // Note that if the cell's *content* needs to change in response
+ // to this height, it will get a special bsize reflow.
+ }
+ }
+ FinishAndStoreOverflow(&desiredSize);
+ if (HasView()) {
+ nsContainerFrame::SyncFrameViewAfterReflow(PresContext(), this, GetView(),
+ desiredSize.VisualOverflow(), 0);
+ }
+ // Let our base class do the usual work
+}
+
+// returns max-ascent amongst all cells that have 'vertical-align: baseline'
+// *including* cells with rowspans
+nscoord nsTableRowFrame::GetMaxCellAscent() const
+{
+ return mMaxCellAscent;
+}
+
+nscoord nsTableRowFrame::GetRowBaseline(WritingMode aWM)
+{
+ if (mMaxCellAscent) {
+ return mMaxCellAscent;
+ }
+
+ // If we don't have a baseline on any of the cells we go for the lowest
+ // content edge of the inner block frames.
+ // Every table cell has a cell frame with its border and padding. Inside
+ // the cell is a block frame. The cell is as high as the tallest cell in
+ // the parent row. As a consequence the block frame might not touch both
+ // the top and the bottom padding of it parent cell frame at the same time.
+ //
+ // bbbbbbbbbbbbbbbbbb cell border: b
+ // bppppppppppppppppb cell padding: p
+ // bpxxxxxxxxxxxxxxpb inner block: x
+ // bpx xpb
+ // bpx xpb
+ // bpx xpb
+ // bpxxxxxxxxxxxxxxpb base line
+ // bp pb
+ // bp pb
+ // bppppppppppppppppb
+ // bbbbbbbbbbbbbbbbbb
+
+ nscoord ascent = 0;
+ nsSize containerSize = GetSize();
+ for (nsIFrame* childFrame : mFrames) {
+ if (IS_TABLE_CELL(childFrame->GetType())) {
+ nsIFrame* firstKid = childFrame->PrincipalChildList().FirstChild();
+ ascent = std::max(ascent,
+ LogicalRect(aWM, firstKid->GetNormalRect(),
+ containerSize).BEnd(aWM));
+ }
+ }
+ return ascent;
+}
+
+nscoord
+nsTableRowFrame::GetInitialBSize(nscoord aPctBasis) const
+{
+ nscoord bsize = 0;
+ if ((aPctBasis > 0) && HasPctBSize()) {
+ bsize = NSToCoordRound(GetPctBSize() * (float)aPctBasis);
+ }
+ if (HasFixedBSize()) {
+ bsize = std::max(bsize, GetFixedBSize());
+ }
+ return std::max(bsize, GetContentBSize());
+}
+
+void
+nsTableRowFrame::ResetBSize(nscoord aFixedBSize)
+{
+ SetHasFixedBSize(false);
+ SetHasPctBSize(false);
+ SetFixedBSize(0);
+ SetPctBSize(0);
+ SetContentBSize(0);
+
+ if (aFixedBSize > 0) {
+ SetFixedBSize(aFixedBSize);
+ }
+
+ mMaxCellAscent = 0;
+ mMaxCellDescent = 0;
+}
+
+void
+nsTableRowFrame::UpdateBSize(nscoord aBSize,
+ nscoord aAscent,
+ nscoord aDescent,
+ nsTableFrame* aTableFrame,
+ nsTableCellFrame* aCellFrame)
+{
+ if (!aTableFrame || !aCellFrame) {
+ NS_ASSERTION(false , "invalid call");
+ return;
+ }
+
+ if (aBSize != NS_UNCONSTRAINEDSIZE) {
+ if (!(aCellFrame->HasVerticalAlignBaseline())) { // only the cell's height matters
+ if (GetInitialBSize() < aBSize) {
+ int32_t rowSpan = aTableFrame->GetEffectiveRowSpan(*aCellFrame);
+ if (rowSpan == 1) {
+ SetContentBSize(aBSize);
+ }
+ }
+ }
+ else { // the alignment on the baseline can change the bsize
+ NS_ASSERTION((aAscent != NS_UNCONSTRAINEDSIZE) &&
+ (aDescent != NS_UNCONSTRAINEDSIZE), "invalid call");
+ // see if this is a long ascender
+ if (mMaxCellAscent < aAscent) {
+ mMaxCellAscent = aAscent;
+ }
+ // see if this is a long descender and without rowspan
+ if (mMaxCellDescent < aDescent) {
+ int32_t rowSpan = aTableFrame->GetEffectiveRowSpan(*aCellFrame);
+ if (rowSpan == 1) {
+ mMaxCellDescent = aDescent;
+ }
+ }
+ // keep the tallest bsize in sync
+ if (GetInitialBSize() < mMaxCellAscent + mMaxCellDescent) {
+ SetContentBSize(mMaxCellAscent + mMaxCellDescent);
+ }
+ }
+ }
+}
+
+nscoord
+nsTableRowFrame::CalcBSize(const ReflowInput& aReflowInput)
+{
+ nsTableFrame* tableFrame = GetTableFrame();
+ nscoord computedBSize = (NS_UNCONSTRAINEDSIZE == aReflowInput.ComputedBSize())
+ ? 0 : aReflowInput.ComputedBSize();
+ ResetBSize(computedBSize);
+
+ WritingMode wm = aReflowInput.GetWritingMode();
+ const nsStylePosition* position = StylePosition();
+ const nsStyleCoord& bsizeStyleCoord = position->BSize(wm);
+ if (bsizeStyleCoord.ConvertsToLength()) {
+ SetFixedBSize(nsRuleNode::ComputeCoordPercentCalc(bsizeStyleCoord, 0));
+ }
+ else if (eStyleUnit_Percent == bsizeStyleCoord.GetUnit()) {
+ SetPctBSize(bsizeStyleCoord.GetPercentValue());
+ }
+ // calc() with percentages is treated like 'auto' on table rows.
+
+ for (nsIFrame* kidFrame : mFrames) {
+ nsTableCellFrame *cellFrame = do_QueryFrame(kidFrame);
+ if (cellFrame) {
+ MOZ_ASSERT(cellFrame->GetWritingMode() == wm);
+ LogicalSize desSize = cellFrame->GetDesiredSize();
+ if ((NS_UNCONSTRAINEDSIZE == aReflowInput.AvailableBSize()) && !GetPrevInFlow()) {
+ CalculateCellActualBSize(cellFrame, desSize.BSize(wm), wm);
+ }
+ // bsize may have changed, adjust descent to absorb any excess difference
+ nscoord ascent;
+ if (!kidFrame->PrincipalChildList().FirstChild()->PrincipalChildList().FirstChild())
+ ascent = desSize.BSize(wm);
+ else
+ ascent = cellFrame->GetCellBaseline();
+ nscoord descent = desSize.BSize(wm) - ascent;
+ UpdateBSize(desSize.BSize(wm), ascent, descent, tableFrame, cellFrame);
+ }
+ }
+ return GetInitialBSize();
+}
+
+/**
+ * We need a custom display item for table row backgrounds. This is only used
+ * when the table row is the root of a stacking context (e.g., has 'opacity').
+ * Table row backgrounds can extend beyond the row frame bounds, when
+ * the row contains row-spanning cells.
+ */
+class nsDisplayTableRowBackground : public nsDisplayTableItem {
+public:
+ nsDisplayTableRowBackground(nsDisplayListBuilder* aBuilder,
+ nsTableRowFrame* aFrame) :
+ nsDisplayTableItem(aBuilder, aFrame) {
+ MOZ_COUNT_CTOR(nsDisplayTableRowBackground);
+ }
+#ifdef NS_BUILD_REFCNT_LOGGING
+ virtual ~nsDisplayTableRowBackground() {
+ MOZ_COUNT_DTOR(nsDisplayTableRowBackground);
+ }
+#endif
+
+ virtual void Paint(nsDisplayListBuilder* aBuilder,
+ nsRenderingContext* aCtx) override;
+ NS_DISPLAY_DECL_NAME("TableRowBackground", TYPE_TABLE_ROW_BACKGROUND)
+};
+
+void
+nsDisplayTableRowBackground::Paint(nsDisplayListBuilder* aBuilder,
+ nsRenderingContext* aCtx)
+{
+ auto rowFrame = static_cast<nsTableRowFrame*>(mFrame);
+ TableBackgroundPainter painter(rowFrame->GetTableFrame(),
+ TableBackgroundPainter::eOrigin_TableRow,
+ mFrame->PresContext(), *aCtx,
+ mVisibleRect, ToReferenceFrame(),
+ aBuilder->GetBackgroundPaintFlags());
+
+ DrawResult result = painter.PaintRow(rowFrame);
+ nsDisplayTableItemGeometry::UpdateDrawResult(this, result);
+}
+
+void
+nsTableRowFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
+ const nsRect& aDirtyRect,
+ const nsDisplayListSet& aLists)
+{
+ nsDisplayTableItem* item = nullptr;
+ if (IsVisibleInSelection(aBuilder)) {
+ bool isRoot = aBuilder->IsAtRootOfPseudoStackingContext();
+ if (isRoot) {
+ // This background is created regardless of whether this frame is
+ // visible or not. Visibility decisions are delegated to the
+ // table background painter.
+ // We would use nsDisplayGeneric for this rare case except that we
+ // need the background to be larger than the row frame in some
+ // cases.
+ item = new (aBuilder) nsDisplayTableRowBackground(aBuilder, this);
+ aLists.BorderBackground()->AppendNewToTop(item);
+ }
+ }
+ nsTableFrame::DisplayGenericTablePart(aBuilder, this, aDirtyRect, aLists, item);
+}
+
+nsIFrame::LogicalSides
+nsTableRowFrame::GetLogicalSkipSides(const ReflowInput* aReflowInput) const
+{
+ if (MOZ_UNLIKELY(StyleBorder()->mBoxDecorationBreak ==
+ StyleBoxDecorationBreak::Clone)) {
+ return LogicalSides();
+ }
+
+ LogicalSides skip;
+ if (nullptr != GetPrevInFlow()) {
+ skip |= eLogicalSideBitsBStart;
+ }
+ if (nullptr != GetNextInFlow()) {
+ skip |= eLogicalSideBitsBEnd;
+ }
+ return skip;
+}
+
+// Calculate the cell's actual bsize given its pass2 bsize.
+// Takes into account the specified bsize (in the style).
+// Modifies the desired bsize that is passed in.
+nsresult
+nsTableRowFrame::CalculateCellActualBSize(nsTableCellFrame* aCellFrame,
+ nscoord& aDesiredBSize,
+ WritingMode aWM)
+{
+ nscoord specifiedBSize = 0;
+
+ // Get the bsize specified in the style information
+ const nsStylePosition* position = aCellFrame->StylePosition();
+
+ int32_t rowSpan = GetTableFrame()->GetEffectiveRowSpan(*aCellFrame);
+
+ const nsStyleCoord& bsizeStyleCoord = position->BSize(aWM);
+ switch (bsizeStyleCoord.GetUnit()) {
+ case eStyleUnit_Calc: {
+ if (bsizeStyleCoord.CalcHasPercent()) {
+ // Treat this like "auto"
+ break;
+ }
+ // Fall through to the coord case
+ MOZ_FALLTHROUGH;
+ }
+ case eStyleUnit_Coord: {
+ // In quirks mode, table cell isize should be content-box, but bsize
+ // should be border-box.
+ // Because of this historic anomaly, we do not use quirk.css
+ // (since we can't specify one value of box-sizing for isize and another
+ // for bsize)
+ specifiedBSize = nsRuleNode::ComputeCoordPercentCalc(bsizeStyleCoord, 0);
+ if (PresContext()->CompatibilityMode() != eCompatibility_NavQuirks &&
+ position->mBoxSizing == StyleBoxSizing::Content) {
+ specifiedBSize +=
+ aCellFrame->GetLogicalUsedBorderAndPadding(aWM).BStartEnd(aWM);
+ }
+
+ if (1 == rowSpan) {
+ SetFixedBSize(specifiedBSize);
+ }
+ break;
+ }
+ case eStyleUnit_Percent: {
+ if (1 == rowSpan) {
+ SetPctBSize(bsizeStyleCoord.GetPercentValue());
+ }
+ // pct bsizes are handled when all of the cells are finished,
+ // so don't set specifiedBSize
+ break;
+ }
+ case eStyleUnit_Auto:
+ default:
+ break;
+ }
+
+ // If the specified bsize is greater than the desired bsize,
+ // then use the specified bsize
+ if (specifiedBSize > aDesiredBSize) {
+ aDesiredBSize = specifiedBSize;
+ }
+
+ return NS_OK;
+}
+
+// Calculates the available isize for the table cell based on the known
+// column isizes taking into account column spans and column spacing
+static nscoord
+CalcAvailISize(nsTableFrame& aTableFrame,
+ nsTableCellFrame& aCellFrame)
+{
+ nscoord cellAvailISize = 0;
+ int32_t colIndex;
+ aCellFrame.GetColIndex(colIndex);
+ int32_t colspan = aTableFrame.GetEffectiveColSpan(aCellFrame);
+ NS_ASSERTION(colspan > 0, "effective colspan should be positive");
+ nsTableFrame* fifTable =
+ static_cast<nsTableFrame*>(aTableFrame.FirstInFlow());
+
+ for (int32_t spanX = 0; spanX < colspan; spanX++) {
+ cellAvailISize +=
+ fifTable->GetColumnISizeFromFirstInFlow(colIndex + spanX);
+ if (spanX > 0 &&
+ aTableFrame.ColumnHasCellSpacingBefore(colIndex + spanX)) {
+ cellAvailISize += aTableFrame.GetColSpacing(colIndex + spanX - 1);
+ }
+ }
+ return cellAvailISize;
+}
+
+nscoord
+GetSpaceBetween(int32_t aPrevColIndex,
+ int32_t aColIndex,
+ int32_t aColSpan,
+ nsTableFrame& aTableFrame,
+ bool aCheckVisibility)
+{
+ nscoord space = 0;
+ int32_t colIdx;
+ nsTableFrame* fifTable =
+ static_cast<nsTableFrame*>(aTableFrame.FirstInFlow());
+ for (colIdx = aPrevColIndex + 1; aColIndex > colIdx; colIdx++) {
+ bool isCollapsed = false;
+ if (!aCheckVisibility) {
+ space += fifTable->GetColumnISizeFromFirstInFlow(colIdx);
+ }
+ else {
+ nsTableColFrame* colFrame = aTableFrame.GetColFrame(colIdx);
+ const nsStyleVisibility* colVis = colFrame->StyleVisibility();
+ bool collapseCol = (NS_STYLE_VISIBILITY_COLLAPSE == colVis->mVisible);
+ nsIFrame* cgFrame = colFrame->GetParent();
+ const nsStyleVisibility* groupVis = cgFrame->StyleVisibility();
+ bool collapseGroup = (NS_STYLE_VISIBILITY_COLLAPSE ==
+ groupVis->mVisible);
+ isCollapsed = collapseCol || collapseGroup;
+ if (!isCollapsed)
+ space += fifTable->GetColumnISizeFromFirstInFlow(colIdx);
+ }
+ if (!isCollapsed && aTableFrame.ColumnHasCellSpacingBefore(colIdx)) {
+ space += aTableFrame.GetColSpacing(colIdx - 1);
+ }
+ }
+ return space;
+}
+
+// subtract the bsizes of aRow's prev in flows from the unpaginated bsize
+static
+nscoord CalcBSizeFromUnpaginatedBSize(nsTableRowFrame& aRow,
+ WritingMode aWM)
+{
+ nscoord bsize = 0;
+ nsTableRowFrame* firstInFlow =
+ static_cast<nsTableRowFrame*>(aRow.FirstInFlow());
+ if (firstInFlow->HasUnpaginatedBSize()) {
+ bsize = firstInFlow->GetUnpaginatedBSize();
+ for (nsIFrame* prevInFlow = aRow.GetPrevInFlow(); prevInFlow;
+ prevInFlow = prevInFlow->GetPrevInFlow()) {
+ bsize -= prevInFlow->BSize(aWM);
+ }
+ }
+ return std::max(bsize, 0);
+}
+
+void
+nsTableRowFrame::ReflowChildren(nsPresContext* aPresContext,
+ ReflowOutput& aDesiredSize,
+ const ReflowInput& aReflowInput,
+ nsTableFrame& aTableFrame,
+ nsReflowStatus& aStatus)
+{
+ aStatus = NS_FRAME_COMPLETE;
+
+ // XXXldb Should we be checking constrained bsize instead?
+ const bool isPaginated = aPresContext->IsPaginated();
+ const bool borderCollapse = aTableFrame.IsBorderCollapse();
+
+ int32_t cellColSpan = 1; // must be defined here so it's set properly for non-cell kids
+
+ // remember the col index of the previous cell to handle rowspans into this row
+ int32_t prevColIndex = -1;
+ nscoord iCoord = 0; // running total of children inline-coord offset
+
+ // This computes the max of all cell bsizes
+ nscoord cellMaxBSize = 0;
+
+ // Reflow each of our existing cell frames
+ WritingMode wm = aReflowInput.GetWritingMode();
+ nsSize containerSize =
+ aReflowInput.ComputedSizeAsContainerIfConstrained();
+
+ for (nsIFrame* kidFrame : mFrames) {
+ nsTableCellFrame *cellFrame = do_QueryFrame(kidFrame);
+ if (!cellFrame) {
+ // XXXldb nsCSSFrameConstructor needs to enforce this!
+ NS_NOTREACHED("yikes, a non-row child");
+
+ // it's an unknown frame type, give it a generic reflow and ignore the results
+ TableCellReflowInput
+ kidReflowInput(aPresContext, aReflowInput, kidFrame,
+ LogicalSize(kidFrame->GetWritingMode(), 0, 0),
+ ReflowInput::CALLER_WILL_INIT);
+ InitChildReflowInput(*aPresContext, LogicalSize(wm), false, kidReflowInput);
+ ReflowOutput desiredSize(aReflowInput);
+ nsReflowStatus status;
+ ReflowChild(kidFrame, aPresContext, desiredSize, kidReflowInput, 0, 0, 0, status);
+ kidFrame->DidReflow(aPresContext, nullptr, nsDidReflowStatus::FINISHED);
+
+ continue;
+ }
+
+ // See if we should only reflow the dirty child frames
+ bool doReflowChild = true;
+ if (!aReflowInput.ShouldReflowAllKids() &&
+ !aTableFrame.IsGeometryDirty() &&
+ !NS_SUBTREE_DIRTY(kidFrame)) {
+ if (!aReflowInput.mFlags.mSpecialBSizeReflow)
+ doReflowChild = false;
+ }
+ else if ((NS_UNCONSTRAINEDSIZE != aReflowInput.AvailableBSize())) {
+ // We don't reflow a rowspan >1 cell here with a constrained bsize.
+ // That happens in nsTableRowGroupFrame::SplitSpanningCells.
+ if (aTableFrame.GetEffectiveRowSpan(*cellFrame) > 1) {
+ doReflowChild = false;
+ }
+ }
+ if (aReflowInput.mFlags.mSpecialBSizeReflow) {
+ if (!isPaginated &&
+ !cellFrame->HasAnyStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE)) {
+ continue;
+ }
+ }
+
+ int32_t cellColIndex;
+ cellFrame->GetColIndex(cellColIndex);
+ cellColSpan = aTableFrame.GetEffectiveColSpan(*cellFrame);
+
+ // If the adjacent cell is in a prior row (because of a rowspan) add in the space
+ if (prevColIndex != (cellColIndex - 1)) {
+ iCoord += GetSpaceBetween(prevColIndex, cellColIndex, cellColSpan, aTableFrame,
+ false);
+ }
+
+ // remember the rightmost (ltr) or leftmost (rtl) column this cell spans into
+ prevColIndex = cellColIndex + (cellColSpan - 1);
+
+ // Reflow the child frame
+ nsRect kidRect = kidFrame->GetRect();
+ LogicalPoint origKidNormalPosition =
+ kidFrame->GetLogicalNormalPosition(wm, containerSize);
+ // All cells' no-relative-positioning position should be snapped to the
+ // row's bstart edge.
+ // This doesn't hold in vertical-rl mode, where we don't yet know the
+ // correct containerSize for the row frame. In that case, we'll have to
+ // fix up child positions later, after determining our desiredSize.
+ NS_ASSERTION(origKidNormalPosition.B(wm) == 0 || wm.IsVerticalRL(),
+ "unexpected kid position");
+
+ nsRect kidVisualOverflow = kidFrame->GetVisualOverflowRect();
+ LogicalPoint kidPosition(wm, iCoord, 0);
+ bool firstReflow = kidFrame->HasAnyStateBits(NS_FRAME_FIRST_REFLOW);
+
+ if (doReflowChild) {
+ // Calculate the available isize for the table cell using the known
+ // column isizes
+ nscoord availCellISize = CalcAvailISize(aTableFrame, *cellFrame);
+
+ Maybe<TableCellReflowInput> kidReflowInput;
+ ReflowOutput desiredSize(aReflowInput);
+
+ // If the avail isize is not the same as last time we reflowed the cell or
+ // the cell wants to be bigger than what was available last time or
+ // it is a style change reflow or we are printing, then we must reflow the
+ // cell. Otherwise we can skip the reflow.
+ // XXXldb Why is this condition distinct from doReflowChild above?
+ WritingMode wm = aReflowInput.GetWritingMode();
+ NS_ASSERTION(cellFrame->GetWritingMode() == wm,
+ "expected consistent writing-mode within table");
+ LogicalSize cellDesiredSize = cellFrame->GetDesiredSize();
+ if ((availCellISize != cellFrame->GetPriorAvailISize()) ||
+ (cellDesiredSize.ISize(wm) > cellFrame->GetPriorAvailISize()) ||
+ HasAnyStateBits(NS_FRAME_IS_DIRTY) ||
+ isPaginated ||
+ NS_SUBTREE_DIRTY(cellFrame) ||
+ // See if it needs a special reflow, or if it had one that we need to undo.
+ cellFrame->HasAnyStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE) ||
+ HasPctBSize()) {
+ // Reflow the cell to fit the available isize, bsize
+ // XXX The old IR_ChildIsDirty code used availCellISize here.
+ LogicalSize kidAvailSize(wm, availCellISize, aReflowInput.AvailableBSize());
+
+ // Reflow the child
+ kidReflowInput.emplace(aPresContext, aReflowInput, kidFrame,
+ kidAvailSize,
+ ReflowInput::CALLER_WILL_INIT);
+ InitChildReflowInput(*aPresContext, kidAvailSize, borderCollapse,
+ *kidReflowInput);
+
+ nsReflowStatus status;
+ ReflowChild(kidFrame, aPresContext, desiredSize, *kidReflowInput,
+ wm, kidPosition, containerSize, 0, status);
+
+ // allow the table to determine if/how the table needs to be rebalanced
+ // If any of the cells are not complete, then we're not complete
+ if (NS_FRAME_IS_NOT_COMPLETE(status)) {
+ aStatus = NS_FRAME_NOT_COMPLETE;
+ }
+ } else {
+ if (iCoord != origKidNormalPosition.I(wm)) {
+ kidFrame->InvalidateFrameSubtree();
+ }
+
+ desiredSize.SetSize(wm, cellDesiredSize);
+ desiredSize.mOverflowAreas = cellFrame->GetOverflowAreas();
+
+ // if we are in a floated table, our position is not yet established, so we cannot reposition our views
+ // the containing block will do this for us after positioning the table
+ if (!aTableFrame.IsFloating()) {
+ // Because we may have moved the frame we need to make sure any views are
+ // positioned properly. We have to do this, because any one of our parent
+ // frames could have moved and we have no way of knowing...
+ nsTableFrame::RePositionViews(kidFrame);
+ }
+ }
+
+ if (NS_UNCONSTRAINEDSIZE == aReflowInput.AvailableBSize()) {
+ if (!GetPrevInFlow()) {
+ // Calculate the cell's actual bsize given its pass2 bsize. This
+ // function takes into account the specified bsize (in the style)
+ CalculateCellActualBSize(cellFrame, desiredSize.BSize(wm), wm);
+ }
+ // bsize may have changed, adjust descent to absorb any excess difference
+ nscoord ascent;
+ if (!kidFrame->PrincipalChildList().FirstChild()->PrincipalChildList().FirstChild()) {
+ ascent = desiredSize.BSize(wm);
+ } else {
+ ascent = ((nsTableCellFrame *)kidFrame)->GetCellBaseline();
+ }
+ nscoord descent = desiredSize.BSize(wm) - ascent;
+ UpdateBSize(desiredSize.BSize(wm), ascent, descent, &aTableFrame, cellFrame);
+ } else {
+ cellMaxBSize = std::max(cellMaxBSize, desiredSize.BSize(wm));
+ int32_t rowSpan = aTableFrame.GetEffectiveRowSpan((nsTableCellFrame&)*kidFrame);
+ if (1 == rowSpan) {
+ SetContentBSize(cellMaxBSize);
+ }
+ }
+
+ // Place the child
+ desiredSize.ISize(wm) = availCellISize;
+
+ if (kidReflowInput) {
+ // We reflowed. Apply relative positioning in the normal way.
+ kidReflowInput->ApplyRelativePositioning(&kidPosition, containerSize);
+ } else if (kidFrame->IsRelativelyPositioned()) {
+ // We didn't reflow. Do the positioning part of what
+ // MovePositionBy does internally. (This codepath should really
+ // be merged into the else below if we can.)
+ nsMargin* computedOffsetProp =
+ kidFrame->Properties().Get(nsIFrame::ComputedOffsetProperty());
+ // Bug 975644: a position:sticky kid can end up with a null
+ // property value here.
+ LogicalMargin computedOffsets(wm, computedOffsetProp ?
+ *computedOffsetProp : nsMargin());
+ ReflowInput::ApplyRelativePositioning(kidFrame, wm, computedOffsets,
+ &kidPosition, containerSize);
+ }
+
+ // In vertical-rl mode, we are likely to have containerSize.width = 0
+ // because ComputedWidth() was NS_UNCONSTRAINEDSIZE.
+ // For cases where that's wrong, we will fix up the position later.
+ FinishReflowChild(kidFrame, aPresContext, desiredSize, nullptr,
+ wm, kidPosition, containerSize, 0);
+
+ nsTableFrame::InvalidateTableFrame(kidFrame, kidRect, kidVisualOverflow,
+ firstReflow);
+
+ iCoord += desiredSize.ISize(wm);
+ } else {
+ if (iCoord != origKidNormalPosition.I(wm)) {
+ // Invalidate the old position
+ kidFrame->InvalidateFrameSubtree();
+ // Move to the new position. As above, we need to account for relative
+ // positioning.
+ kidFrame->MovePositionBy(wm,
+ LogicalPoint(wm, iCoord - origKidNormalPosition.I(wm), 0));
+ nsTableFrame::RePositionViews(kidFrame);
+ // invalidate the new position
+ kidFrame->InvalidateFrameSubtree();
+ }
+ // we need to account for the cell's isize even if it isn't reflowed
+ iCoord += kidFrame->ISize(wm);
+
+ if (kidFrame->GetNextInFlow()) {
+ aStatus = NS_FRAME_NOT_COMPLETE;
+ }
+ }
+ ConsiderChildOverflow(aDesiredSize.mOverflowAreas, kidFrame);
+ iCoord += aTableFrame.GetColSpacing(cellColIndex);
+ }
+
+ // Just set our isize to what was available.
+ // The table will calculate the isize and not use our value.
+ aDesiredSize.ISize(wm) = aReflowInput.AvailableISize();
+
+ if (aReflowInput.mFlags.mSpecialBSizeReflow) {
+ aDesiredSize.BSize(wm) = BSize(wm);
+ } else if (NS_UNCONSTRAINEDSIZE == aReflowInput.AvailableBSize()) {
+ aDesiredSize.BSize(wm) = CalcBSize(aReflowInput);
+ if (GetPrevInFlow()) {
+ nscoord bsize = CalcBSizeFromUnpaginatedBSize(*this, wm);
+ aDesiredSize.BSize(wm) = std::max(aDesiredSize.BSize(wm), bsize);
+ } else {
+ if (isPaginated && HasStyleBSize()) {
+ // set the unpaginated bsize so next in flows can try to honor it
+ SetHasUnpaginatedBSize(true);
+ SetUnpaginatedBSize(aPresContext, aDesiredSize.BSize(wm));
+ }
+ if (isPaginated && HasUnpaginatedBSize()) {
+ aDesiredSize.BSize(wm) = std::max(aDesiredSize.BSize(wm),
+ GetUnpaginatedBSize());
+ }
+ }
+ } else { // constrained bsize, paginated
+ // Compute the bsize we should have from style (subtracting the
+ // bsize from our prev-in-flows from the style bsize)
+ nscoord styleBSize = CalcBSizeFromUnpaginatedBSize(*this, wm);
+ if (styleBSize > aReflowInput.AvailableBSize()) {
+ styleBSize = aReflowInput.AvailableBSize();
+ NS_FRAME_SET_INCOMPLETE(aStatus);
+ }
+ aDesiredSize.BSize(wm) = std::max(cellMaxBSize, styleBSize);
+ }
+
+ if (wm.IsVerticalRL()) {
+ // Any children whose width was not the same as our final
+ // aDesiredSize.BSize will have been misplaced earlier at the
+ // FinishReflowChild stage. So fix them up now.
+ for (nsIFrame* kidFrame : mFrames) {
+ nsTableCellFrame *cellFrame = do_QueryFrame(kidFrame);
+ if (!cellFrame) {
+ continue;
+ }
+ if (kidFrame->BSize(wm) != aDesiredSize.BSize(wm)) {
+ kidFrame->MovePositionBy(wm,
+ LogicalPoint(wm, 0, kidFrame->BSize(wm) - aDesiredSize.BSize(wm)));
+ nsTableFrame::RePositionViews(kidFrame);
+ // Do we need to InvalidateFrameSubtree() here?
+ }
+ }
+ }
+
+ aDesiredSize.UnionOverflowAreasWithDesiredBounds();
+ FinishAndStoreOverflow(&aDesiredSize);
+}
+
+/** Layout the entire row.
+ * This method stacks cells in the inline dir according to HTML 4.0 rules.
+ */
+void
+nsTableRowFrame::Reflow(nsPresContext* aPresContext,
+ ReflowOutput& aDesiredSize,
+ const ReflowInput& aReflowInput,
+ nsReflowStatus& aStatus)
+{
+ MarkInReflow();
+ DO_GLOBAL_REFLOW_COUNT("nsTableRowFrame");
+ DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
+
+ WritingMode wm = aReflowInput.GetWritingMode();
+
+ nsTableFrame* tableFrame = GetTableFrame();
+ const nsStyleVisibility* rowVis = StyleVisibility();
+ bool collapseRow = (NS_STYLE_VISIBILITY_COLLAPSE == rowVis->mVisible);
+ if (collapseRow) {
+ tableFrame->SetNeedToCollapse(true);
+ }
+
+ // see if a special bsize reflow needs to occur due to having a pct bsize
+ nsTableFrame::CheckRequestSpecialBSizeReflow(aReflowInput);
+
+ // See if we have a cell with specified/pct bsize
+ InitHasCellWithStyleBSize(tableFrame);
+
+ ReflowChildren(aPresContext, aDesiredSize, aReflowInput, *tableFrame, aStatus);
+
+ if (aPresContext->IsPaginated() && !NS_FRAME_IS_FULLY_COMPLETE(aStatus) &&
+ ShouldAvoidBreakInside(aReflowInput)) {
+ aStatus = NS_INLINE_LINE_BREAK_BEFORE();
+ }
+
+ // Just set our isize to what was available.
+ // The table will calculate the isize and not use our value.
+ aDesiredSize.ISize(wm) = aReflowInput.AvailableISize();
+
+ // If our parent is in initial reflow, it'll handle invalidating our
+ // entire overflow rect.
+ if (!GetParent()->HasAnyStateBits(NS_FRAME_FIRST_REFLOW) &&
+ nsSize(aDesiredSize.Width(), aDesiredSize.Height()) != mRect.Size()) {
+ InvalidateFrame();
+ }
+
+ // Any absolutely-positioned children will get reflowed in
+ // nsFrame::FixupPositionedTableParts in another pass, so propagate our
+ // dirtiness to them before our parent clears our dirty bits.
+ PushDirtyBitToAbsoluteFrames();
+
+ NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
+}
+
+/**
+ * This function is called by the row group frame's SplitRowGroup() code when
+ * pushing a row frame that has cell frames that span into it. The cell frame
+ * should be reflowed with the specified height
+ */
+nscoord
+nsTableRowFrame::ReflowCellFrame(nsPresContext* aPresContext,
+ const ReflowInput& aReflowInput,
+ bool aIsTopOfPage,
+ nsTableCellFrame* aCellFrame,
+ nscoord aAvailableBSize,
+ nsReflowStatus& aStatus)
+{
+ WritingMode wm = aReflowInput.GetWritingMode();
+
+ // Reflow the cell frame with the specified height. Use the existing width
+ nsSize containerSize = aCellFrame->GetSize();
+ LogicalRect cellRect = aCellFrame->GetLogicalRect(wm, containerSize);
+ nsRect cellVisualOverflow = aCellFrame->GetVisualOverflowRect();
+
+ LogicalSize cellSize = cellRect.Size(wm);
+ LogicalSize availSize(wm, cellRect.ISize(wm), aAvailableBSize);
+ bool borderCollapse = GetTableFrame()->IsBorderCollapse();
+ NS_ASSERTION(aCellFrame->GetWritingMode() == wm,
+ "expected consistent writing-mode within table");
+ TableCellReflowInput
+ cellReflowInput(aPresContext, aReflowInput, aCellFrame, availSize,
+ ReflowInput::CALLER_WILL_INIT);
+ InitChildReflowInput(*aPresContext, availSize, borderCollapse, cellReflowInput);
+ cellReflowInput.mFlags.mIsTopOfPage = aIsTopOfPage;
+
+ ReflowOutput desiredSize(aReflowInput);
+
+ ReflowChild(aCellFrame, aPresContext, desiredSize, cellReflowInput,
+ 0, 0, NS_FRAME_NO_MOVE_FRAME, aStatus);
+ bool fullyComplete = NS_FRAME_IS_COMPLETE(aStatus) && !NS_FRAME_IS_TRUNCATED(aStatus);
+ if (fullyComplete) {
+ desiredSize.BSize(wm) = aAvailableBSize;
+ }
+ aCellFrame->SetSize(wm, LogicalSize(wm, cellSize.ISize(wm),
+ desiredSize.BSize(wm)));
+
+ // Note: BlockDirAlignChild can affect the overflow rect.
+ // XXX What happens if this cell has 'vertical-align: baseline' ?
+ // XXX Why is it assumed that the cell's ascent hasn't changed ?
+ if (fullyComplete) {
+ aCellFrame->BlockDirAlignChild(wm, mMaxCellAscent);
+ }
+
+ nsTableFrame::InvalidateTableFrame(aCellFrame,
+ cellRect.GetPhysicalRect(wm, containerSize),
+ cellVisualOverflow,
+ aCellFrame->
+ HasAnyStateBits(NS_FRAME_FIRST_REFLOW));
+
+ aCellFrame->DidReflow(aPresContext, nullptr, nsDidReflowStatus::FINISHED);
+
+ return desiredSize.BSize(wm);
+}
+
+nscoord
+nsTableRowFrame::CollapseRowIfNecessary(nscoord aRowOffset,
+ nscoord aISize,
+ bool aCollapseGroup,
+ bool& aDidCollapse)
+{
+ const nsStyleVisibility* rowVis = StyleVisibility();
+ bool collapseRow = (NS_STYLE_VISIBILITY_COLLAPSE == rowVis->mVisible);
+ nsTableFrame* tableFrame =
+ static_cast<nsTableFrame*>(GetTableFrame()->FirstInFlow());
+ if (collapseRow) {
+ tableFrame->SetNeedToCollapse(true);
+ }
+
+ if (aRowOffset != 0) {
+ // We're moving, so invalidate our old position
+ InvalidateFrameSubtree();
+ }
+
+ WritingMode wm = GetWritingMode();
+
+ nsSize parentSize = GetParent()->GetSize();
+ LogicalRect rowRect = GetLogicalRect(wm, parentSize);
+ nsRect oldRect = mRect;
+ nsRect oldVisualOverflow = GetVisualOverflowRect();
+
+ rowRect.BStart(wm) -= aRowOffset;
+ rowRect.ISize(wm) = aISize;
+ nsOverflowAreas overflow;
+ nscoord shift = 0;
+ nsSize containerSize = mRect.Size();
+
+ if (aCollapseGroup || collapseRow) {
+ aDidCollapse = true;
+ shift = rowRect.BSize(wm);
+ nsTableCellFrame* cellFrame = GetFirstCell();
+ if (cellFrame) {
+ int32_t rowIndex;
+ cellFrame->GetRowIndex(rowIndex);
+ shift += tableFrame->GetRowSpacing(rowIndex);
+ while (cellFrame) {
+ LogicalRect cRect = cellFrame->GetLogicalRect(wm, containerSize);
+ // If aRowOffset != 0, there's no point in invalidating the cells, since
+ // we've already invalidated our overflow area. Note that we _do_ still
+ // need to invalidate if our row is not moving, because the cell might
+ // span out of this row, so invalidating our row rect won't do enough.
+ if (aRowOffset == 0) {
+ InvalidateFrame();
+ }
+ cRect.BSize(wm) = 0;
+ cellFrame->SetRect(wm, cRect, containerSize);
+ cellFrame = cellFrame->GetNextCell();
+ }
+ } else {
+ shift += tableFrame->GetRowSpacing(GetRowIndex());
+ }
+ rowRect.BSize(wm) = 0;
+ }
+ else { // row is not collapsed
+ // remember the col index of the previous cell to handle rowspans into this
+ // row
+ int32_t prevColIndex = -1;
+ nscoord iPos = 0; // running total of children inline-axis offset
+ nsTableFrame* fifTable =
+ static_cast<nsTableFrame*>(tableFrame->FirstInFlow());
+
+ for (nsIFrame* kidFrame : mFrames) {
+ nsTableCellFrame *cellFrame = do_QueryFrame(kidFrame);
+ if (cellFrame) {
+ int32_t cellColIndex;
+ cellFrame->GetColIndex(cellColIndex);
+ int32_t cellColSpan = tableFrame->GetEffectiveColSpan(*cellFrame);
+
+ // If the adjacent cell is in a prior row (because of a rowspan) add in
+ // the space
+ if (prevColIndex != (cellColIndex - 1)) {
+ iPos += GetSpaceBetween(prevColIndex, cellColIndex, cellColSpan,
+ *tableFrame, true);
+ }
+ LogicalRect cRect(wm, iPos, 0, 0, rowRect.BSize(wm));
+
+ // remember the last (iend-wards-most) column this cell spans into
+ prevColIndex = cellColIndex + cellColSpan - 1;
+ int32_t actualColSpan = cellColSpan;
+ bool isVisible = false;
+ for (int32_t colIdx = cellColIndex; actualColSpan > 0;
+ colIdx++, actualColSpan--) {
+
+ nsTableColFrame* colFrame = tableFrame->GetColFrame(colIdx);
+ const nsStyleVisibility* colVis = colFrame->StyleVisibility();
+ bool collapseCol = (NS_STYLE_VISIBILITY_COLLAPSE ==
+ colVis->mVisible);
+ nsIFrame* cgFrame = colFrame->GetParent();
+ const nsStyleVisibility* groupVis = cgFrame->StyleVisibility();
+ bool collapseGroup = (NS_STYLE_VISIBILITY_COLLAPSE ==
+ groupVis->mVisible);
+ bool isCollapsed = collapseCol || collapseGroup;
+ if (!isCollapsed) {
+ cRect.ISize(wm) += fifTable->GetColumnISizeFromFirstInFlow(colIdx);
+ isVisible = true;
+ if ((actualColSpan > 1)) {
+ nsTableColFrame* nextColFrame =
+ tableFrame->GetColFrame(colIdx + 1);
+ const nsStyleVisibility* nextColVis =
+ nextColFrame->StyleVisibility();
+ if ( (NS_STYLE_VISIBILITY_COLLAPSE != nextColVis->mVisible) &&
+ tableFrame->ColumnHasCellSpacingBefore(colIdx + 1)) {
+ cRect.ISize(wm) += tableFrame->GetColSpacing(cellColIndex);
+ }
+ }
+ }
+ }
+ iPos += cRect.ISize(wm);
+ if (isVisible) {
+ iPos += tableFrame->GetColSpacing(cellColIndex);
+ }
+ int32_t actualRowSpan = tableFrame->GetEffectiveRowSpan(*cellFrame);
+ nsTableRowFrame* rowFrame = GetNextRow();
+ for (actualRowSpan--; actualRowSpan > 0 && rowFrame; actualRowSpan--) {
+ const nsStyleVisibility* nextRowVis = rowFrame->StyleVisibility();
+ bool collapseNextRow = (NS_STYLE_VISIBILITY_COLLAPSE ==
+ nextRowVis->mVisible);
+ if (!collapseNextRow) {
+ LogicalRect nextRect = rowFrame->GetLogicalRect(wm,
+ containerSize);
+ cRect.BSize(wm) +=
+ nextRect.BSize(wm) +
+ tableFrame->GetRowSpacing(rowFrame->GetRowIndex());
+ }
+ rowFrame = rowFrame->GetNextRow();
+ }
+
+ nsRect oldCellRect = cellFrame->GetRect();
+ LogicalPoint oldCellNormalPos =
+ cellFrame->GetLogicalNormalPosition(wm, containerSize);
+
+ nsRect oldCellVisualOverflow = cellFrame->GetVisualOverflowRect();
+
+ if (aRowOffset == 0 && cRect.Origin(wm) != oldCellNormalPos) {
+ // We're moving the cell. Invalidate the old overflow area
+ cellFrame->InvalidateFrameSubtree();
+ }
+
+ cellFrame->MovePositionBy(wm, cRect.Origin(wm) - oldCellNormalPos);
+ cellFrame->SetSize(wm, cRect.Size(wm));
+
+ // XXXbz This looks completely bogus in the cases when we didn't
+ // collapse the cell!
+ LogicalRect cellBounds(wm, 0, 0, cRect.ISize(wm), cRect.BSize(wm));
+ nsRect cellPhysicalBounds =
+ cellBounds.GetPhysicalRect(wm, containerSize);
+ nsOverflowAreas cellOverflow(cellPhysicalBounds, cellPhysicalBounds);
+ cellFrame->FinishAndStoreOverflow(cellOverflow,
+ cRect.Size(wm).GetPhysicalSize(wm));
+ nsTableFrame::RePositionViews(cellFrame);
+ ConsiderChildOverflow(overflow, cellFrame);
+
+ if (aRowOffset == 0) {
+ nsTableFrame::InvalidateTableFrame(cellFrame, oldCellRect,
+ oldCellVisualOverflow, false);
+ }
+ }
+ }
+ }
+
+ SetRect(wm, rowRect, containerSize);
+ overflow.UnionAllWith(nsRect(0, 0, rowRect.Width(wm), rowRect.Height(wm)));
+ FinishAndStoreOverflow(overflow, rowRect.Size(wm).GetPhysicalSize(wm));
+
+ nsTableFrame::RePositionViews(this);
+ nsTableFrame::InvalidateTableFrame(this, oldRect, oldVisualOverflow, false);
+ return shift;
+}
+
+/*
+ * The following method is called by the row group frame's SplitRowGroup()
+ * when it creates a continuing cell frame and wants to insert it into the
+ * row's child list.
+ */
+void
+nsTableRowFrame::InsertCellFrame(nsTableCellFrame* aFrame,
+ int32_t aColIndex)
+{
+ // Find the cell frame where col index < aColIndex
+ nsTableCellFrame* priorCell = nullptr;
+ for (nsIFrame* child : mFrames) {
+ nsTableCellFrame *cellFrame = do_QueryFrame(child);
+ if (cellFrame) {
+ int32_t colIndex;
+ cellFrame->GetColIndex(colIndex);
+ if (colIndex < aColIndex) {
+ priorCell = cellFrame;
+ }
+ else break;
+ }
+ }
+ mFrames.InsertFrame(this, priorCell, aFrame);
+}
+
+nsIAtom*
+nsTableRowFrame::GetType() const
+{
+ return nsGkAtoms::tableRowFrame;
+}
+
+nsTableRowFrame*
+nsTableRowFrame::GetNextRow() const
+{
+ nsIFrame* childFrame = GetNextSibling();
+ while (childFrame) {
+ nsTableRowFrame *rowFrame = do_QueryFrame(childFrame);
+ if (rowFrame) {
+ NS_ASSERTION(mozilla::StyleDisplay::TableRow == childFrame->StyleDisplay()->mDisplay,
+ "wrong display type on rowframe");
+ return rowFrame;
+ }
+ childFrame = childFrame->GetNextSibling();
+ }
+ return nullptr;
+}
+
+NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(RowUnpaginatedHeightProperty, nscoord)
+
+void
+nsTableRowFrame::SetUnpaginatedBSize(nsPresContext* aPresContext,
+ nscoord aValue)
+{
+ NS_ASSERTION(!GetPrevInFlow(), "program error");
+ // Get the property
+ aPresContext->PropertyTable()->
+ Set(this, RowUnpaginatedHeightProperty(), aValue);
+}
+
+nscoord
+nsTableRowFrame::GetUnpaginatedBSize()
+{
+ FrameProperties props = FirstInFlow()->Properties();
+ return props.Get(RowUnpaginatedHeightProperty());
+}
+
+void nsTableRowFrame::SetContinuousBCBorderWidth(LogicalSide aForSide,
+ BCPixelSize aPixelValue)
+{
+ switch (aForSide) {
+ case eLogicalSideIEnd:
+ mIEndContBorderWidth = aPixelValue;
+ return;
+ case eLogicalSideBStart:
+ mBStartContBorderWidth = aPixelValue;
+ return;
+ case eLogicalSideIStart:
+ mIStartContBorderWidth = aPixelValue;
+ return;
+ default:
+ NS_ERROR("invalid NS_SIDE arg");
+ }
+}
+#ifdef ACCESSIBILITY
+a11y::AccType
+nsTableRowFrame::AccessibleType()
+{
+ return a11y::eHTMLTableRowType;
+}
+#endif
+/**
+ * Sets the NS_ROW_HAS_CELL_WITH_STYLE_BSIZE bit to indicate whether
+ * this row has any cells that have non-auto-bsize. (Row-spanning
+ * cells are ignored.)
+ */
+void nsTableRowFrame::InitHasCellWithStyleBSize(nsTableFrame* aTableFrame)
+{
+ WritingMode wm = GetWritingMode();
+
+ for (nsIFrame* kidFrame : mFrames) {
+ nsTableCellFrame *cellFrame = do_QueryFrame(kidFrame);
+ if (!cellFrame) {
+ NS_NOTREACHED("Table row has a non-cell child.");
+ continue;
+ }
+ // Ignore row-spanning cells
+ const nsStyleCoord &cellBSize = cellFrame->StylePosition()->BSize(wm);
+ if (aTableFrame->GetEffectiveRowSpan(*cellFrame) == 1 &&
+ cellBSize.GetUnit() != eStyleUnit_Auto &&
+ /* calc() with percentages treated like 'auto' */
+ (!cellBSize.IsCalcUnit() || !cellBSize.HasPercent())) {
+ AddStateBits(NS_ROW_HAS_CELL_WITH_STYLE_BSIZE);
+ return;
+ }
+ }
+ RemoveStateBits(NS_ROW_HAS_CELL_WITH_STYLE_BSIZE);
+}
+
+void
+nsTableRowFrame::InvalidateFrame(uint32_t aDisplayItemKey)
+{
+ nsIFrame::InvalidateFrame(aDisplayItemKey);
+ GetParent()->InvalidateFrameWithRect(GetVisualOverflowRect() + GetPosition(), aDisplayItemKey);
+}
+
+void
+nsTableRowFrame::InvalidateFrameWithRect(const nsRect& aRect, uint32_t aDisplayItemKey)
+{
+ nsIFrame::InvalidateFrameWithRect(aRect, aDisplayItemKey);
+ // If we have filters applied that would affects our bounds, then
+ // we get an inactive layer created and this is computed
+ // within FrameLayerBuilder
+ GetParent()->InvalidateFrameWithRect(aRect + GetPosition(), aDisplayItemKey);
+}
+
+/* ----- global methods ----- */
+
+nsTableRowFrame*
+NS_NewTableRowFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
+{
+ return new (aPresShell) nsTableRowFrame(aContext);
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsTableRowFrame)
+
+#ifdef DEBUG_FRAME_DUMP
+nsresult
+nsTableRowFrame::GetFrameName(nsAString& aResult) const
+{
+ return MakeFrameName(NS_LITERAL_STRING("TableRow"), aResult);
+}
+#endif