зеркало из https://github.com/mozilla/gecko-dev.git
1526 строки
55 KiB
C++
1526 строки
55 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 "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;
|
|
|
|
struct nsTableCellReflowState : public nsHTMLReflowState
|
|
{
|
|
nsTableCellReflowState(nsPresContext* aPresContext,
|
|
const nsHTMLReflowState& aParentReflowState,
|
|
nsIFrame* aFrame,
|
|
const LogicalSize& aAvailableSpace,
|
|
uint32_t aFlags = 0)
|
|
: nsHTMLReflowState(aPresContext, aParentReflowState, aFrame,
|
|
aAvailableSpace, nullptr, aFlags)
|
|
{
|
|
}
|
|
|
|
void FixUp(const LogicalSize& aAvailSpace);
|
|
};
|
|
|
|
void nsTableCellReflowState::FixUp(const LogicalSize& aAvailSpace)
|
|
{
|
|
// fix the mComputed values during a pass 2 reflow since the cell can be a percentage base
|
|
NS_WARN_IF_FALSE(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::InitChildReflowState(nsPresContext& aPresContext,
|
|
const LogicalSize& aAvailSize,
|
|
bool aBorderCollapse,
|
|
nsTableCellReflowState& aReflowState)
|
|
{
|
|
nsMargin collapseBorder;
|
|
nsMargin* pCollapseBorder = nullptr;
|
|
if (aBorderCollapse) {
|
|
// we only reflow cells, so don't need to check frame type
|
|
nsBCTableCellFrame* bcCellFrame = (nsBCTableCellFrame*)aReflowState.frame;
|
|
if (bcCellFrame) {
|
|
WritingMode wm = GetWritingMode();
|
|
collapseBorder = bcCellFrame->GetBorderWidth(wm).GetPhysicalMargin(wm);
|
|
pCollapseBorder = &collapseBorder;
|
|
}
|
|
}
|
|
aReflowState.Init(&aPresContext, nullptr, pCollapseBorder);
|
|
aReflowState.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(NS_STYLE_DISPLAY_TABLE_ROW == 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();
|
|
nsHTMLReflowMetrics 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->GetFirstPrincipalChild();
|
|
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 nsHTMLReflowState& aReflowState)
|
|
{
|
|
nsTableFrame* tableFrame = GetTableFrame();
|
|
nscoord computedBSize = (NS_UNCONSTRAINEDSIZE == aReflowState.ComputedBSize())
|
|
? 0 : aReflowState.ComputedBSize();
|
|
ResetBSize(computedBSize);
|
|
|
|
WritingMode wm = aReflowState.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 == aReflowState.AvailableBSize()) && !GetPrevInFlow()) {
|
|
CalculateCellActualBSize(cellFrame, desSize.BSize(wm), wm);
|
|
}
|
|
// bsize may have changed, adjust descent to absorb any excess difference
|
|
nscoord ascent;
|
|
if (!kidFrame->GetFirstPrincipalChild()->GetFirstPrincipalChild())
|
|
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 nsHTMLReflowState* aReflowState) const
|
|
{
|
|
if (MOZ_UNLIKELY(StyleBorder()->mBoxDecorationBreak ==
|
|
NS_STYLE_BOX_DECORATION_BREAK_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: {
|
|
nscoord outsideBoxSizing = 0;
|
|
// 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)
|
|
if (PresContext()->CompatibilityMode() != eCompatibility_NavQuirks) {
|
|
switch (position->mBoxSizing) {
|
|
case StyleBoxSizing::Content:
|
|
outsideBoxSizing =
|
|
aCellFrame->GetLogicalUsedBorderAndPadding(aWM).BStartEnd(aWM);
|
|
break;
|
|
case StyleBoxSizing::Padding:
|
|
outsideBoxSizing =
|
|
aCellFrame->GetLogicalUsedBorder(aWM).BStartEnd(aWM);
|
|
break;
|
|
case StyleBoxSizing::Border:
|
|
break;
|
|
}
|
|
}
|
|
|
|
specifiedBSize =
|
|
nsRuleNode::ComputeCoordPercentCalc(bsizeStyleCoord, 0) +
|
|
outsideBoxSizing;
|
|
|
|
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,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
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 = aReflowState.GetWritingMode();
|
|
nsSize containerSize =
|
|
aReflowState.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
|
|
nsTableCellReflowState
|
|
kidReflowState(aPresContext, aReflowState, kidFrame,
|
|
LogicalSize(kidFrame->GetWritingMode(), 0, 0),
|
|
nsHTMLReflowState::CALLER_WILL_INIT);
|
|
InitChildReflowState(*aPresContext, LogicalSize(wm), false, kidReflowState);
|
|
nsHTMLReflowMetrics desiredSize(aReflowState);
|
|
nsReflowStatus status;
|
|
ReflowChild(kidFrame, aPresContext, desiredSize, kidReflowState, 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 (!aReflowState.ShouldReflowAllKids() &&
|
|
!aTableFrame.IsGeometryDirty() &&
|
|
!NS_SUBTREE_DIRTY(kidFrame)) {
|
|
if (!aReflowState.mFlags.mSpecialBSizeReflow)
|
|
doReflowChild = false;
|
|
}
|
|
else if ((NS_UNCONSTRAINEDSIZE != aReflowState.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 (aReflowState.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<nsTableCellReflowState> kidReflowState;
|
|
nsHTMLReflowMetrics desiredSize(aReflowState);
|
|
|
|
// 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 = aReflowState.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, aReflowState.AvailableBSize());
|
|
|
|
// Reflow the child
|
|
kidReflowState.emplace(aPresContext, aReflowState, kidFrame,
|
|
kidAvailSize,
|
|
nsHTMLReflowState::CALLER_WILL_INIT);
|
|
InitChildReflowState(*aPresContext, kidAvailSize, borderCollapse,
|
|
*kidReflowState);
|
|
|
|
nsReflowStatus status;
|
|
ReflowChild(kidFrame, aPresContext, desiredSize, *kidReflowState,
|
|
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 == aReflowState.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->GetFirstPrincipalChild()->GetFirstPrincipalChild()) {
|
|
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 (kidReflowState) {
|
|
// We reflowed. Apply relative positioning in the normal way.
|
|
kidReflowState->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 = static_cast<nsMargin*>
|
|
(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());
|
|
nsHTMLReflowState::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) = aReflowState.AvailableISize();
|
|
|
|
if (aReflowState.mFlags.mSpecialBSizeReflow) {
|
|
aDesiredSize.BSize(wm) = BSize(wm);
|
|
} else if (NS_UNCONSTRAINEDSIZE == aReflowState.AvailableBSize()) {
|
|
aDesiredSize.BSize(wm) = CalcBSize(aReflowState);
|
|
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 > aReflowState.AvailableBSize()) {
|
|
styleBSize = aReflowState.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,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
MarkInReflow();
|
|
DO_GLOBAL_REFLOW_COUNT("nsTableRowFrame");
|
|
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
|
|
|
|
WritingMode wm = aReflowState.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(aReflowState);
|
|
|
|
// See if we have a cell with specified/pct bsize
|
|
InitHasCellWithStyleBSize(tableFrame);
|
|
|
|
ReflowChildren(aPresContext, aDesiredSize, aReflowState, *tableFrame, aStatus);
|
|
|
|
if (aPresContext->IsPaginated() && !NS_FRAME_IS_FULLY_COMPLETE(aStatus) &&
|
|
ShouldAvoidBreakInside(aReflowState)) {
|
|
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) = aReflowState.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, aReflowState, 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 nsHTMLReflowState& aReflowState,
|
|
bool aIsTopOfPage,
|
|
nsTableCellFrame* aCellFrame,
|
|
nscoord aAvailableBSize,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
WritingMode wm = aReflowState.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");
|
|
nsTableCellReflowState
|
|
cellReflowState(aPresContext, aReflowState, aCellFrame, availSize,
|
|
nsHTMLReflowState::CALLER_WILL_INIT);
|
|
InitChildReflowState(*aPresContext, availSize, borderCollapse, cellReflowState);
|
|
cellReflowState.mFlags.mIsTopOfPage = aIsTopOfPage;
|
|
|
|
nsHTMLReflowMetrics desiredSize(aReflowState);
|
|
|
|
ReflowChild(aCellFrame, aPresContext, desiredSize, cellReflowState,
|
|
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(NS_STYLE_DISPLAY_TABLE_ROW == childFrame->StyleDisplay()->mDisplay, "wrong display type on rowframe");
|
|
return rowFrame;
|
|
}
|
|
childFrame = childFrame->GetNextSibling();
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
NS_DECLARE_FRAME_PROPERTY(RowUnpaginatedHeightProperty, nullptr)
|
|
|
|
void
|
|
nsTableRowFrame::SetUnpaginatedBSize(nsPresContext* aPresContext,
|
|
nscoord aValue)
|
|
{
|
|
NS_ASSERTION(!GetPrevInFlow(), "program error");
|
|
// Get the property
|
|
aPresContext->PropertyTable()->
|
|
Set(this, RowUnpaginatedHeightProperty(), NS_INT32_TO_PTR(aValue));
|
|
}
|
|
|
|
nscoord
|
|
nsTableRowFrame::GetUnpaginatedBSize()
|
|
{
|
|
FrameProperties props = FirstInFlow()->Properties();
|
|
return NS_PTR_TO_INT32(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
|