mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
d7f414e2aa
I confirmed that the reftest passes with the patch and fails without the patch. This is the crazy codepath where nsTableRowFrame sets doReflowChild to true, and then tests some additional conditions, and based on those conditions decides to do part (but not all) of the work of reflowing the child. This is making relative and sticky positioning work correctly in that case, which we should really just get rid of, but which I don't want to deal with now. --HG-- extra : transplant_source : %B2%BE%A64%F1%5CG%25%BD%0F%BD%3E%94%80%24%86eEWv
1477 lines
53 KiB
C++
1477 lines
53 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, -1, -1, aFlags)
|
|
{
|
|
}
|
|
|
|
void FixUp(const nsSize& aAvailSpace);
|
|
};
|
|
|
|
void nsTableCellReflowState::FixUp(const nsSize& 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.width,
|
|
"have unconstrained width; this should only result from "
|
|
"very large sizes, not attempts at intrinsic width "
|
|
"calculation");
|
|
if (NS_UNCONSTRAINEDSIZE != ComputedWidth()) {
|
|
nscoord computedWidth =
|
|
aAvailSpace.width - mComputedBorderPadding.LeftRight();
|
|
computedWidth = std::max(0, computedWidth);
|
|
SetComputedWidth(computedWidth);
|
|
}
|
|
if (NS_UNCONSTRAINEDSIZE != ComputedHeight() &&
|
|
NS_UNCONSTRAINEDSIZE != aAvailSpace.height) {
|
|
nscoord computedHeight =
|
|
aAvailSpace.height - mComputedBorderPadding.TopBottom();
|
|
computedHeight = std::max(0, computedHeight);
|
|
SetComputedHeight(computedHeight);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsTableRowFrame::InitChildReflowState(nsPresContext& aPresContext,
|
|
const nsSize& 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) {
|
|
pCollapseBorder = bcCellFrame->GetBorderWidth(collapseBorder);
|
|
}
|
|
}
|
|
aReflowState.Init(&aPresContext, -1, -1, pCollapseBorder);
|
|
aReflowState.FixUp(aAvailSize);
|
|
}
|
|
|
|
void
|
|
nsTableRowFrame::SetFixedHeight(nscoord aValue)
|
|
{
|
|
nscoord height = std::max(0, aValue);
|
|
if (HasFixedHeight()) {
|
|
if (height > mStyleFixedHeight) {
|
|
mStyleFixedHeight = height;
|
|
}
|
|
}
|
|
else {
|
|
mStyleFixedHeight = height;
|
|
if (height > 0) {
|
|
SetHasFixedHeight(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsTableRowFrame::SetPctHeight(float aPctValue,
|
|
bool aForce)
|
|
{
|
|
nscoord height = std::max(0, NSToCoordRound(aPctValue * 100.0f));
|
|
if (HasPctHeight()) {
|
|
if ((height > mStylePctHeight) || aForce) {
|
|
mStylePctHeight = height;
|
|
}
|
|
}
|
|
else {
|
|
mStylePctHeight = height;
|
|
if (height > 0) {
|
|
SetHasPctHeight(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;
|
|
ResetHeight(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 (GetStateBits() & 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 = nsTableFrame::GetTableFrame(this);
|
|
if (tableFrame->IsBorderCollapse() &&
|
|
tableFrame->BCRecalcNeeded(aOldStyleContext, StyleContext())) {
|
|
nsIntRect damageArea(0, GetRowIndex(), tableFrame->GetColCount(), 1);
|
|
tableFrame->AddBCDamageArea(damageArea);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsTableRowFrame::AppendFrames(ChildListID aListID,
|
|
nsFrameList& aFrameList)
|
|
{
|
|
NS_ASSERTION(aListID == kPrincipalList, "unexpected child list");
|
|
|
|
const nsFrameList::Slice& newCells = mFrames.AppendFrames(nullptr, aFrameList);
|
|
|
|
// Add the new cell frames to the table
|
|
nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
|
|
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");
|
|
//Insert Frames in the frame list
|
|
const nsFrameList::Slice& newCells = mFrames.InsertFrames(nullptr, aPrevFrame, aFrameList);
|
|
|
|
// Get the table frame
|
|
nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
|
|
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 = nsTableFrame::GetTableFrame(this);
|
|
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
|
|
GetHeightOfRowsSpannedBelowFirst(nsTableCellFrame& aTableCellFrame,
|
|
nsTableFrame& aTableFrame)
|
|
{
|
|
nscoord height = 0;
|
|
int32_t rowSpan = aTableFrame.GetEffectiveRowSpan(aTableCellFrame);
|
|
// add in height 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()) {
|
|
height += nextRow->GetSize().height;
|
|
rowX++;
|
|
}
|
|
height += aTableFrame.GetCellSpacingY(rowX);
|
|
nextRow = nextRow->GetNextSibling();
|
|
}
|
|
return height;
|
|
}
|
|
|
|
nsTableCellFrame*
|
|
nsTableRowFrame::GetFirstCell()
|
|
{
|
|
nsIFrame* childFrame = mFrames.FirstChild();
|
|
while (childFrame) {
|
|
nsTableCellFrame *cellFrame = do_QueryFrame(childFrame);
|
|
if (cellFrame) {
|
|
return cellFrame;
|
|
}
|
|
childFrame = childFrame->GetNextSibling();
|
|
}
|
|
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 height
|
|
nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
|
|
nsTableIterator iter(*this);
|
|
nsIFrame* childFrame = iter.First();
|
|
|
|
WritingMode wm = GetWritingMode();
|
|
nsHTMLReflowMetrics desiredSize(wm);
|
|
desiredSize.SetSize(wm, GetLogicalSize(wm));
|
|
desiredSize.SetOverflowAreasToDesiredBounds();
|
|
|
|
while (childFrame) {
|
|
nsTableCellFrame *cellFrame = do_QueryFrame(childFrame);
|
|
if (cellFrame) {
|
|
nscoord cellHeight = mRect.height + GetHeightOfRowsSpannedBelowFirst(*cellFrame, *tableFrame);
|
|
|
|
// resize the cell's height
|
|
nsRect cellRect = cellFrame->GetRect();
|
|
nsRect cellVisualOverflow = cellFrame->GetVisualOverflowRect();
|
|
if (cellRect.height != cellHeight)
|
|
{
|
|
cellFrame->SetSize(nsSize(cellRect.width, cellHeight));
|
|
nsTableFrame::InvalidateTableFrame(cellFrame, cellRect,
|
|
cellVisualOverflow,
|
|
false);
|
|
}
|
|
|
|
// realign cell content based on the new height. We might be able to
|
|
// skip this if the height didn't change... maybe. Hard to tell.
|
|
cellFrame->VerticallyAlignChild(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 height reflow.
|
|
}
|
|
// Get the next child
|
|
childFrame = iter.Next();
|
|
}
|
|
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 aWritingMode)
|
|
{
|
|
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
|
|
|
|
nsTableIterator iter(*this);
|
|
nsIFrame* childFrame = iter.First();
|
|
nscoord ascent = 0;
|
|
while (childFrame) {
|
|
if (IS_TABLE_CELL(childFrame->GetType())) {
|
|
nsIFrame* firstKid = childFrame->GetFirstPrincipalChild();
|
|
ascent = std::max(ascent, firstKid->GetNormalRect().YMost());
|
|
}
|
|
// Get the next child
|
|
childFrame = iter.Next();
|
|
}
|
|
return ascent;
|
|
}
|
|
nscoord
|
|
nsTableRowFrame::GetHeight(nscoord aPctBasis) const
|
|
{
|
|
nscoord height = 0;
|
|
if ((aPctBasis > 0) && HasPctHeight()) {
|
|
height = NSToCoordRound(GetPctHeight() * (float)aPctBasis);
|
|
}
|
|
if (HasFixedHeight()) {
|
|
height = std::max(height, GetFixedHeight());
|
|
}
|
|
return std::max(height, GetContentHeight());
|
|
}
|
|
|
|
void
|
|
nsTableRowFrame::ResetHeight(nscoord aFixedHeight)
|
|
{
|
|
SetHasFixedHeight(false);
|
|
SetHasPctHeight(false);
|
|
SetFixedHeight(0);
|
|
SetPctHeight(0);
|
|
SetContentHeight(0);
|
|
|
|
if (aFixedHeight > 0) {
|
|
SetFixedHeight(aFixedHeight);
|
|
}
|
|
|
|
mMaxCellAscent = 0;
|
|
mMaxCellDescent = 0;
|
|
}
|
|
|
|
void
|
|
nsTableRowFrame::UpdateHeight(nscoord aHeight,
|
|
nscoord aAscent,
|
|
nscoord aDescent,
|
|
nsTableFrame* aTableFrame,
|
|
nsTableCellFrame* aCellFrame)
|
|
{
|
|
if (!aTableFrame || !aCellFrame) {
|
|
NS_ASSERTION(false , "invalid call");
|
|
return;
|
|
}
|
|
|
|
if (aHeight != NS_UNCONSTRAINEDSIZE) {
|
|
if (!(aCellFrame->HasVerticalAlignBaseline())) { // only the cell's height matters
|
|
if (GetHeight() < aHeight) {
|
|
int32_t rowSpan = aTableFrame->GetEffectiveRowSpan(*aCellFrame);
|
|
if (rowSpan == 1) {
|
|
SetContentHeight(aHeight);
|
|
}
|
|
}
|
|
}
|
|
else { // the alignment on the baseline can change the height
|
|
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 height in sync
|
|
if (GetHeight() < mMaxCellAscent + mMaxCellDescent) {
|
|
SetContentHeight(mMaxCellAscent + mMaxCellDescent);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
nscoord
|
|
nsTableRowFrame::CalcHeight(const nsHTMLReflowState& aReflowState)
|
|
{
|
|
nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
|
|
nscoord computedHeight = (NS_UNCONSTRAINEDSIZE == aReflowState.ComputedHeight())
|
|
? 0 : aReflowState.ComputedHeight();
|
|
ResetHeight(computedHeight);
|
|
|
|
const nsStylePosition* position = StylePosition();
|
|
if (position->mHeight.ConvertsToLength()) {
|
|
SetFixedHeight(nsRuleNode::ComputeCoordPercentCalc(position->mHeight, 0));
|
|
}
|
|
else if (eStyleUnit_Percent == position->mHeight.GetUnit()) {
|
|
SetPctHeight(position->mHeight.GetPercentValue());
|
|
}
|
|
// calc() with percentages is treated like 'auto' on table rows.
|
|
|
|
for (nsIFrame* kidFrame = mFrames.FirstChild(); kidFrame;
|
|
kidFrame = kidFrame->GetNextSibling()) {
|
|
nsTableCellFrame *cellFrame = do_QueryFrame(kidFrame);
|
|
if (cellFrame) {
|
|
WritingMode wm = cellFrame->GetWritingMode();
|
|
LogicalSize desSize = cellFrame->GetDesiredSize();
|
|
if ((NS_UNCONSTRAINEDSIZE == aReflowState.AvailableHeight()) && !GetPrevInFlow()) {
|
|
CalculateCellActualHeight(cellFrame, desSize.BSize(wm));
|
|
}
|
|
// height 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;
|
|
UpdateHeight(desSize.BSize(wm), ascent, descent, tableFrame, cellFrame);
|
|
}
|
|
}
|
|
return GetHeight();
|
|
}
|
|
|
|
/**
|
|
* 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 ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
|
|
const nsDisplayItemGeometry* aGeometry,
|
|
nsRegion *aInvalidRegion) MOZ_OVERRIDE;
|
|
virtual void Paint(nsDisplayListBuilder* aBuilder,
|
|
nsRenderingContext* aCtx) MOZ_OVERRIDE;
|
|
NS_DISPLAY_DECL_NAME("TableRowBackground", TYPE_TABLE_ROW_BACKGROUND)
|
|
};
|
|
|
|
void
|
|
nsDisplayTableRowBackground::ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
|
|
const nsDisplayItemGeometry* aGeometry,
|
|
nsRegion *aInvalidRegion)
|
|
{
|
|
if (aBuilder->ShouldSyncDecodeImages()) {
|
|
if (nsTableFrame::AnyTablePartHasUndecodedBackgroundImage(mFrame, mFrame->GetNextSibling())) {
|
|
bool snap;
|
|
aInvalidRegion->Or(*aInvalidRegion, GetBounds(aBuilder, &snap));
|
|
}
|
|
}
|
|
|
|
nsDisplayTableItem::ComputeInvalidationRegion(aBuilder, aGeometry, aInvalidRegion);
|
|
}
|
|
|
|
void
|
|
nsDisplayTableRowBackground::Paint(nsDisplayListBuilder* aBuilder,
|
|
nsRenderingContext* aCtx)
|
|
{
|
|
nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(mFrame);
|
|
TableBackgroundPainter painter(tableFrame,
|
|
TableBackgroundPainter::eOrigin_TableRow,
|
|
mFrame->PresContext(), *aCtx,
|
|
mVisibleRect, ToReferenceFrame(),
|
|
aBuilder->GetBackgroundPaintFlags());
|
|
painter.PaintRow(static_cast<nsTableRowFrame*>(mFrame));
|
|
}
|
|
|
|
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 height given its pass2 height.
|
|
// Takes into account the specified height (in the style).
|
|
// Modifies the desired height that is passed in.
|
|
nsresult
|
|
nsTableRowFrame::CalculateCellActualHeight(nsTableCellFrame* aCellFrame,
|
|
nscoord& aDesiredHeight)
|
|
{
|
|
nscoord specifiedHeight = 0;
|
|
|
|
// Get the height specified in the style information
|
|
const nsStylePosition* position = aCellFrame->StylePosition();
|
|
|
|
nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
|
|
int32_t rowSpan = tableFrame->GetEffectiveRowSpan(*aCellFrame);
|
|
|
|
switch (position->mHeight.GetUnit()) {
|
|
case eStyleUnit_Calc: {
|
|
if (position->mHeight.CalcHasPercent()) {
|
|
// Treat this like "auto"
|
|
break;
|
|
}
|
|
// Fall through to the coord case
|
|
}
|
|
case eStyleUnit_Coord: {
|
|
nscoord outsideBoxSizing = 0;
|
|
// In quirks mode, table cell width should be content-box, but height
|
|
// 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 width and another
|
|
// for height)
|
|
if (PresContext()->CompatibilityMode() != eCompatibility_NavQuirks) {
|
|
switch (position->mBoxSizing) {
|
|
case NS_STYLE_BOX_SIZING_CONTENT:
|
|
outsideBoxSizing = aCellFrame->GetUsedBorderAndPadding().TopBottom();
|
|
break;
|
|
case NS_STYLE_BOX_SIZING_PADDING:
|
|
outsideBoxSizing = aCellFrame->GetUsedBorder().TopBottom();
|
|
break;
|
|
default:
|
|
// NS_STYLE_BOX_SIZING_BORDER
|
|
break;
|
|
}
|
|
}
|
|
|
|
specifiedHeight =
|
|
nsRuleNode::ComputeCoordPercentCalc(position->mHeight, 0) +
|
|
outsideBoxSizing;
|
|
|
|
if (1 == rowSpan)
|
|
SetFixedHeight(specifiedHeight);
|
|
break;
|
|
}
|
|
case eStyleUnit_Percent: {
|
|
if (1 == rowSpan)
|
|
SetPctHeight(position->mHeight.GetPercentValue());
|
|
// pct heights are handled when all of the cells are finished, so don't set specifiedHeight
|
|
break;
|
|
}
|
|
case eStyleUnit_Auto:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// If the specified height is greater than the desired height, then use the specified height
|
|
if (specifiedHeight > aDesiredHeight)
|
|
aDesiredHeight = specifiedHeight;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
// Calculates the available width for the table cell based on the known
|
|
// column widths taking into account column spans and column spacing
|
|
static nscoord
|
|
CalcAvailWidth(nsTableFrame& aTableFrame,
|
|
nsTableCellFrame& aCellFrame)
|
|
{
|
|
nscoord cellAvailWidth = 0;
|
|
int32_t colIndex;
|
|
aCellFrame.GetColIndex(colIndex);
|
|
int32_t colspan = aTableFrame.GetEffectiveColSpan(aCellFrame);
|
|
NS_ASSERTION(colspan > 0, "effective colspan should be positive");
|
|
|
|
for (int32_t spanX = 0; spanX < colspan; spanX++) {
|
|
cellAvailWidth += aTableFrame.GetColumnWidth(colIndex + spanX);
|
|
if (spanX > 0 &&
|
|
aTableFrame.ColumnHasCellSpacingBefore(colIndex + spanX)) {
|
|
cellAvailWidth += aTableFrame.GetCellSpacingX(colIndex + spanX - 1);
|
|
}
|
|
}
|
|
return cellAvailWidth;
|
|
}
|
|
|
|
nscoord
|
|
GetSpaceBetween(int32_t aPrevColIndex,
|
|
int32_t aColIndex,
|
|
int32_t aColSpan,
|
|
nsTableFrame& aTableFrame,
|
|
bool aIsLeftToRight,
|
|
bool aCheckVisibility)
|
|
{
|
|
nscoord space = 0;
|
|
int32_t colX;
|
|
if (aIsLeftToRight) {
|
|
for (colX = aPrevColIndex + 1; aColIndex > colX; colX++) {
|
|
bool isCollapsed = false;
|
|
if (!aCheckVisibility) {
|
|
space += aTableFrame.GetColumnWidth(colX);
|
|
}
|
|
else {
|
|
nsTableColFrame* colFrame = aTableFrame.GetColFrame(colX);
|
|
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 += aTableFrame.GetColumnWidth(colX);
|
|
}
|
|
if (!isCollapsed && aTableFrame.ColumnHasCellSpacingBefore(colX)) {
|
|
space += aTableFrame.GetCellSpacingX(colX - 1);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
int32_t lastCol = aColIndex + aColSpan - 1;
|
|
for (colX = aPrevColIndex - 1; colX > lastCol; colX--) {
|
|
bool isCollapsed = false;
|
|
if (!aCheckVisibility) {
|
|
space += aTableFrame.GetColumnWidth(colX);
|
|
}
|
|
else {
|
|
nsTableColFrame* colFrame = aTableFrame.GetColFrame(colX);
|
|
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 += aTableFrame.GetColumnWidth(colX);
|
|
}
|
|
if (!isCollapsed && aTableFrame.ColumnHasCellSpacingBefore(colX)) {
|
|
space += aTableFrame.GetCellSpacingX(colX - 1);
|
|
}
|
|
}
|
|
}
|
|
return space;
|
|
}
|
|
|
|
// subtract the heights of aRow's prev in flows from the unpaginated height
|
|
static
|
|
nscoord CalcHeightFromUnpaginatedHeight(nsPresContext* aPresContext,
|
|
nsTableRowFrame& aRow)
|
|
{
|
|
nscoord height = 0;
|
|
nsTableRowFrame* firstInFlow =
|
|
static_cast<nsTableRowFrame*>(aRow.FirstInFlow());
|
|
if (firstInFlow->HasUnpaginatedHeight()) {
|
|
height = firstInFlow->GetUnpaginatedHeight(aPresContext);
|
|
for (nsIFrame* prevInFlow = aRow.GetPrevInFlow(); prevInFlow;
|
|
prevInFlow = prevInFlow->GetPrevInFlow()) {
|
|
height -= prevInFlow->GetSize().height;
|
|
}
|
|
}
|
|
return std::max(height, 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 height 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
|
|
|
|
nsTableIterator iter(*this);
|
|
// remember the col index of the previous cell to handle rowspans into this row
|
|
int32_t firstPrevColIndex = (iter.IsLeftToRight()) ? -1 : aTableFrame.GetColCount();
|
|
int32_t prevColIndex = firstPrevColIndex;
|
|
nscoord x = 0; // running total of children x offset
|
|
|
|
// This computes the max of all cell heights
|
|
nscoord cellMaxHeight = 0;
|
|
|
|
// Reflow each of our existing cell frames
|
|
for (nsIFrame* kidFrame = iter.First(); kidFrame; kidFrame = iter.Next()) {
|
|
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, nsSize(0,0), 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.mSpecialHeightReflow)
|
|
doReflowChild = false;
|
|
}
|
|
else if ((NS_UNCONSTRAINEDSIZE != aReflowState.AvailableHeight())) {
|
|
// We don't reflow a rowspan >1 cell here with a constrained height.
|
|
// That happens in nsTableRowGroupFrame::SplitSpanningCells.
|
|
if (aTableFrame.GetEffectiveRowSpan(*cellFrame) > 1) {
|
|
doReflowChild = false;
|
|
}
|
|
}
|
|
if (aReflowState.mFlags.mSpecialHeightReflow) {
|
|
if (!isPaginated && !(cellFrame->GetStateBits() &
|
|
NS_FRAME_CONTAINS_RELATIVE_HEIGHT)) {
|
|
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 ((iter.IsLeftToRight() && (prevColIndex != (cellColIndex - 1))) ||
|
|
(!iter.IsLeftToRight() && (prevColIndex != cellColIndex + cellColSpan))) {
|
|
x += GetSpaceBetween(prevColIndex, cellColIndex, cellColSpan, aTableFrame,
|
|
iter.IsLeftToRight(), false);
|
|
}
|
|
|
|
// remember the rightmost (ltr) or leftmost (rtl) column this cell spans into
|
|
prevColIndex = (iter.IsLeftToRight()) ? cellColIndex + (cellColSpan - 1) : cellColIndex;
|
|
|
|
// Reflow the child frame
|
|
nsRect kidRect = kidFrame->GetRect();
|
|
nsPoint origKidNormalPosition = kidFrame->GetNormalPosition();
|
|
MOZ_ASSERT(origKidNormalPosition.y == 0);
|
|
nsRect kidVisualOverflow = kidFrame->GetVisualOverflowRect();
|
|
nsPoint kidPosition(x, 0);
|
|
bool firstReflow =
|
|
(kidFrame->GetStateBits() & NS_FRAME_FIRST_REFLOW) != 0;
|
|
|
|
if (doReflowChild) {
|
|
// Calculate the available width for the table cell using the known column widths
|
|
nscoord availCellWidth =
|
|
CalcAvailWidth(aTableFrame, *cellFrame);
|
|
|
|
Maybe<nsTableCellReflowState> kidReflowState;
|
|
nsHTMLReflowMetrics desiredSize(aReflowState);
|
|
|
|
// If the avail width 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 rowWM = aReflowState.GetWritingMode();
|
|
WritingMode cellWM = cellFrame->GetWritingMode();
|
|
LogicalSize cellDesiredSize = cellFrame->GetDesiredSize();
|
|
if ((availCellWidth != cellFrame->GetPriorAvailWidth()) ||
|
|
(cellDesiredSize.ISize(cellWM) > cellFrame->GetPriorAvailWidth()) ||
|
|
(GetStateBits() & 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->GetStateBits() & NS_FRAME_CONTAINS_RELATIVE_HEIGHT) ||
|
|
HasPctHeight()) {
|
|
// Reflow the cell to fit the available width, height
|
|
// XXX The old IR_ChildIsDirty code used availCellWidth here.
|
|
nsSize kidAvailSize(availCellWidth, aReflowState.AvailableHeight());
|
|
|
|
// Reflow the child
|
|
kidReflowState.emplace(aPresContext, aReflowState, kidFrame,
|
|
LogicalSize(kidFrame->GetWritingMode(),
|
|
kidAvailSize),
|
|
// Cast needed for gcc 4.4.
|
|
uint32_t(nsHTMLReflowState::CALLER_WILL_INIT));
|
|
InitChildReflowState(*aPresContext, kidAvailSize, borderCollapse,
|
|
*kidReflowState);
|
|
|
|
nsReflowStatus status;
|
|
ReflowChild(kidFrame, aPresContext, desiredSize, *kidReflowState,
|
|
x, 0, 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 (x != origKidNormalPosition.x) {
|
|
kidFrame->InvalidateFrameSubtree();
|
|
}
|
|
|
|
desiredSize.SetSize(cellWM, 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.AvailableHeight()) {
|
|
if (!GetPrevInFlow()) {
|
|
// Calculate the cell's actual height given its pass2 height. This
|
|
// function takes into account the specified height (in the style)
|
|
CalculateCellActualHeight(cellFrame, desiredSize.Height());
|
|
}
|
|
// height may have changed, adjust descent to absorb any excess difference
|
|
nscoord ascent;
|
|
if (!kidFrame->GetFirstPrincipalChild()->GetFirstPrincipalChild()) {
|
|
ascent = desiredSize.BSize(rowWM);
|
|
} else {
|
|
ascent = ((nsTableCellFrame *)kidFrame)->GetCellBaseline();
|
|
}
|
|
nscoord descent = desiredSize.BSize(rowWM) - ascent;
|
|
UpdateHeight(desiredSize.BSize(rowWM), ascent, descent, &aTableFrame, cellFrame);
|
|
}
|
|
else {
|
|
cellMaxHeight = std::max(cellMaxHeight, desiredSize.Height());
|
|
int32_t rowSpan = aTableFrame.GetEffectiveRowSpan((nsTableCellFrame&)*kidFrame);
|
|
if (1 == rowSpan) {
|
|
SetContentHeight(cellMaxHeight);
|
|
}
|
|
}
|
|
|
|
// Place the child
|
|
desiredSize.ISize(rowWM) = availCellWidth;
|
|
|
|
if (kidReflowState) {
|
|
// We reflowed. Apply relative positioning in the normal way.
|
|
kidReflowState->ApplyRelativePositioning(&kidPosition);
|
|
} 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.)
|
|
const nsMargin* computedOffsets = static_cast<nsMargin*>
|
|
(kidFrame->Properties().Get(nsIFrame::ComputedOffsetProperty()));
|
|
nsHTMLReflowState::ApplyRelativePositioning(kidFrame, *computedOffsets,
|
|
&kidPosition);
|
|
}
|
|
FinishReflowChild(kidFrame, aPresContext, desiredSize, nullptr,
|
|
kidPosition.x, kidPosition.y, 0);
|
|
|
|
nsTableFrame::InvalidateTableFrame(kidFrame, kidRect, kidVisualOverflow,
|
|
firstReflow);
|
|
|
|
x += desiredSize.Width();
|
|
}
|
|
else {
|
|
if (x != origKidNormalPosition.x) {
|
|
// Invalidate the old position
|
|
kidFrame->InvalidateFrameSubtree();
|
|
// Move to the new position. As above, we need to account for relative
|
|
// positioning.
|
|
kidFrame->MovePositionBy(nsPoint(x - origKidNormalPosition.x, 0));
|
|
nsTableFrame::RePositionViews(kidFrame);
|
|
// invalidate the new position
|
|
kidFrame->InvalidateFrameSubtree();
|
|
}
|
|
// we need to account for the cell's width even if it isn't reflowed
|
|
x += kidRect.width;
|
|
|
|
if (kidFrame->GetNextInFlow()) {
|
|
aStatus = NS_FRAME_NOT_COMPLETE;
|
|
}
|
|
}
|
|
ConsiderChildOverflow(aDesiredSize.mOverflowAreas, kidFrame);
|
|
x += aTableFrame.GetCellSpacingX(cellColIndex);
|
|
}
|
|
|
|
// just set our width to what was available. The table will calculate the width and not use our value.
|
|
aDesiredSize.Width() = aReflowState.AvailableWidth();
|
|
|
|
if (aReflowState.mFlags.mSpecialHeightReflow) {
|
|
aDesiredSize.Height() = mRect.height;
|
|
}
|
|
else if (NS_UNCONSTRAINEDSIZE == aReflowState.AvailableHeight()) {
|
|
aDesiredSize.Height() = CalcHeight(aReflowState);
|
|
if (GetPrevInFlow()) {
|
|
nscoord height = CalcHeightFromUnpaginatedHeight(aPresContext, *this);
|
|
aDesiredSize.Height() = std::max(aDesiredSize.Height(), height);
|
|
}
|
|
else {
|
|
if (isPaginated && HasStyleHeight()) {
|
|
// set the unpaginated height so next in flows can try to honor it
|
|
SetHasUnpaginatedHeight(true);
|
|
SetUnpaginatedHeight(aPresContext, aDesiredSize.Height());
|
|
}
|
|
if (isPaginated && HasUnpaginatedHeight()) {
|
|
aDesiredSize.Height() = std::max(aDesiredSize.Height(), GetUnpaginatedHeight(aPresContext));
|
|
}
|
|
}
|
|
}
|
|
else { // constrained height, paginated
|
|
// Compute the height we should have from style (subtracting the
|
|
// height from our prev-in-flows from the style height)
|
|
nscoord styleHeight = CalcHeightFromUnpaginatedHeight(aPresContext, *this);
|
|
if (styleHeight > aReflowState.AvailableHeight()) {
|
|
styleHeight = aReflowState.AvailableHeight();
|
|
NS_FRAME_SET_INCOMPLETE(aStatus);
|
|
}
|
|
aDesiredSize.Height() = std::max(cellMaxHeight, styleHeight);
|
|
}
|
|
aDesiredSize.UnionOverflowAreasWithDesiredBounds();
|
|
FinishAndStoreOverflow(&aDesiredSize);
|
|
}
|
|
|
|
/** Layout the entire row.
|
|
* This method stacks cells horizontally according to HTML 4.0 rules.
|
|
*/
|
|
void
|
|
nsTableRowFrame::Reflow(nsPresContext* aPresContext,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
DO_GLOBAL_REFLOW_COUNT("nsTableRowFrame");
|
|
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
|
|
|
|
nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
|
|
const nsStyleVisibility* rowVis = StyleVisibility();
|
|
bool collapseRow = (NS_STYLE_VISIBILITY_COLLAPSE == rowVis->mVisible);
|
|
if (collapseRow) {
|
|
tableFrame->SetNeedToCollapse(true);
|
|
}
|
|
|
|
// see if a special height reflow needs to occur due to having a pct height
|
|
nsTableFrame::CheckRequestSpecialHeightReflow(aReflowState);
|
|
|
|
// See if we have a cell with specified/pct height
|
|
InitHasCellWithStyleHeight(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 width to what was available. The table will calculate the width and not use our value.
|
|
aDesiredSize.Width() = aReflowState.AvailableWidth();
|
|
|
|
// If our parent is in initial reflow, it'll handle invalidating our
|
|
// entire overflow rect.
|
|
if (!(GetParent()->GetStateBits() & 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 aAvailableHeight,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
// Reflow the cell frame with the specified height. Use the existing width
|
|
nsRect cellRect = aCellFrame->GetRect();
|
|
nsRect cellVisualOverflow = aCellFrame->GetVisualOverflowRect();
|
|
|
|
nsSize availSize(cellRect.width, aAvailableHeight);
|
|
nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
|
|
bool borderCollapse = tableFrame->IsBorderCollapse();
|
|
nsTableCellReflowState
|
|
cellReflowState(aPresContext, aReflowState, aCellFrame,
|
|
LogicalSize(aCellFrame->GetWritingMode(),
|
|
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.Height() = aAvailableHeight;
|
|
}
|
|
aCellFrame->SetSize(nsSize(cellRect.width, desiredSize.Height()));
|
|
|
|
// Note: VerticallyAlignChild 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->VerticallyAlignChild(mMaxCellAscent);
|
|
}
|
|
|
|
nsTableFrame::InvalidateTableFrame(aCellFrame, cellRect,
|
|
cellVisualOverflow,
|
|
(aCellFrame->GetStateBits() &
|
|
NS_FRAME_FIRST_REFLOW) != 0);
|
|
|
|
aCellFrame->DidReflow(aPresContext, nullptr, nsDidReflowStatus::FINISHED);
|
|
|
|
return desiredSize.Height();
|
|
}
|
|
|
|
nscoord
|
|
nsTableRowFrame::CollapseRowIfNecessary(nscoord aRowOffset,
|
|
nscoord aWidth,
|
|
bool aCollapseGroup,
|
|
bool& aDidCollapse)
|
|
{
|
|
const nsStyleVisibility* rowVis = StyleVisibility();
|
|
bool collapseRow = (NS_STYLE_VISIBILITY_COLLAPSE == rowVis->mVisible);
|
|
nsTableFrame* tableFrame = static_cast<nsTableFrame*>(
|
|
nsTableFrame::GetTableFrame(this)->FirstInFlow());
|
|
if (collapseRow) {
|
|
tableFrame->SetNeedToCollapse(true);
|
|
}
|
|
|
|
if (aRowOffset != 0) {
|
|
// We're moving, so invalidate our old position
|
|
InvalidateFrameSubtree();
|
|
}
|
|
|
|
nsRect rowRect = GetRect();
|
|
nsRect oldRect = rowRect;
|
|
nsRect oldVisualOverflow = GetVisualOverflowRect();
|
|
|
|
rowRect.y -= aRowOffset;
|
|
rowRect.width = aWidth;
|
|
nsOverflowAreas overflow;
|
|
nscoord shift = 0;
|
|
|
|
if (aCollapseGroup || collapseRow) {
|
|
aDidCollapse = true;
|
|
shift = rowRect.height;
|
|
nsTableCellFrame* cellFrame = GetFirstCell();
|
|
if (cellFrame) {
|
|
int32_t rowIndex;
|
|
cellFrame->GetRowIndex(rowIndex);
|
|
shift += tableFrame->GetCellSpacingY(rowIndex);
|
|
while (cellFrame) {
|
|
nsRect cRect = cellFrame->GetRect();
|
|
// 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.height = 0;
|
|
cellFrame->SetRect(cRect);
|
|
cellFrame = cellFrame->GetNextCell();
|
|
}
|
|
} else {
|
|
shift += tableFrame->GetCellSpacingY(GetRowIndex());
|
|
}
|
|
rowRect.height = 0;
|
|
}
|
|
else { // row is not collapsed
|
|
nsTableIterator iter(*this);
|
|
// remember the col index of the previous cell to handle rowspans into this
|
|
// row
|
|
int32_t firstPrevColIndex = (iter.IsLeftToRight()) ? -1 :
|
|
tableFrame->GetColCount();
|
|
int32_t prevColIndex = firstPrevColIndex;
|
|
nscoord x = 0; // running total of children x offset
|
|
|
|
int32_t colIncrement = iter.IsLeftToRight() ? 1 : -1;
|
|
|
|
nsIFrame* kidFrame = iter.First();
|
|
while (kidFrame) {
|
|
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 ((iter.IsLeftToRight() && (prevColIndex != (cellColIndex - 1))) ||
|
|
(!iter.IsLeftToRight() &&
|
|
(prevColIndex != cellColIndex + cellColSpan))) {
|
|
x += GetSpaceBetween(prevColIndex, cellColIndex, cellColSpan,
|
|
*tableFrame, iter.IsLeftToRight(),
|
|
true);
|
|
}
|
|
nsRect cRect(x, 0, 0, rowRect.height);
|
|
|
|
// remember the rightmost (ltr) or leftmost (rtl) column this cell
|
|
// spans into
|
|
prevColIndex = (iter.IsLeftToRight()) ?
|
|
cellColIndex + (cellColSpan - 1) : cellColIndex;
|
|
int32_t startIndex = (iter.IsLeftToRight()) ?
|
|
cellColIndex : cellColIndex + (cellColSpan - 1);
|
|
int32_t actualColSpan = cellColSpan;
|
|
bool isVisible = false;
|
|
for (int32_t colX = startIndex; actualColSpan > 0;
|
|
colX += colIncrement, actualColSpan--) {
|
|
|
|
nsTableColFrame* colFrame = tableFrame->GetColFrame(colX);
|
|
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.width += tableFrame->GetColumnWidth(colX);
|
|
isVisible = true;
|
|
if ((actualColSpan > 1)) {
|
|
nsTableColFrame* nextColFrame =
|
|
tableFrame->GetColFrame(colX + colIncrement);
|
|
const nsStyleVisibility* nextColVis =
|
|
nextColFrame->StyleVisibility();
|
|
if ( (NS_STYLE_VISIBILITY_COLLAPSE != nextColVis->mVisible) &&
|
|
tableFrame->ColumnHasCellSpacingBefore(colX + colIncrement)) {
|
|
cRect.width += tableFrame->GetCellSpacingX(cellColIndex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
x += cRect.width;
|
|
if (isVisible)
|
|
x += tableFrame->GetCellSpacingX(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) {
|
|
nsRect nextRect = rowFrame->GetRect();
|
|
cRect.height += nextRect.height +
|
|
tableFrame->GetCellSpacingY(rowFrame->GetRowIndex());
|
|
}
|
|
rowFrame = rowFrame->GetNextRow();
|
|
}
|
|
|
|
nsRect oldCellRect = cellFrame->GetRect();
|
|
nsPoint oldCellNormalPos = cellFrame->GetNormalPosition();
|
|
nsRect oldCellVisualOverflow = cellFrame->GetVisualOverflowRect();
|
|
|
|
if (aRowOffset == 0 && cRect.TopLeft() != oldCellNormalPos) {
|
|
// We're moving the cell. Invalidate the old overflow area
|
|
cellFrame->InvalidateFrameSubtree();
|
|
}
|
|
|
|
cellFrame->MovePositionBy(cRect.TopLeft() - oldCellNormalPos);
|
|
cellFrame->SetSize(cRect.Size());
|
|
|
|
// XXXbz This looks completely bogus in the cases when we didn't
|
|
// collapse the cell!
|
|
nsRect cellBounds(0, 0, cRect.width, cRect.height);
|
|
nsOverflowAreas cellOverflow(cellBounds, cellBounds);
|
|
cellFrame->FinishAndStoreOverflow(cellOverflow, cRect.Size());
|
|
nsTableFrame::RePositionViews(cellFrame);
|
|
ConsiderChildOverflow(overflow, cellFrame);
|
|
|
|
if (aRowOffset == 0) {
|
|
nsTableFrame::InvalidateTableFrame(cellFrame, oldCellRect,
|
|
oldCellVisualOverflow,
|
|
false);
|
|
}
|
|
}
|
|
kidFrame = iter.Next(); // Get the next child
|
|
}
|
|
}
|
|
|
|
SetRect(rowRect);
|
|
overflow.UnionAllWith(nsRect(0, 0, rowRect.width, rowRect.height));
|
|
FinishAndStoreOverflow(overflow, rowRect.Size());
|
|
|
|
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.FirstChild(); child;
|
|
child = child->GetNextSibling()) {
|
|
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::SetUnpaginatedHeight(nsPresContext* aPresContext,
|
|
nscoord aValue)
|
|
{
|
|
NS_ASSERTION(!GetPrevInFlow(), "program error");
|
|
// Get the property
|
|
aPresContext->PropertyTable()->
|
|
Set(this, RowUnpaginatedHeightProperty(), NS_INT32_TO_PTR(aValue));
|
|
}
|
|
|
|
nscoord
|
|
nsTableRowFrame::GetUnpaginatedHeight(nsPresContext* aPresContext)
|
|
{
|
|
FrameProperties props = FirstInFlow()->Properties();
|
|
return NS_PTR_TO_INT32(props.Get(RowUnpaginatedHeightProperty()));
|
|
}
|
|
|
|
void nsTableRowFrame::SetContinuousBCBorderWidth(uint8_t aForSide,
|
|
BCPixelSize aPixelValue)
|
|
{
|
|
switch (aForSide) {
|
|
case NS_SIDE_RIGHT:
|
|
mRightContBorderWidth = aPixelValue;
|
|
return;
|
|
case NS_SIDE_TOP:
|
|
mTopContBorderWidth = aPixelValue;
|
|
return;
|
|
case NS_SIDE_LEFT:
|
|
mLeftContBorderWidth = 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_HEIGHT bit to indicate whether
|
|
* this row has any cells that have non-auto-height. (Row-spanning
|
|
* cells are ignored.)
|
|
*/
|
|
void nsTableRowFrame::InitHasCellWithStyleHeight(nsTableFrame* aTableFrame)
|
|
{
|
|
nsTableIterator iter(*this);
|
|
|
|
for (nsIFrame* kidFrame = iter.First(); kidFrame; kidFrame = iter.Next()) {
|
|
nsTableCellFrame *cellFrame = do_QueryFrame(kidFrame);
|
|
if (!cellFrame) {
|
|
NS_NOTREACHED("Table row has a non-cell child.");
|
|
continue;
|
|
}
|
|
// Ignore row-spanning cells
|
|
const nsStyleCoord &cellHeight = cellFrame->StylePosition()->mHeight;
|
|
if (aTableFrame->GetEffectiveRowSpan(*cellFrame) == 1 &&
|
|
cellHeight.GetUnit() != eStyleUnit_Auto &&
|
|
/* calc() with percentages treated like 'auto' */
|
|
(!cellHeight.IsCalcUnit() || !cellHeight.HasPercent())) {
|
|
AddStateBits(NS_ROW_HAS_CELL_WITH_STYLE_HEIGHT);
|
|
return;
|
|
}
|
|
}
|
|
RemoveStateBits(NS_ROW_HAS_CELL_WITH_STYLE_HEIGHT);
|
|
}
|
|
|
|
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
|