--- a/layout/tables/nsTableCellFrame.cpp
+++ b/layout/tables/nsTableCellFrame.cpp
@@ -892,17 +892,17 @@ NS_METHOD nsTableCellFrame::Reflow(nsPre
// We need to force the kid to have mVResize set if we've had a
// special reflow in the past, since the non-special reflow needs to
// resize back to what it was without the special height reflow.
kidReflowState.mFlags.mVResize = PR_TRUE;
}
nsPoint kidOrigin(leftInset, topInset);
nsRect origRect = firstKid->GetRect();
- nsRect origOverflowRect = firstKid->GetOverflowRect();
+ nsRect origVisualOverflow = firstKid->GetVisualOverflowRect();
PRBool firstReflow = (firstKid->GetStateBits() & NS_FRAME_FIRST_REFLOW) != 0;
ReflowChild(firstKid, aPresContext, kidSize, kidReflowState,
kidOrigin.x, kidOrigin.y, NS_FRAME_INVALIDATE_ON_MOVE, aStatus);
if (NS_FRAME_OVERFLOW_IS_INCOMPLETE(aStatus)) {
// Don't pass OVERFLOW_INCOMPLETE through tables until they can actually handle it
//XXX should paginate overflow as overflow, but not in this patch (bug 379349)
NS_FRAME_SET_INCOMPLETE(aStatus);
@@ -928,17 +928,17 @@ NS_METHOD nsTableCellFrame::Reflow(nsPre
isEmpty = !CellHasVisibleContent(kidSize.height, tableFrame, firstKid);
}
SetContentEmpty(isEmpty);
// Place the child
FinishReflowChild(firstKid, aPresContext, &kidReflowState, kidSize,
kidOrigin.x, kidOrigin.y, 0);
- nsTableFrame::InvalidateFrame(firstKid, origRect, origOverflowRect,
+ nsTableFrame::InvalidateFrame(firstKid, origRect, origVisualOverflow,
firstReflow);
// first, compute the height which can be set w/o being restricted by aMaxSize.height
nscoord cellHeight = kidSize.height;
if (NS_UNCONSTRAINEDSIZE != cellHeight) {
cellHeight += topInset + bottomInset;
}
--- a/layout/tables/nsTableFrame.cpp
+++ b/layout/tables/nsTableFrame.cpp
@@ -2453,26 +2453,26 @@ nsTableFrame::InitChildReflowState(nsHTM
}
// Position and size aKidFrame and update our reflow state. The origin of
// aKidRect is relative to the upper-left origin of our frame
void nsTableFrame::PlaceChild(nsTableReflowState& aReflowState,
nsIFrame* aKidFrame,
nsHTMLReflowMetrics& aKidDesiredSize,
const nsRect& aOriginalKidRect,
- const nsRect& aOriginalKidOverflowRect)
+ const nsRect& aOriginalKidVisualOverflow)
{
PRBool isFirstReflow =
(aKidFrame->GetStateBits() & NS_FRAME_FIRST_REFLOW) != 0;
// Place and size the child
FinishReflowChild(aKidFrame, PresContext(), nsnull, aKidDesiredSize,
aReflowState.x, aReflowState.y, 0);
- InvalidateFrame(aKidFrame, aOriginalKidRect, aOriginalKidOverflowRect,
+ InvalidateFrame(aKidFrame, aOriginalKidRect, aOriginalKidVisualOverflow,
isFirstReflow);
// Adjust the running y-offset
aReflowState.y += aKidDesiredSize.height;
// If our height is constrained, then update the available height
if (NS_UNCONSTRAINEDSIZE != aReflowState.availSize.height) {
aReflowState.availSize.height -= aKidDesiredSize.height;
@@ -2634,26 +2634,26 @@ nsTableFrame::PlaceRepeatedFooter(nsTabl
nsHTMLReflowState footerReflowState(presContext,
aReflowState.reflowState,
aTfoot, kidAvailSize,
-1, -1, PR_FALSE);
InitChildReflowState(footerReflowState);
aReflowState.y += GetCellSpacingY();
nsRect origTfootRect = aTfoot->GetRect();
- nsRect origTfootOverflowRect = aTfoot->GetOverflowRect();
+ nsRect origTfootVisualOverflow = aTfoot->GetVisualOverflowRect();
nsReflowStatus footerStatus;
nsHTMLReflowMetrics desiredSize;
desiredSize.width = desiredSize.height = 0;
ReflowChild(aTfoot, presContext, desiredSize, footerReflowState,
aReflowState.x, aReflowState.y,
NS_FRAME_INVALIDATE_ON_MOVE, footerStatus);
PlaceChild(aReflowState, aTfoot, desiredSize, origTfootRect,
- origTfootOverflowRect);
+ origTfootVisualOverflow);
}
// Reflow the children based on the avail size and reason in aReflowState
// update aReflowMetrics a aStatus
NS_METHOD
nsTableFrame::ReflowChildren(nsTableReflowState& aReflowState,
nsReflowStatus& aStatus,
nsIFrame*& aLastChildReflowed,
@@ -2735,17 +2735,17 @@ nsTableFrame::ReflowChildren(nsTableRefl
if (footerHeight + cellSpacingY < kidAvailSize.height) {
allowRepeatedFooter = PR_TRUE;
kidAvailSize.height -= footerHeight + cellSpacingY;
}
}
}
nsRect oldKidRect = kidFrame->GetRect();
- nsRect oldKidOverflowRect = kidFrame->GetOverflowRect();
+ nsRect oldKidVisualOverflow = kidFrame->GetVisualOverflowRect();
nsHTMLReflowMetrics desiredSize;
desiredSize.width = desiredSize.height = 0;
// Reflow the child into the available space
nsHTMLReflowState kidReflowState(presContext, aReflowState.reflowState,
kidFrame, kidAvailSize,
-1, -1, PR_FALSE);
@@ -2790,17 +2790,17 @@ nsTableFrame::ReflowChildren(nsTableRefl
(NS_UNCONSTRAINEDSIZE != kidReflowState.availableHeight) &&
kidReflowState.availableHeight < desiredSize.height) {
// if we are on top of the page place with dataloss
if (kidReflowState.mFlags.mIsTopOfPage) {
if (childX+1 < rowGroups.Length()) {
nsIFrame* nextRowGroupFrame = rowGroups[childX + 1];
if (nextRowGroupFrame) {
PlaceChild(aReflowState, kidFrame, desiredSize, oldKidRect,
- oldKidOverflowRect);
+ oldKidVisualOverflow);
if (allowRepeatedFooter) {
PlaceRepeatedFooter(aReflowState, tfoot, footerHeight);
}
aStatus = NS_FRAME_NOT_COMPLETE;
PushChildren(rowGroups, childX + 1);
aLastChildReflowed = kidFrame;
break;
}
@@ -2827,17 +2827,17 @@ nsTableFrame::ReflowChildren(nsTableRefl
(NS_UNCONSTRAINEDSIZE != kidReflowState.availableHeight)) {
nsIFrame* nextKid =
(childX + 1 < rowGroups.Length()) ? rowGroups[childX + 1] : nsnull;
pageBreak = PageBreakAfter(kidFrame, nextKid);
}
// Place the child
PlaceChild(aReflowState, kidFrame, desiredSize, oldKidRect,
- oldKidOverflowRect);
+ oldKidVisualOverflow);
// Remember where we just were in case we end up pushing children
prevKidFrame = kidFrame;
// Special handling for incomplete children
if (NS_FRAME_IS_NOT_COMPLETE(aStatus)) {
kidNextInFlow = kidFrame->GetNextInFlow();
if (!kidNextInFlow) {
@@ -3080,25 +3080,25 @@ nsTableFrame::DistributeHeightToRows(con
rowFrame = rowFrame->GetNextRow();
}
if (amountUsed > 0) {
if (rgRect.y != yOriginRG) {
rgFrame->InvalidateFrameSubtree();
}
nsRect origRgRect = rgRect;
- nsRect origRgOverflowRect = rgFrame->GetOverflowRect();
+ nsRect origRgVisualOverflow = rgFrame->GetVisualOverflowRect();
rgRect.y = yOriginRG;
rgRect.height += amountUsedByRG;
rgFrame->SetRect(rgRect);
- nsTableFrame::InvalidateFrame(rgFrame, origRgRect, origRgOverflowRect,
- PR_FALSE);
+ nsTableFrame::InvalidateFrame(rgFrame, origRgRect,
+ origRgVisualOverflow, PR_FALSE);
}
}
else if (amountUsed > 0 && yOriginRG != rgRect.y) {
rgFrame->InvalidateFrameSubtree();
rgFrame->SetPosition(nsPoint(rgRect.x, yOriginRG));
// Make sure child views are properly positioned
nsTableFrame::RePositionViews(rgFrame);
rgFrame->InvalidateFrameSubtree();
@@ -3174,23 +3174,23 @@ nsTableFrame::DistributeHeightToRows(con
nscoord heightToDistribute = aAmount - amountUsed;
yOriginRG = borderPadding.top + cellSpacingY;
yEndRG = yOriginRG;
for (rgX = 0; rgX < rowGroups.Length(); rgX++) {
nsTableRowGroupFrame* rgFrame = rowGroups[rgX];
nscoord amountUsedByRG = 0;
nscoord yOriginRow = 0;
nsRect rgRect = rgFrame->GetRect();
- nsRect rgOverflowRect = rgFrame->GetOverflowRect();
+ nsRect rgVisualOverflow = rgFrame->GetVisualOverflowRect();
// see if there is an eligible row group or we distribute to all rows
if (!firstUnStyledRG || !rgFrame->HasStyleHeight() || !eligibleRows) {
nsTableRowFrame* rowFrame = rgFrame->GetFirstRow();
while (rowFrame) {
nsRect rowRect = rowFrame->GetRect();
- nsRect rowOverflowRect = rowFrame->GetOverflowRect();
+ nsRect rowVisualOverflow = rowFrame->GetVisualOverflowRect();
// see if there is an eligible row or we distribute to all rows
if (!firstUnStyledRow || !rowFrame->HasStyleHeight() || !eligibleRows) {
float ratio;
if (eligibleRows) {
if (!expandEmptyRows) {
// The amount of additional space each row gets is proportional to
// its height
ratio = float(rowRect.height) / float(divisor);
@@ -3222,17 +3222,17 @@ nsTableFrame::DistributeHeightToRows(con
yEndRG += newRowRect.height + cellSpacingY;
amountUsed += amountForRow;
amountUsedByRG += amountForRow;
NS_ASSERTION((amountUsed <= aAmount), "invalid row allocation");
//rowFrame->DidResize();
nsTableFrame::RePositionViews(rowFrame);
- nsTableFrame::InvalidateFrame(rowFrame, rowRect, rowOverflowRect,
+ nsTableFrame::InvalidateFrame(rowFrame, rowRect, rowVisualOverflow,
PR_FALSE);
}
else {
if (amountUsed > 0 && yOriginRow != rowRect.y) {
rowFrame->InvalidateFrameSubtree();
rowFrame->SetPosition(nsPoint(rowRect.x, yOriginRow));
nsTableFrame::RePositionViews(rowFrame);
rowFrame->InvalidateFrameSubtree();
@@ -3245,17 +3245,17 @@ nsTableFrame::DistributeHeightToRows(con
if (amountUsed > 0) {
if (rgRect.y != yOriginRG) {
rgFrame->InvalidateFrameSubtree();
}
rgFrame->SetRect(nsRect(rgRect.x, yOriginRG, rgRect.width,
rgRect.height + amountUsedByRG));
- nsTableFrame::InvalidateFrame(rgFrame, rgRect, rgOverflowRect,
+ nsTableFrame::InvalidateFrame(rgFrame, rgRect, rgVisualOverflow,
PR_FALSE);
}
// Make sure child views are properly positioned
}
else if (amountUsed > 0 && yOriginRG != rgRect.y) {
rgFrame->InvalidateFrameSubtree();
rgFrame->SetPosition(nsPoint(rgRect.x, yOriginRG));
// Make sure child views are properly positioned
@@ -7163,43 +7163,43 @@ PRBool nsTableFrame::RowIsSpannedInto(PR
}
return result;
}
/* static */
void
nsTableFrame::InvalidateFrame(nsIFrame* aFrame,
const nsRect& aOrigRect,
- const nsRect& aOrigOverflowRect,
+ const nsRect& aOrigVisualOverflow,
PRBool aIsFirstReflow)
{
nsIFrame* parent = aFrame->GetParent();
NS_ASSERTION(parent, "What happened here?");
if (parent->GetStateBits() & NS_FRAME_FIRST_REFLOW) {
// Don't bother; we'll invalidate the parent's overflow rect when
// we finish reflowing it.
return;
}
// The part that looks at both the rect and the overflow rect is a
// bit of a hack. See nsBlockFrame::ReflowLine for an eloquent
// description of its hackishness.
- nsRect overflowRect = aFrame->GetOverflowRect();
+ nsRect visualOverflow = aFrame->GetVisualOverflowRect();
if (aIsFirstReflow ||
aOrigRect.TopLeft() != aFrame->GetPosition() ||
- aOrigOverflowRect.TopLeft() != overflowRect.TopLeft()) {
+ aOrigVisualOverflow.TopLeft() != visualOverflow.TopLeft()) {
// Invalidate the old and new overflow rects. Note that if the
- // frame moved, we can't just use aOrigOverflowRect, since it's in
+ // frame moved, we can't just use aOrigVisualOverflow, since it's in
// coordinates relative to the old position. So invalidate via
// aFrame's parent, and reposition that overflow rect to the right
// place.
// XXXbz this doesn't handle outlines, does it?
- aFrame->Invalidate(overflowRect);
- parent->Invalidate(aOrigOverflowRect + aOrigRect.TopLeft());
+ aFrame->Invalidate(visualOverflow);
+ parent->Invalidate(aOrigVisualOverflow + aOrigRect.TopLeft());
} else {
nsRect rect = aFrame->GetRect();
- aFrame->CheckInvalidateSizeChange(aOrigRect, aOrigOverflowRect,
+ aFrame->CheckInvalidateSizeChange(aOrigRect, aOrigVisualOverflow,
rect.Size());
- aFrame->InvalidateRectDifference(aOrigOverflowRect, overflowRect);
+ aFrame->InvalidateRectDifference(aOrigVisualOverflow, visualOverflow);
parent->InvalidateRectDifference(aOrigRect, rect);
}
}
--- a/layout/tables/nsTableFrame.h
+++ b/layout/tables/nsTableFrame.h
@@ -507,23 +507,23 @@ public:
/**
* To be called on a frame by its parent after setting its size/position and
* calling DidReflow (possibly via FinishReflowChild()). This can also be
* used for child frames which are not being reflowed but did have their size
* or position changed.
*
* @param aFrame The frame to invalidate
* @param aOrigRect The original rect of aFrame (before the change).
- * @param aOrigOverflowRect The original overflow rect of aFrame.
+ * @param aOrigVisualOverflow The original overflow rect of aFrame.
* @param aIsFirstReflow True if the size/position change is due to the
* first reflow of aFrame.
*/
static void InvalidateFrame(nsIFrame* aFrame,
const nsRect& aOrigRect,
- const nsRect& aOrigOverflowRect,
+ const nsRect& aOrigVisualOverflow,
PRBool aIsFirstReflow);
protected:
/** protected constructor.
* @see NewFrame
*/
nsTableFrame(nsStyleContext* aContext);
@@ -603,17 +603,17 @@ protected:
void DistributeHeightToRows(const nsHTMLReflowState& aReflowState,
nscoord aAmount);
void PlaceChild(nsTableReflowState& aReflowState,
nsIFrame* aKidFrame,
nsHTMLReflowMetrics& aKidDesiredSize,
const nsRect& aOriginalKidRect,
- const nsRect& aOriginalKidOverflowRect);
+ const nsRect& aOriginalKidVisualOverflow);
void PlaceRepeatedFooter(nsTableReflowState& aReflowState,
nsTableRowGroupFrame *aTfoot,
nscoord aFooterHeight);
nsIFrame* GetFirstBodyRowGroupFrame();
public:
typedef nsAutoTPtrArray<nsTableRowGroupFrame, 8> RowGroupArray;
/**
--- a/layout/tables/nsTableOuterFrame.cpp
+++ b/layout/tables/nsTableOuterFrame.cpp
@@ -998,25 +998,25 @@ NS_METHOD nsTableOuterFrame::Reflow(nsPr
long captionRSSpace[LONGS_IN_HTMLRS];
nsHTMLReflowState *captionRS =
static_cast<nsHTMLReflowState*>((void*)captionRSSpace);
long innerRSSpace[LONGS_IN_HTMLRS];
nsHTMLReflowState *innerRS =
static_cast<nsHTMLReflowState*>((void*) innerRSSpace);
nsRect origInnerRect = mInnerTableFrame->GetRect();
- nsRect origInnerOverflowRect = mInnerTableFrame->GetOverflowRect();
+ nsRect origInnerVisualOverflow = mInnerTableFrame->GetVisualOverflowRect();
PRBool innerFirstReflow =
(mInnerTableFrame->GetStateBits() & NS_FRAME_FIRST_REFLOW) != 0;
nsRect origCaptionRect;
- nsRect origCaptionOverflowRect;
+ nsRect origCaptionVisualOverflow;
PRBool captionFirstReflow;
if (mCaptionFrame) {
origCaptionRect = mCaptionFrame->GetRect();
- origCaptionOverflowRect = mCaptionFrame->GetOverflowRect();
+ origCaptionVisualOverflow = mCaptionFrame->GetVisualOverflowRect();
captionFirstReflow =
(mCaptionFrame->GetStateBits() & NS_FRAME_FIRST_REFLOW) != 0;
}
// ComputeAutoSize has to match this logic.
if (captionSide == NO_SIDE) {
// We don't have a caption.
OuterBeginReflowChild(aPresContext, mInnerTableFrame, aOuterRS,
@@ -1116,20 +1116,21 @@ NS_METHOD nsTableOuterFrame::Reflow(nsPr
nsPoint innerOrigin;
GetInnerOrigin(captionSide, containSize, captionSize,
captionMargin, innerSize, innerMargin, innerOrigin);
FinishReflowChild(mInnerTableFrame, aPresContext, innerRS, innerMet,
innerOrigin.x, innerOrigin.y, 0);
innerRS->~nsHTMLReflowState();
nsTableFrame::InvalidateFrame(mInnerTableFrame, origInnerRect,
- origInnerOverflowRect, innerFirstReflow);
+ origInnerVisualOverflow, innerFirstReflow);
if (mCaptionFrame) {
nsTableFrame::InvalidateFrame(mCaptionFrame, origCaptionRect,
- origCaptionOverflowRect, captionFirstReflow);
+ origCaptionVisualOverflow,
+ captionFirstReflow);
}
UpdateReflowMetrics(captionSide, aDesiredSize, innerMargin, captionMargin);
// Return our desired rect
NS_FRAME_SET_TRUNCATION(aStatus, aOuterRS, aDesiredSize);
return rv;
--- a/layout/tables/nsTableRowFrame.cpp
+++ b/layout/tables/nsTableRowFrame.cpp
@@ -379,21 +379,22 @@ nsTableRowFrame::DidResize()
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 cellOverflowRect = cellFrame->GetOverflowRect();
+ nsRect cellVisualOverflow = cellFrame->GetVisualOverflowRect();
if (cellRect.height != cellHeight)
{
cellFrame->SetSize(nsSize(cellRect.width, cellHeight));
- nsTableFrame::InvalidateFrame(cellFrame, cellRect, cellOverflowRect,
+ nsTableFrame::InvalidateFrame(cellFrame, cellRect,
+ cellVisualOverflow,
PR_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
@@ -869,17 +870,17 @@ nsTableRowFrame::ReflowChildren(nsPresCo
cellSpacingX, iter.IsLeftToRight(), PR_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();
- nsRect kidOverflowRect = kidFrame->GetOverflowRect();
+ nsRect kidVisualOverflow = kidFrame->GetVisualOverflowRect();
PRBool 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, cellSpacingX);
@@ -965,17 +966,17 @@ nsTableRowFrame::ReflowChildren(nsPresCo
}
}
// Place the child
desiredSize.width = availCellWidth;
FinishReflowChild(kidFrame, aPresContext, nsnull, desiredSize, x, 0, 0);
- nsTableFrame::InvalidateFrame(kidFrame, kidRect, kidOverflowRect,
+ nsTableFrame::InvalidateFrame(kidFrame, kidRect, kidVisualOverflow,
firstReflow);
x += desiredSize.width;
}
else {
if (kidRect.x != x) {
// Invalidate the old position
kidFrame->InvalidateFrameSubtree();
@@ -1094,17 +1095,17 @@ nsTableRowFrame::ReflowCellFrame(nsPresC
nsReflowStatus& aStatus)
{
nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
if (!tableFrame)
ABORT1(NS_ERROR_NULL_POINTER);
// Reflow the cell frame with the specified height. Use the existing width
nsRect cellRect = aCellFrame->GetRect();
- nsRect cellOverflowRect = aCellFrame->GetOverflowRect();
+ nsRect cellVisualOverflow = aCellFrame->GetVisualOverflowRect();
nsSize availSize(cellRect.width, aAvailableHeight);
PRBool borderCollapse = ((nsTableFrame*)tableFrame->GetFirstInFlow())->IsBorderCollapse();
nsTableCellReflowState cellReflowState(aPresContext, aReflowState,
aCellFrame, availSize, PR_FALSE);
InitChildReflowState(*aPresContext, availSize, borderCollapse, cellReflowState);
cellReflowState.mFlags.mIsTopOfPage = aIsTopOfPage;
@@ -1121,17 +1122,17 @@ nsTableRowFrame::ReflowCellFrame(nsPresC
// 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::InvalidateFrame(aCellFrame, cellRect,
- cellOverflowRect,
+ cellVisualOverflow,
(aCellFrame->GetStateBits() &
NS_FRAME_FIRST_REFLOW) != 0);
aCellFrame->DidReflow(aPresContext, nsnull, NS_FRAME_REFLOW_FINISHED);
return desiredSize.height;
}
@@ -1152,17 +1153,17 @@ nsTableRowFrame::CollapseRowIfNecessary(
if (aRowOffset != 0) {
// We're moving, so invalidate our old position
InvalidateFrameSubtree();
}
nsRect rowRect = GetRect();
nsRect oldRect = rowRect;
- nsRect oldOverflowRect = GetOverflowRect();
+ nsRect oldVisualOverflow = GetVisualOverflowRect();
rowRect.y -= aRowOffset;
rowRect.width = aWidth;
nsOverflowAreas overflow;
nscoord shift = 0;
nscoord cellSpacingX = tableFrame->GetCellSpacingX();
nscoord cellSpacingY = tableFrame->GetCellSpacingY();
@@ -1264,17 +1265,17 @@ nsTableRowFrame::CollapseRowIfNecessary(
if (!collapseNextRow) {
nsRect nextRect = rowFrame->GetRect();
cRect.height += nextRect.height + cellSpacingY;
}
rowFrame = rowFrame->GetNextRow();
}
nsRect oldCellRect = cellFrame->GetRect();
- nsRect oldCellOverflowRect = cellFrame->GetOverflowRect();
+ nsRect oldCellVisualOverflow = cellFrame->GetVisualOverflowRect();
if (aRowOffset == 0 && cRect.TopLeft() != oldCellRect.TopLeft()) {
// We're moving the cell. Invalidate the old overflow area
cellFrame->InvalidateFrameSubtree();
}
cellFrame->SetRect(cRect);
@@ -1284,29 +1285,30 @@ nsTableRowFrame::CollapseRowIfNecessary(
nsOverflowAreas cellOverflow(cellBounds, cellBounds);
cellFrame->FinishAndStoreOverflow(cellOverflow,
nsSize(cRect.width, cRect.height));
nsTableFrame::RePositionViews(cellFrame);
ConsiderChildOverflow(overflow, cellFrame);
if (aRowOffset == 0) {
nsTableFrame::InvalidateFrame(cellFrame, oldCellRect,
- oldCellOverflowRect, PR_FALSE);
+ oldCellVisualOverflow,
+ PR_FALSE);
}
}
kidFrame = iter.Next(); // Get the next child
}
}
SetRect(rowRect);
overflow.UnionAllWith(nsRect(0,0,rowRect.width, rowRect.height));
FinishAndStoreOverflow(overflow, nsSize(rowRect.width, rowRect.height));
nsTableFrame::RePositionViews(this);
- nsTableFrame::InvalidateFrame(this, oldRect, oldOverflowRect, PR_FALSE);
+ nsTableFrame::InvalidateFrame(this, oldRect, oldVisualOverflow, PR_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.
*/
--- a/layout/tables/nsTableRowGroupFrame.cpp
+++ b/layout/tables/nsTableRowGroupFrame.cpp
@@ -287,27 +287,27 @@ nsTableRowGroupFrame::GetSkipSides() con
// Position and size aKidFrame and update our reflow state. The origin of
// aKidRect is relative to the upper-left origin of our frame
void
nsTableRowGroupFrame::PlaceChild(nsPresContext* aPresContext,
nsRowGroupReflowState& aReflowState,
nsIFrame* aKidFrame,
nsHTMLReflowMetrics& aDesiredSize,
const nsRect& aOriginalKidRect,
- const nsRect& aOriginalKidOverflowRect)
+ const nsRect& aOriginalKidVisualOverflow)
{
PRBool isFirstReflow =
(aKidFrame->GetStateBits() & NS_FRAME_FIRST_REFLOW) != 0;
// Place and size the child
FinishReflowChild(aKidFrame, aPresContext, nsnull, aDesiredSize, 0,
aReflowState.y, 0);
nsTableFrame::InvalidateFrame(aKidFrame, aOriginalKidRect,
- aOriginalKidOverflowRect, isFirstReflow);
+ aOriginalKidVisualOverflow, isFirstReflow);
// Adjust the running y-offset
aReflowState.y += aDesiredSize.height;
// If our height is constrained then update the available height
if (NS_UNCONSTRAINEDSIZE != aReflowState.availSize.height) {
aReflowState.availSize.height -= aDesiredSize.height;
}
@@ -386,17 +386,17 @@ nsTableRowGroupFrame::ReflowChildren(nsP
// Reflow the row frame
if (reflowAllKids ||
NS_SUBTREE_DIRTY(kidFrame) ||
(aReflowState.reflowState.mFlags.mSpecialHeightReflow &&
(isPaginated || (kidFrame->GetStateBits() &
NS_FRAME_CONTAINS_RELATIVE_HEIGHT)))) {
nsRect oldKidRect = kidFrame->GetRect();
- nsRect oldKidOverflowRect = kidFrame->GetOverflowRect();
+ nsRect oldKidVisualOverflow = kidFrame->GetVisualOverflowRect();
// XXXldb We used to only pass aDesiredSize.mFlags through for the
// incremental reflow codepath.
nsHTMLReflowMetrics desiredSize(aDesiredSize.mFlags);
desiredSize.width = desiredSize.height = 0;
// Reflow the child into the available space, giving it as much height as
// it wants. We'll deal with splitting later after we've computed the row
@@ -420,17 +420,17 @@ nsTableRowGroupFrame::ReflowChildren(nsP
}
rv = ReflowChild(kidFrame, aPresContext, desiredSize, kidReflowState,
0, aReflowState.y, NS_FRAME_INVALIDATE_ON_MOVE,
aStatus);
// Place the child
PlaceChild(aPresContext, aReflowState, kidFrame, desiredSize,
- oldKidRect, oldKidOverflowRect);
+ oldKidRect, oldKidVisualOverflow);
aReflowState.y += cellSpacingY;
if (!reflowAllKids) {
if (IsSimpleRowFrame(aReflowState.tableFrame, kidFrame)) {
// Inform the row of its new height.
rowFrame->DidResize();
// the overflow area may have changed inflate the overflow area
const nsStylePosition *stylePos = GetStylePosition();
@@ -803,31 +803,31 @@ nsTableRowGroupFrame::CalculateRowHeight
}
rowGroupHeight = aReflowState.ComputedHeight();
}
nscoord yOrigin = startRowGroupHeight;
// update the rows with their (potentially) new heights
for (rowFrame = startRowFrame, rowIndex = 0; rowFrame; rowFrame = rowFrame->GetNextRow(), rowIndex++) {
nsRect rowBounds = rowFrame->GetRect();
- nsRect rowOverflowRect = rowFrame->GetOverflowRect();
+ nsRect rowVisualOverflow = rowFrame->GetVisualOverflowRect();
PRBool movedFrame = (rowBounds.y != yOrigin);
nscoord rowHeight = (rowInfo[rowIndex].height > 0) ? rowInfo[rowIndex].height : 0;
if (movedFrame || (rowHeight != rowBounds.height)) {
// Resize/move the row to its final size and position
if (movedFrame) {
rowFrame->InvalidateFrameSubtree();
}
rowFrame->SetRect(nsRect(rowBounds.x, yOrigin, rowBounds.width,
rowHeight));
- nsTableFrame::InvalidateFrame(rowFrame, rowBounds, rowOverflowRect,
+ nsTableFrame::InvalidateFrame(rowFrame, rowBounds, rowVisualOverflow,
PR_FALSE);
}
if (movedFrame) {
nsTableFrame::RePositionViews(rowFrame);
// XXXbz we don't need to update our overflow area?
}
yOrigin += rowHeight + cellSpacingY;
}
@@ -864,17 +864,17 @@ nsTableRowGroupFrame::CollapseRowGroupIf
aWidth, collapseGroup,
didCollapse);
ConsiderChildOverflow(overflow, rowFrame);
rowFrame = rowFrame->GetNextRow();
}
nsRect groupRect = GetRect();
nsRect oldGroupRect = groupRect;
- nsRect oldGroupOverflowRect = GetOverflowRect();
+ nsRect oldGroupVisualOverflow = GetVisualOverflowRect();
groupRect.height -= yGroupOffset;
if (didCollapse) {
// add back the cellspacing between rowgroups
groupRect.height += tableFrame->GetCellSpacingY();
}
groupRect.y -= aYTotalOffset;
@@ -883,17 +883,17 @@ nsTableRowGroupFrame::CollapseRowGroupIf
if (aYTotalOffset != 0) {
InvalidateFrameSubtree();
}
SetRect(groupRect);
overflow.UnionAllWith(nsRect(0, 0, groupRect.width, groupRect.height));
FinishAndStoreOverflow(overflow, nsSize(groupRect.width, groupRect.height));
nsTableFrame::RePositionViews(this);
- nsTableFrame::InvalidateFrame(this, oldGroupRect, oldGroupOverflowRect,
+ nsTableFrame::InvalidateFrame(this, oldGroupRect, oldGroupVisualOverflow,
PR_FALSE);
return yGroupOffset;
}
// Move a child that was skipped during a reflow.
void
nsTableRowGroupFrame::SlideChild(nsRowGroupReflowState& aReflowState,
@@ -1102,28 +1102,29 @@ nsTableRowGroupFrame::SplitRowGroup(nsPr
-1, -1, PR_FALSE);
InitChildReflowState(*aPresContext, borderCollapse, rowReflowState);
rowReflowState.mFlags.mIsTopOfPage = isTopOfPage; // set top of page
nsHTMLReflowMetrics rowMetrics;
// Get the old size before we reflow.
nsRect oldRowRect = rowFrame->GetRect();
- nsRect oldRowOverflowRect = rowFrame->GetOverflowRect();
+ nsRect oldRowVisualOverflow = rowFrame->GetVisualOverflowRect();
// Reflow the cell with the constrained height. A cell with rowspan >1 will get this
// reflow later during SplitSpanningCells.
rv = ReflowChild(rowFrame, aPresContext, rowMetrics, rowReflowState,
0, 0, NS_FRAME_NO_MOVE_FRAME, aStatus);
if (NS_FAILED(rv)) return rv;
rowFrame->SetSize(nsSize(rowMetrics.width, rowMetrics.height));
rowFrame->DidReflow(aPresContext, nsnull, NS_FRAME_REFLOW_FINISHED);
rowFrame->DidResize();
- nsTableFrame::InvalidateFrame(rowFrame, oldRowRect, oldRowOverflowRect,
+ nsTableFrame::InvalidateFrame(rowFrame, oldRowRect,
+ oldRowVisualOverflow,
PR_FALSE);
if (NS_FRAME_IS_NOT_COMPLETE(aStatus)) {
// The row frame is incomplete and all of the rowspan 1 cells' block frames split
if ((rowMetrics.height <= rowReflowState.availableHeight) || isTopOfPage) {
// The row stays on this page because either it split ok or we're on the top of page.
// If top of page and the height exceeded the avail height, then there will be data loss
NS_ASSERTION(rowMetrics.height <= rowReflowState.availableHeight,
--- a/layout/tables/nsTableRowGroupFrame.h
+++ b/layout/tables/nsTableRowGroupFrame.h
@@ -366,17 +366,17 @@ protected:
/** implement abstract method on nsHTMLContainerFrame */
virtual PRIntn GetSkipSides() const;
void PlaceChild(nsPresContext* aPresContext,
nsRowGroupReflowState& aReflowState,
nsIFrame* aKidFrame,
nsHTMLReflowMetrics& aDesiredSize,
const nsRect& aOriginalKidRect,
- const nsRect& aOriginalKidOverflowRect);
+ const nsRect& aOriginalKidVisualOverflow);
void CalculateRowHeights(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState);
void DidResizeRows(nsHTMLReflowMetrics& aDesiredSize);
void SlideChild(nsRowGroupReflowState& aReflowState,