mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
Bug 1155798: Drop end-of-line whitespace from C++ files in layout/tables. (whitespace-only, no review, DONTBUILD)
This commit is contained in:
Daniel Holbert
parent
e0b82aa699
commit
e33a8d57cc
@ -31,10 +31,10 @@ public:
|
||||
virtual void ComputeColumnWidths(const nsHTMLReflowState& aReflowState) override;
|
||||
|
||||
private:
|
||||
// NOTE: Using prefix "BTLS" to avoid overlapping names with
|
||||
// NOTE: Using prefix "BTLS" to avoid overlapping names with
|
||||
// the values of nsLayoutUtils::IntrinsicISizeType
|
||||
enum BtlsWidthType { BTLS_MIN_WIDTH,
|
||||
BTLS_PREF_WIDTH,
|
||||
enum BtlsWidthType { BTLS_MIN_WIDTH,
|
||||
BTLS_PREF_WIDTH,
|
||||
BTLS_FINAL_WIDTH };
|
||||
|
||||
// Compute intrinsic width member variables on the columns.
|
||||
@ -60,12 +60,12 @@ private:
|
||||
// - We're distributing a colspanning cell's
|
||||
// pref or min width to its columns
|
||||
// - The colspanning cell has a specified width.
|
||||
void DistributeWidthToColumns(nscoord aWidth,
|
||||
int32_t aFirstCol,
|
||||
void DistributeWidthToColumns(nscoord aWidth,
|
||||
int32_t aFirstCol,
|
||||
int32_t aColCount,
|
||||
BtlsWidthType aWidthType,
|
||||
bool aSpanHasSpecifiedWidth);
|
||||
|
||||
|
||||
|
||||
// Compute the min and pref widths of the table from the width
|
||||
// variables on the columns.
|
||||
|
||||
@ -28,7 +28,7 @@ SetDamageArea(int32_t aXOrigin,
|
||||
aDamageArea.width = aWidth;
|
||||
aDamageArea.height = aHeight;
|
||||
}
|
||||
|
||||
|
||||
// Empty static array used for SafeElementAt() calls on mRows.
|
||||
static nsCellMap::CellDataArray * sEmptyRow;
|
||||
|
||||
|
||||
@ -32,14 +32,14 @@ nsTableColFrame::~nsTableColFrame()
|
||||
{
|
||||
}
|
||||
|
||||
nsTableColType
|
||||
nsTableColFrame::GetColType() const
|
||||
nsTableColType
|
||||
nsTableColFrame::GetColType() const
|
||||
{
|
||||
return (nsTableColType)((mState & COL_TYPE_BITS) >> COL_TYPE_OFFSET);
|
||||
}
|
||||
|
||||
void
|
||||
nsTableColFrame::SetColType(nsTableColType aType)
|
||||
void
|
||||
nsTableColFrame::SetColType(nsTableColType aType)
|
||||
{
|
||||
NS_ASSERTION(aType != eColAnonymousCol ||
|
||||
(GetPrevContinuation() &&
|
||||
@ -58,7 +58,7 @@ nsTableColFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)
|
||||
|
||||
if (!aOldStyleContext) //avoid this on init
|
||||
return;
|
||||
|
||||
|
||||
nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
|
||||
if (tableFrame->IsBorderCollapse() &&
|
||||
tableFrame->BCRecalcNeeded(aOldStyleContext, StyleContext())) {
|
||||
@ -127,13 +127,13 @@ void nsTableColFrame::Dump(int32_t aIndent)
|
||||
case eColContent:
|
||||
printf(" content ");
|
||||
break;
|
||||
case eColAnonymousCol:
|
||||
case eColAnonymousCol:
|
||||
printf(" anonymous-column ");
|
||||
break;
|
||||
case eColAnonymousColGroup:
|
||||
printf(" anonymous-colgroup ");
|
||||
break;
|
||||
case eColAnonymousCell:
|
||||
case eColAnonymousCell:
|
||||
printf(" anonymous-cell ");
|
||||
break;
|
||||
}
|
||||
@ -149,7 +149,7 @@ void nsTableColFrame::Dump(int32_t aIndent)
|
||||
#endif
|
||||
/* ----- global methods ----- */
|
||||
|
||||
nsTableColFrame*
|
||||
nsTableColFrame*
|
||||
NS_NewTableColFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
|
||||
{
|
||||
return new (aPresShell) nsTableColFrame(aContext);
|
||||
@ -157,7 +157,7 @@ NS_NewTableColFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
|
||||
|
||||
NS_IMPL_FRAMEARENA_HELPERS(nsTableColFrame)
|
||||
|
||||
nsTableColFrame*
|
||||
nsTableColFrame*
|
||||
nsTableColFrame::GetNextCol() const
|
||||
{
|
||||
nsIFrame* childFrame = GetNextSibling();
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
class nsTableCellFrame;
|
||||
|
||||
enum nsTableColType {
|
||||
eColContent = 0, // there is real col content associated
|
||||
eColContent = 0, // there is real col content associated
|
||||
eColAnonymousCol = 1, // the result of a span on a col
|
||||
eColAnonymousColGroup = 2, // the result of a span on a col group
|
||||
eColAnonymousCell = 3 // the result of a cell alone
|
||||
@ -41,9 +41,9 @@ public:
|
||||
nsStyleContext* aContext);
|
||||
/** @see nsIFrame::DidSetStyleContext */
|
||||
virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext) override;
|
||||
|
||||
|
||||
int32_t GetColIndex() const;
|
||||
|
||||
|
||||
void SetColIndex (int32_t aColIndex);
|
||||
|
||||
nsTableColFrame* GetNextCol() const;
|
||||
@ -66,7 +66,7 @@ public:
|
||||
* @see nsGkAtoms::tableColFrame
|
||||
*/
|
||||
virtual nsIAtom* GetType() const override;
|
||||
|
||||
|
||||
#ifdef DEBUG_FRAME_DUMP
|
||||
virtual nsresult GetFrameName(nsAString& aResult) const override;
|
||||
#endif
|
||||
@ -268,7 +268,7 @@ public:
|
||||
{
|
||||
return nsSplittableFrame::IsFrameOfType(aFlags & ~(nsIFrame::eTablePart));
|
||||
}
|
||||
|
||||
|
||||
virtual void InvalidateFrame(uint32_t aDisplayItemKey = 0) override;
|
||||
virtual void InvalidateFrameWithRect(const nsRect& aRect, uint32_t aDisplayItemKey = 0) override;
|
||||
virtual void InvalidateFrameForRemoval() override { InvalidateFrameSubtree(); }
|
||||
@ -290,11 +290,11 @@ protected:
|
||||
// when colspans were present).
|
||||
nscoord mFinalWidth;
|
||||
|
||||
// the index of the column with respect to the whole table (starting at 0)
|
||||
// it should never be smaller then the start column index of the parent
|
||||
// the index of the column with respect to the whole table (starting at 0)
|
||||
// it should never be smaller then the start column index of the parent
|
||||
// colgroup
|
||||
uint32_t mColIndex;
|
||||
|
||||
|
||||
// border width in pixels of the inner half of the border only
|
||||
BCPixelSize mLeftBorderWidth;
|
||||
BCPixelSize mRightBorderWidth;
|
||||
@ -307,12 +307,12 @@ protected:
|
||||
|
||||
inline int32_t nsTableColFrame::GetColIndex() const
|
||||
{
|
||||
return mColIndex;
|
||||
return mColIndex;
|
||||
}
|
||||
|
||||
inline void nsTableColFrame::SetColIndex (int32_t aColIndex)
|
||||
{
|
||||
mColIndex = aColIndex;
|
||||
{
|
||||
mColIndex = aColIndex;
|
||||
}
|
||||
|
||||
inline nscoord nsTableColFrame::GetLeftBorderWidth()
|
||||
|
||||
@ -1325,7 +1325,7 @@ nsTableFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
||||
DisplayBackgroundUnconditional(aBuilder, aLists, false);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// This background is created if any of the table parts are visible,
|
||||
// or if we're doing event handling (since DisplayGenericTablePart
|
||||
// needs the item for the |sortEventBackgrounds|-dependent code).
|
||||
@ -2855,7 +2855,7 @@ nsTableFrame::SetupHeaderFooterChild(const nsTableReflowState& aReflowState,
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
void
|
||||
void
|
||||
nsTableFrame::PlaceRepeatedFooter(nsTableReflowState& aReflowState,
|
||||
nsTableRowGroupFrame *aTfoot,
|
||||
nscoord aFooterHeight)
|
||||
@ -2874,7 +2874,7 @@ nsTableFrame::PlaceRepeatedFooter(nsTableReflowState& aReflowState,
|
||||
|
||||
nsRect origTfootRect = aTfoot->GetRect();
|
||||
nsRect origTfootVisualOverflow = aTfoot->GetVisualOverflowRect();
|
||||
|
||||
|
||||
nsReflowStatus footerStatus;
|
||||
nsHTMLReflowMetrics desiredSize(aReflowState.reflowState);
|
||||
desiredSize.ClearSize();
|
||||
@ -2886,7 +2886,7 @@ nsTableFrame::PlaceRepeatedFooter(nsTableReflowState& aReflowState,
|
||||
PlaceChild(aReflowState, aTfoot, kidPosition, desiredSize, origTfootRect,
|
||||
origTfootVisualOverflow);
|
||||
}
|
||||
|
||||
|
||||
// Reflow the children based on the avail size and reason in aReflowState
|
||||
// update aReflowMetrics a aStatus
|
||||
void
|
||||
|
||||
@ -47,7 +47,7 @@ static inline bool FrameHasBorderOrBackground(nsIFrame* f) {
|
||||
class nsDisplayTableItem : public nsDisplayItem
|
||||
{
|
||||
public:
|
||||
nsDisplayTableItem(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame) :
|
||||
nsDisplayTableItem(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame) :
|
||||
nsDisplayItem(aBuilder, aFrame),
|
||||
mPartHasFixedBackground(false) {}
|
||||
|
||||
@ -72,7 +72,7 @@ class nsAutoPushCurrentTableItem
|
||||
{
|
||||
public:
|
||||
nsAutoPushCurrentTableItem() : mBuilder(nullptr) {}
|
||||
|
||||
|
||||
void Push(nsDisplayListBuilder* aBuilder, nsDisplayTableItem* aPushItem)
|
||||
{
|
||||
mBuilder = aBuilder;
|
||||
@ -133,7 +133,7 @@ public:
|
||||
nsStyleContext* aContext);
|
||||
|
||||
/** sets defaults for table-specific style.
|
||||
* @see nsIFrame::Init
|
||||
* @see nsIFrame::Init
|
||||
*/
|
||||
virtual void Init(nsIContent* aContent,
|
||||
nsContainerFrame* aParent,
|
||||
@ -150,14 +150,14 @@ public:
|
||||
static void CheckRequestSpecialHeightReflow(const nsHTMLReflowState& aReflowState);
|
||||
|
||||
// Notify the frame and its ancestors (up to the containing table) that a special
|
||||
// height reflow will occur.
|
||||
// height reflow will occur.
|
||||
static void RequestSpecialHeightReflow(const nsHTMLReflowState& aReflowState);
|
||||
|
||||
static void RePositionViews(nsIFrame* aFrame);
|
||||
|
||||
static bool PageBreakAfter(nsIFrame* aSourceFrame,
|
||||
nsIFrame* aNextFrame);
|
||||
|
||||
|
||||
// Register a positioned table part with its nsTableFrame. These objects will
|
||||
// be visited by FixupPositionedTableParts after reflow is complete. (See that
|
||||
// function for more explanation.) Should be called during frame construction.
|
||||
@ -172,12 +172,12 @@ public:
|
||||
* Notification that aAttribute has changed for content inside a table (cell, row, etc)
|
||||
*/
|
||||
void AttributeChangedFor(nsIFrame* aFrame,
|
||||
nsIContent* aContent,
|
||||
nsIAtom* aAttribute);
|
||||
nsIContent* aContent,
|
||||
nsIAtom* aAttribute);
|
||||
|
||||
/** @see nsIFrame::DestroyFrom */
|
||||
virtual void DestroyFrom(nsIFrame* aDestructRoot) override;
|
||||
|
||||
|
||||
/** @see nsIFrame::DidSetStyleContext */
|
||||
virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext) override;
|
||||
|
||||
@ -200,7 +200,7 @@ public:
|
||||
|
||||
/** helper method to find the table parent of any table frame object */
|
||||
static nsTableFrame* GetTableFrame(nsIFrame* aSourceFrame);
|
||||
|
||||
|
||||
/* Like GetTableFrame, but will return nullptr if we don't pass through
|
||||
* aMustPassThrough on the way to the table.
|
||||
*/
|
||||
@ -237,7 +237,7 @@ public:
|
||||
nsIFrame* aPriorChildFrame,
|
||||
nsIAtom* aChildType);
|
||||
bool IsAutoHeight();
|
||||
|
||||
|
||||
/** @return true if aDisplayType represents a rowgroup of any sort
|
||||
* (header, footer, or body)
|
||||
*/
|
||||
@ -290,7 +290,7 @@ public:
|
||||
void SetContinuousLeftBCBorderWidth(nscoord aValue);
|
||||
|
||||
friend class nsDelayedCalcBCBorders;
|
||||
|
||||
|
||||
void AddBCDamageArea(const nsIntRect& aValue);
|
||||
bool BCRecalcNeeded(nsStyleContext* aOldStyleContext,
|
||||
nsStyleContext* aNewStyleContext);
|
||||
@ -583,7 +583,7 @@ public:
|
||||
|
||||
protected:
|
||||
|
||||
/** protected constructor.
|
||||
/** protected constructor.
|
||||
* @see NewFrame
|
||||
*/
|
||||
explicit nsTableFrame(nsStyleContext* aContext);
|
||||
@ -600,7 +600,7 @@ public:
|
||||
void SetRowInserted(bool aValue);
|
||||
|
||||
protected:
|
||||
|
||||
|
||||
// A helper function to reflow a header or footer with unconstrained height
|
||||
// to see if it should be made repeatable and also to determine its desired
|
||||
// height.
|
||||
@ -624,7 +624,7 @@ protected:
|
||||
*/
|
||||
nscoord GetCollapsedWidth(nsMargin aBorderPadding);
|
||||
|
||||
|
||||
|
||||
/** Adjust the table for visibility.collapse set on rowgroups, rows,
|
||||
* colgroups and cols
|
||||
* @param aDesiredSize the metrics of the table
|
||||
@ -663,7 +663,7 @@ private:
|
||||
|
||||
public:
|
||||
|
||||
// calculate the computed height of aFrame including its border and padding given
|
||||
// calculate the computed height of aFrame including its border and padding given
|
||||
// its reflow state.
|
||||
nscoord CalcBorderBoxHeight(const nsHTMLReflowState& aReflowState);
|
||||
|
||||
@ -674,8 +674,8 @@ protected:
|
||||
// this function can change the overflow area
|
||||
void CalcDesiredHeight(const nsHTMLReflowState& aReflowState, nsHTMLReflowMetrics& aDesiredSize);
|
||||
|
||||
// The following is a helper for CalcDesiredHeight
|
||||
|
||||
// The following is a helper for CalcDesiredHeight
|
||||
|
||||
void DistributeHeightToRows(const nsHTMLReflowState& aReflowState,
|
||||
nscoord aAmount);
|
||||
|
||||
@ -762,15 +762,15 @@ public:
|
||||
*/
|
||||
nsTableCellMap* GetCellMap() const;
|
||||
|
||||
/** Iterate over the row groups and adjust the row indices of all rows
|
||||
* whose index is >= aRowIndex.
|
||||
/** Iterate over the row groups and adjust the row indices of all rows
|
||||
* whose index is >= aRowIndex.
|
||||
* @param aRowIndex - start adjusting with this index
|
||||
* @param aAdjustment - shift the row index by this amount
|
||||
*/
|
||||
void AdjustRowIndices(int32_t aRowIndex,
|
||||
int32_t aAdjustment);
|
||||
|
||||
/** Reset the rowindices of all rows as they might have changed due to
|
||||
/** Reset the rowindices of all rows as they might have changed due to
|
||||
* rowgroup reordering, exclude new row group frames that show in the
|
||||
* reordering but are not yet inserted into the cellmap
|
||||
* @param aRowGroupsToExclude - an iterator that will produce the row groups
|
||||
@ -808,7 +808,7 @@ public: /* ----- Cell Map public methods ----- */
|
||||
return GetCellMap()->GetRowCount();
|
||||
}
|
||||
|
||||
/** returns the number of columns in this table after redundant columns have been removed
|
||||
/** returns the number of columns in this table after redundant columns have been removed
|
||||
*/
|
||||
int32_t GetEffectiveColCount() const;
|
||||
|
||||
@ -825,10 +825,10 @@ public: /* ----- Cell Map public methods ----- */
|
||||
bool IsAutoLayout();
|
||||
|
||||
public:
|
||||
|
||||
|
||||
#ifdef DEBUG
|
||||
void Dump(bool aDumpRows,
|
||||
bool aDumpCols,
|
||||
bool aDumpCols,
|
||||
bool aDumpCellMap);
|
||||
#endif
|
||||
|
||||
@ -957,7 +957,7 @@ inline bool nsTableFrame::IsBorderCollapse() const
|
||||
return (bool)mBits.mIsBorderCollapse;
|
||||
}
|
||||
|
||||
inline void nsTableFrame::SetBorderCollapse(bool aValue)
|
||||
inline void nsTableFrame::SetBorderCollapse(bool aValue)
|
||||
{
|
||||
mBits.mIsBorderCollapse = aValue;
|
||||
}
|
||||
@ -1009,6 +1009,6 @@ return;}
|
||||
|
||||
#define ABORT1(aReturn) \
|
||||
{NS_ASSERTION(false, "CellIterator program error"); \
|
||||
return aReturn;}
|
||||
return aReturn;}
|
||||
|
||||
#endif
|
||||
|
||||
@ -91,8 +91,8 @@
|
||||
painting process, since they were skipped. They call the appropriate
|
||||
sub-part of the loop (e.g. PaintRow) which will paint the frame and
|
||||
descendants.
|
||||
|
||||
XXX views are going
|
||||
|
||||
XXX views are going
|
||||
*/
|
||||
|
||||
using namespace mozilla::image;
|
||||
@ -327,7 +327,7 @@ TableBackgroundPainter::PaintTable(nsTableFrame* aTableFrame,
|
||||
cgFrame->GetContinuousBCBorderWidth(border);
|
||||
cgData.SetBCBorder(border);
|
||||
}
|
||||
|
||||
|
||||
/*Loop over columns in this colgroup*/
|
||||
for (nsTableColFrame* col = cgFrame->GetFirstColumn(); col;
|
||||
col = static_cast<nsTableColFrame*>(col->GetNextSibling())) {
|
||||
@ -426,7 +426,7 @@ TableBackgroundPainter::PaintRowGroup(nsTableRowGroupFrame* aFrame,
|
||||
}
|
||||
|
||||
// It's OK if cursor is null here.
|
||||
nsTableRowFrame* row = static_cast<nsTableRowFrame*>(cursor);
|
||||
nsTableRowFrame* row = static_cast<nsTableRowFrame*>(cursor);
|
||||
if (!row) {
|
||||
// No useful cursor; just start at the top. Don't bother to set up a
|
||||
// cursor; if we've gotten this far then we've already built the display
|
||||
@ -434,9 +434,9 @@ TableBackgroundPainter::PaintRowGroup(nsTableRowGroupFrame* aFrame,
|
||||
// good reason we don't have a cursor and we shouldn't create one here.
|
||||
row = firstRow;
|
||||
}
|
||||
|
||||
|
||||
DrawResult result = DrawResult::SUCCESS;
|
||||
|
||||
|
||||
/* Finally paint */
|
||||
for (; row; row = row->GetNextRow()) {
|
||||
TableBackgroundData rowBackgroundData(row);
|
||||
@ -451,7 +451,7 @@ TableBackgroundPainter::PaintRowGroup(nsTableRowGroupFrame* aFrame,
|
||||
// All done; cells originating in later rows can't intersect mDirtyRect.
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
DrawResult rowResult =
|
||||
PaintRow(row, aRowGroupBGData, rowBackgroundData,
|
||||
aPassThrough || row->IsPseudoStackingContextFromStyle());
|
||||
@ -511,7 +511,7 @@ TableBackgroundPainter::PaintRow(nsTableRowFrame* aFrame,
|
||||
//else: Use row group's coord system -> no translation necessary
|
||||
|
||||
DrawResult result = DrawResult::SUCCESS;
|
||||
|
||||
|
||||
for (nsTableCellFrame* cell = aFrame->GetFirstCell(); cell; cell = cell->GetNextCell()) {
|
||||
nsRect cellBGRect, rowBGRect, rowGroupBGRect, colBGRect;
|
||||
ComputeCellBackgrounds(cell, aRowGroupBGData, aRowBGData,
|
||||
|
||||
@ -82,7 +82,7 @@ nsTableRowFrame::InitChildReflowState(nsPresContext& aPresContext,
|
||||
aReflowState.FixUp(aAvailSize);
|
||||
}
|
||||
|
||||
void
|
||||
void
|
||||
nsTableRowFrame::SetFixedHeight(nscoord aValue)
|
||||
{
|
||||
nscoord height = std::max(0, aValue);
|
||||
@ -99,7 +99,7 @@ nsTableRowFrame::SetFixedHeight(nscoord aValue)
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
void
|
||||
nsTableRowFrame::SetPctHeight(float aPctValue,
|
||||
bool aForce)
|
||||
{
|
||||
@ -148,7 +148,7 @@ nsTableRowFrame::Init(nsIContent* aContent,
|
||||
if (aPrevInFlow) {
|
||||
// Set the row index
|
||||
nsTableRowFrame* rowFrame = (nsTableRowFrame*)aPrevInFlow;
|
||||
|
||||
|
||||
SetRowIndex(rowFrame->GetRowIndex());
|
||||
}
|
||||
}
|
||||
@ -170,7 +170,7 @@ nsTableRowFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)
|
||||
|
||||
if (!aOldStyleContext) //avoid this on init
|
||||
return;
|
||||
|
||||
|
||||
nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
|
||||
if (tableFrame->IsBorderCollapse() &&
|
||||
tableFrame->BCRecalcNeeded(aOldStyleContext, StyleContext())) {
|
||||
@ -230,7 +230,7 @@ nsTableRowFrame::InsertFrames(ChildListID aListID,
|
||||
prevCellFrame->GetColIndex(colIndex);
|
||||
}
|
||||
tableFrame->InsertCells(cellChildren, GetRowIndex(), colIndex);
|
||||
|
||||
|
||||
PresContext()->PresShell()->FrameNeedsReflow(this, nsIPresShell::eTreeChange,
|
||||
NS_FRAME_HAS_DIRTY_CHILDREN);
|
||||
tableFrame->SetGeometryDirty();
|
||||
@ -276,7 +276,7 @@ nsTableRowFrame::GetUsedPadding() const
|
||||
return nsMargin(0,0,0,0);
|
||||
}
|
||||
|
||||
nscoord
|
||||
nscoord
|
||||
GetHeightOfRowsSpannedBelowFirst(nsTableCellFrame& aTableCellFrame,
|
||||
nsTableFrame& aTableFrame)
|
||||
{
|
||||
@ -295,8 +295,8 @@ GetHeightOfRowsSpannedBelowFirst(nsTableCellFrame& aTableCellFrame,
|
||||
return height;
|
||||
}
|
||||
|
||||
nsTableCellFrame*
|
||||
nsTableRowFrame::GetFirstCell()
|
||||
nsTableCellFrame*
|
||||
nsTableRowFrame::GetFirstCell()
|
||||
{
|
||||
nsIFrame* childFrame = mFrames.FirstChild();
|
||||
while (childFrame) {
|
||||
@ -344,7 +344,7 @@ nsTableRowFrame::DidResize()
|
||||
// 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);
|
||||
@ -375,13 +375,13 @@ 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.
|
||||
// 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
|
||||
@ -420,7 +420,7 @@ nsTableRowFrame::GetHeight(nscoord aPctBasis) const
|
||||
return std::max(height, GetContentHeight());
|
||||
}
|
||||
|
||||
void
|
||||
void
|
||||
nsTableRowFrame::ResetHeight(nscoord aFixedHeight)
|
||||
{
|
||||
SetHasFixedHeight(false);
|
||||
@ -607,13 +607,13 @@ 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()) {
|
||||
@ -647,14 +647,14 @@ nsTableRowFrame::CalculateCellActualHeight(nsTableCellFrame* aCellFrame,
|
||||
nsRuleNode::ComputeCoordPercentCalc(position->mHeight, 0) +
|
||||
outsideBoxSizing;
|
||||
|
||||
if (1 == rowSpan)
|
||||
if (1 == rowSpan)
|
||||
SetFixedHeight(specifiedHeight);
|
||||
break;
|
||||
}
|
||||
case eStyleUnit_Percent: {
|
||||
if (1 == rowSpan)
|
||||
if (1 == rowSpan)
|
||||
SetPctHeight(position->mHeight.GetPercentValue());
|
||||
// pct heights are handled when all of the cells are finished, so don't set specifiedHeight
|
||||
// pct heights are handled when all of the cells are finished, so don't set specifiedHeight
|
||||
break;
|
||||
}
|
||||
case eStyleUnit_Auto:
|
||||
@ -723,7 +723,7 @@ GetSpaceBetween(int32_t aPrevColIndex,
|
||||
space += aTableFrame.GetColSpacing(colX - 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
int32_t lastCol = aColIndex + aColSpan - 1;
|
||||
for (colX = aPrevColIndex - 1; colX > lastCol; colX--) {
|
||||
@ -783,7 +783,7 @@ nsTableRowFrame::ReflowChildren(nsPresContext* aPresContext,
|
||||
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();
|
||||
@ -823,7 +823,7 @@ nsTableRowFrame::ReflowChildren(nsPresContext* aPresContext,
|
||||
doReflowChild = false;
|
||||
}
|
||||
else if ((NS_UNCONSTRAINEDSIZE != aReflowState.AvailableHeight())) {
|
||||
// We don't reflow a rowspan >1 cell here with a constrained height.
|
||||
// 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;
|
||||
@ -843,7 +843,7 @@ nsTableRowFrame::ReflowChildren(nsPresContext* aPresContext,
|
||||
// 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,
|
||||
x += GetSpaceBetween(prevColIndex, cellColIndex, cellColSpan, aTableFrame,
|
||||
iter.IsLeftToRight(), false);
|
||||
}
|
||||
|
||||
@ -910,7 +910,7 @@ nsTableRowFrame::ReflowChildren(nsPresContext* aPresContext,
|
||||
if (x != origKidNormalPosition.x) {
|
||||
kidFrame->InvalidateFrameSubtree();
|
||||
}
|
||||
|
||||
|
||||
desiredSize.SetSize(cellWM, cellDesiredSize);
|
||||
desiredSize.mOverflowAreas = cellFrame->GetOverflowAreas();
|
||||
|
||||
@ -923,7 +923,7 @@ nsTableRowFrame::ReflowChildren(nsPresContext* aPresContext,
|
||||
nsTableFrame::RePositionViews(kidFrame);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (NS_UNCONSTRAINEDSIZE == aReflowState.AvailableHeight()) {
|
||||
if (!GetPrevInFlow()) {
|
||||
// Calculate the cell's actual height given its pass2 height. This
|
||||
@ -968,8 +968,8 @@ nsTableRowFrame::ReflowChildren(nsPresContext* aPresContext,
|
||||
|
||||
nsTableFrame::InvalidateTableFrame(kidFrame, kidRect, kidVisualOverflow,
|
||||
firstReflow);
|
||||
|
||||
x += desiredSize.Width();
|
||||
|
||||
x += desiredSize.Width();
|
||||
}
|
||||
else {
|
||||
if (x != origKidNormalPosition.x) {
|
||||
@ -1086,7 +1086,7 @@ nsTableRowFrame::Reflow(nsPresContext* aPresContext,
|
||||
* pushing a row frame that has cell frames that span into it. The cell frame
|
||||
* should be reflowed with the specified height
|
||||
*/
|
||||
nscoord
|
||||
nscoord
|
||||
nsTableRowFrame::ReflowCellFrame(nsPresContext* aPresContext,
|
||||
const nsHTMLReflowState& aReflowState,
|
||||
bool aIsTopOfPage,
|
||||
@ -1097,7 +1097,7 @@ nsTableRowFrame::ReflowCellFrame(nsPresContext* aPresContext,
|
||||
// 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();
|
||||
@ -1125,12 +1125,12 @@ nsTableRowFrame::ReflowCellFrame(nsPresContext* aPresContext,
|
||||
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();
|
||||
@ -1154,11 +1154,11 @@ nsTableRowFrame::CollapseRowIfNecessary(nscoord aRowOffset,
|
||||
// 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;
|
||||
@ -1280,7 +1280,7 @@ nsTableRowFrame::CollapseRowIfNecessary(nscoord aRowOffset,
|
||||
// We're moving the cell. Invalidate the old overflow area
|
||||
cellFrame->InvalidateFrameSubtree();
|
||||
}
|
||||
|
||||
|
||||
cellFrame->MovePositionBy(cRect.TopLeft() - oldCellNormalPos);
|
||||
cellFrame->SetSize(cRect.Size());
|
||||
|
||||
@ -1291,7 +1291,7 @@ nsTableRowFrame::CollapseRowIfNecessary(nscoord aRowOffset,
|
||||
cellFrame->FinishAndStoreOverflow(cellOverflow, cRect.Size());
|
||||
nsTableFrame::RePositionViews(cellFrame);
|
||||
ConsiderChildOverflow(overflow, cellFrame);
|
||||
|
||||
|
||||
if (aRowOffset == 0) {
|
||||
nsTableFrame::InvalidateTableFrame(cellFrame, oldCellRect,
|
||||
oldCellVisualOverflow,
|
||||
@ -1316,7 +1316,7 @@ nsTableRowFrame::CollapseRowIfNecessary(nscoord aRowOffset,
|
||||
* when it creates a continuing cell frame and wants to insert it into the
|
||||
* row's child list.
|
||||
*/
|
||||
void
|
||||
void
|
||||
nsTableRowFrame::InsertCellFrame(nsTableCellFrame* aFrame,
|
||||
int32_t aColIndex)
|
||||
{
|
||||
@ -1343,7 +1343,7 @@ nsTableRowFrame::GetType() const
|
||||
return nsGkAtoms::tableRowFrame;
|
||||
}
|
||||
|
||||
nsTableRowFrame*
|
||||
nsTableRowFrame*
|
||||
nsTableRowFrame::GetNextRow() const
|
||||
{
|
||||
nsIFrame* childFrame = GetNextSibling();
|
||||
@ -1360,7 +1360,7 @@ nsTableRowFrame::GetNextRow() const
|
||||
|
||||
NS_DECLARE_FRAME_PROPERTY(RowUnpaginatedHeightProperty, nullptr)
|
||||
|
||||
void
|
||||
void
|
||||
nsTableRowFrame::SetUnpaginatedHeight(nsPresContext* aPresContext,
|
||||
nscoord aValue)
|
||||
{
|
||||
@ -1428,8 +1428,8 @@ void nsTableRowFrame::InitHasCellWithStyleHeight(nsTableFrame* aTableFrame)
|
||||
}
|
||||
RemoveStateBits(NS_ROW_HAS_CELL_WITH_STYLE_HEIGHT);
|
||||
}
|
||||
|
||||
void
|
||||
|
||||
void
|
||||
nsTableRowFrame::InvalidateFrame(uint32_t aDisplayItemKey)
|
||||
{
|
||||
nsIFrame::InvalidateFrame(aDisplayItemKey);
|
||||
@ -1448,7 +1448,7 @@ nsTableRowFrame::InvalidateFrameWithRect(const nsRect& aRect, uint32_t aDisplayI
|
||||
|
||||
/* ----- global methods ----- */
|
||||
|
||||
nsTableRowFrame*
|
||||
nsTableRowFrame*
|
||||
NS_NewTableRowFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
|
||||
{
|
||||
return new (aPresShell) nsTableRowFrame(aContext);
|
||||
|
||||
@ -60,7 +60,7 @@ nsTableRowGroupFrame::GetRowCount()
|
||||
"Unexpected frame type");
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
return mFrames.GetLength();
|
||||
}
|
||||
|
||||
@ -77,7 +77,7 @@ int32_t nsTableRowGroupFrame::GetStartRowIndex()
|
||||
nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
|
||||
return tableFrame->GetStartRowIndex(this);
|
||||
}
|
||||
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -114,12 +114,12 @@ nsTableRowGroupFrame::InitRepeatedFrame(nsPresContext* aPresContext,
|
||||
int32_t colIndex;
|
||||
originalCellFrame->GetColIndex(colIndex);
|
||||
copyCellFrame->SetColIndex(colIndex);
|
||||
|
||||
|
||||
// Move to the next cell frame
|
||||
copyCellFrame = copyCellFrame->GetNextCell();
|
||||
originalCellFrame = originalCellFrame->GetNextCell();
|
||||
}
|
||||
|
||||
|
||||
// Move to the next row frame
|
||||
originalRowFrame = originalRowFrame->GetNextRow();
|
||||
copyRowFrame = copyRowFrame->GetNextRow();
|
||||
@ -187,7 +187,7 @@ DisplayRows(nsDisplayListBuilder* aBuilder, nsFrame* aFrame,
|
||||
// in |f| then it's true for |f| itself.
|
||||
nsIFrame* kid = aBuilder->ShouldDescendIntoFrame(f) ?
|
||||
nullptr : f->GetFirstRowContaining(aDirtyRect.y, &overflowAbove);
|
||||
|
||||
|
||||
if (kid) {
|
||||
// have a cursor, use it
|
||||
while (kid) {
|
||||
@ -199,20 +199,20 @@ DisplayRows(nsDisplayListBuilder* aBuilder, nsFrame* aFrame,
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
// No cursor. Traverse children the hard way and build a cursor while we're at it
|
||||
nsTableRowGroupFrame::FrameCursorData* cursor = f->SetupRowCursor();
|
||||
kid = f->GetFirstPrincipalChild();
|
||||
while (kid) {
|
||||
f->BuildDisplayListForChild(aBuilder, kid, aDirtyRect, aLists);
|
||||
|
||||
|
||||
if (cursor) {
|
||||
if (!cursor->AppendFrame(kid)) {
|
||||
f->ClearRowCursor();
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
kid = kid->GetNextSibling();
|
||||
}
|
||||
if (cursor) {
|
||||
@ -235,7 +235,7 @@ nsTableRowGroupFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
||||
item = new (aBuilder) nsDisplayTableRowGroupBackground(aBuilder, this);
|
||||
aLists.BorderBackground()->AppendNewToTop(item);
|
||||
}
|
||||
}
|
||||
}
|
||||
nsTableFrame::DisplayGenericTablePart(aBuilder, this, aDirtyRect,
|
||||
aLists, item, DisplayRows);
|
||||
}
|
||||
@ -260,7 +260,7 @@ nsTableRowGroupFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState)
|
||||
|
||||
// Position and size aKidFrame and update our reflow state. The origin of
|
||||
// aKidRect is relative to the upper-left origin of our frame
|
||||
void
|
||||
void
|
||||
nsTableRowGroupFrame::PlaceChild(nsPresContext* aPresContext,
|
||||
nsRowGroupReflowState& aReflowState,
|
||||
nsIFrame* aKidFrame,
|
||||
@ -289,9 +289,9 @@ nsTableRowGroupFrame::PlaceChild(nsPresContext* aPresContext,
|
||||
}
|
||||
|
||||
void
|
||||
nsTableRowGroupFrame::InitChildReflowState(nsPresContext& aPresContext,
|
||||
nsTableRowGroupFrame::InitChildReflowState(nsPresContext& aPresContext,
|
||||
bool aBorderCollapse,
|
||||
nsHTMLReflowState& aReflowState)
|
||||
nsHTMLReflowState& aReflowState)
|
||||
{
|
||||
nsMargin collapseBorder;
|
||||
nsMargin padding(0,0,0,0);
|
||||
@ -324,7 +324,7 @@ nsTableRowGroupFrame::ReflowChildren(nsPresContext* aPresContext,
|
||||
nsReflowStatus& aStatus,
|
||||
bool* aPageBreakBeforeEnd)
|
||||
{
|
||||
if (aPageBreakBeforeEnd)
|
||||
if (aPageBreakBeforeEnd)
|
||||
*aPageBreakBeforeEnd = false;
|
||||
|
||||
nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
|
||||
@ -332,7 +332,7 @@ nsTableRowGroupFrame::ReflowChildren(nsPresContext* aPresContext,
|
||||
|
||||
// XXXldb Should we really be checking this rather than available height?
|
||||
// (Think about multi-column layout!)
|
||||
bool isPaginated = aPresContext->IsPaginated() &&
|
||||
bool isPaginated = aPresContext->IsPaginated() &&
|
||||
NS_UNCONSTRAINEDSIZE != aReflowState.availSize.height;
|
||||
|
||||
bool haveRow = false;
|
||||
@ -383,8 +383,8 @@ nsTableRowGroupFrame::ReflowChildren(nsPresContext* aPresContext,
|
||||
if (aReflowState.reflowState.IsHResize()) {
|
||||
kidReflowState.SetHResize(true);
|
||||
}
|
||||
|
||||
NS_ASSERTION(kidFrame == mFrames.FirstChild() || prevKidFrame,
|
||||
|
||||
NS_ASSERTION(kidFrame == mFrames.FirstChild() || prevKidFrame,
|
||||
"If we're not on the first frame, we should have a "
|
||||
"previous sibling...");
|
||||
// If prev row has nonzero YMost, then we can't be at the top of the page
|
||||
@ -464,8 +464,8 @@ nsTableRowGroupFrame::ReflowChildren(nsPresContext* aPresContext,
|
||||
}
|
||||
}
|
||||
|
||||
nsTableRowFrame*
|
||||
nsTableRowGroupFrame::GetFirstRow()
|
||||
nsTableRowFrame*
|
||||
nsTableRowGroupFrame::GetFirstRow()
|
||||
{
|
||||
for (nsIFrame* childFrame = mFrames.FirstChild(); childFrame;
|
||||
childFrame = childFrame->GetNextSibling()) {
|
||||
@ -482,8 +482,8 @@ struct RowInfo {
|
||||
RowInfo() { height = pctHeight = hasStyleHeight = hasPctHeight = isSpecial = 0; }
|
||||
unsigned height; // content height or fixed height, excluding pct height
|
||||
unsigned pctHeight:29; // pct height
|
||||
unsigned hasStyleHeight:1;
|
||||
unsigned hasPctHeight:1;
|
||||
unsigned hasStyleHeight:1;
|
||||
unsigned hasPctHeight:1;
|
||||
unsigned isSpecial:1; // there is no cell originating in the row with rowspan=1 and there are at
|
||||
// least 2 cells spanning the row and there is no style height on the row
|
||||
};
|
||||
@ -501,7 +501,7 @@ UpdateHeights(RowInfo& aRowInfo,
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
void
|
||||
nsTableRowGroupFrame::DidResizeRows(nsHTMLReflowMetrics& aDesiredSize)
|
||||
{
|
||||
// update the cells spanning rows with their new heights
|
||||
@ -515,13 +515,13 @@ nsTableRowGroupFrame::DidResizeRows(nsHTMLReflowMetrics& aDesiredSize)
|
||||
}
|
||||
}
|
||||
|
||||
// This calculates the height of all the rows and takes into account
|
||||
// style height on the row group, style heights on rows and cells, style heights on rowspans.
|
||||
// This calculates the height of all the rows and takes into account
|
||||
// style height on the row group, style heights on rows and cells, style heights on rowspans.
|
||||
// Actual row heights will be adjusted later if the table has a style height.
|
||||
// Even if rows don't change height, this method must be called to set the heights of each
|
||||
// cell in the row to the height of its row.
|
||||
void
|
||||
nsTableRowGroupFrame::CalculateRowHeights(nsPresContext* aPresContext,
|
||||
void
|
||||
nsTableRowGroupFrame::CalculateRowHeights(nsPresContext* aPresContext,
|
||||
nsHTMLReflowMetrics& aDesiredSize,
|
||||
const nsHTMLReflowState& aReflowState)
|
||||
{
|
||||
@ -552,8 +552,8 @@ nsTableRowGroupFrame::CalculateRowHeights(nsPresContext* aPresContext,
|
||||
bool hasRowSpanningCell = false;
|
||||
nscoord heightOfRows = 0;
|
||||
nscoord heightOfUnStyledRows = 0;
|
||||
// Get the height of each row without considering rowspans. This will be the max of
|
||||
// the largest desired height of each cell, the largest style height of each cell,
|
||||
// Get the height of each row without considering rowspans. This will be the max of
|
||||
// the largest desired height of each cell, the largest style height of each cell,
|
||||
// the style height of the row.
|
||||
nscoord pctHeightBasis = GetHeightBasis(aReflowState);
|
||||
int32_t rowIndex; // the index in rowInfo, not among the rows in the row group
|
||||
@ -580,11 +580,11 @@ nsTableRowGroupFrame::CalculateRowHeights(nsPresContext* aPresContext,
|
||||
nsTableCellFrame* cellFrame = rowFrame->GetFirstCell();
|
||||
while (cellFrame) {
|
||||
int32_t rowSpan = tableFrame->GetEffectiveRowSpan(rowIndex + startRowIndex, *cellFrame);
|
||||
if (1 == rowSpan) {
|
||||
if (1 == rowSpan) {
|
||||
rowInfo[rowIndex].isSpecial = false;
|
||||
break;
|
||||
}
|
||||
cellFrame = cellFrame->GetNextCell();
|
||||
cellFrame = cellFrame->GetNextCell();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -597,15 +597,15 @@ nsTableRowGroupFrame::CalculateRowHeights(nsPresContext* aPresContext,
|
||||
}
|
||||
|
||||
if (hasRowSpanningCell) {
|
||||
// Get the height of cells with rowspans and allocate any extra space to the rows they span
|
||||
// Get the height of cells with rowspans and allocate any extra space to the rows they span
|
||||
// iteratate the child frames and process the row frames among them
|
||||
for (rowFrame = startRowFrame, rowIndex = 0; rowFrame; rowFrame = rowFrame->GetNextRow(), rowIndex++) {
|
||||
// See if the row has an originating cell with rowspan > 1. We cannot determine this for a row in a
|
||||
// See if the row has an originating cell with rowspan > 1. We cannot determine this for a row in a
|
||||
// continued row group by calling RowHasSpanningCells, because the row's fif may not have any originating
|
||||
// cells yet the row may have a continued cell which originates in it.
|
||||
if (GetPrevInFlow() || tableFrame->RowHasSpanningCells(startRowIndex + rowIndex, numEffCols)) {
|
||||
nsTableCellFrame* cellFrame = rowFrame->GetFirstCell();
|
||||
// iteratate the row's cell frames
|
||||
// iteratate the row's cell frames
|
||||
while (cellFrame) {
|
||||
nscoord cellSpacingY = tableFrame->GetRowSpacing(startRowIndex + rowIndex);
|
||||
int32_t rowSpan = tableFrame->GetEffectiveRowSpan(rowIndex + startRowIndex, *cellFrame);
|
||||
@ -616,7 +616,7 @@ nsTableRowGroupFrame::CalculateRowHeights(nsPresContext* aPresContext,
|
||||
if (rowSpan > 1) { // a cell with rowspan > 1, determine the height of the rows it spans
|
||||
nscoord heightOfRowsSpanned = 0;
|
||||
nscoord heightOfUnStyledRowsSpanned = 0;
|
||||
nscoord numSpecialRowsSpanned = 0;
|
||||
nscoord numSpecialRowsSpanned = 0;
|
||||
nscoord cellSpacingTotal = 0;
|
||||
int32_t spanX;
|
||||
for (spanX = 0; spanX < rowSpan; spanX++) {
|
||||
@ -630,9 +630,9 @@ nsTableRowGroupFrame::CalculateRowHeights(nsPresContext* aPresContext,
|
||||
if (rowInfo[rowIndex + spanX].isSpecial) {
|
||||
numSpecialRowsSpanned++;
|
||||
}
|
||||
}
|
||||
}
|
||||
nscoord heightOfAreaSpanned = heightOfRowsSpanned + cellSpacingTotal;
|
||||
// get the height of the cell
|
||||
// get the height of the cell
|
||||
nsSize cellFrameSize = cellFrame->GetSize();
|
||||
nsSize cellDesSize =
|
||||
cellFrame->GetDesiredSize().GetPhysicalSize(cellFrame->GetWritingMode());
|
||||
@ -645,7 +645,7 @@ nsTableRowGroupFrame::CalculateRowHeights(nsPresContext* aPresContext,
|
||||
cellFrameSize.height += rowFrame->GetMaxCellAscent() -
|
||||
cellFrame->GetCellBaseline();
|
||||
}
|
||||
|
||||
|
||||
if (heightOfAreaSpanned < cellFrameSize.height) {
|
||||
// the cell's height is larger than the available space of the rows it
|
||||
// spans so distribute the excess height to the rows affected
|
||||
@ -654,16 +654,16 @@ nsTableRowGroupFrame::CalculateRowHeights(nsPresContext* aPresContext,
|
||||
if (0 == numSpecialRowsSpanned) {
|
||||
//NS_ASSERTION(heightOfRowsSpanned > 0, "invalid row span situation");
|
||||
bool haveUnStyledRowsSpanned = (heightOfUnStyledRowsSpanned > 0);
|
||||
nscoord divisor = (haveUnStyledRowsSpanned)
|
||||
nscoord divisor = (haveUnStyledRowsSpanned)
|
||||
? heightOfUnStyledRowsSpanned : heightOfRowsSpanned;
|
||||
if (divisor > 0) {
|
||||
for (spanX = rowSpan - 1; spanX >= 0; spanX--) {
|
||||
if (!haveUnStyledRowsSpanned || !rowInfo[rowIndex + spanX].hasStyleHeight) {
|
||||
// The amount of additional space each row gets is proportional to its height
|
||||
float percent = ((float)rowInfo[rowIndex + spanX].height) / ((float)divisor);
|
||||
|
||||
|
||||
// give rows their percentage, except for the first row which gets the remainder
|
||||
nscoord extraForRow = (0 == spanX) ? extra - extraUsed
|
||||
nscoord extraForRow = (0 == spanX) ? extra - extraUsed
|
||||
: NSToCoordRound(((float)(extra)) * percent);
|
||||
extraForRow = std::min(extraForRow, extra - extraUsed);
|
||||
// update the row height
|
||||
@ -688,10 +688,10 @@ nsTableRowGroupFrame::CalculateRowHeights(nsPresContext* aPresContext,
|
||||
if (rowInfo[rowIndex + spanX].isSpecial) {
|
||||
// The amount of additional space each degenerate row gets is proportional to the number of them
|
||||
float percent = 1.0f / ((float)numSpecialRowsSpanned);
|
||||
|
||||
|
||||
// give rows their percentage, except for the first row which gets the remainder
|
||||
nscoord extraForRow = (numSpecialRowsSpanned - 1 == numSpecialRowsAllocated)
|
||||
? extra - extraUsed
|
||||
nscoord extraForRow = (numSpecialRowsSpanned - 1 == numSpecialRowsAllocated)
|
||||
? extra - extraUsed
|
||||
: NSToCoordRound(((float)(extra)) * percent);
|
||||
extraForRow = std::min(extraForRow, extra - extraUsed);
|
||||
// update the row height
|
||||
@ -704,9 +704,9 @@ nsTableRowGroupFrame::CalculateRowHeights(nsPresContext* aPresContext,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} // if (rowSpan > 1)
|
||||
cellFrame = cellFrame->GetNextCell();
|
||||
cellFrame = cellFrame->GetNextCell();
|
||||
} // while (cellFrame)
|
||||
} // if (tableFrame->RowHasSpanningCells(startRowIndex + rowIndex) {
|
||||
} // while (rowFrame)
|
||||
@ -717,7 +717,7 @@ nsTableRowGroupFrame::CalculateRowHeights(nsPresContext* aPresContext,
|
||||
for (rowFrame = startRowFrame, rowIndex = 0; rowFrame && (extra > 0); rowFrame = rowFrame->GetNextRow(), rowIndex++) {
|
||||
RowInfo& rInfo = rowInfo[rowIndex];
|
||||
if (rInfo.hasPctHeight) {
|
||||
nscoord rowExtra = (rInfo.pctHeight > rInfo.height)
|
||||
nscoord rowExtra = (rInfo.pctHeight > rInfo.height)
|
||||
? rInfo.pctHeight - rInfo.height: 0;
|
||||
rowExtra = std::min(rowExtra, extra);
|
||||
UpdateHeights(rInfo, rowExtra, heightOfRows, heightOfUnStyledRows);
|
||||
@ -729,12 +729,12 @@ nsTableRowGroupFrame::CalculateRowHeights(nsPresContext* aPresContext,
|
||||
nscoord rowGroupHeight = startRowGroupHeight + heightOfRows +
|
||||
tableFrame->GetRowSpacing(0, numRows-1);
|
||||
// if we have a style height, allocate the extra height to unconstrained rows
|
||||
if ((aReflowState.ComputedHeight() > rowGroupHeight) &&
|
||||
if ((aReflowState.ComputedHeight() > rowGroupHeight) &&
|
||||
(NS_UNCONSTRAINEDSIZE != aReflowState.ComputedHeight())) {
|
||||
nscoord extraComputedHeight = aReflowState.ComputedHeight() - rowGroupHeight;
|
||||
nscoord extraUsed = 0;
|
||||
bool haveUnStyledRows = (heightOfUnStyledRows > 0);
|
||||
nscoord divisor = (haveUnStyledRows)
|
||||
nscoord divisor = (haveUnStyledRows)
|
||||
? heightOfUnStyledRows : heightOfRows;
|
||||
if (divisor > 0) {
|
||||
styleHeightAllocation = true;
|
||||
@ -744,8 +744,8 @@ nsTableRowGroupFrame::CalculateRowHeights(nsPresContext* aPresContext,
|
||||
// percentage of space it occupies
|
||||
float percent = ((float)rowInfo[rowIndex].height) / ((float)divisor);
|
||||
// give rows their percentage, except for the last row which gets the remainder
|
||||
nscoord extraForRow = (numRows - 1 == rowIndex)
|
||||
? extraComputedHeight - extraUsed
|
||||
nscoord extraForRow = (numRows - 1 == rowIndex)
|
||||
? extraComputedHeight - extraUsed
|
||||
: NSToCoordRound(((float)extraComputedHeight) * percent);
|
||||
extraForRow = std::min(extraForRow, extraComputedHeight - extraUsed);
|
||||
// update the row height
|
||||
@ -769,13 +769,13 @@ nsTableRowGroupFrame::CalculateRowHeights(nsPresContext* aPresContext,
|
||||
nscoord deltaY = yOrigin - rowFrame->GetNormalPosition().y;
|
||||
|
||||
nscoord rowHeight = (rowInfo[rowIndex].height > 0) ? rowInfo[rowIndex].height : 0;
|
||||
|
||||
|
||||
if (deltaY != 0 || (rowHeight != rowBounds.height)) {
|
||||
// Resize/move the row to its final size and position
|
||||
if (deltaY != 0) {
|
||||
rowFrame->InvalidateFrameSubtree();
|
||||
}
|
||||
|
||||
|
||||
rowFrame->MovePositionBy(nsPoint(0, deltaY));
|
||||
rowFrame->SetSize(nsSize(rowBounds.width, rowHeight));
|
||||
|
||||
@ -791,7 +791,7 @@ nsTableRowGroupFrame::CalculateRowHeights(nsPresContext* aPresContext,
|
||||
}
|
||||
|
||||
if (isPaginated && styleHeightAllocation) {
|
||||
// since the row group has a style height, cache the row heights, so next in flows can honor them
|
||||
// since the row group has a style height, cache the row heights, so next in flows can honor them
|
||||
CacheRowHeightsForPrinting(aPresContext, GetFirstRow());
|
||||
}
|
||||
|
||||
@ -827,7 +827,7 @@ nsTableRowGroupFrame::CollapseRowGroupIfNecessary(nscoord aYTotalOffset,
|
||||
nsRect groupRect = GetRect();
|
||||
nsRect oldGroupRect = groupRect;
|
||||
nsRect oldGroupVisualOverflow = GetVisualOverflowRect();
|
||||
|
||||
|
||||
groupRect.height -= yGroupOffset;
|
||||
if (didCollapse) {
|
||||
// add back the cellspacing between rowgroups
|
||||
@ -841,7 +841,7 @@ nsTableRowGroupFrame::CollapseRowGroupIfNecessary(nscoord aYTotalOffset,
|
||||
if (aYTotalOffset != 0) {
|
||||
InvalidateFrameSubtree();
|
||||
}
|
||||
|
||||
|
||||
SetRect(groupRect);
|
||||
overflow.UnionAllWith(nsRect(0, 0, groupRect.width, groupRect.height));
|
||||
FinishAndStoreOverflow(overflow, groupRect.Size());
|
||||
@ -872,7 +872,7 @@ nsTableRowGroupFrame::SlideChild(nsRowGroupReflowState& aReflowState,
|
||||
|
||||
// Create a continuing frame, add it to the child list, and then push it
|
||||
// and the frames that follow
|
||||
void
|
||||
void
|
||||
nsTableRowGroupFrame::CreateContinuingRowFrame(nsPresContext& aPresContext,
|
||||
nsIFrame& aRowFrame,
|
||||
nsIFrame** aContRowFrame)
|
||||
@ -892,13 +892,13 @@ nsTableRowGroupFrame::CreateContinuingRowFrame(nsPresContext& aPresContext,
|
||||
|
||||
// Reflow the cells with rowspan > 1 which originate between aFirstRow
|
||||
// and end on or after aLastRow. aFirstTruncatedRow is the highest row on the
|
||||
// page that contains a cell which cannot split on this page
|
||||
// page that contains a cell which cannot split on this page
|
||||
void
|
||||
nsTableRowGroupFrame::SplitSpanningCells(nsPresContext& aPresContext,
|
||||
const nsHTMLReflowState& aReflowState,
|
||||
nsTableFrame& aTable,
|
||||
nsTableRowFrame& aFirstRow,
|
||||
nsTableRowFrame& aLastRow,
|
||||
nsTableRowFrame& aFirstRow,
|
||||
nsTableRowFrame& aLastRow,
|
||||
bool aFirstRowIsTopOfPage,
|
||||
nscoord aSpanningRowBottom,
|
||||
nsTableRowFrame*& aContRow,
|
||||
@ -922,7 +922,7 @@ nsTableRowGroupFrame::SplitSpanningCells(nsPresContext& aPresContext,
|
||||
for (nsTableCellFrame* cell = row->GetFirstCell(); cell; cell = cell->GetNextCell()) {
|
||||
int32_t rowSpan = aTable.GetEffectiveRowSpan(rowIndex, *cell);
|
||||
// Only reflow rowspan > 1 cells which span aLastRow. Those which don't span aLastRow
|
||||
// were reflowed correctly during the unconstrained height reflow.
|
||||
// were reflowed correctly during the unconstrained height reflow.
|
||||
if ((rowSpan > 1) && (rowIndex + rowSpan > lastRowIndex)) {
|
||||
haveRowSpan = true;
|
||||
nsReflowStatus status;
|
||||
@ -955,7 +955,7 @@ nsTableRowGroupFrame::SplitSpanningCells(nsPresContext& aPresContext,
|
||||
if (cellHeight > cellAvailHeight) {
|
||||
aFirstTruncatedRow = row;
|
||||
if ((row != &aFirstRow) || !aFirstRowIsTopOfPage) {
|
||||
// return now, since we will be getting another reflow after either (1) row is
|
||||
// return now, since we will be getting another reflow after either (1) row is
|
||||
// moved to the next page or (2) the row group is moved to the next page
|
||||
return;
|
||||
}
|
||||
@ -967,7 +967,7 @@ nsTableRowGroupFrame::SplitSpanningCells(nsPresContext& aPresContext,
|
||||
}
|
||||
if (aContRow) {
|
||||
if (row != &aLastRow) {
|
||||
// aContRow needs a continuation for cell, since cell spanned into aLastRow
|
||||
// aContRow needs a continuation for cell, since cell spanned into aLastRow
|
||||
// but does not originate there
|
||||
nsTableCellFrame* contCell = static_cast<nsTableCellFrame*>(
|
||||
aPresContext.PresShell()->FrameConstructor()->
|
||||
@ -986,9 +986,9 @@ nsTableRowGroupFrame::SplitSpanningCells(nsPresContext& aPresContext,
|
||||
}
|
||||
}
|
||||
|
||||
// Remove the next-in-flow of the row, its cells and their cell blocks. This
|
||||
// is necessary in case the row doesn't need a continuation later on or needs
|
||||
// a continuation which doesn't have the same number of cells that now exist.
|
||||
// Remove the next-in-flow of the row, its cells and their cell blocks. This
|
||||
// is necessary in case the row doesn't need a continuation later on or needs
|
||||
// a continuation which doesn't have the same number of cells that now exist.
|
||||
void
|
||||
nsTableRowGroupFrame::UndoContinuedRow(nsPresContext* aPresContext,
|
||||
nsTableRowFrame* aRow)
|
||||
@ -1017,7 +1017,7 @@ nsTableRowGroupFrame::UndoContinuedRow(nsPresContext* aPresContext,
|
||||
}
|
||||
}
|
||||
|
||||
static nsTableRowFrame*
|
||||
static nsTableRowFrame*
|
||||
GetRowBefore(nsTableRowFrame& aStartRow,
|
||||
nsTableRowFrame& aRow)
|
||||
{
|
||||
@ -1036,19 +1036,19 @@ nsTableRowGroupFrame::SplitRowGroup(nsPresContext* aPresContext,
|
||||
nsReflowStatus& aStatus,
|
||||
bool aRowForcedPageBreak)
|
||||
{
|
||||
NS_PRECONDITION(aPresContext->IsPaginated(), "SplitRowGroup currently supports only paged media");
|
||||
NS_PRECONDITION(aPresContext->IsPaginated(), "SplitRowGroup currently supports only paged media");
|
||||
|
||||
nsTableRowFrame* prevRowFrame = nullptr;
|
||||
aDesiredSize.Height() = 0;
|
||||
|
||||
nscoord availWidth = aReflowState.AvailableWidth();
|
||||
nscoord availHeight = aReflowState.AvailableHeight();
|
||||
|
||||
|
||||
const bool borderCollapse = aTableFrame->IsBorderCollapse();
|
||||
|
||||
|
||||
// get the page height
|
||||
nscoord pageHeight = aPresContext->GetPageSize().height;
|
||||
NS_ASSERTION(pageHeight != NS_UNCONSTRAINEDSIZE,
|
||||
NS_ASSERTION(pageHeight != NS_UNCONSTRAINEDSIZE,
|
||||
"The table shouldn't be split when there should be space");
|
||||
|
||||
bool isTopOfPage = aReflowState.mFlags.mIsTopOfPage;
|
||||
@ -1058,7 +1058,7 @@ nsTableRowGroupFrame::SplitRowGroup(nsPresContext* aPresContext,
|
||||
// reflowing its cell as an optimization.
|
||||
aTableFrame->SetGeometryDirty();
|
||||
|
||||
// Walk each of the row frames looking for the first row frame that doesn't fit
|
||||
// Walk each of the row frames looking for the first row frame that doesn't fit
|
||||
// in the available space
|
||||
for (nsTableRowFrame* rowFrame = firstRowThisPage; rowFrame; rowFrame = rowFrame->GetNextRow()) {
|
||||
bool rowIsOnPage = true;
|
||||
@ -1068,9 +1068,9 @@ nsTableRowGroupFrame::SplitRowGroup(nsPresContext* aPresContext,
|
||||
if (rowRect.YMost() > availHeight) {
|
||||
nsTableRowFrame* contRow = nullptr;
|
||||
// Reflow the row in the availabe space and have it split if it is the 1st
|
||||
// row (on the page) or there is at least 5% of the current page available
|
||||
// XXX this 5% should be made a preference
|
||||
if (!prevRowFrame || (availHeight - aDesiredSize.Height() > pageHeight / 20)) {
|
||||
// row (on the page) or there is at least 5% of the current page available
|
||||
// XXX this 5% should be made a preference
|
||||
if (!prevRowFrame || (availHeight - aDesiredSize.Height() > pageHeight / 20)) {
|
||||
nsSize availSize(availWidth, std::max(availHeight - rowRect.y, 0));
|
||||
// don't let the available height exceed what CalculateRowHeights set for it
|
||||
availSize.height = std::min(availSize.height, rowRect.height);
|
||||
@ -1080,7 +1080,7 @@ nsTableRowGroupFrame::SplitRowGroup(nsPresContext* aPresContext,
|
||||
availSize),
|
||||
-1, -1,
|
||||
nsHTMLReflowState::CALLER_WILL_INIT);
|
||||
|
||||
|
||||
InitChildReflowState(*aPresContext, borderCollapse, rowReflowState);
|
||||
rowReflowState.mFlags.mIsTopOfPage = isTopOfPage; // set top of page
|
||||
nsHTMLReflowMetrics rowMetrics(aReflowState);
|
||||
@ -1112,31 +1112,31 @@ nsTableRowGroupFrame::SplitRowGroup(nsPresContext* aPresContext,
|
||||
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(),
|
||||
NS_ASSERTION(rowMetrics.Height() <= rowReflowState.AvailableHeight(),
|
||||
"data loss - incomplete row needed more height than available, on top of page");
|
||||
CreateContinuingRowFrame(*aPresContext, *rowFrame, (nsIFrame**)&contRow);
|
||||
if (contRow) {
|
||||
aDesiredSize.Height() += rowMetrics.Height();
|
||||
if (prevRowFrame)
|
||||
if (prevRowFrame)
|
||||
aDesiredSize.Height() += cellSpacingY;
|
||||
}
|
||||
else return NS_ERROR_NULL_POINTER;
|
||||
}
|
||||
else {
|
||||
// Put the row on the next page to give it more height
|
||||
// Put the row on the next page to give it more height
|
||||
rowIsOnPage = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
// The row frame is complete because either (1) its minimum height is greater than the
|
||||
// available height we gave it, or (2) it may have been given a larger height through
|
||||
// The row frame is complete because either (1) its minimum height is greater than the
|
||||
// available height we gave it, or (2) it may have been given a larger height through
|
||||
// style than its content, or (3) it contains a rowspan >1 cell which hasn't been
|
||||
// reflowed with a constrained height yet (we will find out when SplitSpanningCells is
|
||||
// called below)
|
||||
if (rowMetrics.Height() > availSize.height ||
|
||||
(NS_INLINE_IS_BREAK_BEFORE(aStatus) && !aRowForcedPageBreak)) {
|
||||
// cases (1) and (2)
|
||||
if (isTopOfPage) {
|
||||
if (isTopOfPage) {
|
||||
// We're on top of the page, so keep the row on this page. There will be data loss.
|
||||
// Push the row frame that follows
|
||||
nsTableRowFrame* nextRowFrame = rowFrame->GetNextRow();
|
||||
@ -1144,18 +1144,18 @@ nsTableRowGroupFrame::SplitRowGroup(nsPresContext* aPresContext,
|
||||
aStatus = NS_FRAME_NOT_COMPLETE;
|
||||
}
|
||||
aDesiredSize.Height() += rowMetrics.Height();
|
||||
if (prevRowFrame)
|
||||
if (prevRowFrame)
|
||||
aDesiredSize.Height() += cellSpacingY;
|
||||
NS_WARNING("data loss - complete row needed more height than available, on top of page");
|
||||
}
|
||||
else {
|
||||
// We're not on top of the page, so put the row on the next page to give it more height
|
||||
// We're not on top of the page, so put the row on the next page to give it more height
|
||||
rowIsOnPage = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
} //if (!prevRowFrame || (availHeight - aDesiredSize.Height() > pageHeight / 20))
|
||||
else {
|
||||
else {
|
||||
// put the row on the next page to give it more height
|
||||
rowIsOnPage = false;
|
||||
}
|
||||
@ -1186,7 +1186,7 @@ nsTableRowGroupFrame::SplitRowGroup(nsPresContext* aPresContext,
|
||||
nsTableRowFrame* firstTruncatedRow;
|
||||
nscoord yMost;
|
||||
SplitSpanningCells(*aPresContext, aReflowState, *aTableFrame, *firstRowThisPage,
|
||||
*lastRowThisPage, aReflowState.mFlags.mIsTopOfPage, spanningRowBottom, contRow,
|
||||
*lastRowThisPage, aReflowState.mFlags.mIsTopOfPage, spanningRowBottom, contRow,
|
||||
firstTruncatedRow, yMost);
|
||||
if (firstTruncatedRow) {
|
||||
// A rowspan >1 cell did not fit (and could not split) in the space we gave it
|
||||
@ -1203,7 +1203,7 @@ nsTableRowGroupFrame::SplitRowGroup(nsPresContext* aPresContext,
|
||||
}
|
||||
}
|
||||
else { // (firstTruncatedRow != firstRowThisPage)
|
||||
// Try to put firstTruncateRow on the next page
|
||||
// Try to put firstTruncateRow on the next page
|
||||
nsTableRowFrame* rowBefore = ::GetRowBefore(*firstRowThisPage, *firstTruncatedRow);
|
||||
nscoord oldSpanningRowBottom = spanningRowBottom;
|
||||
spanningRowBottom = rowBefore->GetNormalRect().YMost();
|
||||
@ -1215,8 +1215,8 @@ nsTableRowGroupFrame::SplitRowGroup(nsPresContext* aPresContext,
|
||||
aStatus = NS_FRAME_NOT_COMPLETE;
|
||||
|
||||
// Call SplitSpanningCells again with rowBefore as the last row on the page
|
||||
SplitSpanningCells(*aPresContext, aReflowState, *aTableFrame,
|
||||
*firstRowThisPage, *rowBefore, aReflowState.mFlags.mIsTopOfPage,
|
||||
SplitSpanningCells(*aPresContext, aReflowState, *aTableFrame,
|
||||
*firstRowThisPage, *rowBefore, aReflowState.mFlags.mIsTopOfPage,
|
||||
spanningRowBottom, contRow, firstTruncatedRow, aDesiredSize.Height());
|
||||
if (firstTruncatedRow) {
|
||||
if (aReflowState.mFlags.mIsTopOfPage) {
|
||||
@ -1226,7 +1226,7 @@ nsTableRowGroupFrame::SplitRowGroup(nsPresContext* aPresContext,
|
||||
lastRowThisPage = oldLastRowThisPage;
|
||||
spanningRowBottom = oldSpanningRowBottom;
|
||||
SplitSpanningCells(*aPresContext, aReflowState, *aTableFrame, *firstRowThisPage,
|
||||
*lastRowThisPage, aReflowState.mFlags.mIsTopOfPage, spanningRowBottom, contRow,
|
||||
*lastRowThisPage, aReflowState.mFlags.mIsTopOfPage, spanningRowBottom, contRow,
|
||||
firstTruncatedRow, aDesiredSize.Height());
|
||||
NS_WARNING("data loss in a row spanned cell");
|
||||
}
|
||||
@ -1254,7 +1254,7 @@ nsTableRowGroupFrame::SplitRowGroup(nsPresContext* aPresContext,
|
||||
}
|
||||
break;
|
||||
} // if (rowRect.YMost() > availHeight)
|
||||
else {
|
||||
else {
|
||||
aDesiredSize.Height() = rowRect.YMost();
|
||||
prevRowFrame = rowFrame;
|
||||
// see if there is a page break after the row
|
||||
@ -1305,7 +1305,7 @@ nsTableRowGroupFrame::Reflow(nsPresContext* aPresContext,
|
||||
// Check for an overflow list
|
||||
MoveOverflowToChildList();
|
||||
|
||||
// Reflow the existing frames.
|
||||
// Reflow the existing frames.
|
||||
bool splitDueToPageBreak = false;
|
||||
ReflowChildren(aPresContext, aDesiredSize, state, aStatus,
|
||||
&splitDueToPageBreak);
|
||||
@ -1314,9 +1314,9 @@ nsTableRowGroupFrame::Reflow(nsPresContext* aPresContext,
|
||||
// not paginated ... we can't split across columns yet.
|
||||
if (aReflowState.mFlags.mTableIsSplittable &&
|
||||
NS_UNCONSTRAINEDSIZE != aReflowState.AvailableHeight() &&
|
||||
(NS_FRAME_NOT_COMPLETE == aStatus || splitDueToPageBreak ||
|
||||
(NS_FRAME_NOT_COMPLETE == aStatus || splitDueToPageBreak ||
|
||||
aDesiredSize.Height() > aReflowState.AvailableHeight())) {
|
||||
// Nope, find a place to split the row group
|
||||
// Nope, find a place to split the row group
|
||||
bool specialReflow = (bool)aReflowState.mFlags.mSpecialHeightReflow;
|
||||
((nsHTMLReflowState::ReflowStateFlags&)aReflowState.mFlags).mSpecialHeightReflow = false;
|
||||
|
||||
@ -1334,8 +1334,8 @@ nsTableRowGroupFrame::Reflow(nsPresContext* aPresContext,
|
||||
}
|
||||
|
||||
SetHasStyleHeight((NS_UNCONSTRAINEDSIZE != aReflowState.ComputedHeight()) &&
|
||||
(aReflowState.ComputedHeight() > 0));
|
||||
|
||||
(aReflowState.ComputedHeight() > 0));
|
||||
|
||||
// just set our width to what was available. The table will calculate the width and not use our value.
|
||||
aDesiredSize.Width() = aReflowState.AvailableWidth();
|
||||
|
||||
@ -1347,7 +1347,7 @@ nsTableRowGroupFrame::Reflow(nsPresContext* aPresContext,
|
||||
nsSize(aDesiredSize.Width(), aDesiredSize.Height()) != mRect.Size()) {
|
||||
InvalidateFrame();
|
||||
}
|
||||
|
||||
|
||||
FinishAndStoreOverflow(&aDesiredSize);
|
||||
|
||||
// Any absolutely-positioned children will get reflowed in
|
||||
@ -1374,7 +1374,7 @@ nsTableRowGroupFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)
|
||||
|
||||
if (!aOldStyleContext) //avoid this on init
|
||||
return;
|
||||
|
||||
|
||||
nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
|
||||
if (tableFrame->IsBorderCollapse() &&
|
||||
tableFrame->BCRecalcNeeded(aOldStyleContext, StyleContext())) {
|
||||
@ -1402,7 +1402,7 @@ nsTableRowGroupFrame::AppendFrames(ChildListID aListID,
|
||||
if (rowFrame) {
|
||||
NS_ASSERTION(NS_STYLE_DISPLAY_TABLE_ROW ==
|
||||
e.get()->StyleDisplay()->mDisplay,
|
||||
"wrong display type on rowframe");
|
||||
"wrong display type on rowframe");
|
||||
rows.AppendElement(rowFrame);
|
||||
}
|
||||
}
|
||||
@ -1444,7 +1444,7 @@ nsTableRowGroupFrame::InsertFrames(ChildListID aListID,
|
||||
if (rowFrame) {
|
||||
NS_ASSERTION(NS_STYLE_DISPLAY_TABLE_ROW ==
|
||||
e.get()->StyleDisplay()->mDisplay,
|
||||
"wrong display type on rowframe");
|
||||
"wrong display type on rowframe");
|
||||
rows.AppendElement(rowFrame);
|
||||
if (!gotFirstRow) {
|
||||
rowFrame->SetFirstInserted(true);
|
||||
@ -1512,7 +1512,7 @@ nsTableRowGroupFrame::GetUsedPadding() const
|
||||
return nsMargin(0,0,0,0);
|
||||
}
|
||||
|
||||
nscoord
|
||||
nscoord
|
||||
nsTableRowGroupFrame::GetHeightBasis(const nsHTMLReflowState& aReflowState)
|
||||
{
|
||||
nscoord result = 0;
|
||||
@ -1529,7 +1529,7 @@ nsTableRowGroupFrame::GetHeightBasis(const nsHTMLReflowState& aReflowState)
|
||||
if (parentRS && (tableFrame != parentRS->frame)) {
|
||||
parentRS = parentRS->parentReflowState;
|
||||
}
|
||||
if (parentRS && (tableFrame == parentRS->frame) &&
|
||||
if (parentRS && (tableFrame == parentRS->frame) &&
|
||||
(parentRS->ComputedHeight() > 0) && (parentRS->ComputedHeight() < NS_UNCONSTRAINEDSIZE)) {
|
||||
nscoord cellSpacing = tableFrame->GetRowSpacing(-1, tableFrame->GetRowCount());
|
||||
result = parentRS->ComputedHeight() - cellSpacing;
|
||||
@ -1547,7 +1547,7 @@ nsTableRowGroupFrame::IsSimpleRowFrame(nsTableFrame* aTableFrame,
|
||||
nsTableRowFrame *rowFrame = do_QueryFrame(aFrame);
|
||||
if (rowFrame) {
|
||||
int32_t rowIndex = rowFrame->GetRowIndex();
|
||||
|
||||
|
||||
// It's a simple row frame if there are no cells that span into or
|
||||
// across the row
|
||||
int32_t numEffCols = aTableFrame->GetEffectiveColCount();
|
||||
@ -1567,20 +1567,20 @@ nsTableRowGroupFrame::GetType() const
|
||||
}
|
||||
|
||||
/** find page break before the first row **/
|
||||
bool
|
||||
bool
|
||||
nsTableRowGroupFrame::HasInternalBreakBefore() const
|
||||
{
|
||||
nsIFrame* firstChild = mFrames.FirstChild();
|
||||
nsIFrame* firstChild = mFrames.FirstChild();
|
||||
if (!firstChild)
|
||||
return false;
|
||||
return firstChild->StyleDisplay()->mBreakBefore;
|
||||
}
|
||||
|
||||
/** find page break after the last row **/
|
||||
bool
|
||||
bool
|
||||
nsTableRowGroupFrame::HasInternalBreakAfter() const
|
||||
{
|
||||
nsIFrame* lastChild = mFrames.LastChild();
|
||||
nsIFrame* lastChild = mFrames.LastChild();
|
||||
if (!lastChild)
|
||||
return false;
|
||||
return lastChild->StyleDisplay()->mBreakAfter;
|
||||
@ -1603,7 +1603,7 @@ nsTableRowGroupFrame::GetFrameName(nsAString& aResult) const
|
||||
}
|
||||
#endif
|
||||
|
||||
nsMargin*
|
||||
nsMargin*
|
||||
nsTableRowGroupFrame::GetBCBorderWidth(nsMargin& aBorder)
|
||||
{
|
||||
aBorder.left = aBorder.right = aBorder.top = aBorder.bottom = 0;
|
||||
@ -1656,10 +1656,10 @@ nsTableRowGroupFrame::GetDirection()
|
||||
return (NS_STYLE_DIRECTION_RTL ==
|
||||
table->StyleVisibility()->mDirection);
|
||||
}
|
||||
|
||||
|
||||
NS_IMETHODIMP
|
||||
nsTableRowGroupFrame::GetLine(int32_t aLineNumber,
|
||||
nsIFrame** aFirstFrameOnLine,
|
||||
nsTableRowGroupFrame::GetLine(int32_t aLineNumber,
|
||||
nsIFrame** aFirstFrameOnLine,
|
||||
int32_t* aNumFramesOnLine,
|
||||
nsRect& aLineBounds)
|
||||
{
|
||||
@ -1672,11 +1672,11 @@ nsTableRowGroupFrame::GetLine(int32_t aLineNumber,
|
||||
*aFirstFrameOnLine = nullptr;
|
||||
*aNumFramesOnLine = 0;
|
||||
aLineBounds.SetRect(0, 0, 0, 0);
|
||||
|
||||
|
||||
if ((aLineNumber < 0) || (aLineNumber >= GetRowCount())) {
|
||||
return NS_OK;
|
||||
}
|
||||
aLineNumber += GetStartRowIndex();
|
||||
aLineNumber += GetStartRowIndex();
|
||||
|
||||
*aNumFramesOnLine = cellMap->GetNumCellsOriginatingInRow(aLineNumber);
|
||||
if (*aNumFramesOnLine == 0) {
|
||||
@ -1695,12 +1695,12 @@ nsTableRowGroupFrame::GetLine(int32_t aLineNumber,
|
||||
NS_ERROR("cellmap is lying");
|
||||
return NS_ERROR_FAILURE;
|
||||
}
|
||||
|
||||
|
||||
int32_t
|
||||
nsTableRowGroupFrame::FindLineContaining(nsIFrame* aFrame, int32_t aStartLine)
|
||||
{
|
||||
NS_ENSURE_TRUE(aFrame, -1);
|
||||
|
||||
|
||||
nsTableRowFrame *rowFrame = do_QueryFrame(aFrame);
|
||||
NS_ASSERTION(rowFrame, "RowGroup contains a frame that is not a row");
|
||||
|
||||
@ -1722,10 +1722,10 @@ nsTableRowGroupFrame::CheckLineOrder(int32_t aLine,
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
nsTableRowGroupFrame::FindFrameAt(int32_t aLineNumber,
|
||||
nsPoint aPos,
|
||||
nsTableRowGroupFrame::FindFrameAt(int32_t aLineNumber,
|
||||
nsPoint aPos,
|
||||
nsIFrame** aFrameFound,
|
||||
bool* aPosIsBeforeFirstFrame,
|
||||
bool* aPosIsBeforeFirstFrame,
|
||||
bool* aPosIsAfterLastFrame)
|
||||
{
|
||||
nsTableFrame* table = nsTableFrame::GetTableFrame(this);
|
||||
@ -1734,7 +1734,7 @@ nsTableRowGroupFrame::FindFrameAt(int32_t aLineNumber,
|
||||
WritingMode wm = table->GetWritingMode();
|
||||
nscoord cw = table->GetRect().width;
|
||||
LogicalPoint pos(wm, aPos, cw);
|
||||
|
||||
|
||||
*aFrameFound = nullptr;
|
||||
*aPosIsBeforeFirstFrame = true;
|
||||
*aPosIsAfterLastFrame = false;
|
||||
@ -1744,7 +1744,7 @@ nsTableRowGroupFrame::FindFrameAt(int32_t aLineNumber,
|
||||
if (numCells == 0) {
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
|
||||
nsIFrame* frame = nullptr;
|
||||
int32_t colCount = table->GetColCount();
|
||||
for (int32_t i = 0; i < colCount; i++) {
|
||||
@ -1757,7 +1757,7 @@ nsTableRowGroupFrame::FindFrameAt(int32_t aLineNumber,
|
||||
NS_ASSERTION(frame, "cellmap is lying");
|
||||
bool isRTL = (NS_STYLE_DIRECTION_RTL ==
|
||||
table->StyleVisibility()->mDirection);
|
||||
|
||||
|
||||
nsIFrame* closestFromStart = nullptr;
|
||||
nsIFrame* closestFromEnd = nullptr;
|
||||
int32_t n = numCells;
|
||||
@ -1811,7 +1811,7 @@ nsTableRowGroupFrame::FindFrameAt(int32_t aLineNumber,
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
nsTableRowGroupFrame::GetNextSiblingOnLine(nsIFrame*& aFrame,
|
||||
nsTableRowGroupFrame::GetNextSiblingOnLine(nsIFrame*& aFrame,
|
||||
int32_t aLineNumber)
|
||||
{
|
||||
NS_ENSURE_ARG_POINTER(aFrame);
|
||||
@ -1876,7 +1876,7 @@ nsTableRowGroupFrame::GetFirstRowContaining(nscoord aY, nscoord* aOverflowAbove)
|
||||
|
||||
// The cursor's frame list excludes frames with empty overflow-area, so
|
||||
// we don't need to check that here.
|
||||
|
||||
|
||||
// We use property->mOverflowBelow here instead of computing the frame's
|
||||
// true overflowArea.YMost(), because it is essential for the thresholds
|
||||
// to form a monotonically increasing sequence. Otherwise we would break
|
||||
@ -1921,15 +1921,15 @@ nsTableRowGroupFrame::FrameCursorData::AppendFrame(nsIFrame* aFrame)
|
||||
mOverflowBelow = std::max(mOverflowBelow, overflowBelow);
|
||||
return mFrames.AppendElement(aFrame) != nullptr;
|
||||
}
|
||||
|
||||
void
|
||||
|
||||
void
|
||||
nsTableRowGroupFrame::InvalidateFrame(uint32_t aDisplayItemKey)
|
||||
{
|
||||
nsIFrame::InvalidateFrame(aDisplayItemKey);
|
||||
GetParent()->InvalidateFrameWithRect(GetVisualOverflowRect() + GetPosition(), aDisplayItemKey);
|
||||
}
|
||||
|
||||
void
|
||||
void
|
||||
nsTableRowGroupFrame::InvalidateFrameWithRect(const nsRect& aRect, uint32_t aDisplayItemKey)
|
||||
{
|
||||
nsIFrame::InvalidateFrameWithRect(aRect, aDisplayItemKey);
|
||||
|
||||
@ -34,7 +34,7 @@ struct nsRowGroupReflowState {
|
||||
{
|
||||
availSize.width = reflowState.AvailableWidth();
|
||||
availSize.height = reflowState.AvailableHeight();
|
||||
y = 0;
|
||||
y = 0;
|
||||
}
|
||||
|
||||
~nsRowGroupReflowState() {}
|
||||
@ -43,11 +43,11 @@ struct nsRowGroupReflowState {
|
||||
#define MIN_ROWS_NEEDING_CURSOR 20
|
||||
|
||||
/**
|
||||
* nsTableRowGroupFrame is the frame that maps row groups
|
||||
* nsTableRowGroupFrame is the frame that maps row groups
|
||||
* (HTML tags THEAD, TFOOT, and TBODY). This class cannot be reused
|
||||
* outside of an nsTableFrame. It assumes that its parent is an nsTableFrame, and
|
||||
* outside of an nsTableFrame. It assumes that its parent is an nsTableFrame, and
|
||||
* its children are nsTableRowFrames.
|
||||
*
|
||||
*
|
||||
* @see nsTableFrame
|
||||
* @see nsTableRowFrame
|
||||
*/
|
||||
@ -73,7 +73,7 @@ public:
|
||||
|
||||
/** @see nsIFrame::DidSetStyleContext */
|
||||
virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext) override;
|
||||
|
||||
|
||||
virtual void AppendFrames(ChildListID aListID,
|
||||
nsFrameList& aFrameList) override;
|
||||
virtual void InsertFrames(ChildListID aListID,
|
||||
@ -94,7 +94,7 @@ public:
|
||||
* Rows are all set to the same width and stacked vertically.
|
||||
* <P> rows are not split unless absolutely necessary.
|
||||
*
|
||||
* @param aDesiredSize width set to width of rows, height set to
|
||||
* @param aDesiredSize width set to width of rows, height set to
|
||||
* sum of height of rows that fit in aMaxSize.height.
|
||||
*
|
||||
* @see nsIFrame::Reflow
|
||||
@ -127,7 +127,7 @@ public:
|
||||
*/
|
||||
int32_t GetStartRowIndex();
|
||||
|
||||
/** Adjust the row indices of all rows whose index is >= aRowIndex.
|
||||
/** Adjust the row indices of all rows whose index is >= aRowIndex.
|
||||
* @param aRowIndex - start adjusting with this index
|
||||
* @param aAdjustment - shift the row index by this amount
|
||||
*/
|
||||
@ -146,12 +146,12 @@ public:
|
||||
nsresult InitRepeatedFrame(nsPresContext* aPresContext,
|
||||
nsTableRowGroupFrame* aHeaderFooterFrame);
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Get the total height of all the row rects
|
||||
*/
|
||||
nscoord GetHeightBasis(const nsHTMLReflowState& aReflowState);
|
||||
|
||||
|
||||
nsMargin* GetBCBorderWidth(nsMargin& aBorder);
|
||||
|
||||
/**
|
||||
@ -183,13 +183,13 @@ public:
|
||||
public:
|
||||
virtual void DisposeLineIterator() override { }
|
||||
|
||||
// The table row is the equivalent to a line in block layout.
|
||||
// The table row is the equivalent to a line in block layout.
|
||||
// The nsILineIterator assumes that a line resides in a block, this role is
|
||||
// fullfilled by the row group. Rows in table are counted relative to the
|
||||
// table. The row index of row corresponds to the cellmap coordinates. The
|
||||
// line index with respect to a row group can be computed by substracting the
|
||||
// row index of the first row in the row group.
|
||||
|
||||
|
||||
/** Get the number of rows in a row group
|
||||
* @return the number of lines in a row group
|
||||
*/
|
||||
@ -199,11 +199,11 @@ public:
|
||||
* @return true if the table is rtl
|
||||
*/
|
||||
virtual bool GetDirection() override;
|
||||
|
||||
/** Return structural information about a line.
|
||||
|
||||
/** Return structural information about a line.
|
||||
* @param aLineNumber - the index of the row relative to the row group
|
||||
* If the line-number is invalid then
|
||||
* aFirstFrameOnLine will be nullptr and
|
||||
* aFirstFrameOnLine will be nullptr and
|
||||
* aNumFramesOnLine will be zero.
|
||||
* @param aFirstFrameOnLine - the first cell frame that originates in row
|
||||
* with a rowindex that matches a line number
|
||||
@ -215,7 +215,7 @@ public:
|
||||
nsIFrame** aFirstFrameOnLine,
|
||||
int32_t* aNumFramesOnLine,
|
||||
nsRect& aLineBounds) override;
|
||||
|
||||
|
||||
/** Given a frame that's a child of the rowgroup, find which line its on.
|
||||
* @param aFrame - frame, should be a row
|
||||
* @param aStartLine - minimal index to return
|
||||
@ -255,11 +255,11 @@ public:
|
||||
nsIFrame **aFirstVisual,
|
||||
nsIFrame **aLastVisual) override;
|
||||
|
||||
/** Find the next originating cell frame that originates in the row.
|
||||
/** Find the next originating cell frame that originates in the row.
|
||||
* @param aFrame - cell frame to start with, will return the next cell
|
||||
* originating in a row
|
||||
* @param aLineNumber - the index of the row relative to the table
|
||||
*/
|
||||
*/
|
||||
NS_IMETHOD GetNextSiblingOnLine(nsIFrame*& aFrame, int32_t aLineNumber) override;
|
||||
|
||||
// row cursor methods to speed up searching for the row(s)
|
||||
@ -277,13 +277,13 @@ public:
|
||||
uint32_t mCursorIndex;
|
||||
nscoord mOverflowAbove;
|
||||
nscoord mOverflowBelow;
|
||||
|
||||
|
||||
FrameCursorData()
|
||||
: mFrames(MIN_ROWS_NEEDING_CURSOR), mCursorIndex(0), mOverflowAbove(0),
|
||||
mOverflowBelow(0) {}
|
||||
|
||||
bool AppendFrame(nsIFrame* aFrame);
|
||||
|
||||
|
||||
void FinishBuildingCursor() {
|
||||
mFrames.Compact();
|
||||
}
|
||||
@ -328,10 +328,10 @@ public:
|
||||
protected:
|
||||
explicit nsTableRowGroupFrame(nsStyleContext* aContext);
|
||||
|
||||
void InitChildReflowState(nsPresContext& aPresContext,
|
||||
void InitChildReflowState(nsPresContext& aPresContext,
|
||||
bool aBorderCollapse,
|
||||
nsHTMLReflowState& aReflowState);
|
||||
|
||||
|
||||
virtual LogicalSides GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const override;
|
||||
|
||||
void PlaceChild(nsPresContext* aPresContext,
|
||||
@ -342,7 +342,7 @@ protected:
|
||||
const nsRect& aOriginalKidRect,
|
||||
const nsRect& aOriginalKidVisualOverflow);
|
||||
|
||||
void CalculateRowHeights(nsPresContext* aPresContext,
|
||||
void CalculateRowHeights(nsPresContext* aPresContext,
|
||||
nsHTMLReflowMetrics& aDesiredSize,
|
||||
const nsHTMLReflowState& aReflowState);
|
||||
|
||||
@ -350,7 +350,7 @@ protected:
|
||||
|
||||
void SlideChild(nsRowGroupReflowState& aReflowState,
|
||||
nsIFrame* aKidFrame);
|
||||
|
||||
|
||||
/**
|
||||
* Reflow the frames we've already created
|
||||
*
|
||||
@ -373,8 +373,8 @@ protected:
|
||||
void SplitSpanningCells(nsPresContext& aPresContext,
|
||||
const nsHTMLReflowState& aReflowState,
|
||||
nsTableFrame& aTableFrame,
|
||||
nsTableRowFrame& aFirstRow,
|
||||
nsTableRowFrame& aLastRow,
|
||||
nsTableRowFrame& aFirstRow,
|
||||
nsTableRowFrame& aLastRow,
|
||||
bool aFirstRowIsTopOfPage,
|
||||
nscoord aSpanningRowBottom,
|
||||
nsTableRowFrame*& aContRowFrame,
|
||||
@ -385,14 +385,14 @@ protected:
|
||||
nsIFrame& aRowFrame,
|
||||
nsIFrame** aContRowFrame);
|
||||
|
||||
bool IsSimpleRowFrame(nsTableFrame* aTableFrame,
|
||||
bool IsSimpleRowFrame(nsTableFrame* aTableFrame,
|
||||
nsIFrame* aFrame);
|
||||
|
||||
void GetNextRowSibling(nsIFrame** aRowFrame);
|
||||
|
||||
void UndoContinuedRow(nsPresContext* aPresContext,
|
||||
nsTableRowFrame* aRow);
|
||||
|
||||
|
||||
private:
|
||||
// border widths in pixels in the collapsing border model
|
||||
BCPixelSize mRightContBorderWidth;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user