/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "nsCOMPtr.h"

#include "nsTableRowGroupFrame.h"

#include "nsTableRowFrame.h"

#include "nsTableFrame.h"

#include "nsTableCellFrame.h"

#include "nsPresContext.h"

#include "nsStyleContext.h"

#include "nsStyleConsts.h"

#include "nsIContent.h"

#include "nsGkAtoms.h"

#include "nsIPresShell.h"

#include "nsCSSRendering.h"

#include "nsHTMLParts.h"

#include "nsCSSFrameConstructor.h"

#include "nsDisplayList.h"

#include "nsCellMap.h"  //table cell navigation

#include <algorithm>

using namespace mozilla;

using namespace mozilla::layout;

namespace mozilla {

struct TableRowGroupReflowInput {

  const ReflowInput& reflowInput;  // Our reflow state

  nsTableFrame* tableFrame;

  // The available size (computed from the parent)

  mozilla::LogicalSize availSize;

  // Running block-offset

  nscoord bCoord;

  TableRowGroupReflowInput(const ReflowInput& aReflowInput,

                           nsTableFrame* aTableFrame)

      : reflowInput(aReflowInput),

        tableFrame(aTableFrame),

        availSize(aReflowInput.GetWritingMode(), aReflowInput.AvailableISize(),

                  aReflowInput.AvailableBSize()),

        bCoord(0) {}

  ~TableRowGroupReflowInput() {}

};

}  // namespace mozilla

nsTableRowGroupFrame::nsTableRowGroupFrame(nsStyleContext* aContext)

    : nsContainerFrame(aContext, kClassID) {

  SetRepeatable(false);

}

nsTableRowGroupFrame::~nsTableRowGroupFrame() {}

void nsTableRowGroupFrame::DestroyFrom(nsIFrame* aDestructRoot,

                                       PostDestroyData& aPostDestroyData) {

  if (HasAnyStateBits(NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN)) {

    nsTableFrame::UnregisterPositionedTablePart(this, aDestructRoot);

  }

  nsContainerFrame::DestroyFrom(aDestructRoot, aPostDestroyData);

}

NS_QUERYFRAME_HEAD(nsTableRowGroupFrame)

NS_QUERYFRAME_ENTRY(nsTableRowGroupFrame)

NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)

int32_t nsTableRowGroupFrame::GetRowCount() {

#ifdef DEBUG

  for (nsFrameList::Enumerator e(mFrames); !e.AtEnd(); e.Next()) {

    NS_ASSERTION(

        e.get()->StyleDisplay()->mDisplay == mozilla::StyleDisplay::TableRow,

        "Unexpected display");

    NS_ASSERTION(e.get()->IsTableRowFrame(), "Unexpected frame type");

  }

#endif

  return mFrames.GetLength();

}

int32_t nsTableRowGroupFrame::GetStartRowIndex() {

  int32_t result = -1;

  if (mFrames.NotEmpty()) {

    NS_ASSERTION(mFrames.FirstChild()->IsTableRowFrame(),

                 "Unexpected frame type");

    result = static_cast<nsTableRowFrame*>(mFrames.FirstChild())->GetRowIndex();

  }

  // if the row group doesn't have any children, get it the hard way

  if (-1 == result) {

    return GetTableFrame()->GetStartRowIndex(this);

  }

  return result;

}

void nsTableRowGroupFrame::AdjustRowIndices(int32_t aRowIndex,

                                            int32_t anAdjustment) {

  for (nsIFrame* rowFrame : mFrames) {

    if (mozilla::StyleDisplay::TableRow == rowFrame->StyleDisplay()->mDisplay) {

      int32_t index = ((nsTableRowFrame*)rowFrame)->GetRowIndex();

      if (index >= aRowIndex)

        ((nsTableRowFrame*)rowFrame)->SetRowIndex(index + anAdjustment);

    }

  }

}

int32_t nsTableRowGroupFrame::GetAdjustmentForStoredIndex(

    int32_t aStoredIndex) {

  nsTableFrame* tableFrame = GetTableFrame();

  return tableFrame->GetAdjustmentForStoredIndex(aStoredIndex);

}

void nsTableRowGroupFrame::MarkRowsAsDeleted(nsTableRowFrame& aStartRowFrame,

                                             int32_t aNumRowsToDelete) {

  nsTableRowFrame* currentRowFrame = &aStartRowFrame;

  for (;;) {

    // XXXneerja - Instead of calling AddDeletedRowIndex() per row frame

    // it is possible to change AddDeleteRowIndex to instead take

    // <start row index> and <num of rows to mark for deletion> as arguments.

    // The problem that emerges here is mDeletedRowIndexRanges only stores

    // disjoint index ranges and since AddDeletedRowIndex() must operate on

    // the "stored" index, in some cases it is possible that the range

    // of indices to delete becomes overlapping EG: Deleting rows 9 - 11 and

    // then from the remaining rows deleting the *new* rows 7 to 20.

    // Handling these overlapping ranges is much more complicated to

    // implement and so I opted to add the deleted row index of one row at a

    // time and maintain the invariant that the range of deleted row indices

    // is always disjoint.

    currentRowFrame->AddDeletedRowIndex();

    if (--aNumRowsToDelete == 0) {

      break;

    }

    currentRowFrame = do_QueryFrame(currentRowFrame->GetNextSibling());

    if (!currentRowFrame) {

      MOZ_ASSERT_UNREACHABLE("expected another row frame");

      break;

    }

  }

}

void nsTableRowGroupFrame::AddDeletedRowIndex(int32_t aDeletedRowStoredIndex) {

  nsTableFrame* tableFrame = GetTableFrame();

  return tableFrame->AddDeletedRowIndex(aDeletedRowStoredIndex);

}

nsresult nsTableRowGroupFrame::InitRepeatedFrame(

    nsTableRowGroupFrame* aHeaderFooterFrame) {

  nsTableRowFrame* copyRowFrame = GetFirstRow();

  nsTableRowFrame* originalRowFrame = aHeaderFooterFrame->GetFirstRow();

  AddStateBits(NS_REPEATED_ROW_OR_ROWGROUP);

  while (copyRowFrame && originalRowFrame) {

    copyRowFrame->AddStateBits(NS_REPEATED_ROW_OR_ROWGROUP);

    int rowIndex = originalRowFrame->GetRowIndex();

    copyRowFrame->SetRowIndex(rowIndex);

    // For each table cell frame set its column index

    nsTableCellFrame* originalCellFrame = originalRowFrame->GetFirstCell();

    nsTableCellFrame* copyCellFrame = copyRowFrame->GetFirstCell();

    while (copyCellFrame && originalCellFrame) {

      NS_ASSERTION(

          originalCellFrame->GetContent() == copyCellFrame->GetContent(),

          "cell frames have different content");

      uint32_t colIndex = originalCellFrame->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();

  }

  return NS_OK;

}

// Handle the child-traversal part of DisplayGenericTablePart

static void DisplayRows(nsDisplayListBuilder* aBuilder, nsFrame* aFrame,

                        const nsDisplayListSet& aLists) {

  nscoord overflowAbove;

  nsTableRowGroupFrame* f = static_cast<nsTableRowGroupFrame*>(aFrame);

  // Don't try to use the row cursor if we have to descend into placeholders;

  // we might have rows containing placeholders, where the row's overflow

  // area doesn't intersect the dirty rect but we need to descend into the row

  // to see out of flows.

  // Note that we really want to check ShouldDescendIntoFrame for all

  // the rows in |f|, but that's exactly what we're trying to avoid, so we

  // approximate it by checking it for |f|: if it's true for any row

  // in |f| then it's true for |f| itself.

  nsIFrame* kid = aBuilder->ShouldDescendIntoFrame(f, true)

                      ? nullptr

                      : f->GetFirstRowContaining(aBuilder->GetVisibleRect().y,

                                                 &overflowAbove);

  if (kid) {

    // have a cursor, use it

    while (kid) {

      if (kid->GetRect().y - overflowAbove >=

              aBuilder->GetVisibleRect().YMost() &&

          kid->GetNormalRect().y - overflowAbove >=

              aBuilder->GetVisibleRect().YMost())

        break;

      f->BuildDisplayListForChild(aBuilder, kid, aLists);

      kid = kid->GetNextSibling();

    }

    return;

  }

  // No cursor. Traverse children the hard way and build a cursor while we're at

  // it

  nsTableRowGroupFrame::FrameCursorData* cursor = f->SetupRowCursor();

  kid = f->PrincipalChildList().FirstChild();

  while (kid) {

    f->BuildDisplayListForChild(aBuilder, kid, aLists);

    if (cursor) {

      if (!cursor->AppendFrame(kid)) {

        f->ClearRowCursor();

        return;

      }

    }

    kid = kid->GetNextSibling();

  }

  if (cursor) {

    cursor->FinishBuildingCursor();

  }

}

void nsTableRowGroupFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,

                                            const nsDisplayListSet& aLists) {

  nsTableFrame::DisplayGenericTablePart(aBuilder, this, aLists, DisplayRows);

}

nsIFrame::LogicalSides nsTableRowGroupFrame::GetLogicalSkipSides(

    const ReflowInput* aReflowInput) const {

  if (MOZ_UNLIKELY(StyleBorder()->mBoxDecorationBreak ==

                   StyleBoxDecorationBreak::Clone)) {

    return LogicalSides();

  }

  LogicalSides skip;

  if (nullptr != GetPrevInFlow()) {

    skip |= eLogicalSideBitsBStart;

  }

  if (nullptr != GetNextInFlow()) {

    skip |= eLogicalSideBitsBEnd;

  }

  return skip;

}

// Position and size aKidFrame and update our reflow state.

void nsTableRowGroupFrame::PlaceChild(

    nsPresContext* aPresContext, TableRowGroupReflowInput& aReflowInput,

    nsIFrame* aKidFrame, WritingMode aWM, const LogicalPoint& aKidPosition,

    const nsSize& aContainerSize, ReflowOutput& aDesiredSize,

    const nsRect& aOriginalKidRect, const nsRect& aOriginalKidVisualOverflow) {

  bool isFirstReflow = aKidFrame->HasAnyStateBits(NS_FRAME_FIRST_REFLOW);

  // Place and size the child

  FinishReflowChild(aKidFrame, aPresContext, aDesiredSize, nullptr, aWM,

                    aKidPosition, aContainerSize, 0);

  nsTableFrame* tableFrame = GetTableFrame();

  if (tableFrame->IsBorderCollapse()) {

    nsTableFrame::InvalidateTableFrame(

        aKidFrame, aOriginalKidRect, aOriginalKidVisualOverflow, isFirstReflow);

  }

  // Adjust the running block-offset

  aReflowInput.bCoord += aDesiredSize.BSize(aWM);

  // If our block-size is constrained then update the available bsize

  if (NS_UNCONSTRAINEDSIZE != aReflowInput.availSize.BSize(aWM)) {

    aReflowInput.availSize.BSize(aWM) -= aDesiredSize.BSize(aWM);

  }

}

void nsTableRowGroupFrame::InitChildReflowInput(nsPresContext& aPresContext,

                                                bool aBorderCollapse,

                                                ReflowInput& aReflowInput) {

  nsMargin collapseBorder;

  nsMargin padding(0, 0, 0, 0);

  nsMargin* pCollapseBorder = nullptr;

  if (aBorderCollapse) {

    nsTableRowFrame* rowFrame = do_QueryFrame(aReflowInput.mFrame);

    if (rowFrame) {

      WritingMode wm = GetWritingMode();

      LogicalMargin border = rowFrame->GetBCBorderWidth(wm);

      collapseBorder = border.GetPhysicalMargin(wm);

      pCollapseBorder = &collapseBorder;

    }

  }

  aReflowInput.Init(&aPresContext, nullptr, pCollapseBorder, &padding);

}

static void CacheRowBSizesForPrinting(nsPresContext* aPresContext,

                                      nsTableRowFrame* aFirstRow,

                                      WritingMode aWM) {

  for (nsTableRowFrame* row = aFirstRow; row; row = row->GetNextRow()) {

    if (!row->GetPrevInFlow()) {

      row->SetHasUnpaginatedBSize(true);

      row->SetUnpaginatedBSize(aPresContext, row->BSize(aWM));

    }

  }

}

void nsTableRowGroupFrame::ReflowChildren(

    nsPresContext* aPresContext, ReflowOutput& aDesiredSize,

    TableRowGroupReflowInput& aReflowInput, nsReflowStatus& aStatus,

    bool* aPageBreakBeforeEnd) {

  if (aPageBreakBeforeEnd) {

    *aPageBreakBeforeEnd = false;

  }

  WritingMode wm = aReflowInput.reflowInput.GetWritingMode();

  nsTableFrame* tableFrame = GetTableFrame();

  const bool borderCollapse = tableFrame->IsBorderCollapse();

  // XXXldb Should we really be checking IsPaginated(),

  // or should we *only* check available block-size?

  // (Think about multi-column layout!)

  bool isPaginated = aPresContext->IsPaginated() &&

                     NS_UNCONSTRAINEDSIZE != aReflowInput.availSize.BSize(wm);

  bool haveRow = false;

  bool reflowAllKids = aReflowInput.reflowInput.ShouldReflowAllKids() ||

                       tableFrame->IsGeometryDirty();

  // in vertical-rl mode, we always need the row bsizes in order to

  // get the necessary containerSize for placing our kids

  bool needToCalcRowBSizes = reflowAllKids || wm.IsVerticalRL();

  nsSize containerSize =

      aReflowInput.reflowInput.ComputedSizeAsContainerIfConstrained();

  nsIFrame* prevKidFrame = nullptr;

  for (nsIFrame *kidFrame = mFrames.FirstChild(); kidFrame;

       prevKidFrame = kidFrame, kidFrame = kidFrame->GetNextSibling()) {

    nsTableRowFrame* rowFrame = do_QueryFrame(kidFrame);

    if (!rowFrame) {

      // XXXldb nsCSSFrameConstructor needs to enforce this!

      NS_NOTREACHED("yikes, a non-row child");

      continue;

    }

    nscoord cellSpacingB = tableFrame->GetRowSpacing(rowFrame->GetRowIndex());

    haveRow = true;

    // Reflow the row frame

    if (reflowAllKids || NS_SUBTREE_DIRTY(kidFrame) ||

        (aReflowInput.reflowInput.mFlags.mSpecialBSizeReflow &&

         (isPaginated ||

          kidFrame->HasAnyStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE)))) {

      LogicalRect oldKidRect = kidFrame->GetLogicalRect(wm, containerSize);

      nsRect oldKidVisualOverflow = kidFrame->GetVisualOverflowRect();

      // XXXldb We used to only pass aDesiredSize.mFlags through for the

      // incremental reflow codepath.

      ReflowOutput desiredSize(aReflowInput.reflowInput, aDesiredSize.mFlags);

      desiredSize.ClearSize();

      // Reflow the child into the available space, giving it as much bsize as

      // it wants. We'll deal with splitting later after we've computed the row

      // bsizes, taking into account cells with row spans...

      LogicalSize kidAvailSize = aReflowInput.availSize;

      kidAvailSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;

      ReflowInput kidReflowInput(aPresContext, aReflowInput.reflowInput,

                                 kidFrame, kidAvailSize, nullptr,

                                 ReflowInput::CALLER_WILL_INIT);

      InitChildReflowInput(*aPresContext, borderCollapse, kidReflowInput);

      // This can indicate that columns were resized.

      if (aReflowInput.reflowInput.IsIResize()) {

        kidReflowInput.SetIResize(true);

      }

      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

      if (prevKidFrame && prevKidFrame->GetNormalRect().YMost() > 0) {

        kidReflowInput.mFlags.mIsTopOfPage = false;

      }

      LogicalPoint kidPosition(wm, 0, aReflowInput.bCoord);

      ReflowChild(kidFrame, aPresContext, desiredSize, kidReflowInput, wm,

                  kidPosition, containerSize, 0, aStatus);

      kidReflowInput.ApplyRelativePositioning(&kidPosition, containerSize);

      // Place the child

      PlaceChild(aPresContext, aReflowInput, kidFrame, wm, kidPosition,

                 containerSize, desiredSize,

                 oldKidRect.GetPhysicalRect(wm, containerSize),

                 oldKidVisualOverflow);

      aReflowInput.bCoord += cellSpacingB;

      if (!reflowAllKids) {

        if (IsSimpleRowFrame(aReflowInput.tableFrame, rowFrame)) {

          // Inform the row of its new bsize.

          rowFrame->DidResize();

          // the overflow area may have changed inflate the overflow area

          const nsStylePosition* stylePos = StylePosition();

          nsStyleUnit unit = stylePos->BSize(wm).GetUnit();

          if (aReflowInput.tableFrame->IsAutoBSize(wm) &&

              unit != eStyleUnit_Coord) {

            // Because other cells in the row may need to be aligned

            // differently, repaint the entire row

            InvalidateFrame();

          } else if (oldKidRect.BSize(wm) != desiredSize.BSize(wm)) {

            needToCalcRowBSizes = true;

          }

        } else {

          needToCalcRowBSizes = true;

        }

      }

      if (isPaginated && aPageBreakBeforeEnd && !*aPageBreakBeforeEnd) {

        nsTableRowFrame* nextRow = rowFrame->GetNextRow();

        if (nextRow) {

          *aPageBreakBeforeEnd =

              nsTableFrame::PageBreakAfter(kidFrame, nextRow);

        }

      }

    } else {

      SlideChild(aReflowInput, kidFrame);

      // Adjust the running b-offset so we know where the next row should be

      // placed

      nscoord bSize = kidFrame->BSize(wm) + cellSpacingB;

      aReflowInput.bCoord += bSize;

      if (NS_UNCONSTRAINEDSIZE != aReflowInput.availSize.BSize(wm)) {

        aReflowInput.availSize.BSize(wm) -= bSize;

      }

    }

    ConsiderChildOverflow(aDesiredSize.mOverflowAreas, kidFrame);

  }

  if (haveRow) {

    aReflowInput.bCoord -=

        tableFrame->GetRowSpacing(GetStartRowIndex() + GetRowCount());

  }

  // Return our desired rect

  aDesiredSize.ISize(wm) = aReflowInput.reflowInput.AvailableISize();

  aDesiredSize.BSize(wm) = aReflowInput.bCoord;

  if (aReflowInput.reflowInput.mFlags.mSpecialBSizeReflow) {

    DidResizeRows(aDesiredSize);

    if (isPaginated) {

      CacheRowBSizesForPrinting(aPresContext, GetFirstRow(), wm);

    }

  } else if (needToCalcRowBSizes) {

    CalculateRowBSizes(aPresContext, aDesiredSize, aReflowInput.reflowInput);

    if (!reflowAllKids) {

      InvalidateFrame();

    }

  }

}

nsTableRowFrame* nsTableRowGroupFrame::GetFirstRow() {

  for (nsIFrame* childFrame : mFrames) {

    nsTableRowFrame* rowFrame = do_QueryFrame(childFrame);

    if (rowFrame) {

      return rowFrame;

    }

  }

  return nullptr;

}

nsTableRowFrame* nsTableRowGroupFrame::GetLastRow() {

  for (auto iter = mFrames.rbegin(), end = mFrames.rend(); iter != end;

       ++iter) {

    nsTableRowFrame* rowFrame = do_QueryFrame(*iter);

    if (rowFrame) {

      return rowFrame;

    }

  }

  return nullptr;

}

struct RowInfo {

  RowInfo() { bSize = pctBSize = hasStyleBSize = hasPctBSize = isSpecial = 0; }

  unsigned bSize;          // content bsize or fixed bsize, excluding pct bsize

  unsigned pctBSize : 29;  // pct bsize

  unsigned hasStyleBSize : 1;

  unsigned hasPctBSize : 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 bsize on the row

};

static void UpdateBSizes(RowInfo& aRowInfo, nscoord aAdditionalBSize,

                         nscoord& aTotal, nscoord& aUnconstrainedTotal) {

  aRowInfo.bSize += aAdditionalBSize;

  aTotal += aAdditionalBSize;

  if (!aRowInfo.hasStyleBSize) {

    aUnconstrainedTotal += aAdditionalBSize;

  }

}

void nsTableRowGroupFrame::DidResizeRows(ReflowOutput& aDesiredSize) {

  // Update the cells spanning rows with their new bsizes.

  // This is the place where all of the cells in the row get set to the bsize

  // of the row.

  // Reset the overflow area.

  aDesiredSize.mOverflowAreas.Clear();

  for (nsTableRowFrame* rowFrame = GetFirstRow(); rowFrame;

       rowFrame = rowFrame->GetNextRow()) {

    rowFrame->DidResize();

    ConsiderChildOverflow(aDesiredSize.mOverflowAreas, rowFrame);

  }

}

// This calculates the bsize of all the rows and takes into account

// style bsize on the row group, style bsizes on rows and cells, style bsizes on

// rowspans. Actual row bsizes will be adjusted later if the table has a style

// bsize. Even if rows don't change bsize, this method must be called to set the

// bsizes of each cell in the row to the bsize of its row.

void nsTableRowGroupFrame::CalculateRowBSizes(nsPresContext* aPresContext,

                                              ReflowOutput& aDesiredSize,

                                              const ReflowInput& aReflowInput) {

  nsTableFrame* tableFrame = GetTableFrame();

  const bool isPaginated = aPresContext->IsPaginated();

  int32_t numEffCols = tableFrame->GetEffectiveColCount();

  int32_t startRowIndex = GetStartRowIndex();

  // find the row corresponding to the row index we just found

  nsTableRowFrame* startRowFrame = GetFirstRow();

  if (!startRowFrame) {

    return;

  }

  // The current row group block-size is the block-origin of the 1st row

  // we are about to calculate a block-size for.

  WritingMode wm = aReflowInput.GetWritingMode();

  nsSize containerSize;  // actual value is unimportant as we're initially

                         // computing sizes, not physical positions

  nscoord startRowGroupBSize =

      startRowFrame->GetLogicalNormalPosition(wm, containerSize).B(wm);

  int32_t numRows =

      GetRowCount() - (startRowFrame->GetRowIndex() - GetStartRowIndex());

  // Collect the current bsize of each row.

  if (numRows <= 0) return;

  AutoTArray<RowInfo, 32> rowInfo;

  if (!rowInfo.AppendElements(numRows)) {

    return;

  }

  bool hasRowSpanningCell = false;

  nscoord bSizeOfRows = 0;

  nscoord bSizeOfUnStyledRows = 0;

  // Get the bsize of each row without considering rowspans. This will be the

  // max of the largest desired bsize of each cell, the largest style bsize of

  // each cell, the style bsize of the row.

  nscoord pctBSizeBasis = GetBSizeBasis(aReflowInput);

  int32_t

      rowIndex;  // the index in rowInfo, not among the rows in the row group

  nsTableRowFrame* rowFrame;

  for (rowFrame = startRowFrame, rowIndex = 0; rowFrame;

       rowFrame = rowFrame->GetNextRow(), rowIndex++) {

    nscoord nonPctBSize = rowFrame->GetContentBSize();

    if (isPaginated) {

      nonPctBSize = std::max(nonPctBSize, rowFrame->BSize(wm));

    }

    if (!rowFrame->GetPrevInFlow()) {

      if (rowFrame->HasPctBSize()) {

        rowInfo[rowIndex].hasPctBSize = true;

        rowInfo[rowIndex].pctBSize = rowFrame->GetInitialBSize(pctBSizeBasis);

      }

      rowInfo[rowIndex].hasStyleBSize = rowFrame->HasStyleBSize();

      nonPctBSize = std::max(nonPctBSize, rowFrame->GetFixedBSize());

    }

    UpdateBSizes(rowInfo[rowIndex], nonPctBSize, bSizeOfRows,

                 bSizeOfUnStyledRows);

    if (!rowInfo[rowIndex].hasStyleBSize) {

      if (isPaginated ||

          tableFrame->HasMoreThanOneCell(rowIndex + startRowIndex)) {

        rowInfo[rowIndex].isSpecial = true;

        // iteratate the row's cell frames to see if any do not have rowspan > 1

        nsTableCellFrame* cellFrame = rowFrame->GetFirstCell();

        while (cellFrame) {

          int32_t rowSpan = tableFrame->GetEffectiveRowSpan(

              rowIndex + startRowIndex, *cellFrame);

          if (1 == rowSpan) {

            rowInfo[rowIndex].isSpecial = false;

            break;

          }

          cellFrame = cellFrame->GetNextCell();

        }

      }

    }

    // See if a cell spans into the row. If so we'll have to do the next step

    if (!hasRowSpanningCell) {

      if (tableFrame->RowIsSpannedInto(rowIndex + startRowIndex, numEffCols)) {

        hasRowSpanningCell = true;

      }

    }

  }

  if (hasRowSpanningCell) {

    // Get the bsize 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 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

        while (cellFrame) {

          nscoord cellSpacingB =

              tableFrame->GetRowSpacing(startRowIndex + rowIndex);

          int32_t rowSpan = tableFrame->GetEffectiveRowSpan(

              rowIndex + startRowIndex, *cellFrame);

          if ((rowIndex + rowSpan) > numRows) {

            // there might be rows pushed already to the nextInFlow

            rowSpan = numRows - rowIndex;

          }

          if (rowSpan > 1) {  // a cell with rowspan > 1, determine the bsize of

                              // the rows it spans

            nscoord bsizeOfRowsSpanned = 0;

            nscoord bsizeOfUnStyledRowsSpanned = 0;

            nscoord numSpecialRowsSpanned = 0;

            nscoord cellSpacingTotal = 0;

            int32_t spanX;

            for (spanX = 0; spanX < rowSpan; spanX++) {

              bsizeOfRowsSpanned += rowInfo[rowIndex + spanX].bSize;

              if (!rowInfo[rowIndex + spanX].hasStyleBSize) {

                bsizeOfUnStyledRowsSpanned += rowInfo[rowIndex + spanX].bSize;

              }

              if (0 != spanX) {

                cellSpacingTotal += cellSpacingB;

              }

              if (rowInfo[rowIndex + spanX].isSpecial) {

                numSpecialRowsSpanned++;

              }

            }

            nscoord bsizeOfAreaSpanned = bsizeOfRowsSpanned + cellSpacingTotal;

            // get the bsize of the cell

            LogicalSize cellFrameSize = cellFrame->GetLogicalSize(wm);

            LogicalSize cellDesSize = cellFrame->GetDesiredSize();

            rowFrame->CalculateCellActualBSize(cellFrame, cellDesSize.BSize(wm),

                                               wm);

            cellFrameSize.BSize(wm) = cellDesSize.BSize(wm);

            if (cellFrame->HasVerticalAlignBaseline()) {

              // to ensure that a spanning cell with a long descender doesn't

              // collide with the next row, we need to take into account the

              // shift that will be done to align the cell on the baseline of

              // the row.

              cellFrameSize.BSize(wm) +=

                  rowFrame->GetMaxCellAscent() - cellFrame->GetCellBaseline();

            }

            if (bsizeOfAreaSpanned < cellFrameSize.BSize(wm)) {

              // the cell's bsize is larger than the available space of the rows

              // it spans so distribute the excess bsize to the rows affected

              nscoord extra = cellFrameSize.BSize(wm) - bsizeOfAreaSpanned;

              nscoord extraUsed = 0;

              if (0 == numSpecialRowsSpanned) {

                // NS_ASSERTION(bsizeOfRowsSpanned > 0, "invalid row span

                // situation");

                bool haveUnStyledRowsSpanned = (bsizeOfUnStyledRowsSpanned > 0);

                nscoord divisor = (haveUnStyledRowsSpanned)

                                      ? bsizeOfUnStyledRowsSpanned

                                      : bsizeOfRowsSpanned;

                if (divisor > 0) {

                  for (spanX = rowSpan - 1; spanX >= 0; spanX--) {

                    if (!haveUnStyledRowsSpanned ||

                        !rowInfo[rowIndex + spanX].hasStyleBSize) {

                      // The amount of additional space each row gets is

                      // proportional to its bsize

                      float percent = ((float)rowInfo[rowIndex + spanX].bSize) /

                                      ((float)divisor);

                      // give rows their percentage, except for the first row

                      // which gets the remainder

                      nscoord extraForRow =

                          (0 == spanX)

                              ? extra - extraUsed

                              : NSToCoordRound(((float)(extra)) * percent);

                      extraForRow = std::min(extraForRow, extra - extraUsed);

                      // update the row bsize

                      UpdateBSizes(rowInfo[rowIndex + spanX], extraForRow,

                                   bSizeOfRows, bSizeOfUnStyledRows);

                      extraUsed += extraForRow;

                      if (extraUsed >= extra) {

                        NS_ASSERTION((extraUsed == extra),

                                     "invalid row bsize calculation");

                        break;

                      }

                    }

                  }

                } else {

                  // put everything in the last row

                  UpdateBSizes(rowInfo[rowIndex + rowSpan - 1], extra,

                               bSizeOfRows, bSizeOfUnStyledRows);

                }

              } else {

                // give the extra to the special rows

                nscoord numSpecialRowsAllocated = 0;

                for (spanX = rowSpan - 1; spanX >= 0; spanX--) {

                  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

                            : NSToCoordRound(((float)(extra)) * percent);

                    extraForRow = std::min(extraForRow, extra - extraUsed);

                    // update the row bsize

                    UpdateBSizes(rowInfo[rowIndex + spanX], extraForRow,

                                 bSizeOfRows, bSizeOfUnStyledRows);

                    extraUsed += extraForRow;

                    if (extraUsed >= extra) {

                      NS_ASSERTION((extraUsed == extra),

                                   "invalid row bsize calculation");

                      break;

                    }

                  }

                }

              }

            }

          }  // if (rowSpan > 1)

          cellFrame = cellFrame->GetNextCell();

        }  // while (cellFrame)

      }    // if (tableFrame->RowHasSpanningCells(startRowIndex + rowIndex) {

    }      // while (rowFrame)

  }

  // pct bsize rows have already got their content bsizes.

  // Give them their pct bsizes up to pctBSizeBasis

  nscoord extra = pctBSizeBasis - bSizeOfRows;

  for (rowFrame = startRowFrame, rowIndex = 0; rowFrame && (extra > 0);

       rowFrame = rowFrame->GetNextRow(), rowIndex++) {

    RowInfo& rInfo = rowInfo[rowIndex];

    if (rInfo.hasPctBSize) {

      nscoord rowExtra =

          (rInfo.pctBSize > rInfo.bSize) ? rInfo.pctBSize - rInfo.bSize : 0;

      rowExtra = std::min(rowExtra, extra);

      UpdateBSizes(rInfo, rowExtra, bSizeOfRows, bSizeOfUnStyledRows);

      extra -= rowExtra;

    }

  }

  bool styleBSizeAllocation = false;

  nscoord rowGroupBSize = startRowGroupBSize + bSizeOfRows +

                          tableFrame->GetRowSpacing(0, numRows - 1);

  // if we have a style bsize, allocate the extra bsize to unconstrained rows

  if ((aReflowInput.ComputedBSize() > rowGroupBSize) &&

      (NS_UNCONSTRAINEDSIZE != aReflowInput.ComputedBSize())) {

    nscoord extraComputedBSize = aReflowInput.ComputedBSize() - rowGroupBSize;

    nscoord extraUsed = 0;

    bool haveUnStyledRows = (bSizeOfUnStyledRows > 0);

    nscoord divisor = (haveUnStyledRows) ? bSizeOfUnStyledRows : bSizeOfRows;

    if (divisor > 0) {

      styleBSizeAllocation = true;

      for (rowIndex = 0; rowIndex < numRows; rowIndex++) {

        if (!haveUnStyledRows || !rowInfo[rowIndex].hasStyleBSize) {

          // The amount of additional space each row gets is based on the

          // percentage of space it occupies

          float percent = ((float)rowInfo[rowIndex].bSize) / ((float)divisor);

          // give rows their percentage, except for the last row which gets the

          // remainder

          nscoord extraForRow =

              (numRows - 1 == rowIndex)

                  ? extraComputedBSize - extraUsed

                  : NSToCoordRound(((float)extraComputedBSize) * percent);

          extraForRow = std::min(extraForRow, extraComputedBSize - extraUsed);

          // update the row bsize

          UpdateBSizes(rowInfo[rowIndex], extraForRow, bSizeOfRows,

                       bSizeOfUnStyledRows);

          extraUsed += extraForRow;

          if (extraUsed >= extraComputedBSize) {

            NS_ASSERTION((extraUsed == extraComputedBSize),

                         "invalid row bsize calculation");

            break;

          }

        }

      }

    }

    rowGroupBSize = aReflowInput.ComputedBSize();

  }

  if (wm.IsVertical()) {

    // we need the correct containerSize below for block positioning in

    // vertical-rl writing mode

    containerSize.width = rowGroupBSize;

  }

  nscoord bOrigin = startRowGroupBSize;

  // update the rows with their (potentially) new bsizes

  for (rowFrame = startRowFrame, rowIndex = 0; rowFrame;

       rowFrame = rowFrame->GetNextRow(), rowIndex++) {

    nsRect rowBounds = rowFrame->GetRect();

    LogicalSize rowBoundsSize(wm, rowBounds.Size());

    nsRect rowVisualOverflow = rowFrame->GetVisualOverflowRect();

    nscoord deltaB =

        bOrigin - rowFrame->GetLogicalNormalPosition(wm, containerSize).B(wm);

    nscoord rowBSize =

        (rowInfo[rowIndex].bSize > 0) ? rowInfo[rowIndex].bSize : 0;

    if (deltaB != 0 || (rowBSize != rowBoundsSize.BSize(wm))) {

      // Resize/move the row to its final size and position

      if (deltaB != 0) {

        rowFrame->InvalidateFrameSubtree();

      }

      rowFrame->MovePositionBy(wm, LogicalPoint(wm, 0, deltaB));

      rowFrame->SetSize(LogicalSize(wm, rowBoundsSize.ISize(wm), rowBSize));

      nsTableFrame::InvalidateTableFrame(rowFrame, rowBounds, rowVisualOverflow,

                                         false);

      if (deltaB != 0) {

        nsTableFrame::RePositionViews(rowFrame);

        // XXXbz we don't need to update our overflow area?

      }

    }

    bOrigin += rowBSize + tableFrame->GetRowSpacing(startRowIndex + rowIndex);

  }

  if (isPaginated && styleBSizeAllocation) {

    // since the row group has a style bsize, cache the row bsizes,

    // so next in flows can honor them

    CacheRowBSizesForPrinting(aPresContext, GetFirstRow(), wm);

  }

  DidResizeRows(aDesiredSize);

  aDesiredSize.BSize(wm) = rowGroupBSize;  // Adjust our desired size

}

nscoord nsTableRowGroupFrame::CollapseRowGroupIfNecessary(nscoord aBTotalOffset,

                                                          nscoord aISize,

                                                          WritingMode aWM) {

  nsTableFrame* tableFrame = GetTableFrame();

  nsSize containerSize = tableFrame->GetSize();

  const nsStyleVisibility* groupVis = StyleVisibility();

  bool collapseGroup = (NS_STYLE_VISIBILITY_COLLAPSE == groupVis->mVisible);

  if (collapseGroup) {

    tableFrame->SetNeedToCollapse(true);

  }

  nsOverflowAreas overflow;

  nsTableRowFrame* rowFrame = GetFirstRow();

  bool didCollapse = false;

  nscoord bGroupOffset = 0;

  while (rowFrame) {

    bGroupOffset += rowFrame->CollapseRowIfNecessary(

        bGroupOffset, aISize, collapseGroup, didCollapse);

    ConsiderChildOverflow(overflow, rowFrame);

    rowFrame = rowFrame->GetNextRow();

  }

  LogicalRect groupRect = GetLogicalRect(aWM, containerSize);

  nsRect oldGroupRect = GetRect();

  nsRect oldGroupVisualOverflow = GetVisualOverflowRect();