mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-28 11:28:38 +00:00
7392 lines
267 KiB
C++
7392 lines
267 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=2 sw=2 et tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "mozilla/Likely.h"
|
|
#include "mozilla/MathAlgorithms.h"
|
|
|
|
#include "nsCOMPtr.h"
|
|
#include "nsTableFrame.h"
|
|
#include "nsRenderingContext.h"
|
|
#include "nsStyleContext.h"
|
|
#include "nsStyleConsts.h"
|
|
#include "nsIContent.h"
|
|
#include "nsCellMap.h"
|
|
#include "nsTableCellFrame.h"
|
|
#include "nsHTMLParts.h"
|
|
#include "nsTableColFrame.h"
|
|
#include "nsTableColGroupFrame.h"
|
|
#include "nsTableRowFrame.h"
|
|
#include "nsTableRowGroupFrame.h"
|
|
#include "nsTableOuterFrame.h"
|
|
#include "nsTablePainter.h"
|
|
|
|
#include "BasicTableLayoutStrategy.h"
|
|
#include "FixedTableLayoutStrategy.h"
|
|
|
|
#include "nsPresContext.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsCSSRendering.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsCSSAnonBoxes.h"
|
|
#include "nsIPresShell.h"
|
|
#include "nsIDOMElement.h"
|
|
#include "nsIDOMHTMLElement.h"
|
|
#include "nsIScriptError.h"
|
|
#include "nsFrameManager.h"
|
|
#include "nsError.h"
|
|
#include "nsAutoPtr.h"
|
|
#include "nsCSSFrameConstructor.h"
|
|
#include "nsStyleSet.h"
|
|
#include "nsDisplayList.h"
|
|
#include "nsIScrollableFrame.h"
|
|
#include "nsCSSProps.h"
|
|
#include "RestyleTracker.h"
|
|
#include <algorithm>
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::layout;
|
|
|
|
/********************************************************************************
|
|
** nsTableReflowState **
|
|
********************************************************************************/
|
|
|
|
struct nsTableReflowState {
|
|
|
|
// the real reflow state
|
|
const nsHTMLReflowState& reflowState;
|
|
|
|
// The table's available size
|
|
nsSize availSize;
|
|
|
|
// Stationary x-offset
|
|
nscoord x;
|
|
|
|
// Running y-offset
|
|
nscoord y;
|
|
|
|
nsTableReflowState(nsPresContext& aPresContext,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsTableFrame& aTableFrame,
|
|
nscoord aAvailWidth,
|
|
nscoord aAvailHeight)
|
|
: reflowState(aReflowState)
|
|
{
|
|
Init(aPresContext, aTableFrame, aAvailWidth, aAvailHeight);
|
|
}
|
|
|
|
void Init(nsPresContext& aPresContext,
|
|
nsTableFrame& aTableFrame,
|
|
nscoord aAvailWidth,
|
|
nscoord aAvailHeight)
|
|
{
|
|
nsTableFrame* table = static_cast<nsTableFrame*>(aTableFrame.FirstInFlow());
|
|
nsMargin borderPadding = table->GetChildAreaOffset(&reflowState);
|
|
nscoord cellSpacingX = table->GetCellSpacingX();
|
|
|
|
x = borderPadding.left + cellSpacingX;
|
|
y = borderPadding.top; //cellspacing added during reflow
|
|
|
|
availSize.width = aAvailWidth;
|
|
if (NS_UNCONSTRAINEDSIZE != availSize.width) {
|
|
availSize.width -= borderPadding.left + borderPadding.right
|
|
+ (2 * cellSpacingX);
|
|
availSize.width = std::max(0, availSize.width);
|
|
}
|
|
|
|
availSize.height = aAvailHeight;
|
|
if (NS_UNCONSTRAINEDSIZE != availSize.height) {
|
|
availSize.height -= borderPadding.top + borderPadding.bottom
|
|
+ (2 * table->GetCellSpacingY());
|
|
availSize.height = std::max(0, availSize.height);
|
|
}
|
|
}
|
|
|
|
nsTableReflowState(nsPresContext& aPresContext,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsTableFrame& aTableFrame)
|
|
: reflowState(aReflowState)
|
|
{
|
|
Init(aPresContext, aTableFrame, aReflowState.AvailableWidth(), aReflowState.AvailableHeight());
|
|
}
|
|
|
|
};
|
|
|
|
/********************************************************************************
|
|
** nsTableFrame **
|
|
********************************************************************************/
|
|
|
|
struct BCPropertyData
|
|
{
|
|
BCPropertyData() : mTopBorderWidth(0), mRightBorderWidth(0),
|
|
mBottomBorderWidth(0), mLeftBorderWidth(0),
|
|
mLeftCellBorderWidth(0), mRightCellBorderWidth(0) {}
|
|
nsIntRect mDamageArea;
|
|
BCPixelSize mTopBorderWidth;
|
|
BCPixelSize mRightBorderWidth;
|
|
BCPixelSize mBottomBorderWidth;
|
|
BCPixelSize mLeftBorderWidth;
|
|
BCPixelSize mLeftCellBorderWidth;
|
|
BCPixelSize mRightCellBorderWidth;
|
|
};
|
|
|
|
nsIFrame*
|
|
nsTableFrame::GetParentStyleContextFrame() const
|
|
{
|
|
// Since our parent, the table outer frame, returned this frame, we
|
|
// must return whatever our parent would normally have returned.
|
|
|
|
NS_PRECONDITION(mParent, "table constructed without outer table");
|
|
if (!mContent->GetParent() && !StyleContext()->GetPseudo()) {
|
|
// We're the root. We have no style context parent.
|
|
return nullptr;
|
|
}
|
|
|
|
return static_cast<nsFrame*>(GetParent())->DoGetParentStyleContextFrame();
|
|
}
|
|
|
|
|
|
nsIAtom*
|
|
nsTableFrame::GetType() const
|
|
{
|
|
return nsGkAtoms::tableFrame;
|
|
}
|
|
|
|
|
|
nsTableFrame::nsTableFrame(nsStyleContext* aContext)
|
|
: nsContainerFrame(aContext),
|
|
mCellMap(nullptr),
|
|
mTableLayoutStrategy(nullptr)
|
|
{
|
|
memset(&mBits, 0, sizeof(mBits));
|
|
}
|
|
|
|
void
|
|
nsTableFrame::Init(nsIContent* aContent,
|
|
nsIFrame* aParent,
|
|
nsIFrame* aPrevInFlow)
|
|
{
|
|
NS_PRECONDITION(!mCellMap, "Init called twice");
|
|
NS_PRECONDITION(!aPrevInFlow ||
|
|
aPrevInFlow->GetType() == nsGkAtoms::tableFrame,
|
|
"prev-in-flow must be of same type");
|
|
|
|
// Let the base class do its processing
|
|
nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
|
|
|
|
// see if border collapse is on, if so set it
|
|
const nsStyleTableBorder* tableStyle = StyleTableBorder();
|
|
bool borderCollapse = (NS_STYLE_BORDER_COLLAPSE == tableStyle->mBorderCollapse);
|
|
SetBorderCollapse(borderCollapse);
|
|
|
|
// Create the cell map if this frame is the first-in-flow.
|
|
if (!aPrevInFlow) {
|
|
mCellMap = new nsTableCellMap(*this, borderCollapse);
|
|
}
|
|
|
|
if (aPrevInFlow) {
|
|
// set my width, because all frames in a table flow are the same width and
|
|
// code in nsTableOuterFrame depends on this being set
|
|
mRect.width = aPrevInFlow->GetSize().width;
|
|
}
|
|
else {
|
|
NS_ASSERTION(!mTableLayoutStrategy, "strategy was created before Init was called");
|
|
// create the strategy
|
|
if (IsAutoLayout())
|
|
mTableLayoutStrategy = new BasicTableLayoutStrategy(this);
|
|
else
|
|
mTableLayoutStrategy = new FixedTableLayoutStrategy(this);
|
|
}
|
|
}
|
|
|
|
nsTableFrame::~nsTableFrame()
|
|
{
|
|
delete mCellMap;
|
|
delete mTableLayoutStrategy;
|
|
}
|
|
|
|
void
|
|
nsTableFrame::DestroyFrom(nsIFrame* aDestructRoot)
|
|
{
|
|
mColGroups.DestroyFramesFrom(aDestructRoot);
|
|
nsContainerFrame::DestroyFrom(aDestructRoot);
|
|
}
|
|
|
|
// Make sure any views are positioned properly
|
|
void
|
|
nsTableFrame::RePositionViews(nsIFrame* aFrame)
|
|
{
|
|
nsContainerFrame::PositionFrameView(aFrame);
|
|
nsContainerFrame::PositionChildViews(aFrame);
|
|
}
|
|
|
|
static bool
|
|
IsRepeatedFrame(nsIFrame* kidFrame)
|
|
{
|
|
return (kidFrame->GetType() == nsGkAtoms::tableRowFrame ||
|
|
kidFrame->GetType() == nsGkAtoms::tableRowGroupFrame) &&
|
|
(kidFrame->GetStateBits() & NS_REPEATED_ROW_OR_ROWGROUP);
|
|
}
|
|
|
|
bool
|
|
nsTableFrame::PageBreakAfter(nsIFrame* aSourceFrame,
|
|
nsIFrame* aNextFrame)
|
|
{
|
|
const nsStyleDisplay* display = aSourceFrame->StyleDisplay();
|
|
nsTableRowGroupFrame* prevRg = do_QueryFrame(aSourceFrame);
|
|
// don't allow a page break after a repeated element ...
|
|
if ((display->mBreakAfter || (prevRg && prevRg->HasInternalBreakAfter())) &&
|
|
!IsRepeatedFrame(aSourceFrame)) {
|
|
return !(aNextFrame && IsRepeatedFrame(aNextFrame)); // or before
|
|
}
|
|
|
|
if (aNextFrame) {
|
|
display = aNextFrame->StyleDisplay();
|
|
// don't allow a page break before a repeated element ...
|
|
nsTableRowGroupFrame* nextRg = do_QueryFrame(aNextFrame);
|
|
if ((display->mBreakBefore ||
|
|
(nextRg && nextRg->HasInternalBreakBefore())) &&
|
|
!IsRepeatedFrame(aNextFrame)) {
|
|
return !IsRepeatedFrame(aSourceFrame); // or after
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
typedef nsTArray<nsIFrame*> FrameTArray;
|
|
|
|
/* static */ void
|
|
nsTableFrame::DestroyPositionedTablePartArray(void* aPropertyValue)
|
|
{
|
|
auto positionedObjs = static_cast<FrameTArray*>(aPropertyValue);
|
|
delete positionedObjs;
|
|
}
|
|
|
|
/* static */ void
|
|
nsTableFrame::RegisterPositionedTablePart(nsIFrame* aFrame)
|
|
{
|
|
// Supporting relative positioning for table parts other than table cells has
|
|
// the potential to break sites that apply 'position: relative' to those
|
|
// parts, expecting nothing to happen. We warn at the console to make tracking
|
|
// down the issue easy.
|
|
if (nsGkAtoms::tableCellFrame != aFrame->GetType()) {
|
|
nsIContent* content = aFrame->GetContent();
|
|
nsPresContext* presContext = aFrame->PresContext();
|
|
if (content && !presContext->HasWarnedAboutPositionedTableParts()) {
|
|
presContext->SetHasWarnedAboutPositionedTableParts();
|
|
nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
|
|
NS_LITERAL_CSTRING("Layout: Tables"),
|
|
content->OwnerDoc(),
|
|
nsContentUtils::eLAYOUT_PROPERTIES,
|
|
"TablePartRelPosWarning");
|
|
}
|
|
}
|
|
|
|
nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(aFrame);
|
|
MOZ_ASSERT(tableFrame, "Should have a table frame here");
|
|
tableFrame = static_cast<nsTableFrame*>(tableFrame->FirstContinuation());
|
|
|
|
// Retrieve the positioned parts array for this table.
|
|
FrameProperties props = tableFrame->Properties();
|
|
auto positionedParts =
|
|
static_cast<FrameTArray*>(props.Get(PositionedTablePartArray()));
|
|
|
|
// Lazily create the array if it doesn't exist yet.
|
|
if (!positionedParts) {
|
|
positionedParts = new FrameTArray;
|
|
props.Set(PositionedTablePartArray(), positionedParts);
|
|
}
|
|
|
|
// Add this frame to the list.
|
|
positionedParts->AppendElement(aFrame);
|
|
}
|
|
|
|
/* static */ void
|
|
nsTableFrame::UnregisterPositionedTablePart(nsIFrame* aFrame,
|
|
nsIFrame* aDestructRoot)
|
|
{
|
|
// Retrieve the table frame, and ensure that we hit aDestructRoot on the way.
|
|
// If we don't, that means that the table frame will be destroyed, so we don't
|
|
// need to bother with unregistering this frame.
|
|
nsTableFrame* tableFrame = GetTableFramePassingThrough(aDestructRoot, aFrame);
|
|
if (!tableFrame) {
|
|
return;
|
|
}
|
|
tableFrame = static_cast<nsTableFrame*>(tableFrame->FirstContinuation());
|
|
|
|
// Retrieve the positioned parts array for this table.
|
|
FrameProperties props = tableFrame->Properties();
|
|
auto positionedParts =
|
|
static_cast<FrameTArray*>(props.Get(PositionedTablePartArray()));
|
|
|
|
// Remove the frame.
|
|
MOZ_ASSERT(positionedParts &&
|
|
positionedParts->IndexOf(aFrame) != FrameTArray::NoIndex,
|
|
"Asked to unregister a positioned table part that wasn't registered");
|
|
if (positionedParts) {
|
|
positionedParts->RemoveElement(aFrame);
|
|
}
|
|
}
|
|
|
|
// XXX this needs to be cleaned up so that the frame constructor breaks out col group
|
|
// frames into a separate child list, bug 343048.
|
|
nsresult
|
|
nsTableFrame::SetInitialChildList(ChildListID aListID,
|
|
nsFrameList& aChildList)
|
|
{
|
|
|
|
if (!mFrames.IsEmpty() || !mColGroups.IsEmpty()) {
|
|
// We already have child frames which means we've already been
|
|
// initialized
|
|
NS_NOTREACHED("unexpected second call to SetInitialChildList");
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
if (aListID != kPrincipalList) {
|
|
// All we know about is the principal child list.
|
|
NS_NOTREACHED("unknown frame list");
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
// XXXbz the below code is an icky cesspit that's only needed in its current
|
|
// form for two reasons:
|
|
// 1) Both rowgroups and column groups come in on the principal child list.
|
|
while (aChildList.NotEmpty()) {
|
|
nsIFrame* childFrame = aChildList.FirstChild();
|
|
aChildList.RemoveFirstChild();
|
|
const nsStyleDisplay* childDisplay = childFrame->StyleDisplay();
|
|
|
|
if (NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP == childDisplay->mDisplay) {
|
|
NS_ASSERTION(nsGkAtoms::tableColGroupFrame == childFrame->GetType(),
|
|
"This is not a colgroup");
|
|
mColGroups.AppendFrame(nullptr, childFrame);
|
|
}
|
|
else { // row groups and unknown frames go on the main list for now
|
|
mFrames.AppendFrame(nullptr, childFrame);
|
|
}
|
|
}
|
|
|
|
// If we have a prev-in-flow, then we're a table that has been split and
|
|
// so don't treat this like an append
|
|
if (!GetPrevInFlow()) {
|
|
// process col groups first so that real cols get constructed before
|
|
// anonymous ones due to cells in rows.
|
|
InsertColGroups(0, mColGroups);
|
|
InsertRowGroups(mFrames);
|
|
// calc collapsing borders
|
|
if (IsBorderCollapse()) {
|
|
SetFullBCDamageArea();
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void nsTableFrame::AttributeChangedFor(nsIFrame* aFrame,
|
|
nsIContent* aContent,
|
|
nsIAtom* aAttribute)
|
|
{
|
|
nsTableCellFrame *cellFrame = do_QueryFrame(aFrame);
|
|
if (cellFrame) {
|
|
if ((nsGkAtoms::rowspan == aAttribute) ||
|
|
(nsGkAtoms::colspan == aAttribute)) {
|
|
nsTableCellMap* cellMap = GetCellMap();
|
|
if (cellMap) {
|
|
// for now just remove the cell from the map and reinsert it
|
|
int32_t rowIndex, colIndex;
|
|
cellFrame->GetRowIndex(rowIndex);
|
|
cellFrame->GetColIndex(colIndex);
|
|
RemoveCell(cellFrame, rowIndex);
|
|
nsAutoTArray<nsTableCellFrame*, 1> cells;
|
|
cells.AppendElement(cellFrame);
|
|
InsertCells(cells, rowIndex, colIndex - 1);
|
|
|
|
// XXX Should this use eStyleChange? It currently doesn't need
|
|
// to, but it might given more optimization.
|
|
PresContext()->PresShell()->
|
|
FrameNeedsReflow(this, nsIPresShell::eTreeChange, NS_FRAME_IS_DIRTY);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* ****** CellMap methods ******* */
|
|
|
|
/* return the effective col count */
|
|
int32_t nsTableFrame::GetEffectiveColCount() const
|
|
{
|
|
int32_t colCount = GetColCount();
|
|
if (LayoutStrategy()->GetType() == nsITableLayoutStrategy::Auto) {
|
|
nsTableCellMap* cellMap = GetCellMap();
|
|
if (!cellMap) {
|
|
return 0;
|
|
}
|
|
// don't count cols at the end that don't have originating cells
|
|
for (int32_t colX = colCount - 1; colX >= 0; colX--) {
|
|
if (cellMap->GetNumCellsOriginatingInCol(colX) > 0) {
|
|
break;
|
|
}
|
|
colCount--;
|
|
}
|
|
}
|
|
return colCount;
|
|
}
|
|
|
|
int32_t nsTableFrame::GetIndexOfLastRealCol()
|
|
{
|
|
int32_t numCols = mColFrames.Length();
|
|
if (numCols > 0) {
|
|
for (int32_t colX = numCols - 1; colX >= 0; colX--) {
|
|
nsTableColFrame* colFrame = GetColFrame(colX);
|
|
if (colFrame) {
|
|
if (eColAnonymousCell != colFrame->GetColType()) {
|
|
return colX;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
nsTableColFrame*
|
|
nsTableFrame::GetColFrame(int32_t aColIndex) const
|
|
{
|
|
NS_ASSERTION(!GetPrevInFlow(), "GetColFrame called on next in flow");
|
|
int32_t numCols = mColFrames.Length();
|
|
if ((aColIndex >= 0) && (aColIndex < numCols)) {
|
|
return mColFrames.ElementAt(aColIndex);
|
|
}
|
|
else {
|
|
NS_ERROR("invalid col index");
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
int32_t nsTableFrame::GetEffectiveRowSpan(int32_t aRowIndex,
|
|
const nsTableCellFrame& aCell) const
|
|
{
|
|
nsTableCellMap* cellMap = GetCellMap();
|
|
NS_PRECONDITION (nullptr != cellMap, "bad call, cellMap not yet allocated.");
|
|
|
|
int32_t colIndex;
|
|
aCell.GetColIndex(colIndex);
|
|
return cellMap->GetEffectiveRowSpan(aRowIndex, colIndex);
|
|
}
|
|
|
|
int32_t nsTableFrame::GetEffectiveRowSpan(const nsTableCellFrame& aCell,
|
|
nsCellMap* aCellMap)
|
|
{
|
|
nsTableCellMap* tableCellMap = GetCellMap(); if (!tableCellMap) ABORT1(1);
|
|
|
|
int32_t colIndex, rowIndex;
|
|
aCell.GetColIndex(colIndex);
|
|
aCell.GetRowIndex(rowIndex);
|
|
|
|
if (aCellMap)
|
|
return aCellMap->GetRowSpan(rowIndex, colIndex, true);
|
|
else
|
|
return tableCellMap->GetEffectiveRowSpan(rowIndex, colIndex);
|
|
}
|
|
|
|
int32_t nsTableFrame::GetEffectiveColSpan(const nsTableCellFrame& aCell,
|
|
nsCellMap* aCellMap) const
|
|
{
|
|
nsTableCellMap* tableCellMap = GetCellMap(); if (!tableCellMap) ABORT1(1);
|
|
|
|
int32_t colIndex, rowIndex;
|
|
aCell.GetColIndex(colIndex);
|
|
aCell.GetRowIndex(rowIndex);
|
|
bool ignore;
|
|
|
|
if (aCellMap)
|
|
return aCellMap->GetEffectiveColSpan(*tableCellMap, rowIndex, colIndex, ignore);
|
|
else
|
|
return tableCellMap->GetEffectiveColSpan(rowIndex, colIndex);
|
|
}
|
|
|
|
bool nsTableFrame::HasMoreThanOneCell(int32_t aRowIndex) const
|
|
{
|
|
nsTableCellMap* tableCellMap = GetCellMap(); if (!tableCellMap) ABORT1(1);
|
|
return tableCellMap->HasMoreThanOneCell(aRowIndex);
|
|
}
|
|
|
|
void nsTableFrame::AdjustRowIndices(int32_t aRowIndex,
|
|
int32_t aAdjustment)
|
|
{
|
|
// Iterate over the row groups and adjust the row indices of all rows
|
|
// whose index is >= aRowIndex.
|
|
RowGroupArray rowGroups;
|
|
OrderRowGroups(rowGroups);
|
|
|
|
for (uint32_t rgX = 0; rgX < rowGroups.Length(); rgX++) {
|
|
rowGroups[rgX]->AdjustRowIndices(aRowIndex, aAdjustment);
|
|
}
|
|
}
|
|
|
|
|
|
void nsTableFrame::ResetRowIndices(const nsFrameList::Slice& aRowGroupsToExclude)
|
|
{
|
|
// Iterate over the row groups and adjust the row indices of all rows
|
|
// omit the rowgroups that will be inserted later
|
|
RowGroupArray rowGroups;
|
|
OrderRowGroups(rowGroups);
|
|
|
|
int32_t rowIndex = 0;
|
|
nsTHashtable<nsPtrHashKey<nsTableRowGroupFrame> > excludeRowGroups;
|
|
nsFrameList::Enumerator excludeRowGroupsEnumerator(aRowGroupsToExclude);
|
|
while (!excludeRowGroupsEnumerator.AtEnd()) {
|
|
excludeRowGroups.PutEntry(static_cast<nsTableRowGroupFrame*>(excludeRowGroupsEnumerator.get()));
|
|
excludeRowGroupsEnumerator.Next();
|
|
}
|
|
|
|
for (uint32_t rgX = 0; rgX < rowGroups.Length(); rgX++) {
|
|
nsTableRowGroupFrame* rgFrame = rowGroups[rgX];
|
|
if (!excludeRowGroups.GetEntry(rgFrame)) {
|
|
const nsFrameList& rowFrames = rgFrame->PrincipalChildList();
|
|
for (nsFrameList::Enumerator rows(rowFrames); !rows.AtEnd(); rows.Next()) {
|
|
if (NS_STYLE_DISPLAY_TABLE_ROW==rows.get()->StyleDisplay()->mDisplay) {
|
|
((nsTableRowFrame *)rows.get())->SetRowIndex(rowIndex);
|
|
rowIndex++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
void nsTableFrame::InsertColGroups(int32_t aStartColIndex,
|
|
const nsFrameList::Slice& aColGroups)
|
|
{
|
|
int32_t colIndex = aStartColIndex;
|
|
nsFrameList::Enumerator colGroups(aColGroups);
|
|
for (; !colGroups.AtEnd(); colGroups.Next()) {
|
|
MOZ_ASSERT(colGroups.get()->GetType() == nsGkAtoms::tableColGroupFrame);
|
|
nsTableColGroupFrame* cgFrame =
|
|
static_cast<nsTableColGroupFrame*>(colGroups.get());
|
|
cgFrame->SetStartColumnIndex(colIndex);
|
|
// XXXbz this sucks. AddColsToTable will actually remove colgroups from
|
|
// the list we're traversing! Need to fix things here. :( I guess this is
|
|
// why the old code used pointer-to-last-frame as opposed to
|
|
// pointer-to-frame-after-last....
|
|
|
|
// How about dealing with this by storing a const reference to the
|
|
// mNextSibling of the framelist's last frame, instead of storing a pointer
|
|
// to the first-after-next frame? Will involve making nsFrameList friend
|
|
// of nsIFrame, but it's time for that anyway.
|
|
cgFrame->AddColsToTable(colIndex, false,
|
|
colGroups.get()->PrincipalChildList());
|
|
int32_t numCols = cgFrame->GetColCount();
|
|
colIndex += numCols;
|
|
}
|
|
|
|
nsFrameList::Enumerator remainingColgroups = colGroups.GetUnlimitedEnumerator();
|
|
if (!remainingColgroups.AtEnd()) {
|
|
nsTableColGroupFrame::ResetColIndices(
|
|
static_cast<nsTableColGroupFrame*>(remainingColgroups.get()), colIndex);
|
|
}
|
|
}
|
|
|
|
void nsTableFrame::InsertCol(nsTableColFrame& aColFrame,
|
|
int32_t aColIndex)
|
|
{
|
|
mColFrames.InsertElementAt(aColIndex, &aColFrame);
|
|
nsTableColType insertedColType = aColFrame.GetColType();
|
|
int32_t numCacheCols = mColFrames.Length();
|
|
nsTableCellMap* cellMap = GetCellMap();
|
|
if (cellMap) {
|
|
int32_t numMapCols = cellMap->GetColCount();
|
|
if (numCacheCols > numMapCols) {
|
|
bool removedFromCache = false;
|
|
if (eColAnonymousCell != insertedColType) {
|
|
nsTableColFrame* lastCol = mColFrames.ElementAt(numCacheCols - 1);
|
|
if (lastCol) {
|
|
nsTableColType lastColType = lastCol->GetColType();
|
|
if (eColAnonymousCell == lastColType) {
|
|
// remove the col from the cache
|
|
mColFrames.RemoveElementAt(numCacheCols - 1);
|
|
// remove the col from the eColGroupAnonymousCell col group
|
|
nsTableColGroupFrame* lastColGroup = (nsTableColGroupFrame *)mColGroups.LastChild();
|
|
if (lastColGroup) {
|
|
lastColGroup->RemoveChild(*lastCol, false);
|
|
|
|
// remove the col group if it is empty
|
|
if (lastColGroup->GetColCount() <= 0) {
|
|
mColGroups.DestroyFrame((nsIFrame*)lastColGroup);
|
|
}
|
|
}
|
|
removedFromCache = true;
|
|
}
|
|
}
|
|
}
|
|
if (!removedFromCache) {
|
|
cellMap->AddColsAtEnd(1);
|
|
}
|
|
}
|
|
}
|
|
// for now, just bail and recalc all of the collapsing borders
|
|
if (IsBorderCollapse()) {
|
|
nsIntRect damageArea(aColIndex, 0, 1, GetRowCount());
|
|
AddBCDamageArea(damageArea);
|
|
}
|
|
}
|
|
|
|
void nsTableFrame::RemoveCol(nsTableColGroupFrame* aColGroupFrame,
|
|
int32_t aColIndex,
|
|
bool aRemoveFromCache,
|
|
bool aRemoveFromCellMap)
|
|
{
|
|
if (aRemoveFromCache) {
|
|
mColFrames.RemoveElementAt(aColIndex);
|
|
}
|
|
if (aRemoveFromCellMap) {
|
|
nsTableCellMap* cellMap = GetCellMap();
|
|
if (cellMap) {
|
|
AppendAnonymousColFrames(1);
|
|
}
|
|
}
|
|
// for now, just bail and recalc all of the collapsing borders
|
|
if (IsBorderCollapse()) {
|
|
nsIntRect damageArea(0, 0, GetColCount(), GetRowCount());
|
|
AddBCDamageArea(damageArea);
|
|
}
|
|
}
|
|
|
|
/** Get the cell map for this table frame. It is not always mCellMap.
|
|
* Only the first-in-flow has a legit cell map.
|
|
*/
|
|
nsTableCellMap*
|
|
nsTableFrame::GetCellMap() const
|
|
{
|
|
return static_cast<nsTableFrame*>(FirstInFlow())->mCellMap;
|
|
}
|
|
|
|
// XXX this needs to be moved to nsCSSFrameConstructor
|
|
nsTableColGroupFrame*
|
|
nsTableFrame::CreateAnonymousColGroupFrame(nsTableColGroupType aColGroupType)
|
|
{
|
|
nsIContent* colGroupContent = GetContent();
|
|
nsPresContext* presContext = PresContext();
|
|
nsIPresShell *shell = presContext->PresShell();
|
|
|
|
nsRefPtr<nsStyleContext> colGroupStyle;
|
|
colGroupStyle = shell->StyleSet()->
|
|
ResolveAnonymousBoxStyle(nsCSSAnonBoxes::tableColGroup, mStyleContext);
|
|
// Create a col group frame
|
|
nsIFrame* newFrame = NS_NewTableColGroupFrame(shell, colGroupStyle);
|
|
((nsTableColGroupFrame *)newFrame)->SetColType(aColGroupType);
|
|
newFrame->Init(colGroupContent, this, nullptr);
|
|
return (nsTableColGroupFrame *)newFrame;
|
|
}
|
|
|
|
void
|
|
nsTableFrame::AppendAnonymousColFrames(int32_t aNumColsToAdd)
|
|
{
|
|
// get the last col group frame
|
|
nsTableColGroupFrame* colGroupFrame =
|
|
static_cast<nsTableColGroupFrame*>(mColGroups.LastChild());
|
|
|
|
if (!colGroupFrame ||
|
|
(colGroupFrame->GetColType() != eColGroupAnonymousCell)) {
|
|
int32_t colIndex = (colGroupFrame) ?
|
|
colGroupFrame->GetStartColumnIndex() +
|
|
colGroupFrame->GetColCount() : 0;
|
|
colGroupFrame = CreateAnonymousColGroupFrame(eColGroupAnonymousCell);
|
|
if (!colGroupFrame) {
|
|
return;
|
|
}
|
|
// add the new frame to the child list
|
|
mColGroups.AppendFrame(this, colGroupFrame);
|
|
colGroupFrame->SetStartColumnIndex(colIndex);
|
|
}
|
|
AppendAnonymousColFrames(colGroupFrame, aNumColsToAdd, eColAnonymousCell,
|
|
true);
|
|
|
|
}
|
|
|
|
// XXX this needs to be moved to nsCSSFrameConstructor
|
|
// Right now it only creates the col frames at the end
|
|
void
|
|
nsTableFrame::AppendAnonymousColFrames(nsTableColGroupFrame* aColGroupFrame,
|
|
int32_t aNumColsToAdd,
|
|
nsTableColType aColType,
|
|
bool aAddToTable)
|
|
{
|
|
NS_PRECONDITION(aColGroupFrame, "null frame");
|
|
NS_PRECONDITION(aColType != eColAnonymousCol, "Shouldn't happen");
|
|
|
|
nsIPresShell *shell = PresContext()->PresShell();
|
|
|
|
// Get the last col frame
|
|
nsFrameList newColFrames;
|
|
|
|
int32_t startIndex = mColFrames.Length();
|
|
int32_t lastIndex = startIndex + aNumColsToAdd - 1;
|
|
|
|
for (int32_t childX = startIndex; childX <= lastIndex; childX++) {
|
|
nsIContent* iContent;
|
|
nsRefPtr<nsStyleContext> styleContext;
|
|
nsStyleContext* parentStyleContext;
|
|
|
|
// all anonymous cols that we create here use a pseudo style context of the
|
|
// col group
|
|
iContent = aColGroupFrame->GetContent();
|
|
parentStyleContext = aColGroupFrame->StyleContext();
|
|
styleContext = shell->StyleSet()->
|
|
ResolveAnonymousBoxStyle(nsCSSAnonBoxes::tableCol, parentStyleContext);
|
|
// ASSERTION to check for bug 54454 sneaking back in...
|
|
NS_ASSERTION(iContent, "null content in CreateAnonymousColFrames");
|
|
|
|
// create the new col frame
|
|
nsIFrame* colFrame = NS_NewTableColFrame(shell, styleContext);
|
|
((nsTableColFrame *) colFrame)->SetColType(aColType);
|
|
colFrame->Init(iContent, aColGroupFrame, nullptr);
|
|
|
|
newColFrames.AppendFrame(nullptr, colFrame);
|
|
}
|
|
nsFrameList& cols = aColGroupFrame->GetWritableChildList();
|
|
nsIFrame* oldLastCol = cols.LastChild();
|
|
const nsFrameList::Slice& newCols =
|
|
cols.InsertFrames(nullptr, oldLastCol, newColFrames);
|
|
if (aAddToTable) {
|
|
// get the starting col index in the cache
|
|
int32_t startColIndex;
|
|
if (oldLastCol) {
|
|
startColIndex =
|
|
static_cast<nsTableColFrame*>(oldLastCol)->GetColIndex() + 1;
|
|
} else {
|
|
startColIndex = aColGroupFrame->GetStartColumnIndex();
|
|
}
|
|
|
|
aColGroupFrame->AddColsToTable(startColIndex, true, newCols);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsTableFrame::MatchCellMapToColCache(nsTableCellMap* aCellMap)
|
|
{
|
|
int32_t numColsInMap = GetColCount();
|
|
int32_t numColsInCache = mColFrames.Length();
|
|
int32_t numColsToAdd = numColsInMap - numColsInCache;
|
|
if (numColsToAdd > 0) {
|
|
// this sets the child list, updates the col cache and cell map
|
|
AppendAnonymousColFrames(numColsToAdd);
|
|
}
|
|
if (numColsToAdd < 0) {
|
|
int32_t numColsNotRemoved = DestroyAnonymousColFrames(-numColsToAdd);
|
|
// if the cell map has fewer cols than the cache, correct it
|
|
if (numColsNotRemoved > 0) {
|
|
aCellMap->AddColsAtEnd(numColsNotRemoved);
|
|
}
|
|
}
|
|
if (numColsToAdd && HasZeroColSpans()) {
|
|
SetNeedColSpanExpansion(true);
|
|
}
|
|
if (NeedColSpanExpansion()) {
|
|
// This flag can be set in two ways -- either by changing
|
|
// the number of columns (that happens in the block above),
|
|
// or by adding a cell with colspan="0" to the cellmap. To
|
|
// handle the latter case we need to explicitly check the
|
|
// flag here -- it may be set even if the number of columns
|
|
// did not change.
|
|
//
|
|
// @see nsCellMap::AppendCell
|
|
|
|
aCellMap->ExpandZeroColSpans();
|
|
}
|
|
}
|
|
|
|
void
|
|
nsTableFrame::DidResizeColumns()
|
|
{
|
|
NS_PRECONDITION(!GetPrevInFlow(),
|
|
"should only be called on first-in-flow");
|
|
if (mBits.mResizedColumns)
|
|
return; // already marked
|
|
|
|
for (nsTableFrame *f = this; f;
|
|
f = static_cast<nsTableFrame*>(f->GetNextInFlow()))
|
|
f->mBits.mResizedColumns = true;
|
|
}
|
|
|
|
void
|
|
nsTableFrame::AppendCell(nsTableCellFrame& aCellFrame,
|
|
int32_t aRowIndex)
|
|
{
|
|
nsTableCellMap* cellMap = GetCellMap();
|
|
if (cellMap) {
|
|
nsIntRect damageArea(0,0,0,0);
|
|
cellMap->AppendCell(aCellFrame, aRowIndex, true, damageArea);
|
|
MatchCellMapToColCache(cellMap);
|
|
if (IsBorderCollapse()) {
|
|
AddBCDamageArea(damageArea);
|
|
}
|
|
}
|
|
}
|
|
|
|
void nsTableFrame::InsertCells(nsTArray<nsTableCellFrame*>& aCellFrames,
|
|
int32_t aRowIndex,
|
|
int32_t aColIndexBefore)
|
|
{
|
|
nsTableCellMap* cellMap = GetCellMap();
|
|
if (cellMap) {
|
|
nsIntRect damageArea(0,0,0,0);
|
|
cellMap->InsertCells(aCellFrames, aRowIndex, aColIndexBefore, damageArea);
|
|
MatchCellMapToColCache(cellMap);
|
|
if (IsBorderCollapse()) {
|
|
AddBCDamageArea(damageArea);
|
|
}
|
|
}
|
|
}
|
|
|
|
// this removes the frames from the col group and table, but not the cell map
|
|
int32_t
|
|
nsTableFrame::DestroyAnonymousColFrames(int32_t aNumFrames)
|
|
{
|
|
// only remove cols that are of type eTypeAnonymous cell (they are at the end)
|
|
int32_t endIndex = mColFrames.Length() - 1;
|
|
int32_t startIndex = (endIndex - aNumFrames) + 1;
|
|
int32_t numColsRemoved = 0;
|
|
for (int32_t colX = endIndex; colX >= startIndex; colX--) {
|
|
nsTableColFrame* colFrame = GetColFrame(colX);
|
|
if (colFrame && (eColAnonymousCell == colFrame->GetColType())) {
|
|
nsTableColGroupFrame* cgFrame =
|
|
static_cast<nsTableColGroupFrame*>(colFrame->GetParent());
|
|
// remove the frame from the colgroup
|
|
cgFrame->RemoveChild(*colFrame, false);
|
|
// remove the frame from the cache, but not the cell map
|
|
RemoveCol(nullptr, colX, true, false);
|
|
numColsRemoved++;
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
return (aNumFrames - numColsRemoved);
|
|
}
|
|
|
|
void nsTableFrame::RemoveCell(nsTableCellFrame* aCellFrame,
|
|
int32_t aRowIndex)
|
|
{
|
|
nsTableCellMap* cellMap = GetCellMap();
|
|
if (cellMap) {
|
|
nsIntRect damageArea(0,0,0,0);
|
|
cellMap->RemoveCell(aCellFrame, aRowIndex, damageArea);
|
|
MatchCellMapToColCache(cellMap);
|
|
if (IsBorderCollapse()) {
|
|
AddBCDamageArea(damageArea);
|
|
}
|
|
}
|
|
}
|
|
|
|
int32_t
|
|
nsTableFrame::GetStartRowIndex(nsTableRowGroupFrame* aRowGroupFrame)
|
|
{
|
|
RowGroupArray orderedRowGroups;
|
|
OrderRowGroups(orderedRowGroups);
|
|
|
|
int32_t rowIndex = 0;
|
|
for (uint32_t rgIndex = 0; rgIndex < orderedRowGroups.Length(); rgIndex++) {
|
|
nsTableRowGroupFrame* rgFrame = orderedRowGroups[rgIndex];
|
|
if (rgFrame == aRowGroupFrame) {
|
|
break;
|
|
}
|
|
int32_t numRows = rgFrame->GetRowCount();
|
|
rowIndex += numRows;
|
|
}
|
|
return rowIndex;
|
|
}
|
|
|
|
// this cannot extend beyond a single row group
|
|
void nsTableFrame::AppendRows(nsTableRowGroupFrame* aRowGroupFrame,
|
|
int32_t aRowIndex,
|
|
nsTArray<nsTableRowFrame*>& aRowFrames)
|
|
{
|
|
nsTableCellMap* cellMap = GetCellMap();
|
|
if (cellMap) {
|
|
int32_t absRowIndex = GetStartRowIndex(aRowGroupFrame) + aRowIndex;
|
|
InsertRows(aRowGroupFrame, aRowFrames, absRowIndex, true);
|
|
}
|
|
}
|
|
|
|
// this cannot extend beyond a single row group
|
|
int32_t
|
|
nsTableFrame::InsertRows(nsTableRowGroupFrame* aRowGroupFrame,
|
|
nsTArray<nsTableRowFrame*>& aRowFrames,
|
|
int32_t aRowIndex,
|
|
bool aConsiderSpans)
|
|
{
|
|
#ifdef DEBUG_TABLE_CELLMAP
|
|
printf("=== insertRowsBefore firstRow=%d \n", aRowIndex);
|
|
Dump(true, false, true);
|
|
#endif
|
|
|
|
int32_t numColsToAdd = 0;
|
|
nsTableCellMap* cellMap = GetCellMap();
|
|
if (cellMap) {
|
|
nsIntRect damageArea(0,0,0,0);
|
|
int32_t origNumRows = cellMap->GetRowCount();
|
|
int32_t numNewRows = aRowFrames.Length();
|
|
cellMap->InsertRows(aRowGroupFrame, aRowFrames, aRowIndex, aConsiderSpans, damageArea);
|
|
MatchCellMapToColCache(cellMap);
|
|
if (aRowIndex < origNumRows) {
|
|
AdjustRowIndices(aRowIndex, numNewRows);
|
|
}
|
|
// assign the correct row indices to the new rows. If they were adjusted above
|
|
// it may not have been done correctly because each row is constructed with index 0
|
|
for (int32_t rowY = 0; rowY < numNewRows; rowY++) {
|
|
nsTableRowFrame* rowFrame = aRowFrames.ElementAt(rowY);
|
|
rowFrame->SetRowIndex(aRowIndex + rowY);
|
|
}
|
|
if (IsBorderCollapse()) {
|
|
AddBCDamageArea(damageArea);
|
|
}
|
|
}
|
|
#ifdef DEBUG_TABLE_CELLMAP
|
|
printf("=== insertRowsAfter \n");
|
|
Dump(true, false, true);
|
|
#endif
|
|
|
|
return numColsToAdd;
|
|
}
|
|
|
|
// this cannot extend beyond a single row group
|
|
void nsTableFrame::RemoveRows(nsTableRowFrame& aFirstRowFrame,
|
|
int32_t aNumRowsToRemove,
|
|
bool aConsiderSpans)
|
|
{
|
|
#ifdef TBD_OPTIMIZATION
|
|
// decide if we need to rebalance. we have to do this here because the row group
|
|
// cannot do it when it gets the dirty reflow corresponding to the frame being destroyed
|
|
bool stopTelling = false;
|
|
for (nsIFrame* kidFrame = aFirstFrame.FirstChild(); (kidFrame && !stopAsking);
|
|
kidFrame = kidFrame->GetNextSibling()) {
|
|
nsTableCellFrame *cellFrame = do_QueryFrame(kidFrame);
|
|
if (cellFrame) {
|
|
stopTelling = tableFrame->CellChangedWidth(*cellFrame, cellFrame->GetPass1MaxElementWidth(),
|
|
cellFrame->GetMaximumWidth(), true);
|
|
}
|
|
}
|
|
// XXX need to consider what happens if there are cells that have rowspans
|
|
// into the deleted row. Need to consider moving rows if a rebalance doesn't happen
|
|
#endif
|
|
|
|
int32_t firstRowIndex = aFirstRowFrame.GetRowIndex();
|
|
#ifdef DEBUG_TABLE_CELLMAP
|
|
printf("=== removeRowsBefore firstRow=%d numRows=%d\n", firstRowIndex, aNumRowsToRemove);
|
|
Dump(true, false, true);
|
|
#endif
|
|
nsTableCellMap* cellMap = GetCellMap();
|
|
if (cellMap) {
|
|
nsIntRect damageArea(0,0,0,0);
|
|
cellMap->RemoveRows(firstRowIndex, aNumRowsToRemove, aConsiderSpans, damageArea);
|
|
MatchCellMapToColCache(cellMap);
|
|
if (IsBorderCollapse()) {
|
|
AddBCDamageArea(damageArea);
|
|
}
|
|
}
|
|
AdjustRowIndices(firstRowIndex, -aNumRowsToRemove);
|
|
#ifdef DEBUG_TABLE_CELLMAP
|
|
printf("=== removeRowsAfter\n");
|
|
Dump(true, true, true);
|
|
#endif
|
|
}
|
|
|
|
// collect the rows ancestors of aFrame
|
|
int32_t
|
|
nsTableFrame::CollectRows(nsIFrame* aFrame,
|
|
nsTArray<nsTableRowFrame*>& aCollection)
|
|
{
|
|
NS_PRECONDITION(aFrame, "null frame");
|
|
int32_t numRows = 0;
|
|
nsIFrame* childFrame = aFrame->GetFirstPrincipalChild();
|
|
while (childFrame) {
|
|
aCollection.AppendElement(static_cast<nsTableRowFrame*>(childFrame));
|
|
numRows++;
|
|
childFrame = childFrame->GetNextSibling();
|
|
}
|
|
return numRows;
|
|
}
|
|
|
|
void
|
|
nsTableFrame::InsertRowGroups(const nsFrameList::Slice& aRowGroups)
|
|
{
|
|
#ifdef DEBUG_TABLE_CELLMAP
|
|
printf("=== insertRowGroupsBefore\n");
|
|
Dump(true, false, true);
|
|
#endif
|
|
nsTableCellMap* cellMap = GetCellMap();
|
|
if (cellMap) {
|
|
RowGroupArray orderedRowGroups;
|
|
OrderRowGroups(orderedRowGroups);
|
|
|
|
nsAutoTArray<nsTableRowFrame*, 8> rows;
|
|
// Loop over the rowgroups and check if some of them are new, if they are
|
|
// insert cellmaps in the order that is predefined by OrderRowGroups,
|
|
// XXXbz this code is O(N*M) where N is number of new rowgroups
|
|
// and M is number of rowgroups we have!
|
|
uint32_t rgIndex;
|
|
for (rgIndex = 0; rgIndex < orderedRowGroups.Length(); rgIndex++) {
|
|
for (nsFrameList::Enumerator rowgroups(aRowGroups); !rowgroups.AtEnd();
|
|
rowgroups.Next()) {
|
|
if (orderedRowGroups[rgIndex] == rowgroups.get()) {
|
|
nsTableRowGroupFrame* priorRG =
|
|
(0 == rgIndex) ? nullptr : orderedRowGroups[rgIndex - 1];
|
|
// create and add the cell map for the row group
|
|
cellMap->InsertGroupCellMap(orderedRowGroups[rgIndex], priorRG);
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
cellMap->Synchronize(this);
|
|
ResetRowIndices(aRowGroups);
|
|
|
|
//now that the cellmaps are reordered too insert the rows
|
|
for (rgIndex = 0; rgIndex < orderedRowGroups.Length(); rgIndex++) {
|
|
for (nsFrameList::Enumerator rowgroups(aRowGroups); !rowgroups.AtEnd();
|
|
rowgroups.Next()) {
|
|
if (orderedRowGroups[rgIndex] == rowgroups.get()) {
|
|
nsTableRowGroupFrame* priorRG =
|
|
(0 == rgIndex) ? nullptr : orderedRowGroups[rgIndex - 1];
|
|
// collect the new row frames in an array and add them to the table
|
|
int32_t numRows = CollectRows(rowgroups.get(), rows);
|
|
if (numRows > 0) {
|
|
int32_t rowIndex = 0;
|
|
if (priorRG) {
|
|
int32_t priorNumRows = priorRG->GetRowCount();
|
|
rowIndex = priorRG->GetStartRowIndex() + priorNumRows;
|
|
}
|
|
InsertRows(orderedRowGroups[rgIndex], rows, rowIndex, true);
|
|
rows.Clear();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
#ifdef DEBUG_TABLE_CELLMAP
|
|
printf("=== insertRowGroupsAfter\n");
|
|
Dump(true, true, true);
|
|
#endif
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Child frame enumeration
|
|
|
|
const nsFrameList&
|
|
nsTableFrame::GetChildList(ChildListID aListID) const
|
|
{
|
|
if (aListID == kColGroupList) {
|
|
return mColGroups;
|
|
}
|
|
return nsContainerFrame::GetChildList(aListID);
|
|
}
|
|
|
|
void
|
|
nsTableFrame::GetChildLists(nsTArray<ChildList>* aLists) const
|
|
{
|
|
nsContainerFrame::GetChildLists(aLists);
|
|
mColGroups.AppendIfNonempty(aLists, kColGroupList);
|
|
}
|
|
|
|
nsRect
|
|
nsDisplayTableItem::GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) {
|
|
*aSnap = false;
|
|
return mFrame->GetVisualOverflowRectRelativeToSelf() + ToReferenceFrame();
|
|
}
|
|
|
|
bool
|
|
nsDisplayTableItem::IsVaryingRelativeToMovingFrame(nsDisplayListBuilder* aBuilder,
|
|
nsIFrame* aFrame)
|
|
{
|
|
if (!mPartHasFixedBackground)
|
|
return false;
|
|
|
|
// If aFrame is mFrame or an ancestor in this document, and aFrame is
|
|
// not the viewport frame, then moving aFrame will move mFrame
|
|
// relative to the viewport, so our fixed-pos background will change.
|
|
return mFrame == aFrame ||
|
|
nsLayoutUtils::IsProperAncestorFrame(aFrame, mFrame);
|
|
}
|
|
|
|
/* static */ void
|
|
nsDisplayTableItem::UpdateForFrameBackground(nsIFrame* aFrame)
|
|
{
|
|
nsStyleContext *bgSC;
|
|
if (!nsCSSRendering::FindBackground(aFrame, &bgSC))
|
|
return;
|
|
if (!bgSC->StyleBackground()->HasFixedBackground())
|
|
return;
|
|
|
|
mPartHasFixedBackground = true;
|
|
}
|
|
|
|
class nsDisplayTableBorderBackground : public nsDisplayTableItem {
|
|
public:
|
|
nsDisplayTableBorderBackground(nsDisplayListBuilder* aBuilder,
|
|
nsTableFrame* aFrame) :
|
|
nsDisplayTableItem(aBuilder, aFrame) {
|
|
MOZ_COUNT_CTOR(nsDisplayTableBorderBackground);
|
|
}
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
|
virtual ~nsDisplayTableBorderBackground() {
|
|
MOZ_COUNT_DTOR(nsDisplayTableBorderBackground);
|
|
}
|
|
#endif
|
|
|
|
virtual void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
|
|
const nsDisplayItemGeometry* aGeometry,
|
|
nsRegion *aInvalidRegion) MOZ_OVERRIDE;
|
|
virtual void Paint(nsDisplayListBuilder* aBuilder,
|
|
nsRenderingContext* aCtx) MOZ_OVERRIDE;
|
|
NS_DISPLAY_DECL_NAME("TableBorderBackground", TYPE_TABLE_BORDER_BACKGROUND)
|
|
};
|
|
|
|
#ifdef DEBUG
|
|
static bool
|
|
IsFrameAllowedInTable(nsIAtom* aType)
|
|
{
|
|
return IS_TABLE_CELL(aType) ||
|
|
nsGkAtoms::tableRowFrame == aType ||
|
|
nsGkAtoms::tableRowGroupFrame == aType ||
|
|
nsGkAtoms::scrollFrame == aType ||
|
|
nsGkAtoms::tableFrame == aType ||
|
|
nsGkAtoms::tableColFrame == aType ||
|
|
nsGkAtoms::tableColGroupFrame == aType;
|
|
}
|
|
#endif
|
|
|
|
/* static */ bool
|
|
nsTableFrame::AnyTablePartHasUndecodedBackgroundImage(nsIFrame* aStart,
|
|
nsIFrame* aEnd)
|
|
{
|
|
for (nsIFrame* f = aStart; f != aEnd; f = f->GetNextSibling()) {
|
|
NS_ASSERTION(IsFrameAllowedInTable(f->GetType()), "unexpected frame type");
|
|
|
|
if (!nsCSSRendering::AreAllBackgroundImagesDecodedForFrame(f))
|
|
return true;
|
|
|
|
nsTableCellFrame *cellFrame = do_QueryFrame(f);
|
|
if (cellFrame)
|
|
continue;
|
|
|
|
if (AnyTablePartHasUndecodedBackgroundImage(f->PrincipalChildList().FirstChild(), nullptr))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void
|
|
nsDisplayTableBorderBackground::ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
|
|
const nsDisplayItemGeometry* aGeometry,
|
|
nsRegion *aInvalidRegion)
|
|
{
|
|
if (aBuilder->ShouldSyncDecodeImages()) {
|
|
if (nsTableFrame::AnyTablePartHasUndecodedBackgroundImage(mFrame, mFrame->GetNextSibling()) ||
|
|
nsTableFrame::AnyTablePartHasUndecodedBackgroundImage(
|
|
mFrame->GetChildList(nsIFrame::kColGroupList).FirstChild(), nullptr)) {
|
|
bool snap;
|
|
aInvalidRegion->Or(*aInvalidRegion, GetBounds(aBuilder, &snap));
|
|
}
|
|
}
|
|
|
|
nsDisplayTableItem::ComputeInvalidationRegion(aBuilder, aGeometry, aInvalidRegion);
|
|
}
|
|
|
|
void
|
|
nsDisplayTableBorderBackground::Paint(nsDisplayListBuilder* aBuilder,
|
|
nsRenderingContext* aCtx)
|
|
{
|
|
static_cast<nsTableFrame*>(mFrame)->
|
|
PaintTableBorderBackground(*aCtx, mVisibleRect,
|
|
ToReferenceFrame(),
|
|
aBuilder->GetBackgroundPaintFlags());
|
|
}
|
|
|
|
static int32_t GetTablePartRank(nsDisplayItem* aItem)
|
|
{
|
|
nsIAtom* type = aItem->Frame()->GetType();
|
|
if (type == nsGkAtoms::tableFrame)
|
|
return 0;
|
|
if (type == nsGkAtoms::tableRowGroupFrame)
|
|
return 1;
|
|
if (type == nsGkAtoms::tableRowFrame)
|
|
return 2;
|
|
return 3;
|
|
}
|
|
|
|
static bool CompareByTablePartRank(nsDisplayItem* aItem1, nsDisplayItem* aItem2,
|
|
void* aClosure)
|
|
{
|
|
return GetTablePartRank(aItem1) <= GetTablePartRank(aItem2);
|
|
}
|
|
|
|
/* static */ void
|
|
nsTableFrame::GenericTraversal(nsDisplayListBuilder* aBuilder, nsFrame* aFrame,
|
|
const nsRect& aDirtyRect, const nsDisplayListSet& aLists)
|
|
{
|
|
// This is similar to what nsContainerFrame::BuildDisplayListForNonBlockChildren
|
|
// does, except that we allow the children's background and borders to go
|
|
// in our BorderBackground list. This doesn't really affect background
|
|
// painting --- the children won't actually draw their own backgrounds
|
|
// because the nsTableFrame already drew them, unless a child has its own
|
|
// stacking context, in which case the child won't use its passed-in
|
|
// BorderBackground list anyway. It does affect cell borders though; this
|
|
// lets us get cell borders into the nsTableFrame's BorderBackground list.
|
|
nsIFrame* kid = aFrame->GetFirstPrincipalChild();
|
|
while (kid) {
|
|
aFrame->BuildDisplayListForChild(aBuilder, kid, aDirtyRect, aLists);
|
|
kid = kid->GetNextSibling();
|
|
}
|
|
}
|
|
|
|
/* static */ void
|
|
nsTableFrame::DisplayGenericTablePart(nsDisplayListBuilder* aBuilder,
|
|
nsFrame* aFrame,
|
|
const nsRect& aDirtyRect,
|
|
const nsDisplayListSet& aLists,
|
|
nsDisplayTableItem* aDisplayItem,
|
|
DisplayGenericTablePartTraversal aTraversal)
|
|
{
|
|
nsDisplayList eventsBorderBackground;
|
|
// If we need to sort the event backgrounds, then we'll put descendants'
|
|
// display items into their own set of lists.
|
|
bool sortEventBackgrounds = aDisplayItem && aBuilder->IsForEventDelivery();
|
|
nsDisplayListCollection separatedCollection;
|
|
const nsDisplayListSet* lists = sortEventBackgrounds ? &separatedCollection : &aLists;
|
|
|
|
nsAutoPushCurrentTableItem pushTableItem;
|
|
if (aDisplayItem) {
|
|
pushTableItem.Push(aBuilder, aDisplayItem);
|
|
}
|
|
|
|
if (aFrame->IsVisibleForPainting(aBuilder)) {
|
|
nsDisplayTableItem* currentItem = aBuilder->GetCurrentTableItem();
|
|
// currentItem may be null, when none of the table parts have a
|
|
// background or border
|
|
if (currentItem) {
|
|
currentItem->UpdateForFrameBackground(aFrame);
|
|
}
|
|
|
|
// Paint the outset box-shadows for the table frames
|
|
bool hasBoxShadow = aFrame->StyleBorder()->mBoxShadow != nullptr;
|
|
if (hasBoxShadow) {
|
|
lists->BorderBackground()->AppendNewToTop(
|
|
new (aBuilder) nsDisplayBoxShadowOuter(aBuilder, aFrame));
|
|
}
|
|
|
|
// Create dedicated background display items per-frame when we're
|
|
// handling events.
|
|
// XXX how to handle collapsed borders?
|
|
if (aBuilder->IsForEventDelivery()) {
|
|
nsDisplayBackgroundImage::AppendBackgroundItemsToTop(aBuilder, aFrame,
|
|
lists->BorderBackground());
|
|
}
|
|
|
|
// Paint the inset box-shadows for the table frames
|
|
if (hasBoxShadow) {
|
|
lists->BorderBackground()->AppendNewToTop(
|
|
new (aBuilder) nsDisplayBoxShadowInner(aBuilder, aFrame));
|
|
}
|
|
}
|
|
|
|
aTraversal(aBuilder, aFrame, aDirtyRect, *lists);
|
|
|
|
if (sortEventBackgrounds) {
|
|
// Ensure that the table frame event background goes before the
|
|
// table rowgroups event backgrounds, before the table row event backgrounds,
|
|
// before everything else (cells and their blocks)
|
|
separatedCollection.BorderBackground()->Sort(aBuilder, CompareByTablePartRank, nullptr);
|
|
separatedCollection.MoveTo(aLists);
|
|
}
|
|
|
|
aFrame->DisplayOutline(aBuilder, aLists);
|
|
}
|
|
|
|
static bool
|
|
AnyTablePartHasBorderOrBackground(nsIFrame* aStart, nsIFrame* aEnd)
|
|
{
|
|
for (nsIFrame* f = aStart; f != aEnd; f = f->GetNextSibling()) {
|
|
NS_ASSERTION(IsFrameAllowedInTable(f->GetType()), "unexpected frame type");
|
|
|
|
if (FrameHasBorderOrBackground(f))
|
|
return true;
|
|
|
|
nsTableCellFrame *cellFrame = do_QueryFrame(f);
|
|
if (cellFrame)
|
|
continue;
|
|
|
|
if (AnyTablePartHasBorderOrBackground(f->PrincipalChildList().FirstChild(), nullptr))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// table paint code is concerned primarily with borders and bg color
|
|
// SEC: TODO: adjust the rect for captions
|
|
void
|
|
nsTableFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
|
const nsRect& aDirtyRect,
|
|
const nsDisplayListSet& aLists)
|
|
{
|
|
DO_GLOBAL_REFLOW_COUNT_DSP_COLOR("nsTableFrame", NS_RGB(255,128,255));
|
|
|
|
nsDisplayTableItem* item = nullptr;
|
|
if (IsVisibleInSelection(aBuilder)) {
|
|
if (StyleVisibility()->IsVisible()) {
|
|
nsMargin deflate = GetDeflationForBackground(PresContext());
|
|
// If 'deflate' is (0,0,0,0) then we can paint the table background
|
|
// in its own display item, so do that to take advantage of
|
|
// opacity and visibility optimizations
|
|
if (deflate == nsMargin(0, 0, 0, 0)) {
|
|
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).
|
|
// Specific visibility decisions are delegated to the table background
|
|
// painter, which handles borders and backgrounds for the table.
|
|
if (aBuilder->IsForEventDelivery() ||
|
|
AnyTablePartHasBorderOrBackground(this, GetNextSibling()) ||
|
|
AnyTablePartHasBorderOrBackground(mColGroups.FirstChild(), nullptr)) {
|
|
item = new (aBuilder) nsDisplayTableBorderBackground(aBuilder, this);
|
|
aLists.BorderBackground()->AppendNewToTop(item);
|
|
}
|
|
}
|
|
DisplayGenericTablePart(aBuilder, this, aDirtyRect, aLists, item);
|
|
}
|
|
|
|
nsMargin
|
|
nsTableFrame::GetDeflationForBackground(nsPresContext* aPresContext) const
|
|
{
|
|
if (eCompatibility_NavQuirks != aPresContext->CompatibilityMode() ||
|
|
!IsBorderCollapse())
|
|
return nsMargin(0,0,0,0);
|
|
|
|
return GetOuterBCBorder();
|
|
}
|
|
|
|
// XXX We don't put the borders and backgrounds in tree order like we should.
|
|
// That requires some major surgery which we aren't going to do right now.
|
|
void
|
|
nsTableFrame::PaintTableBorderBackground(nsRenderingContext& aRenderingContext,
|
|
const nsRect& aDirtyRect,
|
|
nsPoint aPt, uint32_t aBGPaintFlags)
|
|
{
|
|
nsPresContext* presContext = PresContext();
|
|
|
|
TableBackgroundPainter painter(this, TableBackgroundPainter::eOrigin_Table,
|
|
presContext, aRenderingContext,
|
|
aDirtyRect, aPt, aBGPaintFlags);
|
|
nsMargin deflate = GetDeflationForBackground(presContext);
|
|
// If 'deflate' is (0,0,0,0) then we'll paint the table background
|
|
// in a separate display item, so don't do it here.
|
|
nsresult rv = painter.PaintTable(this, deflate, deflate != nsMargin(0, 0, 0, 0));
|
|
if (NS_FAILED(rv)) return;
|
|
|
|
if (StyleVisibility()->IsVisible()) {
|
|
if (!IsBorderCollapse()) {
|
|
int skipSides = GetSkipSides();
|
|
nsRect rect(aPt, mRect.Size());
|
|
nsCSSRendering::PaintBorder(presContext, aRenderingContext, this,
|
|
aDirtyRect, rect, mStyleContext, skipSides);
|
|
}
|
|
else {
|
|
// XXX we should probably get rid of this translation at some stage
|
|
// But that would mean modifying PaintBCBorders, ugh
|
|
nsRenderingContext::AutoPushTranslation translate(&aRenderingContext, aPt);
|
|
PaintBCBorders(aRenderingContext, aDirtyRect - aPt);
|
|
}
|
|
}
|
|
}
|
|
|
|
int
|
|
nsTableFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const
|
|
{
|
|
if (MOZ_UNLIKELY(StyleBorder()->mBoxDecorationBreak ==
|
|
NS_STYLE_BOX_DECORATION_BREAK_CLONE)) {
|
|
return 0;
|
|
}
|
|
|
|
int skip = 0;
|
|
// frame attribute was accounted for in nsHTMLTableElement::MapTableBorderInto
|
|
// account for pagination
|
|
if (nullptr != GetPrevInFlow()) {
|
|
skip |= LOGICAL_SIDE_B_START;
|
|
}
|
|
if (nullptr != GetNextInFlow()) {
|
|
skip |= LOGICAL_SIDE_B_END;
|
|
}
|
|
return skip;
|
|
}
|
|
|
|
void
|
|
nsTableFrame::SetColumnDimensions(nscoord aHeight,
|
|
const nsMargin& aBorderPadding)
|
|
{
|
|
nscoord cellSpacingX = GetCellSpacingX();
|
|
nscoord cellSpacingY = GetCellSpacingY();
|
|
nscoord colHeight = aHeight -= aBorderPadding.top + aBorderPadding.bottom +
|
|
2* cellSpacingY;
|
|
|
|
nsTableIterator iter(mColGroups);
|
|
nsIFrame* colGroupFrame = iter.First();
|
|
bool tableIsLTR = StyleVisibility()->mDirection == NS_STYLE_DIRECTION_LTR;
|
|
int32_t colX =tableIsLTR ? 0 : std::max(0, GetColCount() - 1);
|
|
int32_t tableColIncr = tableIsLTR ? 1 : -1;
|
|
nsPoint colGroupOrigin(aBorderPadding.left + cellSpacingX,
|
|
aBorderPadding.top + cellSpacingY);
|
|
while (colGroupFrame) {
|
|
MOZ_ASSERT(colGroupFrame->GetType() == nsGkAtoms::tableColGroupFrame);
|
|
nscoord colGroupWidth = 0;
|
|
nsTableIterator iterCol(*colGroupFrame);
|
|
nsIFrame* colFrame = iterCol.First();
|
|
nsPoint colOrigin(0,0);
|
|
while (colFrame) {
|
|
if (NS_STYLE_DISPLAY_TABLE_COLUMN ==
|
|
colFrame->StyleDisplay()->mDisplay) {
|
|
NS_ASSERTION(colX < GetColCount(), "invalid number of columns");
|
|
nscoord colWidth = GetColumnWidth(colX);
|
|
nsRect colRect(colOrigin.x, colOrigin.y, colWidth, colHeight);
|
|
colFrame->SetRect(colRect);
|
|
colOrigin.x += colWidth + cellSpacingX;
|
|
colGroupWidth += colWidth + cellSpacingX;
|
|
colX += tableColIncr;
|
|
}
|
|
colFrame = iterCol.Next();
|
|
}
|
|
if (colGroupWidth) {
|
|
colGroupWidth -= cellSpacingX;
|
|
}
|
|
|
|
nsRect colGroupRect(colGroupOrigin.x, colGroupOrigin.y, colGroupWidth, colHeight);
|
|
colGroupFrame->SetRect(colGroupRect);
|
|
colGroupFrame = iter.Next();
|
|
colGroupOrigin.x += colGroupWidth + cellSpacingX;
|
|
}
|
|
}
|
|
|
|
// SEC: TODO need to worry about continuing frames prev/next in flow for splitting across pages.
|
|
|
|
// XXX this could be made more general to handle row modifications that change the
|
|
// table height, but first we need to scrutinize every Invalidate
|
|
void
|
|
nsTableFrame::ProcessRowInserted(nscoord aNewHeight)
|
|
{
|
|
SetRowInserted(false); // reset the bit that got us here
|
|
nsTableFrame::RowGroupArray rowGroups;
|
|
OrderRowGroups(rowGroups);
|
|
// find the row group containing the inserted row
|
|
for (uint32_t rgX = 0; rgX < rowGroups.Length(); rgX++) {
|
|
nsTableRowGroupFrame* rgFrame = rowGroups[rgX];
|
|
NS_ASSERTION(rgFrame, "Must have rgFrame here");
|
|
nsIFrame* childFrame = rgFrame->GetFirstPrincipalChild();
|
|
// find the row that was inserted first
|
|
while (childFrame) {
|
|
nsTableRowFrame *rowFrame = do_QueryFrame(childFrame);
|
|
if (rowFrame) {
|
|
if (rowFrame->IsFirstInserted()) {
|
|
rowFrame->SetFirstInserted(false);
|
|
// damage the table from the 1st row inserted to the end of the table
|
|
nsIFrame::InvalidateFrame();
|
|
// XXXbz didn't we do this up front? Why do we need to do it again?
|
|
SetRowInserted(false);
|
|
return; // found it, so leave
|
|
}
|
|
}
|
|
childFrame = childFrame->GetNextSibling();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* virtual */ void
|
|
nsTableFrame::MarkIntrinsicWidthsDirty()
|
|
{
|
|
nsITableLayoutStrategy* tls = LayoutStrategy();
|
|
if (MOZ_UNLIKELY(!tls)) {
|
|
// This is a FrameNeedsReflow() from nsBlockFrame::RemoveFrame()
|
|
// walking up the ancestor chain in a table next-in-flow. In this case
|
|
// our original first-in-flow (which owns the TableLayoutStrategy) has
|
|
// already been destroyed and unhooked from the flow chain and thusly
|
|
// LayoutStrategy() returns null. All the frames in the flow will be
|
|
// destroyed so no need to mark anything dirty here. See bug 595758.
|
|
return;
|
|
}
|
|
tls->MarkIntrinsicWidthsDirty();
|
|
|
|
// XXXldb Call SetBCDamageArea?
|
|
|
|
nsContainerFrame::MarkIntrinsicWidthsDirty();
|
|
}
|
|
|
|
/* virtual */ nscoord
|
|
nsTableFrame::GetMinWidth(nsRenderingContext *aRenderingContext)
|
|
{
|
|
if (NeedToCalcBCBorders())
|
|
CalcBCBorders();
|
|
|
|
ReflowColGroups(aRenderingContext);
|
|
|
|
return LayoutStrategy()->GetMinWidth(aRenderingContext);
|
|
}
|
|
|
|
/* virtual */ nscoord
|
|
nsTableFrame::GetPrefWidth(nsRenderingContext *aRenderingContext)
|
|
{
|
|
if (NeedToCalcBCBorders())
|
|
CalcBCBorders();
|
|
|
|
ReflowColGroups(aRenderingContext);
|
|
|
|
return LayoutStrategy()->GetPrefWidth(aRenderingContext, false);
|
|
}
|
|
|
|
/* virtual */ nsIFrame::IntrinsicWidthOffsetData
|
|
nsTableFrame::IntrinsicWidthOffsets(nsRenderingContext* aRenderingContext)
|
|
{
|
|
IntrinsicWidthOffsetData result =
|
|
nsContainerFrame::IntrinsicWidthOffsets(aRenderingContext);
|
|
|
|
result.hMargin = 0;
|
|
result.hPctMargin = 0;
|
|
|
|
if (IsBorderCollapse()) {
|
|
result.hPadding = 0;
|
|
result.hPctPadding = 0;
|
|
|
|
nsMargin outerBC = GetIncludedOuterBCBorder();
|
|
result.hBorder = outerBC.LeftRight();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* virtual */ nsSize
|
|
nsTableFrame::ComputeSize(nsRenderingContext *aRenderingContext,
|
|
nsSize aCBSize, nscoord aAvailableWidth,
|
|
nsSize aMargin, nsSize aBorder, nsSize aPadding,
|
|
uint32_t aFlags)
|
|
{
|
|
nsSize result =
|
|
nsContainerFrame::ComputeSize(aRenderingContext, aCBSize, aAvailableWidth,
|
|
aMargin, aBorder, aPadding, aFlags);
|
|
|
|
// If we're a container for font size inflation, then shrink
|
|
// wrapping inside of us should not apply font size inflation.
|
|
AutoMaybeDisableFontInflation an(this);
|
|
|
|
// Tables never shrink below their min width.
|
|
nscoord minWidth = GetMinWidth(aRenderingContext);
|
|
if (minWidth > result.width)
|
|
result.width = minWidth;
|
|
|
|
return result;
|
|
}
|
|
|
|
nscoord
|
|
nsTableFrame::TableShrinkWidthToFit(nsRenderingContext *aRenderingContext,
|
|
nscoord aWidthInCB)
|
|
{
|
|
// If we're a container for font size inflation, then shrink
|
|
// wrapping inside of us should not apply font size inflation.
|
|
AutoMaybeDisableFontInflation an(this);
|
|
|
|
nscoord result;
|
|
nscoord minWidth = GetMinWidth(aRenderingContext);
|
|
if (minWidth > aWidthInCB) {
|
|
result = minWidth;
|
|
} else {
|
|
// Tables shrink width to fit with a slightly different algorithm
|
|
// from the one they use for their intrinsic widths (the difference
|
|
// relates to handling of percentage widths on columns). So this
|
|
// function differs from nsFrame::ShrinkWidthToFit by only the
|
|
// following line.
|
|
// Since we've already called GetMinWidth, we don't need to do any
|
|
// of the other stuff GetPrefWidth does.
|
|
nscoord prefWidth =
|
|
LayoutStrategy()->GetPrefWidth(aRenderingContext, true);
|
|
if (prefWidth > aWidthInCB) {
|
|
result = aWidthInCB;
|
|
} else {
|
|
result = prefWidth;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/* virtual */ nsSize
|
|
nsTableFrame::ComputeAutoSize(nsRenderingContext *aRenderingContext,
|
|
nsSize aCBSize, nscoord aAvailableWidth,
|
|
nsSize aMargin, nsSize aBorder, nsSize aPadding,
|
|
bool aShrinkWrap)
|
|
{
|
|
// Tables always shrink-wrap.
|
|
nscoord cbBased = aAvailableWidth - aMargin.width - aBorder.width -
|
|
aPadding.width;
|
|
return nsSize(TableShrinkWidthToFit(aRenderingContext, cbBased),
|
|
NS_UNCONSTRAINEDSIZE);
|
|
}
|
|
|
|
// Return true if aParentReflowState.frame or any of its ancestors within
|
|
// the containing table have non-auto height. (e.g. pct or fixed height)
|
|
bool
|
|
nsTableFrame::AncestorsHaveStyleHeight(const nsHTMLReflowState& aParentReflowState)
|
|
{
|
|
for (const nsHTMLReflowState* rs = &aParentReflowState;
|
|
rs && rs->frame; rs = rs->parentReflowState) {
|
|
nsIAtom* frameType = rs->frame->GetType();
|
|
if (IS_TABLE_CELL(frameType) ||
|
|
(nsGkAtoms::tableRowFrame == frameType) ||
|
|
(nsGkAtoms::tableRowGroupFrame == frameType)) {
|
|
const nsStyleCoord &height = rs->mStylePosition->mHeight;
|
|
// calc() with percentages treated like 'auto' on internal table elements
|
|
if (height.GetUnit() != eStyleUnit_Auto &&
|
|
(!height.IsCalcUnit() || !height.HasPercent())) {
|
|
return true;
|
|
}
|
|
}
|
|
else if (nsGkAtoms::tableFrame == frameType) {
|
|
// we reached the containing table, so always return
|
|
return rs->mStylePosition->mHeight.GetUnit() != eStyleUnit_Auto;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// See if a special height reflow needs to occur and if so, call RequestSpecialHeightReflow
|
|
void
|
|
nsTableFrame::CheckRequestSpecialHeightReflow(const nsHTMLReflowState& aReflowState)
|
|
{
|
|
NS_ASSERTION(IS_TABLE_CELL(aReflowState.frame->GetType()) ||
|
|
aReflowState.frame->GetType() == nsGkAtoms::tableRowFrame ||
|
|
aReflowState.frame->GetType() == nsGkAtoms::tableRowGroupFrame ||
|
|
aReflowState.frame->GetType() == nsGkAtoms::tableFrame,
|
|
"unexpected frame type");
|
|
if (!aReflowState.frame->GetPrevInFlow() && // 1st in flow
|
|
(NS_UNCONSTRAINEDSIZE == aReflowState.ComputedHeight() || // no computed height
|
|
0 == aReflowState.ComputedHeight()) &&
|
|
eStyleUnit_Percent == aReflowState.mStylePosition->mHeight.GetUnit() && // pct height
|
|
nsTableFrame::AncestorsHaveStyleHeight(*aReflowState.parentReflowState)) {
|
|
nsTableFrame::RequestSpecialHeightReflow(aReflowState);
|
|
}
|
|
}
|
|
|
|
// Notify the frame and its ancestors (up to the containing table) that a special
|
|
// height reflow will occur. During a special height reflow, a table, row group,
|
|
// row, or cell returns the last size it was reflowed at. However, the table may
|
|
// change the height of row groups, rows, cells in DistributeHeightToRows after.
|
|
// And the row group can change the height of rows, cells in CalculateRowHeights.
|
|
void
|
|
nsTableFrame::RequestSpecialHeightReflow(const nsHTMLReflowState& aReflowState)
|
|
{
|
|
// notify the frame and its ancestors of the special reflow, stopping at the containing table
|
|
for (const nsHTMLReflowState* rs = &aReflowState; rs && rs->frame; rs = rs->parentReflowState) {
|
|
nsIAtom* frameType = rs->frame->GetType();
|
|
NS_ASSERTION(IS_TABLE_CELL(frameType) ||
|
|
nsGkAtoms::tableRowFrame == frameType ||
|
|
nsGkAtoms::tableRowGroupFrame == frameType ||
|
|
nsGkAtoms::tableFrame == frameType,
|
|
"unexpected frame type");
|
|
|
|
rs->frame->AddStateBits(NS_FRAME_CONTAINS_RELATIVE_HEIGHT);
|
|
if (nsGkAtoms::tableFrame == frameType) {
|
|
NS_ASSERTION(rs != &aReflowState,
|
|
"should not request special height reflow for table");
|
|
// always stop when we reach a table
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/******************************************************************************************
|
|
* Before reflow, intrinsic width calculation is done using GetMinWidth
|
|
* and GetPrefWidth. This used to be known as pass 1 reflow.
|
|
*
|
|
* After the intrinsic width calculation, the table determines the
|
|
* column widths using BalanceColumnWidths() and
|
|
* then reflows each child again with a constrained avail width. This reflow is referred to
|
|
* as the pass 2 reflow.
|
|
*
|
|
* A special height reflow (pass 3 reflow) can occur during an initial or resize reflow
|
|
* if (a) a row group, row, cell, or a frame inside a cell has a percent height but no computed
|
|
* height or (b) in paginated mode, a table has a height. (a) supports percent nested tables
|
|
* contained inside cells whose heights aren't known until after the pass 2 reflow. (b) is
|
|
* necessary because the table cannot split until after the pass 2 reflow. The mechanics of
|
|
* the special height reflow (variety a) are as follows:
|
|
*
|
|
* 1) Each table related frame (table, row group, row, cell) implements NeedsSpecialReflow()
|
|
* to indicate that it should get the reflow. It does this when it has a percent height but
|
|
* no computed height by calling CheckRequestSpecialHeightReflow(). This method calls
|
|
* RequestSpecialHeightReflow() which calls SetNeedSpecialReflow() on its ancestors until
|
|
* it reaches the containing table and calls SetNeedToInitiateSpecialReflow() on it. For
|
|
* percent height frames inside cells, during DidReflow(), the cell's NotifyPercentHeight()
|
|
* is called (the cell is the reflow state's mPercentHeightObserver in this case).
|
|
* NotifyPercentHeight() calls RequestSpecialHeightReflow().
|
|
*
|
|
* 2) After the pass 2 reflow, if the table's NeedToInitiateSpecialReflow(true) was called, it
|
|
* will do the special height reflow, setting the reflow state's mFlags.mSpecialHeightReflow
|
|
* to true and mSpecialHeightInitiator to itself. It won't do this if IsPrematureSpecialHeightReflow()
|
|
* returns true because in that case another special height reflow will be coming along with the
|
|
* containing table as the mSpecialHeightInitiator. It is only relevant to do the reflow when
|
|
* the mSpecialHeightInitiator is the containing table, because if it is a remote ancestor, then
|
|
* appropriate heights will not be known.
|
|
*
|
|
* 3) Since the heights of the table, row groups, rows, and cells was determined during the pass 2
|
|
* reflow, they return their last desired sizes during the special height reflow. The reflow only
|
|
* permits percent height frames inside the cells to resize based on the cells height and that height
|
|
* was determined during the pass 2 reflow.
|
|
*
|
|
* So, in the case of deeply nested tables, all of the tables that were told to initiate a special
|
|
* reflow will do so, but if a table is already in a special reflow, it won't inititate the reflow
|
|
* until the current initiator is its containing table. Since these reflows are only received by
|
|
* frames that need them and they don't cause any rebalancing of tables, the extra overhead is minimal.
|
|
*
|
|
* The type of special reflow that occurs during printing (variety b) follows the same mechanism except
|
|
* that all frames will receive the reflow even if they don't really need them.
|
|
*
|
|
* Open issues with the special height reflow:
|
|
*
|
|
* 1) At some point there should be 2 kinds of special height reflows because (a) and (b) above are
|
|
* really quite different. This would avoid unnecessary reflows during printing.
|
|
* 2) When a cell contains frames whose percent heights > 100%, there is data loss (see bug 115245).
|
|
* However, this can also occur if a cell has a fixed height and there is no special height reflow.
|
|
*
|
|
* XXXldb Special height reflow should really be its own method, not
|
|
* part of nsIFrame::Reflow. It should then call nsIFrame::Reflow on
|
|
* the contents of the cells to do the necessary vertical resizing.
|
|
*
|
|
******************************************************************************************/
|
|
|
|
/* Layout the entire inner table. */
|
|
nsresult nsTableFrame::Reflow(nsPresContext* aPresContext,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
DO_GLOBAL_REFLOW_COUNT("nsTableFrame");
|
|
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
|
|
bool isPaginated = aPresContext->IsPaginated();
|
|
|
|
aStatus = NS_FRAME_COMPLETE;
|
|
if (!GetPrevInFlow() && !mTableLayoutStrategy) {
|
|
NS_ASSERTION(false, "strategy should have been created in Init");
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
nsresult rv = NS_OK;
|
|
|
|
// see if collapsing borders need to be calculated
|
|
if (!GetPrevInFlow() && IsBorderCollapse() && NeedToCalcBCBorders()) {
|
|
CalcBCBorders();
|
|
}
|
|
|
|
aDesiredSize.Width() = aReflowState.AvailableWidth();
|
|
|
|
// Check for an overflow list, and append any row group frames being pushed
|
|
MoveOverflowToChildList();
|
|
|
|
bool haveDesiredHeight = false;
|
|
SetHaveReflowedColGroups(false);
|
|
|
|
// Reflow the entire table (pass 2 and possibly pass 3). This phase is necessary during a
|
|
// constrained initial reflow and other reflows which require either a strategy init or balance.
|
|
// This isn't done during an unconstrained reflow, because it will occur later when the parent
|
|
// reflows with a constrained width.
|
|
if (NS_SUBTREE_DIRTY(this) ||
|
|
aReflowState.ShouldReflowAllKids() ||
|
|
IsGeometryDirty() ||
|
|
aReflowState.mFlags.mVResize) {
|
|
|
|
if (aReflowState.ComputedHeight() != NS_UNCONSTRAINEDSIZE ||
|
|
// Also check mVResize, to handle the first Reflow preceding a
|
|
// special height Reflow, when we've already had a special height
|
|
// Reflow (where mComputedHeight would not be
|
|
// NS_UNCONSTRAINEDSIZE, but without a style change in between).
|
|
aReflowState.mFlags.mVResize) {
|
|
// XXX Eventually, we should modify DistributeHeightToRows to use
|
|
// nsTableRowFrame::GetHeight instead of nsIFrame::GetSize().height.
|
|
// That way, it will make its calculations based on internal table
|
|
// frame heights as they are before they ever had any extra height
|
|
// distributed to them. In the meantime, this reflows all the
|
|
// internal table frames, which restores them to their state before
|
|
// DistributeHeightToRows was called.
|
|
SetGeometryDirty();
|
|
}
|
|
|
|
bool needToInitiateSpecialReflow =
|
|
!!(GetStateBits() & NS_FRAME_CONTAINS_RELATIVE_HEIGHT);
|
|
// see if an extra reflow will be necessary in pagination mode when there is a specified table height
|
|
if (isPaginated && !GetPrevInFlow() && (NS_UNCONSTRAINEDSIZE != aReflowState.AvailableHeight())) {
|
|
nscoord tableSpecifiedHeight = CalcBorderBoxHeight(aReflowState);
|
|
if ((tableSpecifiedHeight > 0) &&
|
|
(tableSpecifiedHeight != NS_UNCONSTRAINEDSIZE)) {
|
|
needToInitiateSpecialReflow = true;
|
|
}
|
|
}
|
|
nsIFrame* lastChildReflowed = nullptr;
|
|
|
|
NS_ASSERTION(!aReflowState.mFlags.mSpecialHeightReflow,
|
|
"Shouldn't be in special height reflow here!");
|
|
|
|
// do the pass 2 reflow unless this is a special height reflow and we will be
|
|
// initiating a special height reflow
|
|
// XXXldb I changed this. Should I change it back?
|
|
|
|
// if we need to initiate a special height reflow, then don't constrain the
|
|
// height of the reflow before that
|
|
nscoord availHeight = needToInitiateSpecialReflow
|
|
? NS_UNCONSTRAINEDSIZE : aReflowState.AvailableHeight();
|
|
|
|
ReflowTable(aDesiredSize, aReflowState, availHeight,
|
|
lastChildReflowed, aStatus);
|
|
|
|
// reevaluate special height reflow conditions
|
|
if (GetStateBits() & NS_FRAME_CONTAINS_RELATIVE_HEIGHT)
|
|
needToInitiateSpecialReflow = true;
|
|
|
|
// XXXldb Are all these conditions correct?
|
|
if (needToInitiateSpecialReflow && NS_FRAME_IS_COMPLETE(aStatus)) {
|
|
// XXXldb Do we need to set the mVResize flag on any reflow states?
|
|
|
|
nsHTMLReflowState &mutable_rs =
|
|
const_cast<nsHTMLReflowState&>(aReflowState);
|
|
|
|
// distribute extra vertical space to rows
|
|
CalcDesiredHeight(aReflowState, aDesiredSize);
|
|
mutable_rs.mFlags.mSpecialHeightReflow = true;
|
|
|
|
ReflowTable(aDesiredSize, aReflowState, aReflowState.AvailableHeight(),
|
|
lastChildReflowed, aStatus);
|
|
|
|
if (lastChildReflowed && NS_FRAME_IS_NOT_COMPLETE(aStatus)) {
|
|
// if there is an incomplete child, then set the desired height to include it but not the next one
|
|
nsMargin borderPadding = GetChildAreaOffset(&aReflowState);
|
|
aDesiredSize.Height() = borderPadding.bottom + GetCellSpacingY() +
|
|
lastChildReflowed->GetRect().YMost();
|
|
}
|
|
haveDesiredHeight = true;
|
|
|
|
mutable_rs.mFlags.mSpecialHeightReflow = false;
|
|
}
|
|
}
|
|
else {
|
|
// Calculate the overflow area contribution from our children.
|
|
for (nsIFrame* kid = GetFirstPrincipalChild(); kid; kid = kid->GetNextSibling()) {
|
|
ConsiderChildOverflow(aDesiredSize.mOverflowAreas, kid);
|
|
}
|
|
}
|
|
|
|
aDesiredSize.Width() = aReflowState.ComputedWidth() +
|
|
aReflowState.ComputedPhysicalBorderPadding().LeftRight();
|
|
if (!haveDesiredHeight) {
|
|
CalcDesiredHeight(aReflowState, aDesiredSize);
|
|
}
|
|
if (IsRowInserted()) {
|
|
ProcessRowInserted(aDesiredSize.Height());
|
|
}
|
|
|
|
nsMargin borderPadding = GetChildAreaOffset(&aReflowState);
|
|
SetColumnDimensions(aDesiredSize.Height(), borderPadding);
|
|
if (NeedToCollapse() &&
|
|
(NS_UNCONSTRAINEDSIZE != aReflowState.AvailableWidth())) {
|
|
AdjustForCollapsingRowsCols(aDesiredSize, borderPadding);
|
|
}
|
|
|
|
// If there are any relatively-positioned table parts, we need to reflow their
|
|
// absolutely-positioned descendants now that their dimensions are final.
|
|
FixupPositionedTableParts(aPresContext, aDesiredSize, aReflowState);
|
|
|
|
// make sure the table overflow area does include the table rect.
|
|
nsRect tableRect(0, 0, aDesiredSize.Width(), aDesiredSize.Height()) ;
|
|
|
|
if (!ShouldApplyOverflowClipping(this, aReflowState.mStyleDisplay)) {
|
|
// collapsed border may leak out
|
|
nsMargin bcMargin = GetExcludedOuterBCBorder();
|
|
tableRect.Inflate(bcMargin);
|
|
}
|
|
aDesiredSize.mOverflowAreas.UnionAllWith(tableRect);
|
|
|
|
if ((GetStateBits() & NS_FRAME_FIRST_REFLOW) ||
|
|
nsSize(aDesiredSize.Width(), aDesiredSize.Height()) != mRect.Size()) {
|
|
nsIFrame::InvalidateFrame();
|
|
}
|
|
|
|
FinishAndStoreOverflow(&aDesiredSize);
|
|
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
|
|
return rv;
|
|
}
|
|
|
|
void
|
|
nsTableFrame::FixupPositionedTableParts(nsPresContext* aPresContext,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState)
|
|
{
|
|
auto positionedParts =
|
|
static_cast<FrameTArray*>(Properties().Get(PositionedTablePartArray()));
|
|
if (!positionedParts) {
|
|
return;
|
|
}
|
|
|
|
OverflowChangedTracker overflowTracker;
|
|
overflowTracker.SetSubtreeRoot(this);
|
|
|
|
for (size_t i = 0; i < positionedParts->Length(); ++i) {
|
|
nsIFrame* positionedPart = positionedParts->ElementAt(i);
|
|
|
|
// As we've already finished reflow, positionedParts's size and overflow
|
|
// areas have already been assigned, so we just pull them back out.
|
|
nsSize size(positionedPart->GetSize());
|
|
nsHTMLReflowMetrics desiredSize(aReflowState.GetWritingMode());
|
|
desiredSize.Width() = size.width;
|
|
desiredSize.Height() = size.height;
|
|
desiredSize.mOverflowAreas = positionedPart->GetOverflowAreasRelativeToSelf();
|
|
|
|
// Construct a dummy reflow state and reflow status.
|
|
// XXX(seth): Note that the dummy reflow state doesn't have a correct
|
|
// chain of parent reflow states. It also doesn't necessarily have a
|
|
// correct containing block.
|
|
nsHTMLReflowState reflowState(aPresContext, positionedPart,
|
|
aReflowState.rendContext,
|
|
nsSize(size.width, NS_UNCONSTRAINEDSIZE),
|
|
nsHTMLReflowState::DUMMY_PARENT_REFLOW_STATE);
|
|
nsReflowStatus reflowStatus = NS_FRAME_COMPLETE;
|
|
|
|
// Reflow absolutely-positioned descendants of the positioned part.
|
|
// FIXME: Unconditionally using NS_UNCONSTRAINEDSIZE for the height and
|
|
// ignoring any change to the reflow status aren't correct. We'll never
|
|
// paginate absolutely positioned frames.
|
|
overflowTracker.AddFrame(positionedPart,
|
|
OverflowChangedTracker::CHILDREN_AND_PARENT_CHANGED);
|
|
nsFrame* positionedFrame = static_cast<nsFrame*>(positionedPart);
|
|
positionedFrame->FinishReflowWithAbsoluteFrames(PresContext(),
|
|
desiredSize,
|
|
reflowState,
|
|
reflowStatus,
|
|
true);
|
|
}
|
|
|
|
// Propagate updated overflow areas up the tree.
|
|
overflowTracker.Flush();
|
|
|
|
// Update our own overflow areas. (OverflowChangedTracker doesn't update the
|
|
// subtree root itself.)
|
|
aDesiredSize.SetOverflowAreasToDesiredBounds();
|
|
nsLayoutUtils::UnionChildOverflow(this, aDesiredSize.mOverflowAreas);
|
|
}
|
|
|
|
bool
|
|
nsTableFrame::UpdateOverflow()
|
|
{
|
|
nsRect bounds(nsPoint(0, 0), GetSize());
|
|
|
|
// As above in Reflow, make sure the table overflow area includes the table
|
|
// rect, and check for collapsed borders leaking out.
|
|
if (!ShouldApplyOverflowClipping(this, StyleDisplay())) {
|
|
nsMargin bcMargin = GetExcludedOuterBCBorder();
|
|
bounds.Inflate(bcMargin);
|
|
}
|
|
|
|
nsOverflowAreas overflowAreas(bounds, bounds);
|
|
nsLayoutUtils::UnionChildOverflow(this, overflowAreas);
|
|
|
|
return FinishAndStoreOverflow(overflowAreas, GetSize());
|
|
}
|
|
|
|
nsresult
|
|
nsTableFrame::ReflowTable(nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nscoord aAvailHeight,
|
|
nsIFrame*& aLastChildReflowed,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
aLastChildReflowed = nullptr;
|
|
|
|
if (!GetPrevInFlow()) {
|
|
mTableLayoutStrategy->ComputeColumnWidths(aReflowState);
|
|
}
|
|
// Constrain our reflow width to the computed table width (of the 1st in flow).
|
|
// and our reflow height to our avail height minus border, padding, cellspacing
|
|
aDesiredSize.Width() = aReflowState.ComputedWidth() +
|
|
aReflowState.ComputedPhysicalBorderPadding().LeftRight();
|
|
nsTableReflowState reflowState(*PresContext(), aReflowState, *this,
|
|
aDesiredSize.Width(), aAvailHeight);
|
|
ReflowChildren(reflowState, aStatus, aLastChildReflowed,
|
|
aDesiredSize.mOverflowAreas);
|
|
|
|
ReflowColGroups(aReflowState.rendContext);
|
|
return rv;
|
|
}
|
|
|
|
nsIFrame*
|
|
nsTableFrame::GetFirstBodyRowGroupFrame()
|
|
{
|
|
nsIFrame* headerFrame = nullptr;
|
|
nsIFrame* footerFrame = nullptr;
|
|
|
|
for (nsIFrame* kidFrame = mFrames.FirstChild(); nullptr != kidFrame; ) {
|
|
const nsStyleDisplay* childDisplay = kidFrame->StyleDisplay();
|
|
|
|
// We expect the header and footer row group frames to be first, and we only
|
|
// allow one header and one footer
|
|
if (NS_STYLE_DISPLAY_TABLE_HEADER_GROUP == childDisplay->mDisplay) {
|
|
if (headerFrame) {
|
|
// We already have a header frame and so this header frame is treated
|
|
// like an ordinary body row group frame
|
|
return kidFrame;
|
|
}
|
|
headerFrame = kidFrame;
|
|
|
|
} else if (NS_STYLE_DISPLAY_TABLE_FOOTER_GROUP == childDisplay->mDisplay) {
|
|
if (footerFrame) {
|
|
// We already have a footer frame and so this footer frame is treated
|
|
// like an ordinary body row group frame
|
|
return kidFrame;
|
|
}
|
|
footerFrame = kidFrame;
|
|
|
|
} else if (NS_STYLE_DISPLAY_TABLE_ROW_GROUP == childDisplay->mDisplay) {
|
|
return kidFrame;
|
|
}
|
|
|
|
// Get the next child
|
|
kidFrame = kidFrame->GetNextSibling();
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
// Table specific version that takes into account repeated header and footer
|
|
// frames when continuing table frames
|
|
void
|
|
nsTableFrame::PushChildren(const RowGroupArray& aRowGroups,
|
|
int32_t aPushFrom)
|
|
{
|
|
NS_PRECONDITION(aPushFrom > 0, "pushing first child");
|
|
|
|
// extract the frames from the array into a sibling list
|
|
nsFrameList frames;
|
|
uint32_t childX;
|
|
for (childX = aPushFrom; childX < aRowGroups.Length(); ++childX) {
|
|
nsTableRowGroupFrame* rgFrame = aRowGroups[childX];
|
|
if (!rgFrame->IsRepeatable()) {
|
|
mFrames.RemoveFrame(rgFrame);
|
|
frames.AppendFrame(nullptr, rgFrame);
|
|
}
|
|
}
|
|
|
|
if (frames.IsEmpty()) {
|
|
return;
|
|
}
|
|
|
|
nsTableFrame* nextInFlow = static_cast<nsTableFrame*>(GetNextInFlow());
|
|
if (nextInFlow) {
|
|
// Insert the frames after any repeated header and footer frames.
|
|
nsIFrame* firstBodyFrame = nextInFlow->GetFirstBodyRowGroupFrame();
|
|
nsIFrame* prevSibling = nullptr;
|
|
if (firstBodyFrame) {
|
|
prevSibling = firstBodyFrame->GetPrevSibling();
|
|
}
|
|
// When pushing and pulling frames we need to check for whether any
|
|
// views need to be reparented.
|
|
ReparentFrameViewList(frames, this, nextInFlow);
|
|
nextInFlow->mFrames.InsertFrames(nextInFlow, prevSibling,
|
|
frames);
|
|
}
|
|
else {
|
|
// Add the frames to our overflow list.
|
|
SetOverflowFrames(frames);
|
|
}
|
|
}
|
|
|
|
// collapsing row groups, rows, col groups and cols are accounted for after both passes of
|
|
// reflow so that it has no effect on the calculations of reflow.
|
|
void
|
|
nsTableFrame::AdjustForCollapsingRowsCols(nsHTMLReflowMetrics& aDesiredSize,
|
|
nsMargin aBorderPadding)
|
|
{
|
|
nscoord yTotalOffset = 0; // total offset among all rows in all row groups
|
|
|
|
// reset the bit, it will be set again if row/rowgroup or col/colgroup are
|
|
// collapsed
|
|
SetNeedToCollapse(false);
|
|
|
|
// collapse the rows and/or row groups as necessary
|
|
// Get the ordered children
|
|
RowGroupArray rowGroups;
|
|
OrderRowGroups(rowGroups);
|
|
|
|
nsTableFrame* firstInFlow = static_cast<nsTableFrame*>(FirstInFlow());
|
|
nscoord width = firstInFlow->GetCollapsedWidth(aBorderPadding);
|
|
nscoord rgWidth = width - 2 * GetCellSpacingX();
|
|
nsOverflowAreas overflow;
|
|
// Walk the list of children
|
|
for (uint32_t childX = 0; childX < rowGroups.Length(); childX++) {
|
|
nsTableRowGroupFrame* rgFrame = rowGroups[childX];
|
|
NS_ASSERTION(rgFrame, "Must have row group frame here");
|
|
yTotalOffset += rgFrame->CollapseRowGroupIfNecessary(yTotalOffset, rgWidth);
|
|
ConsiderChildOverflow(overflow, rgFrame);
|
|
}
|
|
|
|
aDesiredSize.Height() -= yTotalOffset;
|
|
aDesiredSize.Width() = width;
|
|
overflow.UnionAllWith(nsRect(0, 0, aDesiredSize.Width(), aDesiredSize.Height()));
|
|
FinishAndStoreOverflow(overflow,
|
|
nsSize(aDesiredSize.Width(), aDesiredSize.Height()));
|
|
}
|
|
|
|
|
|
nscoord
|
|
nsTableFrame::GetCollapsedWidth(nsMargin aBorderPadding)
|
|
{
|
|
NS_ASSERTION(!GetPrevInFlow(), "GetCollapsedWidth called on next in flow");
|
|
nscoord cellSpacingX = GetCellSpacingX();
|
|
nscoord width = cellSpacingX;
|
|
width += aBorderPadding.left + aBorderPadding.right;
|
|
for (nsIFrame* groupFrame = mColGroups.FirstChild(); groupFrame;
|
|
groupFrame = groupFrame->GetNextSibling()) {
|
|
const nsStyleVisibility* groupVis = groupFrame->StyleVisibility();
|
|
bool collapseGroup = (NS_STYLE_VISIBILITY_COLLAPSE == groupVis->mVisible);
|
|
nsTableColGroupFrame* cgFrame = (nsTableColGroupFrame*)groupFrame;
|
|
for (nsTableColFrame* colFrame = cgFrame->GetFirstColumn(); colFrame;
|
|
colFrame = colFrame->GetNextCol()) {
|
|
const nsStyleDisplay* colDisplay = colFrame->StyleDisplay();
|
|
int32_t colX = colFrame->GetColIndex();
|
|
if (NS_STYLE_DISPLAY_TABLE_COLUMN == colDisplay->mDisplay) {
|
|
const nsStyleVisibility* colVis = colFrame->StyleVisibility();
|
|
bool collapseCol = (NS_STYLE_VISIBILITY_COLLAPSE == colVis->mVisible);
|
|
int32_t colWidth = GetColumnWidth(colX);
|
|
if (!collapseGroup && !collapseCol) {
|
|
width += colWidth;
|
|
if (ColumnHasCellSpacingBefore(colX))
|
|
width += cellSpacingX;
|
|
}
|
|
else {
|
|
SetNeedToCollapse(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return width;
|
|
}
|
|
|
|
/* virtual */ void
|
|
nsTableFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)
|
|
{
|
|
nsContainerFrame::DidSetStyleContext(aOldStyleContext);
|
|
|
|
if (!aOldStyleContext) //avoid this on init
|
|
return;
|
|
|
|
if (IsBorderCollapse() &&
|
|
BCRecalcNeeded(aOldStyleContext, StyleContext())) {
|
|
SetFullBCDamageArea();
|
|
}
|
|
|
|
//avoid this on init or nextinflow
|
|
if (!mTableLayoutStrategy || GetPrevInFlow())
|
|
return;
|
|
|
|
bool isAuto = IsAutoLayout();
|
|
if (isAuto != (LayoutStrategy()->GetType() == nsITableLayoutStrategy::Auto)) {
|
|
nsITableLayoutStrategy* temp;
|
|
if (isAuto)
|
|
temp = new BasicTableLayoutStrategy(this);
|
|
else
|
|
temp = new FixedTableLayoutStrategy(this);
|
|
|
|
if (temp) {
|
|
delete mTableLayoutStrategy;
|
|
mTableLayoutStrategy = temp;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
nsTableFrame::AppendFrames(ChildListID aListID,
|
|
nsFrameList& aFrameList)
|
|
{
|
|
NS_ASSERTION(aListID == kPrincipalList || aListID == kColGroupList,
|
|
"unexpected child list");
|
|
|
|
// Because we actually have two child lists, one for col group frames and one
|
|
// for everything else, we need to look at each frame individually
|
|
// XXX The frame construction code should be separating out child frames
|
|
// based on the type, bug 343048.
|
|
while (!aFrameList.IsEmpty()) {
|
|
nsIFrame* f = aFrameList.FirstChild();
|
|
aFrameList.RemoveFrame(f);
|
|
|
|
// See what kind of frame we have
|
|
const nsStyleDisplay* display = f->StyleDisplay();
|
|
|
|
if (NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP == display->mDisplay) {
|
|
nsTableColGroupFrame* lastColGroup =
|
|
nsTableColGroupFrame::GetLastRealColGroup(this);
|
|
int32_t startColIndex = (lastColGroup)
|
|
? lastColGroup->GetStartColumnIndex() + lastColGroup->GetColCount() : 0;
|
|
mColGroups.InsertFrame(nullptr, lastColGroup, f);
|
|
// Insert the colgroup and its cols into the table
|
|
InsertColGroups(startColIndex,
|
|
nsFrameList::Slice(mColGroups, f, f->GetNextSibling()));
|
|
} else if (IsRowGroup(display->mDisplay)) {
|
|
// Append the new row group frame to the sibling chain
|
|
mFrames.AppendFrame(nullptr, f);
|
|
|
|
// insert the row group and its rows into the table
|
|
InsertRowGroups(nsFrameList::Slice(mFrames, f, nullptr));
|
|
} else {
|
|
// Nothing special to do, just add the frame to our child list
|
|
NS_NOTREACHED("How did we get here? Frame construction screwed up");
|
|
mFrames.AppendFrame(nullptr, f);
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUG_TABLE_CELLMAP
|
|
printf("=== TableFrame::AppendFrames\n");
|
|
Dump(true, true, true);
|
|
#endif
|
|
PresContext()->PresShell()->FrameNeedsReflow(this, nsIPresShell::eTreeChange,
|
|
NS_FRAME_HAS_DIRTY_CHILDREN);
|
|
SetGeometryDirty();
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
// Needs to be at file scope or ArrayLength fails to compile.
|
|
struct ChildListInsertions {
|
|
nsIFrame::ChildListID mID;
|
|
nsFrameList mList;
|
|
};
|
|
|
|
nsresult
|
|
nsTableFrame::InsertFrames(ChildListID aListID,
|
|
nsIFrame* aPrevFrame,
|
|
nsFrameList& aFrameList)
|
|
{
|
|
// The frames in aFrameList can be a mix of row group frames and col group
|
|
// frames. The problem is that they should go in separate child lists so
|
|
// we need to deal with that here...
|
|
// XXX The frame construction code should be separating out child frames
|
|
// based on the type, bug 343048.
|
|
|
|
NS_ASSERTION(!aPrevFrame || aPrevFrame->GetParent() == this,
|
|
"inserting after sibling frame with different parent");
|
|
|
|
if ((aPrevFrame && !aPrevFrame->GetNextSibling()) ||
|
|
(!aPrevFrame && GetChildList(aListID).IsEmpty())) {
|
|
// Treat this like an append; still a workaround for bug 343048.
|
|
return AppendFrames(aListID, aFrameList);
|
|
}
|
|
|
|
// Collect ColGroupFrames into a separate list and insert those separately
|
|
// from the other frames (bug 759249).
|
|
ChildListInsertions insertions[2]; // ColGroup, other
|
|
const nsStyleDisplay* display = aFrameList.FirstChild()->StyleDisplay();
|
|
nsFrameList::FrameLinkEnumerator e(aFrameList);
|
|
for (; !aFrameList.IsEmpty(); e.Next()) {
|
|
nsIFrame* next = e.NextFrame();
|
|
if (!next || next->StyleDisplay()->mDisplay != display->mDisplay) {
|
|
nsFrameList head = aFrameList.ExtractHead(e);
|
|
if (display->mDisplay == NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP) {
|
|
insertions[0].mID = kColGroupList;
|
|
insertions[0].mList.AppendFrames(nullptr, head);
|
|
} else {
|
|
insertions[1].mID = kPrincipalList;
|
|
insertions[1].mList.AppendFrames(nullptr, head);
|
|
}
|
|
if (!next) {
|
|
break;
|
|
}
|
|
display = next->StyleDisplay();
|
|
}
|
|
}
|
|
for (uint32_t i = 0; i < ArrayLength(insertions); ++i) {
|
|
// We pass aPrevFrame for both ColGroup and other frames since
|
|
// HomogenousInsertFrames will only use it if it's a suitable
|
|
// prev-sibling for the frames in the frame list.
|
|
if (!insertions[i].mList.IsEmpty()) {
|
|
HomogenousInsertFrames(insertions[i].mID, aPrevFrame,
|
|
insertions[i].mList);
|
|
}
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsTableFrame::HomogenousInsertFrames(ChildListID aListID,
|
|
nsIFrame* aPrevFrame,
|
|
nsFrameList& aFrameList)
|
|
{
|
|
// See what kind of frame we have
|
|
const nsStyleDisplay* display = aFrameList.FirstChild()->StyleDisplay();
|
|
#ifdef DEBUG
|
|
// Verify that either all siblings have display:table-column-group, or they
|
|
// all have display values different from table-column-group.
|
|
for (nsFrameList::Enumerator e(aFrameList); !e.AtEnd(); e.Next()) {
|
|
const nsStyleDisplay* nextDisplay = e.get()->StyleDisplay();
|
|
MOZ_ASSERT((display->mDisplay == NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP) ==
|
|
(nextDisplay->mDisplay == NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP),
|
|
"heterogenous childlist");
|
|
}
|
|
#endif
|
|
if (aPrevFrame) {
|
|
const nsStyleDisplay* prevDisplay = aPrevFrame->StyleDisplay();
|
|
// Make sure they belong on the same frame list
|
|
if ((display->mDisplay == NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP) !=
|
|
(prevDisplay->mDisplay == NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP)) {
|
|
// the previous frame is not valid, see comment at ::AppendFrames
|
|
// XXXbz Using content indices here means XBL will get screwed
|
|
// over... Oh, well.
|
|
nsIFrame* pseudoFrame = aFrameList.FirstChild();
|
|
nsIContent* parentContent = GetContent();
|
|
nsIContent* content;
|
|
aPrevFrame = nullptr;
|
|
while (pseudoFrame && (parentContent ==
|
|
(content = pseudoFrame->GetContent()))) {
|
|
pseudoFrame = pseudoFrame->GetFirstPrincipalChild();
|
|
}
|
|
nsCOMPtr<nsIContent> container = content->GetParent();
|
|
if (MOZ_LIKELY(container)) { // XXX need this null-check, see bug 411823.
|
|
int32_t newIndex = container->IndexOf(content);
|
|
nsIFrame* kidFrame;
|
|
bool isColGroup = (NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP ==
|
|
display->mDisplay);
|
|
nsTableColGroupFrame* lastColGroup;
|
|
if (isColGroup) {
|
|
kidFrame = mColGroups.FirstChild();
|
|
lastColGroup = nsTableColGroupFrame::GetLastRealColGroup(this);
|
|
}
|
|
else {
|
|
kidFrame = mFrames.FirstChild();
|
|
}
|
|
// Important: need to start at a value smaller than all valid indices
|
|
int32_t lastIndex = -1;
|
|
while (kidFrame) {
|
|
if (isColGroup) {
|
|
if (kidFrame == lastColGroup) {
|
|
aPrevFrame = kidFrame; // there is no real colgroup after this one
|
|
break;
|
|
}
|
|
}
|
|
pseudoFrame = kidFrame;
|
|
while (pseudoFrame && (parentContent ==
|
|
(content = pseudoFrame->GetContent()))) {
|
|
pseudoFrame = pseudoFrame->GetFirstPrincipalChild();
|
|
}
|
|
int32_t index = container->IndexOf(content);
|
|
if (index > lastIndex && index < newIndex) {
|
|
lastIndex = index;
|
|
aPrevFrame = kidFrame;
|
|
}
|
|
kidFrame = kidFrame->GetNextSibling();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP == display->mDisplay) {
|
|
NS_ASSERTION(aListID == kColGroupList, "unexpected child list");
|
|
// Insert the column group frames
|
|
const nsFrameList::Slice& newColgroups =
|
|
mColGroups.InsertFrames(nullptr, aPrevFrame, aFrameList);
|
|
// find the starting col index for the first new col group
|
|
int32_t startColIndex = 0;
|
|
if (aPrevFrame) {
|
|
nsTableColGroupFrame* prevColGroup =
|
|
(nsTableColGroupFrame*)GetFrameAtOrBefore(this, aPrevFrame,
|
|
nsGkAtoms::tableColGroupFrame);
|
|
if (prevColGroup) {
|
|
startColIndex = prevColGroup->GetStartColumnIndex() + prevColGroup->GetColCount();
|
|
}
|
|
}
|
|
InsertColGroups(startColIndex, newColgroups);
|
|
} else if (IsRowGroup(display->mDisplay)) {
|
|
NS_ASSERTION(aListID == kPrincipalList, "unexpected child list");
|
|
// Insert the frames in the sibling chain
|
|
const nsFrameList::Slice& newRowGroups =
|
|
mFrames.InsertFrames(nullptr, aPrevFrame, aFrameList);
|
|
|
|
InsertRowGroups(newRowGroups);
|
|
} else {
|
|
NS_ASSERTION(aListID == kPrincipalList, "unexpected child list");
|
|
NS_NOTREACHED("How did we even get here?");
|
|
// Just insert the frame and don't worry about reflowing it
|
|
mFrames.InsertFrames(nullptr, aPrevFrame, aFrameList);
|
|
return;
|
|
}
|
|
|
|
PresContext()->PresShell()->FrameNeedsReflow(this, nsIPresShell::eTreeChange,
|
|
NS_FRAME_HAS_DIRTY_CHILDREN);
|
|
SetGeometryDirty();
|
|
#ifdef DEBUG_TABLE_CELLMAP
|
|
printf("=== TableFrame::InsertFrames\n");
|
|
Dump(true, true, true);
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
void
|
|
nsTableFrame::DoRemoveFrame(ChildListID aListID,
|
|
nsIFrame* aOldFrame)
|
|
{
|
|
if (aListID == kColGroupList) {
|
|
nsIFrame* nextColGroupFrame = aOldFrame->GetNextSibling();
|
|
nsTableColGroupFrame* colGroup = (nsTableColGroupFrame*)aOldFrame;
|
|
int32_t firstColIndex = colGroup->GetStartColumnIndex();
|
|
int32_t lastColIndex = firstColIndex + colGroup->GetColCount() - 1;
|
|
mColGroups.DestroyFrame(aOldFrame);
|
|
nsTableColGroupFrame::ResetColIndices(nextColGroupFrame, firstColIndex);
|
|
// remove the cols from the table
|
|
int32_t colX;
|
|
for (colX = lastColIndex; colX >= firstColIndex; colX--) {
|
|
nsTableColFrame* colFrame = mColFrames.SafeElementAt(colX);
|
|
if (colFrame) {
|
|
RemoveCol(colGroup, colX, true, false);
|
|
}
|
|
}
|
|
|
|
int32_t numAnonymousColsToAdd = GetColCount() - mColFrames.Length();
|
|
if (numAnonymousColsToAdd > 0) {
|
|
// this sets the child list, updates the col cache and cell map
|
|
AppendAnonymousColFrames(numAnonymousColsToAdd);
|
|
}
|
|
|
|
} else {
|
|
NS_ASSERTION(aListID == kPrincipalList, "unexpected child list");
|
|
nsTableRowGroupFrame* rgFrame =
|
|
static_cast<nsTableRowGroupFrame*>(aOldFrame);
|
|
// remove the row group from the cell map
|
|
nsTableCellMap* cellMap = GetCellMap();
|
|
if (cellMap) {
|
|
cellMap->RemoveGroupCellMap(rgFrame);
|
|
}
|
|
|
|
// remove the row group frame from the sibling chain
|
|
mFrames.DestroyFrame(aOldFrame);
|
|
|
|
// the removal of a row group changes the cellmap, the columns might change
|
|
if (cellMap) {
|
|
cellMap->Synchronize(this);
|
|
// Create an empty slice
|
|
ResetRowIndices(nsFrameList::Slice(mFrames, nullptr, nullptr));
|
|
nsIntRect damageArea;
|
|
cellMap->RebuildConsideringCells(nullptr, nullptr, 0, 0, false, damageArea);
|
|
|
|
static_cast<nsTableFrame*>(FirstInFlow())->MatchCellMapToColCache(cellMap);
|
|
}
|
|
}
|
|
}
|
|
|
|
nsresult
|
|
nsTableFrame::RemoveFrame(ChildListID aListID,
|
|
nsIFrame* aOldFrame)
|
|
{
|
|
NS_ASSERTION(aListID == kColGroupList ||
|
|
NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP !=
|
|
aOldFrame->StyleDisplay()->mDisplay,
|
|
"Wrong list name; use kColGroupList iff colgroup");
|
|
nsIPresShell* shell = PresContext()->PresShell();
|
|
nsTableFrame* lastParent = nullptr;
|
|
while (aOldFrame) {
|
|
nsIFrame* oldFrameNextContinuation = aOldFrame->GetNextContinuation();
|
|
nsTableFrame* parent = static_cast<nsTableFrame*>(aOldFrame->GetParent());
|
|
if (parent != lastParent) {
|
|
parent->DrainSelfOverflowList();
|
|
}
|
|
parent->DoRemoveFrame(aListID, aOldFrame);
|
|
aOldFrame = oldFrameNextContinuation;
|
|
if (parent != lastParent) {
|
|
// for now, just bail and recalc all of the collapsing borders
|
|
// as the cellmap changes we need to recalc
|
|
if (parent->IsBorderCollapse()) {
|
|
parent->SetFullBCDamageArea();
|
|
}
|
|
parent->SetGeometryDirty();
|
|
shell->FrameNeedsReflow(parent, nsIPresShell::eTreeChange,
|
|
NS_FRAME_HAS_DIRTY_CHILDREN);
|
|
lastParent = parent;
|
|
}
|
|
}
|
|
#ifdef DEBUG_TABLE_CELLMAP
|
|
printf("=== TableFrame::RemoveFrame\n");
|
|
Dump(true, true, true);
|
|
#endif
|
|
return NS_OK;
|
|
}
|
|
|
|
/* virtual */ nsMargin
|
|
nsTableFrame::GetUsedBorder() const
|
|
{
|
|
if (!IsBorderCollapse())
|
|
return nsContainerFrame::GetUsedBorder();
|
|
|
|
return GetIncludedOuterBCBorder();
|
|
}
|
|
|
|
/* virtual */ nsMargin
|
|
nsTableFrame::GetUsedPadding() const
|
|
{
|
|
if (!IsBorderCollapse())
|
|
return nsContainerFrame::GetUsedPadding();
|
|
|
|
return nsMargin(0,0,0,0);
|
|
}
|
|
|
|
/* virtual */ nsMargin
|
|
nsTableFrame::GetUsedMargin() const
|
|
{
|
|
// The margin is inherited to the outer table frame via
|
|
// the ::-moz-table-outer rule in ua.css.
|
|
return nsMargin(0, 0, 0, 0);
|
|
}
|
|
|
|
// Destructor function for BCPropertyData properties
|
|
static void
|
|
DestroyBCProperty(void* aPropertyValue)
|
|
{
|
|
delete static_cast<BCPropertyData*>(aPropertyValue);
|
|
}
|
|
|
|
NS_DECLARE_FRAME_PROPERTY(TableBCProperty, DestroyBCProperty)
|
|
|
|
BCPropertyData*
|
|
nsTableFrame::GetBCProperty(bool aCreateIfNecessary) const
|
|
{
|
|
FrameProperties props = Properties();
|
|
BCPropertyData* value = static_cast<BCPropertyData*>
|
|
(props.Get(TableBCProperty()));
|
|
if (!value && aCreateIfNecessary) {
|
|
value = new BCPropertyData();
|
|
props.Set(TableBCProperty(), value);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
static void
|
|
DivideBCBorderSize(BCPixelSize aPixelSize,
|
|
BCPixelSize& aSmallHalf,
|
|
BCPixelSize& aLargeHalf)
|
|
{
|
|
aSmallHalf = aPixelSize / 2;
|
|
aLargeHalf = aPixelSize - aSmallHalf;
|
|
}
|
|
|
|
nsMargin
|
|
nsTableFrame::GetOuterBCBorder() const
|
|
{
|
|
if (NeedToCalcBCBorders())
|
|
const_cast<nsTableFrame*>(this)->CalcBCBorders();
|
|
|
|
nsMargin border(0, 0, 0, 0);
|
|
int32_t p2t = nsPresContext::AppUnitsPerCSSPixel();
|
|
BCPropertyData* propData = GetBCProperty();
|
|
if (propData) {
|
|
border.top = BC_BORDER_TOP_HALF_COORD(p2t, propData->mTopBorderWidth);
|
|
border.right = BC_BORDER_RIGHT_HALF_COORD(p2t, propData->mRightBorderWidth);
|
|
border.bottom = BC_BORDER_BOTTOM_HALF_COORD(p2t, propData->mBottomBorderWidth);
|
|
border.left = BC_BORDER_LEFT_HALF_COORD(p2t, propData->mLeftBorderWidth);
|
|
}
|
|
return border;
|
|
}
|
|
|
|
nsMargin
|
|
nsTableFrame::GetIncludedOuterBCBorder() const
|
|
{
|
|
if (NeedToCalcBCBorders())
|
|
const_cast<nsTableFrame*>(this)->CalcBCBorders();
|
|
|
|
nsMargin border(0, 0, 0, 0);
|
|
int32_t p2t = nsPresContext::AppUnitsPerCSSPixel();
|
|
BCPropertyData* propData = GetBCProperty();
|
|
if (propData) {
|
|
border.top += BC_BORDER_TOP_HALF_COORD(p2t, propData->mTopBorderWidth);
|
|
border.right += BC_BORDER_RIGHT_HALF_COORD(p2t, propData->mRightCellBorderWidth);
|
|
border.bottom += BC_BORDER_BOTTOM_HALF_COORD(p2t, propData->mBottomBorderWidth);
|
|
border.left += BC_BORDER_LEFT_HALF_COORD(p2t, propData->mLeftCellBorderWidth);
|
|
}
|
|
return border;
|
|
}
|
|
|
|
nsMargin
|
|
nsTableFrame::GetExcludedOuterBCBorder() const
|
|
{
|
|
return GetOuterBCBorder() - GetIncludedOuterBCBorder();
|
|
}
|
|
|
|
static
|
|
void GetSeparateModelBorderPadding(const nsHTMLReflowState* aReflowState,
|
|
nsStyleContext& aStyleContext,
|
|
nsMargin& aBorderPadding)
|
|
{
|
|
// XXXbz Either we _do_ have a reflow state and then we can use its
|
|
// mComputedBorderPadding or we don't and then we get the padding
|
|
// wrong!
|
|
const nsStyleBorder* border = aStyleContext.StyleBorder();
|
|
aBorderPadding = border->GetComputedBorder();
|
|
if (aReflowState) {
|
|
aBorderPadding += aReflowState->ComputedPhysicalPadding();
|
|
}
|
|
}
|
|
|
|
nsMargin
|
|
nsTableFrame::GetChildAreaOffset(const nsHTMLReflowState* aReflowState) const
|
|
{
|
|
nsMargin offset(0,0,0,0);
|
|
if (IsBorderCollapse()) {
|
|
offset = GetIncludedOuterBCBorder();
|
|
}
|
|
else {
|
|
GetSeparateModelBorderPadding(aReflowState, *mStyleContext, offset);
|
|
}
|
|
return offset;
|
|
}
|
|
|
|
void
|
|
nsTableFrame::InitChildReflowState(nsHTMLReflowState& aReflowState)
|
|
{
|
|
nsMargin collapseBorder;
|
|
nsMargin padding(0,0,0,0);
|
|
nsMargin* pCollapseBorder = nullptr;
|
|
nsPresContext* presContext = PresContext();
|
|
if (IsBorderCollapse()) {
|
|
nsTableRowGroupFrame* rgFrame =
|
|
static_cast<nsTableRowGroupFrame*>(aReflowState.frame);
|
|
pCollapseBorder = rgFrame->GetBCBorderWidth(collapseBorder);
|
|
}
|
|
aReflowState.Init(presContext, -1, -1, pCollapseBorder, &padding);
|
|
|
|
NS_ASSERTION(!mBits.mResizedColumns ||
|
|
!aReflowState.parentReflowState->mFlags.mSpecialHeightReflow,
|
|
"should not resize columns on special height reflow");
|
|
if (mBits.mResizedColumns) {
|
|
aReflowState.mFlags.mHResize = true;
|
|
}
|
|
}
|
|
|
|
// Position and size aKidFrame and update our reflow state. The origin of
|
|
// aKidRect is relative to the upper-left origin of our frame
|
|
void nsTableFrame::PlaceChild(nsTableReflowState& aReflowState,
|
|
nsIFrame* aKidFrame,
|
|
nsHTMLReflowMetrics& aKidDesiredSize,
|
|
const nsRect& aOriginalKidRect,
|
|
const nsRect& aOriginalKidVisualOverflow)
|
|
{
|
|
bool isFirstReflow =
|
|
(aKidFrame->GetStateBits() & NS_FRAME_FIRST_REFLOW) != 0;
|
|
|
|
// Place and size the child
|
|
FinishReflowChild(aKidFrame, PresContext(), aKidDesiredSize, nullptr,
|
|
aReflowState.x, aReflowState.y, 0);
|
|
|
|
InvalidateTableFrame(aKidFrame, aOriginalKidRect, aOriginalKidVisualOverflow,
|
|
isFirstReflow);
|
|
|
|
// Adjust the running y-offset
|
|
aReflowState.y += aKidDesiredSize.Height();
|
|
|
|
// If our height is constrained, then update the available height
|
|
if (NS_UNCONSTRAINEDSIZE != aReflowState.availSize.height) {
|
|
aReflowState.availSize.height -= aKidDesiredSize.Height();
|
|
}
|
|
}
|
|
|
|
void
|
|
nsTableFrame::OrderRowGroups(RowGroupArray& aChildren,
|
|
nsTableRowGroupFrame** aHead,
|
|
nsTableRowGroupFrame** aFoot) const
|
|
{
|
|
aChildren.Clear();
|
|
nsTableRowGroupFrame* head = nullptr;
|
|
nsTableRowGroupFrame* foot = nullptr;
|
|
|
|
nsIFrame* kidFrame = mFrames.FirstChild();
|
|
while (kidFrame) {
|
|
const nsStyleDisplay* kidDisplay = kidFrame->StyleDisplay();
|
|
nsTableRowGroupFrame* rowGroup =
|
|
static_cast<nsTableRowGroupFrame*>(kidFrame);
|
|
|
|
switch (kidDisplay->mDisplay) {
|
|
case NS_STYLE_DISPLAY_TABLE_HEADER_GROUP:
|
|
if (head) { // treat additional thead like tbody
|
|
aChildren.AppendElement(rowGroup);
|
|
}
|
|
else {
|
|
head = rowGroup;
|
|
}
|
|
break;
|
|
case NS_STYLE_DISPLAY_TABLE_FOOTER_GROUP:
|
|
if (foot) { // treat additional tfoot like tbody
|
|
aChildren.AppendElement(rowGroup);
|
|
}
|
|
else {
|
|
foot = rowGroup;
|
|
}
|
|
break;
|
|
case NS_STYLE_DISPLAY_TABLE_ROW_GROUP:
|
|
aChildren.AppendElement(rowGroup);
|
|
break;
|
|
default:
|
|
NS_NOTREACHED("How did this produce an nsTableRowGroupFrame?");
|
|
// Just ignore it
|
|
break;
|
|
}
|
|
// Get the next sibling but skip it if it's also the next-in-flow, since
|
|
// a next-in-flow will not be part of the current table.
|
|
while (kidFrame) {
|
|
nsIFrame* nif = kidFrame->GetNextInFlow();
|
|
kidFrame = kidFrame->GetNextSibling();
|
|
if (kidFrame != nif)
|
|
break;
|
|
}
|
|
}
|
|
|
|
// put the thead first
|
|
if (head) {
|
|
aChildren.InsertElementAt(0, head);
|
|
}
|
|
if (aHead)
|
|
*aHead = head;
|
|
// put the tfoot after the last tbody
|
|
if (foot) {
|
|
aChildren.AppendElement(foot);
|
|
}
|
|
if (aFoot)
|
|
*aFoot = foot;
|
|
}
|
|
|
|
nsTableRowGroupFrame*
|
|
nsTableFrame::GetTHead() const
|
|
{
|
|
nsIFrame* kidFrame = mFrames.FirstChild();
|
|
while (kidFrame) {
|
|
if (kidFrame->StyleDisplay()->mDisplay ==
|
|
NS_STYLE_DISPLAY_TABLE_HEADER_GROUP) {
|
|
return static_cast<nsTableRowGroupFrame*>(kidFrame);
|
|
}
|
|
|
|
// Get the next sibling but skip it if it's also the next-in-flow, since
|
|
// a next-in-flow will not be part of the current table.
|
|
while (kidFrame) {
|
|
nsIFrame* nif = kidFrame->GetNextInFlow();
|
|
kidFrame = kidFrame->GetNextSibling();
|
|
if (kidFrame != nif)
|
|
break;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
nsTableRowGroupFrame*
|
|
nsTableFrame::GetTFoot() const
|
|
{
|
|
nsIFrame* kidFrame = mFrames.FirstChild();
|
|
while (kidFrame) {
|
|
if (kidFrame->StyleDisplay()->mDisplay ==
|
|
NS_STYLE_DISPLAY_TABLE_FOOTER_GROUP) {
|
|
return static_cast<nsTableRowGroupFrame*>(kidFrame);
|
|
}
|
|
|
|
// Get the next sibling but skip it if it's also the next-in-flow, since
|
|
// a next-in-flow will not be part of the current table.
|
|
while (kidFrame) {
|
|
nsIFrame* nif = kidFrame->GetNextInFlow();
|
|
kidFrame = kidFrame->GetNextSibling();
|
|
if (kidFrame != nif)
|
|
break;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
static bool
|
|
IsRepeatable(nscoord aFrameHeight, nscoord aPageHeight)
|
|
{
|
|
return aFrameHeight < (aPageHeight / 4);
|
|
}
|
|
|
|
nsresult
|
|
nsTableFrame::SetupHeaderFooterChild(const nsTableReflowState& aReflowState,
|
|
nsTableRowGroupFrame* aFrame,
|
|
nscoord* aDesiredHeight)
|
|
{
|
|
nsPresContext* presContext = PresContext();
|
|
nscoord pageHeight = presContext->GetPageSize().height;
|
|
|
|
// Reflow the child with unconstrainted height
|
|
nsHTMLReflowState kidReflowState(presContext, aReflowState.reflowState,
|
|
aFrame,
|
|
nsSize(aReflowState.availSize.width, NS_UNCONSTRAINEDSIZE),
|
|
-1, -1, nsHTMLReflowState::CALLER_WILL_INIT);
|
|
InitChildReflowState(kidReflowState);
|
|
kidReflowState.mFlags.mIsTopOfPage = true;
|
|
nsHTMLReflowMetrics desiredSize(aReflowState.reflowState);
|
|
desiredSize.Width() = desiredSize.Height() = 0;
|
|
nsReflowStatus status;
|
|
nsresult rv = ReflowChild(aFrame, presContext, desiredSize, kidReflowState,
|
|
aReflowState.x, aReflowState.y, 0, status);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
// The child will be reflowed again "for real" so no need to place it now
|
|
|
|
aFrame->SetRepeatable(IsRepeatable(desiredSize.Height(), pageHeight));
|
|
*aDesiredHeight = desiredSize.Height();
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsTableFrame::PlaceRepeatedFooter(nsTableReflowState& aReflowState,
|
|
nsTableRowGroupFrame *aTfoot,
|
|
nscoord aFooterHeight)
|
|
{
|
|
nsPresContext* presContext = PresContext();
|
|
nsSize kidAvailSize(aReflowState.availSize);
|
|
kidAvailSize.height = aFooterHeight;
|
|
nsHTMLReflowState footerReflowState(presContext,
|
|
aReflowState.reflowState,
|
|
aTfoot, kidAvailSize,
|
|
-1, -1,
|
|
nsHTMLReflowState::CALLER_WILL_INIT);
|
|
InitChildReflowState(footerReflowState);
|
|
aReflowState.y += GetCellSpacingY();
|
|
|
|
nsRect origTfootRect = aTfoot->GetRect();
|
|
nsRect origTfootVisualOverflow = aTfoot->GetVisualOverflowRect();
|
|
|
|
nsReflowStatus footerStatus;
|
|
nsHTMLReflowMetrics desiredSize(aReflowState.reflowState);
|
|
desiredSize.Width() = desiredSize.Height() = 0;
|
|
ReflowChild(aTfoot, presContext, desiredSize, footerReflowState,
|
|
aReflowState.x, aReflowState.y, 0, footerStatus);
|
|
PlaceChild(aReflowState, aTfoot, desiredSize, origTfootRect,
|
|
origTfootVisualOverflow);
|
|
}
|
|
|
|
// Reflow the children based on the avail size and reason in aReflowState
|
|
// update aReflowMetrics a aStatus
|
|
nsresult
|
|
nsTableFrame::ReflowChildren(nsTableReflowState& aReflowState,
|
|
nsReflowStatus& aStatus,
|
|
nsIFrame*& aLastChildReflowed,
|
|
nsOverflowAreas& aOverflowAreas)
|
|
{
|
|
aStatus = NS_FRAME_COMPLETE;
|
|
aLastChildReflowed = nullptr;
|
|
|
|
nsIFrame* prevKidFrame = nullptr;
|
|
nsresult rv = NS_OK;
|
|
nscoord cellSpacingY = GetCellSpacingY();
|
|
|
|
nsPresContext* presContext = PresContext();
|
|
// XXXldb Should we be checking constrained height instead?
|
|
// tables are not able to pull back children from its next inflow, so even
|
|
// under paginated contexts tables are should not paginate if they are inside
|
|
// column set
|
|
bool isPaginated = presContext->IsPaginated() &&
|
|
NS_UNCONSTRAINEDSIZE != aReflowState.availSize.height &&
|
|
aReflowState.reflowState.mFlags.mTableIsSplittable;
|
|
|
|
aOverflowAreas.Clear();
|
|
|
|
bool reflowAllKids = aReflowState.reflowState.ShouldReflowAllKids() ||
|
|
mBits.mResizedColumns ||
|
|
IsGeometryDirty();
|
|
|
|
RowGroupArray rowGroups;
|
|
nsTableRowGroupFrame *thead, *tfoot;
|
|
OrderRowGroups(rowGroups, &thead, &tfoot);
|
|
bool pageBreak = false;
|
|
nscoord footerHeight = 0;
|
|
|
|
// Determine the repeatablility of headers and footers, and also the desired
|
|
// height of any repeatable footer.
|
|
// The repeatability of headers on continued tables is handled
|
|
// when they are created in nsCSSFrameConstructor::CreateContinuingTableFrame.
|
|
// We handle the repeatability of footers again here because we need to
|
|
// determine the footer's height anyway. We could perhaps optimize by
|
|
// using the footer's prev-in-flow's height instead of reflowing it again,
|
|
// but there's no real need.
|
|
if (isPaginated) {
|
|
if (thead && !GetPrevInFlow()) {
|
|
nscoord desiredHeight;
|
|
rv = SetupHeaderFooterChild(aReflowState, thead, &desiredHeight);
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
}
|
|
if (tfoot) {
|
|
rv = SetupHeaderFooterChild(aReflowState, tfoot, &footerHeight);
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
}
|
|
}
|
|
// if the child is a tbody in paginated mode reduce the height by a repeated footer
|
|
bool allowRepeatedFooter = false;
|
|
for (uint32_t childX = 0; childX < rowGroups.Length(); childX++) {
|
|
nsIFrame* kidFrame = rowGroups[childX];
|
|
// Get the frame state bits
|
|
// See if we should only reflow the dirty child frames
|
|
if (reflowAllKids ||
|
|
NS_SUBTREE_DIRTY(kidFrame) ||
|
|
(aReflowState.reflowState.mFlags.mSpecialHeightReflow &&
|
|
(isPaginated || (kidFrame->GetStateBits() &
|
|
NS_FRAME_CONTAINS_RELATIVE_HEIGHT)))) {
|
|
if (pageBreak) {
|
|
if (allowRepeatedFooter) {
|
|
PlaceRepeatedFooter(aReflowState, tfoot, footerHeight);
|
|
}
|
|
else if (tfoot && tfoot->IsRepeatable()) {
|
|
tfoot->SetRepeatable(false);
|
|
}
|
|
PushChildren(rowGroups, childX);
|
|
aStatus = NS_FRAME_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
|
|
nsSize kidAvailSize(aReflowState.availSize);
|
|
allowRepeatedFooter = false;
|
|
if (isPaginated && (NS_UNCONSTRAINEDSIZE != kidAvailSize.height)) {
|
|
nsTableRowGroupFrame* kidRG =
|
|
static_cast<nsTableRowGroupFrame*>(kidFrame);
|
|
if (kidRG != thead && kidRG != tfoot && tfoot && tfoot->IsRepeatable()) {
|
|
// the child is a tbody and there is a repeatable footer
|
|
NS_ASSERTION(tfoot == rowGroups[rowGroups.Length() - 1], "Missing footer!");
|
|
if (footerHeight + cellSpacingY < kidAvailSize.height) {
|
|
allowRepeatedFooter = true;
|
|
kidAvailSize.height -= footerHeight + cellSpacingY;
|
|
}
|
|
}
|
|
}
|
|
|
|
nsRect oldKidRect = kidFrame->GetRect();
|
|
nsRect oldKidVisualOverflow = kidFrame->GetVisualOverflowRect();
|
|
|
|
nsHTMLReflowMetrics desiredSize(aReflowState.reflowState);
|
|
desiredSize.Width() = desiredSize.Height() = 0;
|
|
|
|
// Reflow the child into the available space
|
|
nsHTMLReflowState kidReflowState(presContext, aReflowState.reflowState,
|
|
kidFrame, kidAvailSize,
|
|
-1, -1,
|
|
nsHTMLReflowState::CALLER_WILL_INIT);
|
|
InitChildReflowState(kidReflowState);
|
|
|
|
// If this isn't the first row group, and the previous row group has a
|
|
// nonzero YMost, then we can't be at the top of the page.
|
|
// We ignore a repeated head row group in this check to avoid causing
|
|
// infinite loops in some circumstances - see bug 344883.
|
|
if (childX > ((thead && IsRepeatedFrame(thead)) ? 1u : 0u) &&
|
|
(rowGroups[childX - 1]->GetRect().YMost() > 0)) {
|
|
kidReflowState.mFlags.mIsTopOfPage = false;
|
|
}
|
|
aReflowState.y += cellSpacingY;
|
|
if (NS_UNCONSTRAINEDSIZE != aReflowState.availSize.height) {
|
|
aReflowState.availSize.height -= cellSpacingY;
|
|
}
|
|
// record the presence of a next in flow, it might get destroyed so we
|
|
// need to reorder the row group array
|
|
bool reorder = false;
|
|
if (kidFrame->GetNextInFlow())
|
|
reorder = true;
|
|
|
|
rv = ReflowChild(kidFrame, presContext, desiredSize, kidReflowState,
|
|
aReflowState.x, aReflowState.y, 0, aStatus);
|
|
|
|
if (reorder) {
|
|
// reorder row groups the reflow may have changed the nextinflows
|
|
OrderRowGroups(rowGroups, &thead, &tfoot);
|
|
childX = rowGroups.IndexOf(kidFrame);
|
|
if (childX == RowGroupArray::NoIndex) {
|
|
// XXXbz can this happen?
|
|
childX = rowGroups.Length();
|
|
}
|
|
}
|
|
if (isPaginated && !NS_FRAME_IS_FULLY_COMPLETE(aStatus) &&
|
|
ShouldAvoidBreakInside(aReflowState.reflowState)) {
|
|
aStatus = NS_INLINE_LINE_BREAK_BEFORE();
|
|
break;
|
|
}
|
|
// see if the rowgroup did not fit on this page might be pushed on
|
|
// the next page
|
|
if (isPaginated &&
|
|
(NS_INLINE_IS_BREAK_BEFORE(aStatus) ||
|
|
(NS_FRAME_IS_COMPLETE(aStatus) &&
|
|
(NS_UNCONSTRAINEDSIZE != kidReflowState.AvailableHeight()) &&
|
|
kidReflowState.AvailableHeight() < desiredSize.Height()))) {
|
|
if (ShouldAvoidBreakInside(aReflowState.reflowState)) {
|
|
aStatus = NS_INLINE_LINE_BREAK_BEFORE();
|
|
break;
|
|
}
|
|
// if we are on top of the page place with dataloss
|
|
if (kidReflowState.mFlags.mIsTopOfPage) {
|
|
if (childX+1 < rowGroups.Length()) {
|
|
nsIFrame* nextRowGroupFrame = rowGroups[childX + 1];
|
|
if (nextRowGroupFrame) {
|
|
PlaceChild(aReflowState, kidFrame, desiredSize, oldKidRect,
|
|
oldKidVisualOverflow);
|
|
if (allowRepeatedFooter) {
|
|
PlaceRepeatedFooter(aReflowState, tfoot, footerHeight);
|
|
}
|
|
else if (tfoot && tfoot->IsRepeatable()) {
|
|
tfoot->SetRepeatable(false);
|
|
}
|
|
aStatus = NS_FRAME_NOT_COMPLETE;
|
|
PushChildren(rowGroups, childX + 1);
|
|
aLastChildReflowed = kidFrame;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else { // we are not on top, push this rowgroup onto the next page
|
|
if (prevKidFrame) { // we had a rowgroup before so push this
|
|
if (allowRepeatedFooter) {
|
|
PlaceRepeatedFooter(aReflowState, tfoot, footerHeight);
|
|
}
|
|
else if (tfoot && tfoot->IsRepeatable()) {
|
|
tfoot->SetRepeatable(false);
|
|
}
|
|
aStatus = NS_FRAME_NOT_COMPLETE;
|
|
PushChildren(rowGroups, childX);
|
|
aLastChildReflowed = prevKidFrame;
|
|
break;
|
|
}
|
|
else { // we can't push so lets make clear how much space we need
|
|
PlaceChild(aReflowState, kidFrame, desiredSize, oldKidRect,
|
|
oldKidVisualOverflow);
|
|
aLastChildReflowed = kidFrame;
|
|
if (allowRepeatedFooter) {
|
|
PlaceRepeatedFooter(aReflowState, tfoot, footerHeight);
|
|
aLastChildReflowed = tfoot;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
aLastChildReflowed = kidFrame;
|
|
|
|
pageBreak = false;
|
|
// see if there is a page break after this row group or before the next one
|
|
if (NS_FRAME_IS_COMPLETE(aStatus) && isPaginated &&
|
|
(NS_UNCONSTRAINEDSIZE != kidReflowState.AvailableHeight())) {
|
|
nsIFrame* nextKid =
|
|
(childX + 1 < rowGroups.Length()) ? rowGroups[childX + 1] : nullptr;
|
|
pageBreak = PageBreakAfter(kidFrame, nextKid);
|
|
}
|
|
|
|
// Place the child
|
|
PlaceChild(aReflowState, kidFrame, desiredSize, oldKidRect,
|
|
oldKidVisualOverflow);
|
|
|
|
// Remember where we just were in case we end up pushing children
|
|
prevKidFrame = kidFrame;
|
|
|
|
// Special handling for incomplete children
|
|
if (NS_FRAME_IS_NOT_COMPLETE(aStatus)) {
|
|
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
|
|
if (!kidNextInFlow) {
|
|
// The child doesn't have a next-in-flow so create a continuing
|
|
// frame. This hooks the child into the flow
|
|
kidNextInFlow = presContext->PresShell()->FrameConstructor()->
|
|
CreateContinuingFrame(presContext, kidFrame, this);
|
|
|
|
// Insert the kid's new next-in-flow into our sibling list...
|
|
mFrames.InsertFrame(nullptr, kidFrame, kidNextInFlow);
|
|
// and in rowGroups after childX so that it will get pushed below.
|
|
rowGroups.InsertElementAt(childX + 1,
|
|
static_cast<nsTableRowGroupFrame*>(kidNextInFlow));
|
|
} else if (kidNextInFlow == kidFrame->GetNextSibling()) {
|
|
// OrderRowGroups excludes NIFs in the child list from 'rowGroups'
|
|
// so we deal with that here to make sure they get pushed.
|
|
MOZ_ASSERT(!rowGroups.Contains(kidNextInFlow),
|
|
"OrderRowGroups must not put our NIF in 'rowGroups'");
|
|
rowGroups.InsertElementAt(childX + 1,
|
|
static_cast<nsTableRowGroupFrame*>(kidNextInFlow));
|
|
}
|
|
|
|
// We've used up all of our available space so push the remaining
|
|
// children.
|
|
if (allowRepeatedFooter) {
|
|
PlaceRepeatedFooter(aReflowState, tfoot, footerHeight);
|
|
}
|
|
else if (tfoot && tfoot->IsRepeatable()) {
|
|
tfoot->SetRepeatable(false);
|
|
}
|
|
|
|
nsIFrame* nextSibling = kidFrame->GetNextSibling();
|
|
if (nextSibling) {
|
|
PushChildren(rowGroups, childX + 1);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else { // it isn't being reflowed
|
|
aReflowState.y += cellSpacingY;
|
|
nsRect kidRect = kidFrame->GetRect();
|
|
if (kidRect.y != aReflowState.y) {
|
|
// invalidate the old position
|
|
kidFrame->InvalidateFrameSubtree();
|
|
kidRect.y = aReflowState.y;
|
|
kidFrame->SetRect(kidRect); // move to the new position
|
|
RePositionViews(kidFrame);
|
|
// invalidate the new position
|
|
kidFrame->InvalidateFrameSubtree();
|
|
}
|
|
aReflowState.y += kidRect.height;
|
|
|
|
// If our height is constrained then update the available height.
|
|
if (NS_UNCONSTRAINEDSIZE != aReflowState.availSize.height) {
|
|
aReflowState.availSize.height -= cellSpacingY + kidRect.height;
|
|
}
|
|
}
|
|
ConsiderChildOverflow(aOverflowAreas, kidFrame);
|
|
}
|
|
|
|
// We've now propagated the column resizes and geometry changes to all
|
|
// the children.
|
|
mBits.mResizedColumns = false;
|
|
ClearGeometryDirty();
|
|
|
|
return rv;
|
|
}
|
|
|
|
void
|
|
nsTableFrame::ReflowColGroups(nsRenderingContext *aRenderingContext)
|
|
{
|
|
if (!GetPrevInFlow() && !HaveReflowedColGroups()) {
|
|
nsHTMLReflowMetrics kidMet(GetWritingMode());
|
|
nsPresContext *presContext = PresContext();
|
|
for (nsIFrame* kidFrame = mColGroups.FirstChild(); kidFrame;
|
|
kidFrame = kidFrame->GetNextSibling()) {
|
|
if (NS_SUBTREE_DIRTY(kidFrame)) {
|
|
// The column groups don't care about dimensions or reflow states.
|
|
nsHTMLReflowState kidReflowState(presContext, kidFrame,
|
|
aRenderingContext, nsSize(0,0));
|
|
nsReflowStatus cgStatus;
|
|
ReflowChild(kidFrame, presContext, kidMet, kidReflowState, 0, 0, 0,
|
|
cgStatus);
|
|
FinishReflowChild(kidFrame, presContext, kidMet, nullptr, 0, 0, 0);
|
|
}
|
|
}
|
|
SetHaveReflowedColGroups(true);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsTableFrame::CalcDesiredHeight(const nsHTMLReflowState& aReflowState, nsHTMLReflowMetrics& aDesiredSize)
|
|
{
|
|
nsTableCellMap* cellMap = GetCellMap();
|
|
if (!cellMap) {
|
|
NS_ASSERTION(false, "never ever call me until the cell map is built!");
|
|
aDesiredSize.Height() = 0;
|
|
return;
|
|
}
|
|
nscoord cellSpacingY = GetCellSpacingY();
|
|
nsMargin borderPadding = GetChildAreaOffset(&aReflowState);
|
|
|
|
// get the natural height based on the last child's (row group) rect
|
|
RowGroupArray rowGroups;
|
|
OrderRowGroups(rowGroups);
|
|
if (rowGroups.IsEmpty()) {
|
|
// tables can be used as rectangular items without content
|
|
nscoord tableSpecifiedHeight = CalcBorderBoxHeight(aReflowState);
|
|
if ((NS_UNCONSTRAINEDSIZE != tableSpecifiedHeight) &&
|
|
(tableSpecifiedHeight > 0) &&
|
|
eCompatibility_NavQuirks != PresContext()->CompatibilityMode()) {
|
|
// empty tables should not have a size in quirks mode
|
|
aDesiredSize.Height() = tableSpecifiedHeight;
|
|
}
|
|
else
|
|
aDesiredSize.Height() = 0;
|
|
return;
|
|
}
|
|
int32_t rowCount = cellMap->GetRowCount();
|
|
int32_t colCount = cellMap->GetColCount();
|
|
nscoord desiredHeight = borderPadding.top + borderPadding.bottom;
|
|
if (rowCount > 0 && colCount > 0) {
|
|
desiredHeight += cellSpacingY;
|
|
for (uint32_t rgX = 0; rgX < rowGroups.Length(); rgX++) {
|
|
desiredHeight += rowGroups[rgX]->GetSize().height + cellSpacingY;
|
|
}
|
|
}
|
|
|
|
// see if a specified table height requires dividing additional space to rows
|
|
if (!GetPrevInFlow()) {
|
|
nscoord tableSpecifiedHeight = CalcBorderBoxHeight(aReflowState);
|
|
if ((tableSpecifiedHeight > 0) &&
|
|
(tableSpecifiedHeight != NS_UNCONSTRAINEDSIZE) &&
|
|
(tableSpecifiedHeight > desiredHeight)) {
|
|
// proportionately distribute the excess height to unconstrained rows in each
|
|
// unconstrained row group.
|
|
DistributeHeightToRows(aReflowState, tableSpecifiedHeight - desiredHeight);
|
|
// this might have changed the overflow area incorporate the childframe overflow area.
|
|
for (nsIFrame* kidFrame = mFrames.FirstChild(); kidFrame; kidFrame = kidFrame->GetNextSibling()) {
|
|
ConsiderChildOverflow(aDesiredSize.mOverflowAreas, kidFrame);
|
|
}
|
|
desiredHeight = tableSpecifiedHeight;
|
|
}
|
|
}
|
|
aDesiredSize.Height() = desiredHeight;
|
|
}
|
|
|
|
static
|
|
void ResizeCells(nsTableFrame& aTableFrame)
|
|
{
|
|
nsTableFrame::RowGroupArray rowGroups;
|
|
aTableFrame.OrderRowGroups(rowGroups);
|
|
nsHTMLReflowMetrics tableDesiredSize(aTableFrame.GetWritingMode()); // ???
|
|
nsRect tableRect = aTableFrame.GetRect();
|
|
tableDesiredSize.Width() = tableRect.width;
|
|
tableDesiredSize.Height() = tableRect.height;
|
|
tableDesiredSize.SetOverflowAreasToDesiredBounds();
|
|
|
|
for (uint32_t rgX = 0; rgX < rowGroups.Length(); rgX++) {
|
|
nsTableRowGroupFrame* rgFrame = rowGroups[rgX];
|
|
|
|
nsRect rowGroupRect = rgFrame->GetRect();
|
|
nsHTMLReflowMetrics groupDesiredSize(tableDesiredSize.GetWritingMode());
|
|
groupDesiredSize.Width() = rowGroupRect.width;
|
|
groupDesiredSize.Height() = rowGroupRect.height;
|
|
groupDesiredSize.SetOverflowAreasToDesiredBounds();
|
|
|
|
nsTableRowFrame* rowFrame = rgFrame->GetFirstRow();
|
|
while (rowFrame) {
|
|
rowFrame->DidResize();
|
|
rgFrame->ConsiderChildOverflow(groupDesiredSize.mOverflowAreas, rowFrame);
|
|
rowFrame = rowFrame->GetNextRow();
|
|
}
|
|
rgFrame->FinishAndStoreOverflow(&groupDesiredSize);
|
|
tableDesiredSize.mOverflowAreas.UnionWith(groupDesiredSize.mOverflowAreas +
|
|
rgFrame->GetPosition());
|
|
}
|
|
aTableFrame.FinishAndStoreOverflow(&tableDesiredSize);
|
|
}
|
|
|
|
void
|
|
nsTableFrame::DistributeHeightToRows(const nsHTMLReflowState& aReflowState,
|
|
nscoord aAmount)
|
|
{
|
|
nscoord cellSpacingY = GetCellSpacingY();
|
|
|
|
nsMargin borderPadding = GetChildAreaOffset(&aReflowState);
|
|
|
|
RowGroupArray rowGroups;
|
|
OrderRowGroups(rowGroups);
|
|
|
|
nscoord amountUsed = 0;
|
|
// distribute space to each pct height row whose row group doesn't have a computed
|
|
// height, and base the pct on the table height. If the row group had a computed
|
|
// height, then this was already done in nsTableRowGroupFrame::CalculateRowHeights
|
|
nscoord pctBasis = aReflowState.ComputedHeight() - (GetCellSpacingY() * (GetRowCount() + 1));
|
|
nscoord yOriginRG = borderPadding.top + GetCellSpacingY();
|
|
nscoord yEndRG = yOriginRG;
|
|
uint32_t rgX;
|
|
for (rgX = 0; rgX < rowGroups.Length(); rgX++) {
|
|
nsTableRowGroupFrame* rgFrame = rowGroups[rgX];
|
|
nscoord amountUsedByRG = 0;
|
|
nscoord yOriginRow = 0;
|
|
nsRect rgRect = rgFrame->GetRect();
|
|
if (!rgFrame->HasStyleHeight()) {
|
|
nsTableRowFrame* rowFrame = rgFrame->GetFirstRow();
|
|
while (rowFrame) {
|
|
nsRect rowRect = rowFrame->GetRect();
|
|
if ((amountUsed < aAmount) && rowFrame->HasPctHeight()) {
|
|
nscoord pctHeight = rowFrame->GetHeight(pctBasis);
|
|
nscoord amountForRow = std::min(aAmount - amountUsed, pctHeight - rowRect.height);
|
|
if (amountForRow > 0) {
|
|
nsRect oldRowRect = rowRect;
|
|
rowRect.height += amountForRow;
|
|
// XXXbz we don't need to change rowRect.y to be yOriginRow?
|
|
rowFrame->SetRect(rowRect);
|
|
yOriginRow += rowRect.height + cellSpacingY;
|
|
yEndRG += rowRect.height + cellSpacingY;
|
|
amountUsed += amountForRow;
|
|
amountUsedByRG += amountForRow;
|
|
//rowFrame->DidResize();
|
|
nsTableFrame::RePositionViews(rowFrame);
|
|
|
|
rgFrame->InvalidateFrameWithRect(oldRowRect);
|
|
rgFrame->InvalidateFrame();
|
|
}
|
|
}
|
|
else {
|
|
if (amountUsed > 0 && yOriginRow != rowRect.y &&
|
|
!(GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
|
|
rowFrame->InvalidateFrameSubtree();
|
|
rowFrame->SetPosition(nsPoint(rowRect.x, yOriginRow));
|
|
nsTableFrame::RePositionViews(rowFrame);
|
|
rowFrame->InvalidateFrameSubtree();
|
|
}
|
|
yOriginRow += rowRect.height + cellSpacingY;
|
|
yEndRG += rowRect.height + cellSpacingY;
|
|
}
|
|
rowFrame = rowFrame->GetNextRow();
|
|
}
|
|
if (amountUsed > 0) {
|
|
if (rgRect.y != yOriginRG) {
|
|
rgFrame->InvalidateFrameSubtree();
|
|
}
|
|
|
|
nsRect origRgRect = rgRect;
|
|
nsRect origRgVisualOverflow = rgFrame->GetVisualOverflowRect();
|
|
|
|
rgRect.y = yOriginRG;
|
|
rgRect.height += amountUsedByRG;
|
|
|
|
rgFrame->SetRect(rgRect);
|
|
|
|
nsTableFrame::InvalidateTableFrame(rgFrame, origRgRect,
|
|
origRgVisualOverflow, false);
|
|
}
|
|
}
|
|
else if (amountUsed > 0 && yOriginRG != rgRect.y) {
|
|
rgFrame->InvalidateFrameSubtree();
|
|
rgFrame->SetPosition(nsPoint(rgRect.x, yOriginRG));
|
|
// Make sure child views are properly positioned
|
|
nsTableFrame::RePositionViews(rgFrame);
|
|
rgFrame->InvalidateFrameSubtree();
|
|
}
|
|
yOriginRG = yEndRG;
|
|
}
|
|
|
|
if (amountUsed >= aAmount) {
|
|
ResizeCells(*this);
|
|
return;
|
|
}
|
|
|
|
// get the first row without a style height where its row group has an
|
|
// unconstrained height
|
|
nsTableRowGroupFrame* firstUnStyledRG = nullptr;
|
|
nsTableRowFrame* firstUnStyledRow = nullptr;
|
|
for (rgX = 0; rgX < rowGroups.Length() && !firstUnStyledRG; rgX++) {
|
|
nsTableRowGroupFrame* rgFrame = rowGroups[rgX];
|
|
if (!rgFrame->HasStyleHeight()) {
|
|
nsTableRowFrame* rowFrame = rgFrame->GetFirstRow();
|
|
while (rowFrame) {
|
|
if (!rowFrame->HasStyleHeight()) {
|
|
firstUnStyledRG = rgFrame;
|
|
firstUnStyledRow = rowFrame;
|
|
break;
|
|
}
|
|
rowFrame = rowFrame->GetNextRow();
|
|
}
|
|
}
|
|
}
|
|
|
|
nsTableRowFrame* lastEligibleRow = nullptr;
|
|
// Accumulate the correct divisor. This will be the total total height of all
|
|
// unstyled rows inside unstyled row groups, unless there are none, in which
|
|
// case, it will be number of all rows. If the unstyled rows don't have a
|
|
// height, divide the space equally among them.
|
|
nscoord divisor = 0;
|
|
int32_t eligibleRows = 0;
|
|
bool expandEmptyRows = false;
|
|
|
|
if (!firstUnStyledRow) {
|
|
// there is no unstyled row
|
|
divisor = GetRowCount();
|
|
}
|
|
else {
|
|
for (rgX = 0; rgX < rowGroups.Length(); rgX++) {
|
|
nsTableRowGroupFrame* rgFrame = rowGroups[rgX];
|
|
if (!firstUnStyledRG || !rgFrame->HasStyleHeight()) {
|
|
nsTableRowFrame* rowFrame = rgFrame->GetFirstRow();
|
|
while (rowFrame) {
|
|
if (!firstUnStyledRG || !rowFrame->HasStyleHeight()) {
|
|
NS_ASSERTION(rowFrame->GetSize().height >= 0,
|
|
"negative row frame height");
|
|
divisor += rowFrame->GetSize().height;
|
|
eligibleRows++;
|
|
lastEligibleRow = rowFrame;
|
|
}
|
|
rowFrame = rowFrame->GetNextRow();
|
|
}
|
|
}
|
|
}
|
|
if (divisor <= 0) {
|
|
if (eligibleRows > 0) {
|
|
expandEmptyRows = true;
|
|
}
|
|
else {
|
|
NS_ERROR("invalid divisor");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
// allocate the extra height to the unstyled row groups and rows
|
|
nscoord heightToDistribute = aAmount - amountUsed;
|
|
yOriginRG = borderPadding.top + cellSpacingY;
|
|
yEndRG = yOriginRG;
|
|
for (rgX = 0; rgX < rowGroups.Length(); rgX++) {
|
|
nsTableRowGroupFrame* rgFrame = rowGroups[rgX];
|
|
nscoord amountUsedByRG = 0;
|
|
nscoord yOriginRow = 0;
|
|
nsRect rgRect = rgFrame->GetRect();
|
|
nsRect rgVisualOverflow = rgFrame->GetVisualOverflowRect();
|
|
// see if there is an eligible row group or we distribute to all rows
|
|
if (!firstUnStyledRG || !rgFrame->HasStyleHeight() || !eligibleRows) {
|
|
nsTableRowFrame* rowFrame = rgFrame->GetFirstRow();
|
|
while (rowFrame) {
|
|
nsRect rowRect = rowFrame->GetRect();
|
|
nsRect rowVisualOverflow = rowFrame->GetVisualOverflowRect();
|
|
// see if there is an eligible row or we distribute to all rows
|
|
if (!firstUnStyledRow || !rowFrame->HasStyleHeight() || !eligibleRows) {
|
|
float ratio;
|
|
if (eligibleRows) {
|
|
if (!expandEmptyRows) {
|
|
// The amount of additional space each row gets is proportional to
|
|
// its height
|
|
ratio = float(rowRect.height) / float(divisor);
|
|
} else {
|
|
// empty rows get all the same additional space
|
|
ratio = 1.0f / float(eligibleRows);
|
|
}
|
|
}
|
|
else {
|
|
// all rows get the same additional space
|
|
ratio = 1.0f / float(divisor);
|
|
}
|
|
// give rows their additional space, except for the last row which
|
|
// gets the remainder
|
|
nscoord amountForRow = (rowFrame == lastEligibleRow)
|
|
? aAmount - amountUsed : NSToCoordRound(((float)(heightToDistribute)) * ratio);
|
|
amountForRow = std::min(amountForRow, aAmount - amountUsed);
|
|
|
|
if (yOriginRow != rowRect.y) {
|
|
rowFrame->InvalidateFrameSubtree();
|
|
}
|
|
|
|
// update the row height
|
|
nsRect newRowRect(rowRect.x, yOriginRow, rowRect.width,
|
|
rowRect.height + amountForRow);
|
|
rowFrame->SetRect(newRowRect);
|
|
|
|
yOriginRow += newRowRect.height + cellSpacingY;
|
|
yEndRG += newRowRect.height + cellSpacingY;
|
|
|
|
amountUsed += amountForRow;
|
|
amountUsedByRG += amountForRow;
|
|
NS_ASSERTION((amountUsed <= aAmount), "invalid row allocation");
|
|
//rowFrame->DidResize();
|
|
nsTableFrame::RePositionViews(rowFrame);
|
|
|
|
nsTableFrame::InvalidateTableFrame(rowFrame, rowRect, rowVisualOverflow,
|
|
false);
|
|
}
|
|
else {
|
|
if (amountUsed > 0 && yOriginRow != rowRect.y) {
|
|
rowFrame->InvalidateFrameSubtree();
|
|
rowFrame->SetPosition(nsPoint(rowRect.x, yOriginRow));
|
|
nsTableFrame::RePositionViews(rowFrame);
|
|
rowFrame->InvalidateFrameSubtree();
|
|
}
|
|
yOriginRow += rowRect.height + cellSpacingY;
|
|
yEndRG += rowRect.height + cellSpacingY;
|
|
}
|
|
rowFrame = rowFrame->GetNextRow();
|
|
}
|
|
if (amountUsed > 0) {
|
|
if (rgRect.y != yOriginRG) {
|
|
rgFrame->InvalidateFrameSubtree();
|
|
}
|
|
|
|
rgFrame->SetRect(nsRect(rgRect.x, yOriginRG, rgRect.width,
|
|
rgRect.height + amountUsedByRG));
|
|
|
|
nsTableFrame::InvalidateTableFrame(rgFrame, rgRect, rgVisualOverflow,
|
|
false);
|
|
}
|
|
// Make sure child views are properly positioned
|
|
}
|
|
else if (amountUsed > 0 && yOriginRG != rgRect.y) {
|
|
rgFrame->InvalidateFrameSubtree();
|
|
rgFrame->SetPosition(nsPoint(rgRect.x, yOriginRG));
|
|
// Make sure child views are properly positioned
|
|
nsTableFrame::RePositionViews(rgFrame);
|
|
rgFrame->InvalidateFrameSubtree();
|
|
}
|
|
yOriginRG = yEndRG;
|
|
}
|
|
|
|
ResizeCells(*this);
|
|
}
|
|
|
|
int32_t nsTableFrame::GetColumnWidth(int32_t aColIndex)
|
|
{
|
|
nsTableFrame* firstInFlow = static_cast<nsTableFrame*>(FirstInFlow());
|
|
if (this == firstInFlow) {
|
|
nsTableColFrame* colFrame = GetColFrame(aColIndex);
|
|
return colFrame ? colFrame->GetFinalWidth() : 0;
|
|
}
|
|
return firstInFlow->GetColumnWidth(aColIndex);
|
|
}
|
|
|
|
// XXX: could cache this. But be sure to check style changes if you do!
|
|
nscoord nsTableFrame::GetCellSpacingX()
|
|
{
|
|
if (IsBorderCollapse())
|
|
return 0;
|
|
|
|
return StyleTableBorder()->mBorderSpacingX;
|
|
}
|
|
|
|
// XXX: could cache this. But be sure to check style changes if you do!
|
|
nscoord nsTableFrame::GetCellSpacingY()
|
|
{
|
|
if (IsBorderCollapse())
|
|
return 0;
|
|
|
|
return StyleTableBorder()->mBorderSpacingY;
|
|
}
|
|
|
|
|
|
/* virtual */ nscoord
|
|
nsTableFrame::GetBaseline() const
|
|
{
|
|
nscoord ascent = 0;
|
|
RowGroupArray orderedRowGroups;
|
|
OrderRowGroups(orderedRowGroups);
|
|
nsTableRowFrame* firstRow = nullptr;
|
|
for (uint32_t rgIndex = 0; rgIndex < orderedRowGroups.Length(); rgIndex++) {
|
|
nsTableRowGroupFrame* rgFrame = orderedRowGroups[rgIndex];
|
|
if (rgFrame->GetRowCount()) {
|
|
firstRow = rgFrame->GetFirstRow();
|
|
ascent = rgFrame->GetRect().y + firstRow->GetRect().y + firstRow->GetRowBaseline();
|
|
break;
|
|
}
|
|
}
|
|
if (!firstRow)
|
|
ascent = GetRect().height;
|
|
return ascent;
|
|
}
|
|
/* ----- global methods ----- */
|
|
|
|
nsIFrame*
|
|
NS_NewTableFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
|
|
{
|
|
return new (aPresShell) nsTableFrame(aContext);
|
|
}
|
|
|
|
NS_IMPL_FRAMEARENA_HELPERS(nsTableFrame)
|
|
|
|
nsTableFrame*
|
|
nsTableFrame::GetTableFrame(nsIFrame* aFrame)
|
|
{
|
|
for (nsIFrame* ancestor = aFrame->GetParent(); ancestor;
|
|
ancestor = ancestor->GetParent()) {
|
|
if (nsGkAtoms::tableFrame == ancestor->GetType()) {
|
|
return static_cast<nsTableFrame*>(ancestor);
|
|
}
|
|
}
|
|
NS_RUNTIMEABORT("unable to find table parent");
|
|
return nullptr;
|
|
}
|
|
|
|
nsTableFrame*
|
|
nsTableFrame::GetTableFramePassingThrough(nsIFrame* aMustPassThrough,
|
|
nsIFrame* aFrame)
|
|
{
|
|
MOZ_ASSERT(aMustPassThrough == aFrame ||
|
|
nsLayoutUtils::IsProperAncestorFrame(aMustPassThrough, aFrame),
|
|
"aMustPassThrough should be an ancestor");
|
|
|
|
// Retrieve the table frame, and ensure that we hit aMustPassThrough on the
|
|
// way. If we don't, just return null.
|
|
bool hitPassThroughFrame = false;
|
|
nsTableFrame* tableFrame = nullptr;
|
|
for (nsIFrame* ancestor = aFrame; ancestor; ancestor = ancestor->GetParent()) {
|
|
if (ancestor == aMustPassThrough) {
|
|
hitPassThroughFrame = true;
|
|
}
|
|
if (nsGkAtoms::tableFrame == ancestor->GetType()) {
|
|
tableFrame = static_cast<nsTableFrame*>(ancestor);
|
|
break;
|
|
}
|
|
}
|
|
|
|
MOZ_ASSERT(tableFrame, "Should have a table frame here");
|
|
return hitPassThroughFrame ? tableFrame : nullptr;
|
|
}
|
|
|
|
bool
|
|
nsTableFrame::IsAutoHeight()
|
|
{
|
|
const nsStyleCoord &height = StylePosition()->mHeight;
|
|
// Don't consider calc() here like this quirk for percent.
|
|
return height.GetUnit() == eStyleUnit_Auto ||
|
|
(height.GetUnit() == eStyleUnit_Percent &&
|
|
height.GetPercentValue() <= 0.0f);
|
|
}
|
|
|
|
nscoord
|
|
nsTableFrame::CalcBorderBoxHeight(const nsHTMLReflowState& aState)
|
|
{
|
|
nscoord height = aState.ComputedHeight();
|
|
if (NS_AUTOHEIGHT != height) {
|
|
nsMargin borderPadding = GetChildAreaOffset(&aState);
|
|
height += borderPadding.top + borderPadding.bottom;
|
|
}
|
|
height = std::max(0, height);
|
|
|
|
return height;
|
|
}
|
|
|
|
bool
|
|
nsTableFrame::IsAutoLayout()
|
|
{
|
|
if (StyleTable()->mLayoutStrategy == NS_STYLE_TABLE_LAYOUT_AUTO)
|
|
return true;
|
|
// a fixed-layout inline-table must have a width
|
|
// and tables with 'width: -moz-max-content' must be auto-layout
|
|
// (at least as long as FixedTableLayoutStrategy::GetPrefWidth returns
|
|
// nscoord_MAX)
|
|
const nsStyleCoord &width = StylePosition()->mWidth;
|
|
return (width.GetUnit() == eStyleUnit_Auto) ||
|
|
(width.GetUnit() == eStyleUnit_Enumerated &&
|
|
width.GetIntValue() == NS_STYLE_WIDTH_MAX_CONTENT);
|
|
}
|
|
|
|
#ifdef DEBUG_FRAME_DUMP
|
|
nsresult
|
|
nsTableFrame::GetFrameName(nsAString& aResult) const
|
|
{
|
|
return MakeFrameName(NS_LITERAL_STRING("Table"), aResult);
|
|
}
|
|
#endif
|
|
|
|
// Find the closet sibling before aPriorChildFrame (including aPriorChildFrame) that
|
|
// is of type aChildType
|
|
nsIFrame*
|
|
nsTableFrame::GetFrameAtOrBefore(nsIFrame* aParentFrame,
|
|
nsIFrame* aPriorChildFrame,
|
|
nsIAtom* aChildType)
|
|
{
|
|
nsIFrame* result = nullptr;
|
|
if (!aPriorChildFrame) {
|
|
return result;
|
|
}
|
|
if (aChildType == aPriorChildFrame->GetType()) {
|
|
return aPriorChildFrame;
|
|
}
|
|
|
|
// aPriorChildFrame is not of type aChildType, so we need start from
|
|
// the beginnng and find the closest one
|
|
nsIFrame* lastMatchingFrame = nullptr;
|
|
nsIFrame* childFrame = aParentFrame->GetFirstPrincipalChild();
|
|
while (childFrame && (childFrame != aPriorChildFrame)) {
|
|
if (aChildType == childFrame->GetType()) {
|
|
lastMatchingFrame = childFrame;
|
|
}
|
|
childFrame = childFrame->GetNextSibling();
|
|
}
|
|
return lastMatchingFrame;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
void
|
|
nsTableFrame::DumpRowGroup(nsIFrame* aKidFrame)
|
|
{
|
|
if (!aKidFrame)
|
|
return;
|
|
|
|
nsIFrame* cFrame = aKidFrame->GetFirstPrincipalChild();
|
|
while (cFrame) {
|
|
nsTableRowFrame *rowFrame = do_QueryFrame(cFrame);
|
|
if (rowFrame) {
|
|
printf("row(%d)=%p ", rowFrame->GetRowIndex(),
|
|
static_cast<void*>(rowFrame));
|
|
nsIFrame* childFrame = cFrame->GetFirstPrincipalChild();
|
|
while (childFrame) {
|
|
nsTableCellFrame *cellFrame = do_QueryFrame(childFrame);
|
|
if (cellFrame) {
|
|
int32_t colIndex;
|
|
cellFrame->GetColIndex(colIndex);
|
|
printf("cell(%d)=%p ", colIndex, static_cast<void*>(childFrame));
|
|
}
|
|
childFrame = childFrame->GetNextSibling();
|
|
}
|
|
printf("\n");
|
|
}
|
|
else {
|
|
DumpRowGroup(rowFrame);
|
|
}
|
|
cFrame = cFrame->GetNextSibling();
|
|
}
|
|
}
|
|
|
|
void
|
|
nsTableFrame::Dump(bool aDumpRows,
|
|
bool aDumpCols,
|
|
bool aDumpCellMap)
|
|
{
|
|
printf("***START TABLE DUMP*** \n");
|
|
// dump the columns widths array
|
|
printf("mColWidths=");
|
|
int32_t numCols = GetColCount();
|
|
int32_t colX;
|
|
for (colX = 0; colX < numCols; colX++) {
|
|
printf("%d ", GetColumnWidth(colX));
|
|
}
|
|
printf("\n");
|
|
|
|
if (aDumpRows) {
|
|
nsIFrame* kidFrame = mFrames.FirstChild();
|
|
while (kidFrame) {
|
|
DumpRowGroup(kidFrame);
|
|
kidFrame = kidFrame->GetNextSibling();
|
|
}
|
|
}
|
|
|
|
if (aDumpCols) {
|
|
// output col frame cache
|
|
printf("\n col frame cache ->");
|
|
for (colX = 0; colX < numCols; colX++) {
|
|
nsTableColFrame* colFrame = mColFrames.ElementAt(colX);
|
|
if (0 == (colX % 8)) {
|
|
printf("\n");
|
|
}
|
|
printf ("%d=%p ", colX, static_cast<void*>(colFrame));
|
|
nsTableColType colType = colFrame->GetColType();
|
|
switch (colType) {
|
|
case eColContent:
|
|
printf(" content ");
|
|
break;
|
|
case eColAnonymousCol:
|
|
printf(" anonymous-column ");
|
|
break;
|
|
case eColAnonymousColGroup:
|
|
printf(" anonymous-colgroup ");
|
|
break;
|
|
case eColAnonymousCell:
|
|
printf(" anonymous-cell ");
|
|
break;
|
|
}
|
|
}
|
|
printf("\n colgroups->");
|
|
for (nsIFrame* childFrame = mColGroups.FirstChild(); childFrame;
|
|
childFrame = childFrame->GetNextSibling()) {
|
|
if (nsGkAtoms::tableColGroupFrame == childFrame->GetType()) {
|
|
nsTableColGroupFrame* colGroupFrame = (nsTableColGroupFrame *)childFrame;
|
|
colGroupFrame->Dump(1);
|
|
}
|
|
}
|
|
for (colX = 0; colX < numCols; colX++) {
|
|
printf("\n");
|
|
nsTableColFrame* colFrame = GetColFrame(colX);
|
|
colFrame->Dump(1);
|
|
}
|
|
}
|
|
if (aDumpCellMap) {
|
|
nsTableCellMap* cellMap = GetCellMap();
|
|
cellMap->Dump();
|
|
}
|
|
printf(" ***END TABLE DUMP*** \n");
|
|
}
|
|
#endif
|
|
|
|
// nsTableIterator
|
|
nsTableIterator::nsTableIterator(nsIFrame& aSource)
|
|
{
|
|
nsIFrame* firstChild = aSource.GetFirstPrincipalChild();
|
|
Init(firstChild);
|
|
}
|
|
|
|
nsTableIterator::nsTableIterator(nsFrameList& aSource)
|
|
{
|
|
nsIFrame* firstChild = aSource.FirstChild();
|
|
Init(firstChild);
|
|
}
|
|
|
|
void nsTableIterator::Init(nsIFrame* aFirstChild)
|
|
{
|
|
mFirstListChild = aFirstChild;
|
|
mFirstChild = aFirstChild;
|
|
mCurrentChild = nullptr;
|
|
mLeftToRight = true;
|
|
mCount = -1;
|
|
|
|
if (!mFirstChild) {
|
|
return;
|
|
}
|
|
|
|
nsTableFrame* table = nsTableFrame::GetTableFrame(mFirstChild);
|
|
mLeftToRight = (NS_STYLE_DIRECTION_LTR ==
|
|
table->StyleVisibility()->mDirection);
|
|
|
|
if (!mLeftToRight) {
|
|
mCount = 0;
|
|
nsIFrame* nextChild = mFirstChild->GetNextSibling();
|
|
while (nullptr != nextChild) {
|
|
mCount++;
|
|
mFirstChild = nextChild;
|
|
nextChild = nextChild->GetNextSibling();
|
|
}
|
|
}
|
|
}
|
|
|
|
nsIFrame* nsTableIterator::First()
|
|
{
|
|
mCurrentChild = mFirstChild;
|
|
return mCurrentChild;
|
|
}
|
|
|
|
nsIFrame* nsTableIterator::Next()
|
|
{
|
|
if (!mCurrentChild) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (mLeftToRight) {
|
|
mCurrentChild = mCurrentChild->GetNextSibling();
|
|
return mCurrentChild;
|
|
}
|
|
else {
|
|
nsIFrame* targetChild = mCurrentChild;
|
|
mCurrentChild = nullptr;
|
|
nsIFrame* child = mFirstListChild;
|
|
while (child && (child != targetChild)) {
|
|
mCurrentChild = child;
|
|
child = child->GetNextSibling();
|
|
}
|
|
return mCurrentChild;
|
|
}
|
|
}
|
|
|
|
bool nsTableIterator::IsLeftToRight()
|
|
{
|
|
return mLeftToRight;
|
|
}
|
|
|
|
int32_t nsTableIterator::Count()
|
|
{
|
|
if (-1 == mCount) {
|
|
mCount = 0;
|
|
nsIFrame* child = mFirstListChild;
|
|
while (nullptr != child) {
|
|
mCount++;
|
|
child = child->GetNextSibling();
|
|
}
|
|
}
|
|
return mCount;
|
|
}
|
|
|
|
bool
|
|
nsTableFrame::ColumnHasCellSpacingBefore(int32_t aColIndex) const
|
|
{
|
|
// Since fixed-layout tables should not have their column sizes change
|
|
// as they load, we assume that all columns are significant.
|
|
if (LayoutStrategy()->GetType() == nsITableLayoutStrategy::Fixed)
|
|
return true;
|
|
// the first column is always significant
|
|
if (aColIndex == 0)
|
|
return true;
|
|
nsTableCellMap* cellMap = GetCellMap();
|
|
if (!cellMap)
|
|
return false;
|
|
return cellMap->GetNumCellsOriginatingInCol(aColIndex) > 0;
|
|
}
|
|
|
|
/********************************************************************************
|
|
* Collapsing Borders
|
|
*
|
|
* The CSS spec says to resolve border conflicts in this order:
|
|
* 1) any border with the style HIDDEN wins
|
|
* 2) the widest border with a style that is not NONE wins
|
|
* 3) the border styles are ranked in this order, highest to lowest precedence:
|
|
* double, solid, dashed, dotted, ridge, outset, groove, inset
|
|
* 4) borders that are of equal width and style (differ only in color) have this precedence:
|
|
* cell, row, rowgroup, col, colgroup, table
|
|
* 5) if all border styles are NONE, then that's the computed border style.
|
|
*******************************************************************************/
|
|
|
|
#ifdef DEBUG
|
|
#define VerifyNonNegativeDamageRect(r) \
|
|
NS_ASSERTION((r).x >= 0, "negative col index"); \
|
|
NS_ASSERTION((r).y >= 0, "negative row index"); \
|
|
NS_ASSERTION((r).width >= 0, "negative horizontal damage"); \
|
|
NS_ASSERTION((r).height >= 0, "negative vertical damage");
|
|
#define VerifyDamageRect(r) \
|
|
VerifyNonNegativeDamageRect(r); \
|
|
NS_ASSERTION((r).XMost() <= GetColCount(), \
|
|
"horizontal damage extends outside table"); \
|
|
NS_ASSERTION((r).YMost() <= GetRowCount(), \
|
|
"vertical damage extends outside table");
|
|
#endif
|
|
|
|
void
|
|
nsTableFrame::AddBCDamageArea(const nsIntRect& aValue)
|
|
{
|
|
NS_ASSERTION(IsBorderCollapse(), "invalid AddBCDamageArea call");
|
|
#ifdef DEBUG
|
|
VerifyDamageRect(aValue);
|
|
#endif
|
|
|
|
SetNeedToCalcBCBorders(true);
|
|
// Get the property
|
|
BCPropertyData* value = GetBCProperty(true);
|
|
if (value) {
|
|
#ifdef DEBUG
|
|
VerifyNonNegativeDamageRect(value->mDamageArea);
|
|
#endif
|
|
// Clamp the old damage area to the current table area in case it shrunk.
|
|
int32_t cols = GetColCount();
|
|
if (value->mDamageArea.XMost() > cols) {
|
|
if (value->mDamageArea.x > cols) {
|
|
value->mDamageArea.x = cols;
|
|
value->mDamageArea.width = 0;
|
|
}
|
|
else {
|
|
value->mDamageArea.width = cols - value->mDamageArea.x;
|
|
}
|
|
}
|
|
int32_t rows = GetRowCount();
|
|
if (value->mDamageArea.YMost() > rows) {
|
|
if (value->mDamageArea.y > rows) {
|
|
value->mDamageArea.y = rows;
|
|
value->mDamageArea.height = 0;
|
|
}
|
|
else {
|
|
value->mDamageArea.height = rows - value->mDamageArea.y;
|
|
}
|
|
}
|
|
|
|
// Construct a union of the new and old damage areas.
|
|
value->mDamageArea.UnionRect(value->mDamageArea, aValue);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
nsTableFrame::SetFullBCDamageArea()
|
|
{
|
|
NS_ASSERTION(IsBorderCollapse(), "invalid SetFullBCDamageArea call");
|
|
|
|
SetNeedToCalcBCBorders(true);
|
|
|
|
BCPropertyData* value = GetBCProperty(true);
|
|
if (value) {
|
|
value->mDamageArea = nsIntRect(0, 0, GetColCount(), GetRowCount());
|
|
}
|
|
}
|
|
|
|
|
|
/* BCCellBorder represents a border segment which can be either a horizontal
|
|
* or a vertical segment. For each segment we need to know the color, width,
|
|
* style, who owns it and how long it is in cellmap coordinates.
|
|
* Ownership of these segments is important to calculate which corners should
|
|
* be bevelled. This structure has dual use, its used first to compute the
|
|
* dominant border for horizontal and vertical segments and to store the
|
|
* preliminary computed border results in the BCCellBorders structure.
|
|
* This temporary storage is not symmetric with respect to horizontal and
|
|
* vertical border segments, its always column oriented. For each column in
|
|
* the cellmap there is a temporary stored vertical and horizontal segment.
|
|
* XXX_Bernd this asymmetry is the root of those rowspan bc border errors
|
|
*/
|
|
struct BCCellBorder
|
|
{
|
|
BCCellBorder() { Reset(0, 1); }
|
|
void Reset(uint32_t aRowIndex, uint32_t aRowSpan);
|
|
nscolor color; // border segment color
|
|
BCPixelSize width; // border segment width in pixel coordinates !!
|
|
uint8_t style; // border segment style, possible values are defined
|
|
// in nsStyleConsts.h as NS_STYLE_BORDER_STYLE_*
|
|
BCBorderOwner owner; // border segment owner, possible values are defined
|
|
// in celldata.h. In the cellmap for each border
|
|
// segment we store the owner and later when
|
|
// painting we know the owner and can retrieve the
|
|
// style info from the corresponding frame
|
|
int32_t rowIndex; // rowIndex of temporary stored horizontal border
|
|
// segments relative to the table
|
|
int32_t rowSpan; // row span of temporary stored horizontal border
|
|
// segments
|
|
};
|
|
|
|
void
|
|
BCCellBorder::Reset(uint32_t aRowIndex,
|
|
uint32_t aRowSpan)
|
|
{
|
|
style = NS_STYLE_BORDER_STYLE_NONE;
|
|
color = 0;
|
|
width = 0;
|
|
owner = eTableOwner;
|
|
rowIndex = aRowIndex;
|
|
rowSpan = aRowSpan;
|
|
}
|
|
|
|
class BCMapCellIterator;
|
|
|
|
/*****************************************************************
|
|
* BCMapCellInfo
|
|
* This structure stores information about the cellmap and all involved
|
|
* table related frames that are used during the computation of winning borders
|
|
* in CalcBCBorders so that they do need to be looked up again and again when
|
|
* iterating over the cells.
|
|
****************************************************************/
|
|
struct BCMapCellInfo
|
|
{
|
|
BCMapCellInfo(nsTableFrame* aTableFrame);
|
|
void ResetCellInfo();
|
|
void SetInfo(nsTableRowFrame* aNewRow,
|
|
int32_t aColIndex,
|
|
BCCellData* aCellData,
|
|
BCMapCellIterator* aIter,
|
|
nsCellMap* aCellMap = nullptr);
|
|
// The BCMapCellInfo has functions to set the continous
|
|
// border widths (see nsTablePainter.cpp for a description of the continous
|
|
// borders concept). The widths are computed inside these functions based on
|
|
// the current position inside the table and the cached frames that correspond
|
|
// to this position. The widths are stored in member variables of the internal
|
|
// table frames.
|
|
void SetTableTopLeftContBCBorder();
|
|
void SetRowGroupLeftContBCBorder();
|
|
void SetRowGroupRightContBCBorder();
|
|
void SetRowGroupBottomContBCBorder();
|
|
void SetRowLeftContBCBorder();
|
|
void SetRowRightContBCBorder();
|
|
void SetColumnTopRightContBCBorder();
|
|
void SetColumnBottomContBCBorder();
|
|
void SetColGroupBottomContBCBorder();
|
|
void SetInnerRowGroupBottomContBCBorder(const nsIFrame* aNextRowGroup,
|
|
nsTableRowFrame* aNextRow);
|
|
|
|
// functions to set the border widths on the table related frames, where the
|
|
// knowledge about the current position in the table is used.
|
|
void SetTableTopBorderWidth(BCPixelSize aWidth);
|
|
void SetTableLeftBorderWidth(int32_t aRowY, BCPixelSize aWidth);
|
|
void SetTableRightBorderWidth(int32_t aRowY, BCPixelSize aWidth);
|
|
void SetTableBottomBorderWidth(BCPixelSize aWidth);
|
|
void SetLeftBorderWidths(BCPixelSize aWidth);
|
|
void SetRightBorderWidths(BCPixelSize aWidth);
|
|
void SetTopBorderWidths(BCPixelSize aWidth);
|
|
void SetBottomBorderWidths(BCPixelSize aWidth);
|
|
|
|
// functions to compute the borders; they depend on the
|
|
// knowledge about the current position in the table. The edge functions
|
|
// should be called if a table edge is involved, otherwise the internal
|
|
// functions should be called.
|
|
BCCellBorder GetTopEdgeBorder();
|
|
BCCellBorder GetBottomEdgeBorder();
|
|
BCCellBorder GetLeftEdgeBorder();
|
|
BCCellBorder GetRightEdgeBorder();
|
|
BCCellBorder GetRightInternalBorder();
|
|
BCCellBorder GetLeftInternalBorder();
|
|
BCCellBorder GetTopInternalBorder();
|
|
BCCellBorder GetBottomInternalBorder();
|
|
|
|
// functions to set the interal position information
|
|
void SetColumn(int32_t aColX);
|
|
// Increment the row as we loop over the rows of a rowspan
|
|
void IncrementRow(bool aResetToTopRowOfCell = false);
|
|
|
|
// Helper functions to get extent of the cell
|
|
int32_t GetCellEndRowIndex() const;
|
|
int32_t GetCellEndColIndex() const;
|
|
|
|
// storage of table information
|
|
nsTableFrame* mTableFrame;
|
|
int32_t mNumTableRows;
|
|
int32_t mNumTableCols;
|
|
BCPropertyData* mTableBCData;
|
|
|
|
// storage of table ltr information, the border collapse code swaps the sides
|
|
// to account for rtl tables, this is done through mStartSide and mEndSide
|
|
bool mTableIsLTR;
|
|
mozilla::css::Side mStartSide;
|
|
mozilla::css::Side mEndSide;
|
|
|
|
// a cell can only belong to one rowgroup
|
|
nsTableRowGroupFrame* mRowGroup;
|
|
|
|
// a cell with a rowspan has a top and a bottom row, and rows in between
|
|
nsTableRowFrame* mTopRow;
|
|
nsTableRowFrame* mBottomRow;
|
|
nsTableRowFrame* mCurrentRowFrame;
|
|
|
|
// a cell with a colspan has a left and right column and columns in between
|
|
// they can belong to different colgroups
|
|
nsTableColGroupFrame* mColGroup;
|
|
nsTableColGroupFrame* mCurrentColGroupFrame;
|
|
|
|
nsTableColFrame* mLeftCol;
|
|
nsTableColFrame* mRightCol;
|
|
nsTableColFrame* mCurrentColFrame;
|
|
|
|
// cell information
|
|
BCCellData* mCellData;
|
|
nsBCTableCellFrame* mCell;
|
|
|
|
int32_t mRowIndex;
|
|
int32_t mRowSpan;
|
|
int32_t mColIndex;
|
|
int32_t mColSpan;
|
|
|
|
// flags to describe the position of the cell with respect to the row- and
|
|
// colgroups, for instance mRgAtTop documents that the top cell border hits
|
|
// a rowgroup border
|
|
bool mRgAtTop;
|
|
bool mRgAtBottom;
|
|
bool mCgAtLeft;
|
|
bool mCgAtRight;
|
|
|
|
};
|
|
|
|
|
|
BCMapCellInfo::BCMapCellInfo(nsTableFrame* aTableFrame)
|
|
{
|
|
mTableFrame = aTableFrame;
|
|
mTableIsLTR =
|
|
aTableFrame->StyleVisibility()->mDirection == NS_STYLE_DIRECTION_LTR;
|
|
if (mTableIsLTR) {
|
|
mStartSide = NS_SIDE_LEFT;
|
|
mEndSide = NS_SIDE_RIGHT;
|
|
}
|
|
else {
|
|
mStartSide = NS_SIDE_RIGHT;
|
|
mEndSide = NS_SIDE_LEFT;
|
|
}
|
|
mNumTableRows = mTableFrame->GetRowCount();
|
|
mNumTableCols = mTableFrame->GetColCount();
|
|
mTableBCData = static_cast<BCPropertyData*>
|
|
(mTableFrame->Properties().Get(TableBCProperty()));
|
|
|
|
ResetCellInfo();
|
|
}
|
|
|
|
void BCMapCellInfo::ResetCellInfo()
|
|
{
|
|
mCellData = nullptr;
|
|
mRowGroup = nullptr;
|
|
mTopRow = nullptr;
|
|
mBottomRow = nullptr;
|
|
mColGroup = nullptr;
|
|
mLeftCol = nullptr;
|
|
mRightCol = nullptr;
|
|
mCell = nullptr;
|
|
mRowIndex = mRowSpan = mColIndex = mColSpan = 0;
|
|
mRgAtTop = mRgAtBottom = mCgAtLeft = mCgAtRight = false;
|
|
}
|
|
|
|
inline int32_t BCMapCellInfo::GetCellEndRowIndex() const
|
|
{
|
|
return mRowIndex + mRowSpan - 1;
|
|
}
|
|
|
|
inline int32_t BCMapCellInfo::GetCellEndColIndex() const
|
|
{
|
|
return mColIndex + mColSpan - 1;
|
|
}
|
|
|
|
|
|
class BCMapCellIterator
|
|
{
|
|
public:
|
|
BCMapCellIterator(nsTableFrame* aTableFrame,
|
|
const nsIntRect& aDamageArea);
|
|
|
|
void First(BCMapCellInfo& aMapCellInfo);
|
|
|
|
void Next(BCMapCellInfo& aMapCellInfo);
|
|
|
|
void PeekRight(BCMapCellInfo& aRefInfo,
|
|
uint32_t aRowIndex,
|
|
BCMapCellInfo& aAjaInfo);
|
|
|
|
void PeekBottom(BCMapCellInfo& aRefInfo,
|
|
uint32_t aColIndex,
|
|
BCMapCellInfo& aAjaInfo);
|
|
|
|
bool IsNewRow() { return mIsNewRow; }
|
|
|
|
nsTableRowFrame* GetPrevRow() const { return mPrevRow; }
|
|
nsTableRowFrame* GetCurrentRow() const { return mRow; }
|
|
nsTableRowGroupFrame* GetCurrentRowGroup() const { return mRowGroup;}
|
|
|
|
int32_t mRowGroupStart;
|
|
int32_t mRowGroupEnd;
|
|
bool mAtEnd;
|
|
nsCellMap* mCellMap;
|
|
|
|
private:
|
|
bool SetNewRow(nsTableRowFrame* row = nullptr);
|
|
bool SetNewRowGroup(bool aFindFirstDamagedRow);
|
|
|
|
nsTableFrame* mTableFrame;
|
|
nsTableCellMap* mTableCellMap;
|
|
nsTableFrame::RowGroupArray mRowGroups;
|
|
nsTableRowGroupFrame* mRowGroup;
|
|
int32_t mRowGroupIndex;
|
|
uint32_t mNumTableRows;
|
|
nsTableRowFrame* mRow;
|
|
nsTableRowFrame* mPrevRow;
|
|
bool mIsNewRow;
|
|
int32_t mRowIndex;
|
|
uint32_t mNumTableCols;
|
|
int32_t mColIndex;
|
|
nsPoint mAreaStart;
|
|
nsPoint mAreaEnd;
|
|
};
|
|
|
|
BCMapCellIterator::BCMapCellIterator(nsTableFrame* aTableFrame,
|
|
const nsIntRect& aDamageArea)
|
|
:mTableFrame(aTableFrame)
|
|
{
|
|
mTableCellMap = aTableFrame->GetCellMap();
|
|
|
|
mAreaStart.x = aDamageArea.x;
|
|
mAreaStart.y = aDamageArea.y;
|
|
mAreaEnd.y = aDamageArea.y + aDamageArea.height - 1;
|
|
mAreaEnd.x = aDamageArea.x + aDamageArea.width - 1;
|
|
|
|
mNumTableRows = mTableFrame->GetRowCount();
|
|
mRow = nullptr;
|
|
mRowIndex = 0;
|
|
mNumTableCols = mTableFrame->GetColCount();
|
|
mColIndex = 0;
|
|
mRowGroupIndex = -1;
|
|
|
|
// Get the ordered row groups
|
|
aTableFrame->OrderRowGroups(mRowGroups);
|
|
|
|
mAtEnd = true; // gets reset when First() is called
|
|
}
|
|
|
|
// fill fields that we need for border collapse computation on a given cell
|
|
void
|
|
BCMapCellInfo::SetInfo(nsTableRowFrame* aNewRow,
|
|
int32_t aColIndex,
|
|
BCCellData* aCellData,
|
|
BCMapCellIterator* aIter,
|
|
nsCellMap* aCellMap)
|
|
{
|
|
// fill the cell information
|
|
mCellData = aCellData;
|
|
mColIndex = aColIndex;
|
|
|
|
// initialize the row information if it was not previously set for cells in
|
|
// this row
|
|
mRowIndex = 0;
|
|
if (aNewRow) {
|
|
mTopRow = aNewRow;
|
|
mRowIndex = aNewRow->GetRowIndex();
|
|
}
|
|
|
|
// fill cell frame info and row information
|
|
mCell = nullptr;
|
|
mRowSpan = 1;
|
|
mColSpan = 1;
|
|
if (aCellData) {
|
|
mCell = static_cast<nsBCTableCellFrame*>(aCellData->GetCellFrame());
|
|
if (mCell) {
|
|
if (!mTopRow) {
|
|
mTopRow = static_cast<nsTableRowFrame*>(mCell->GetParent());
|
|
if (!mTopRow) ABORT0();
|
|
mRowIndex = mTopRow->GetRowIndex();
|
|
}
|
|
mColSpan = mTableFrame->GetEffectiveColSpan(*mCell, aCellMap);
|
|
mRowSpan = mTableFrame->GetEffectiveRowSpan(*mCell, aCellMap);
|
|
}
|
|
}
|
|
|
|
if (!mTopRow) {
|
|
mTopRow = aIter->GetCurrentRow();
|
|
}
|
|
if (1 == mRowSpan) {
|
|
mBottomRow = mTopRow;
|
|
}
|
|
else {
|
|
mBottomRow = mTopRow->GetNextRow();
|
|
if (mBottomRow) {
|
|
for (int32_t spanY = 2; mBottomRow && (spanY < mRowSpan); spanY++) {
|
|
mBottomRow = mBottomRow->GetNextRow();
|
|
}
|
|
NS_ASSERTION(mBottomRow, "spanned row not found");
|
|
}
|
|
else {
|
|
NS_ASSERTION(false, "error in cell map");
|
|
mRowSpan = 1;
|
|
mBottomRow = mTopRow;
|
|
}
|
|
}
|
|
// row group frame info
|
|
// try to reuse the rgStart and rgEnd from the iterator as calls to
|
|
// GetRowCount() are computationally expensive and should be avoided if
|
|
// possible
|
|
uint32_t rgStart = aIter->mRowGroupStart;
|
|
uint32_t rgEnd = aIter->mRowGroupEnd;
|
|
mRowGroup = static_cast<nsTableRowGroupFrame*>(mTopRow->GetParent());
|
|
if (mRowGroup != aIter->GetCurrentRowGroup()) {
|
|
rgStart = mRowGroup->GetStartRowIndex();
|
|
rgEnd = rgStart + mRowGroup->GetRowCount() - 1;
|
|
}
|
|
uint32_t rowIndex = mTopRow->GetRowIndex();
|
|
mRgAtTop = (rgStart == rowIndex);
|
|
mRgAtBottom = (rgEnd == rowIndex + mRowSpan - 1);
|
|
|
|
// col frame info
|
|
mLeftCol = mTableFrame->GetColFrame(aColIndex);
|
|
if (!mLeftCol) ABORT0();
|
|
|
|
mRightCol = mLeftCol;
|
|
if (mColSpan > 1) {
|
|
nsTableColFrame* colFrame = mTableFrame->GetColFrame(aColIndex +
|
|
mColSpan -1);
|
|
if (!colFrame) ABORT0();
|
|
mRightCol = colFrame;
|
|
}
|
|
|
|
// col group frame info
|
|
mColGroup = static_cast<nsTableColGroupFrame*>(mLeftCol->GetParent());
|
|
int32_t cgStart = mColGroup->GetStartColumnIndex();
|
|
int32_t cgEnd = std::max(0, cgStart + mColGroup->GetColCount() - 1);
|
|
mCgAtLeft = (cgStart == aColIndex);
|
|
mCgAtRight = (cgEnd == aColIndex + mColSpan - 1);
|
|
}
|
|
|
|
bool
|
|
BCMapCellIterator::SetNewRow(nsTableRowFrame* aRow)
|
|
{
|
|
mAtEnd = true;
|
|
mPrevRow = mRow;
|
|
if (aRow) {
|
|
mRow = aRow;
|
|
}
|
|
else if (mRow) {
|
|
mRow = mRow->GetNextRow();
|
|
}
|
|
if (mRow) {
|
|
mRowIndex = mRow->GetRowIndex();
|
|
// get to the first entry with an originating cell
|
|
int32_t rgRowIndex = mRowIndex - mRowGroupStart;
|
|
if (uint32_t(rgRowIndex) >= mCellMap->mRows.Length())
|
|
ABORT1(false);
|
|
const nsCellMap::CellDataArray& row = mCellMap->mRows[rgRowIndex];
|
|
|
|
for (mColIndex = mAreaStart.x; mColIndex <= mAreaEnd.x; mColIndex++) {
|
|
CellData* cellData = row.SafeElementAt(mColIndex);
|
|
if (!cellData) { // add a dead cell data
|
|
nsIntRect damageArea;
|
|
cellData = mCellMap->AppendCell(*mTableCellMap, nullptr, rgRowIndex,
|
|
false, 0, damageArea);
|
|
if (!cellData) ABORT1(false);
|
|
}
|
|
if (cellData && (cellData->IsOrig() || cellData->IsDead())) {
|
|
break;
|
|
}
|
|
}
|
|
mIsNewRow = true;
|
|
mAtEnd = false;
|
|
}
|
|
else ABORT1(false);
|
|
|
|
return !mAtEnd;
|
|
}
|
|
|
|
bool
|
|
BCMapCellIterator::SetNewRowGroup(bool aFindFirstDamagedRow)
|
|
{
|
|
mAtEnd = true;
|
|
int32_t numRowGroups = mRowGroups.Length();
|
|
mCellMap = nullptr;
|
|
for (mRowGroupIndex++; mRowGroupIndex < numRowGroups; mRowGroupIndex++) {
|
|
mRowGroup = mRowGroups[mRowGroupIndex];
|
|
int32_t rowCount = mRowGroup->GetRowCount();
|
|
mRowGroupStart = mRowGroup->GetStartRowIndex();
|
|
mRowGroupEnd = mRowGroupStart + rowCount - 1;
|
|
if (rowCount > 0) {
|
|
mCellMap = mTableCellMap->GetMapFor(mRowGroup, mCellMap);
|
|
if (!mCellMap) ABORT1(false);
|
|
nsTableRowFrame* firstRow = mRowGroup->GetFirstRow();
|
|
if (aFindFirstDamagedRow) {
|
|
if ((mAreaStart.y >= mRowGroupStart) && (mAreaStart.y <= mRowGroupEnd)) {
|
|
// the damage area starts in the row group
|
|
if (aFindFirstDamagedRow) {
|
|
// find the correct first damaged row
|
|
int32_t numRows = mAreaStart.y - mRowGroupStart;
|
|
for (int32_t i = 0; i < numRows; i++) {
|
|
firstRow = firstRow->GetNextRow();
|
|
if (!firstRow) ABORT1(false);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
continue;
|
|
}
|
|
}
|
|
if (SetNewRow(firstRow)) { // sets mAtEnd
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return !mAtEnd;
|
|
}
|
|
|
|
void
|
|
BCMapCellIterator::First(BCMapCellInfo& aMapInfo)
|
|
{
|
|
aMapInfo.ResetCellInfo();
|
|
|
|
SetNewRowGroup(true); // sets mAtEnd
|
|
while (!mAtEnd) {
|
|
if ((mAreaStart.y >= mRowGroupStart) && (mAreaStart.y <= mRowGroupEnd)) {
|
|
BCCellData* cellData =
|
|
static_cast<BCCellData*>(mCellMap->GetDataAt(mAreaStart.y -
|
|
mRowGroupStart,
|
|
mAreaStart.x));
|
|
if (cellData && (cellData->IsOrig() || cellData->IsDead())) {
|
|
aMapInfo.SetInfo(mRow, mAreaStart.x, cellData, this);
|
|
return;
|
|
}
|
|
else {
|
|
NS_ASSERTION(((0 == mAreaStart.x) && (mRowGroupStart == mAreaStart.y)) ,
|
|
"damage area expanded incorrectly");
|
|
}
|
|
}
|
|
SetNewRowGroup(true); // sets mAtEnd
|
|
}
|
|
}
|
|
|
|
void
|
|
BCMapCellIterator::Next(BCMapCellInfo& aMapInfo)
|
|
{
|
|
if (mAtEnd) ABORT0();
|
|
aMapInfo.ResetCellInfo();
|
|
|
|
mIsNewRow = false;
|
|
mColIndex++;
|
|
while ((mRowIndex <= mAreaEnd.y) && !mAtEnd) {
|
|
for (; mColIndex <= mAreaEnd.x; mColIndex++) {
|
|
int32_t rgRowIndex = mRowIndex - mRowGroupStart;
|
|
BCCellData* cellData =
|
|
static_cast<BCCellData*>(mCellMap->GetDataAt(rgRowIndex, mColIndex));
|
|
if (!cellData) { // add a dead cell data
|
|
nsIntRect damageArea;
|
|
cellData =
|
|
static_cast<BCCellData*>(mCellMap->AppendCell(*mTableCellMap, nullptr,
|
|
rgRowIndex, false, 0,
|
|
damageArea));
|
|
if (!cellData) ABORT0();
|
|
}
|
|
if (cellData && (cellData->IsOrig() || cellData->IsDead())) {
|
|
aMapInfo.SetInfo(mRow, mColIndex, cellData, this);
|
|
return;
|
|
}
|
|
}
|
|
if (mRowIndex >= mRowGroupEnd) {
|
|
SetNewRowGroup(false); // could set mAtEnd
|
|
}
|
|
else {
|
|
SetNewRow(); // could set mAtEnd
|
|
}
|
|
}
|
|
mAtEnd = true;
|
|
}
|
|
|
|
void
|
|
BCMapCellIterator::PeekRight(BCMapCellInfo& aRefInfo,
|
|
uint32_t aRowIndex,
|
|
BCMapCellInfo& aAjaInfo)
|
|
{
|
|
aAjaInfo.ResetCellInfo();
|
|
int32_t colIndex = aRefInfo.mColIndex + aRefInfo.mColSpan;
|
|
uint32_t rgRowIndex = aRowIndex - mRowGroupStart;
|
|
|
|
BCCellData* cellData =
|
|
static_cast<BCCellData*>(mCellMap->GetDataAt(rgRowIndex, colIndex));
|
|
if (!cellData) { // add a dead cell data
|
|
NS_ASSERTION(colIndex < mTableCellMap->GetColCount(), "program error");
|
|
nsIntRect damageArea;
|
|
cellData =
|
|
static_cast<BCCellData*>(mCellMap->AppendCell(*mTableCellMap, nullptr,
|
|
rgRowIndex, false, 0,
|
|
damageArea));
|
|
if (!cellData) ABORT0();
|
|
}
|
|
nsTableRowFrame* row = nullptr;
|
|
if (cellData->IsRowSpan()) {
|
|
rgRowIndex -= cellData->GetRowSpanOffset();
|
|
cellData =
|
|
static_cast<BCCellData*>(mCellMap->GetDataAt(rgRowIndex, colIndex));
|
|
if (!cellData)
|
|
ABORT0();
|
|
}
|
|
else {
|
|
row = mRow;
|
|
}
|
|
aAjaInfo.SetInfo(row, colIndex, cellData, this);
|
|
}
|
|
|
|
void
|
|
BCMapCellIterator::PeekBottom(BCMapCellInfo& aRefInfo,
|
|
uint32_t aColIndex,
|
|
BCMapCellInfo& aAjaInfo)
|
|
{
|
|
aAjaInfo.ResetCellInfo();
|
|
int32_t rowIndex = aRefInfo.mRowIndex + aRefInfo.mRowSpan;
|
|
int32_t rgRowIndex = rowIndex - mRowGroupStart;
|
|
nsTableRowGroupFrame* rg = mRowGroup;
|
|
nsCellMap* cellMap = mCellMap;
|
|
nsTableRowFrame* nextRow = nullptr;
|
|
if (rowIndex > mRowGroupEnd) {
|
|
int32_t nextRgIndex = mRowGroupIndex;
|
|
do {
|
|
nextRgIndex++;
|
|
rg = mRowGroups.SafeElementAt(nextRgIndex);
|
|
if (rg) {
|
|
cellMap = mTableCellMap->GetMapFor(rg, cellMap); if (!cellMap) ABORT0();
|
|
rgRowIndex = 0;
|
|
nextRow = rg->GetFirstRow();
|
|
}
|
|
}
|
|
while (rg && !nextRow);
|
|
if(!rg) return;
|
|
}
|
|
else {
|
|
// get the row within the same row group
|
|
nextRow = mRow;
|
|
for (int32_t i = 0; i < aRefInfo.mRowSpan; i++) {
|
|
nextRow = nextRow->GetNextRow(); if (!nextRow) ABORT0();
|
|
}
|
|
}
|
|
|
|
BCCellData* cellData =
|
|
static_cast<BCCellData*>(cellMap->GetDataAt(rgRowIndex, aColIndex));
|
|
if (!cellData) { // add a dead cell data
|
|
NS_ASSERTION(rgRowIndex < cellMap->GetRowCount(), "program error");
|
|
nsIntRect damageArea;
|
|
cellData =
|
|
static_cast<BCCellData*>(cellMap->AppendCell(*mTableCellMap, nullptr,
|
|
rgRowIndex, false, 0,
|
|
damageArea));
|
|
if (!cellData) ABORT0();
|
|
}
|
|
if (cellData->IsColSpan()) {
|
|
aColIndex -= cellData->GetColSpanOffset();
|
|
cellData =
|
|
static_cast<BCCellData*>(cellMap->GetDataAt(rgRowIndex, aColIndex));
|
|
}
|
|
aAjaInfo.SetInfo(nextRow, aColIndex, cellData, this, cellMap);
|
|
}
|
|
|
|
// Assign priorities to border styles. For example, styleToPriority(NS_STYLE_BORDER_STYLE_SOLID)
|
|
// will return the priority of NS_STYLE_BORDER_STYLE_SOLID.
|
|
static uint8_t styleToPriority[13] = { 0, // NS_STYLE_BORDER_STYLE_NONE
|
|
2, // NS_STYLE_BORDER_STYLE_GROOVE
|
|
4, // NS_STYLE_BORDER_STYLE_RIDGE
|
|
5, // NS_STYLE_BORDER_STYLE_DOTTED
|
|
6, // NS_STYLE_BORDER_STYLE_DASHED
|
|
7, // NS_STYLE_BORDER_STYLE_SOLID
|
|
8, // NS_STYLE_BORDER_STYLE_DOUBLE
|
|
1, // NS_STYLE_BORDER_STYLE_INSET
|
|
3, // NS_STYLE_BORDER_STYLE_OUTSET
|
|
9 };// NS_STYLE_BORDER_STYLE_HIDDEN
|
|
// priority rules follow CSS 2.1 spec
|
|
// 'hidden', 'double', 'solid', 'dashed', 'dotted', 'ridge', 'outset', 'groove',
|
|
// and the lowest: 'inset'. none is even weaker
|
|
#define CELL_CORNER true
|
|
|
|
/** return the border style, border color for a given frame and side
|
|
* @param aFrame - query the info for this frame
|
|
* @param aSide - the side of the frame
|
|
* @param aStyle - the border style
|
|
* @param aColor - the border color
|
|
* @param aTableIsLTR - table direction is LTR
|
|
*/
|
|
static void
|
|
GetColorAndStyle(const nsIFrame* aFrame,
|
|
mozilla::css::Side aSide,
|
|
uint8_t& aStyle,
|
|
nscolor& aColor,
|
|
bool aTableIsLTR)
|
|
{
|
|
NS_PRECONDITION(aFrame, "null frame");
|
|
// initialize out arg
|
|
aColor = 0;
|
|
const nsStyleBorder* styleData = aFrame->StyleBorder();
|
|
if(!aTableIsLTR) { // revert the directions
|
|
if (NS_SIDE_RIGHT == aSide) {
|
|
aSide = NS_SIDE_LEFT;
|
|
}
|
|
else if (NS_SIDE_LEFT == aSide) {
|
|
aSide = NS_SIDE_RIGHT;
|
|
}
|
|
}
|
|
aStyle = styleData->GetBorderStyle(aSide);
|
|
|
|
if ((NS_STYLE_BORDER_STYLE_NONE == aStyle) ||
|
|
(NS_STYLE_BORDER_STYLE_HIDDEN == aStyle)) {
|
|
return;
|
|
}
|
|
aColor = aFrame->StyleContext()->GetVisitedDependentColor(
|
|
nsCSSProps::SubpropertyEntryFor(eCSSProperty_border_color)[aSide]);
|
|
}
|
|
|
|
/** coerce the paint style as required by CSS2.1
|
|
* @param aFrame - query the info for this frame
|
|
* @param aSide - the side of the frame
|
|
* @param aStyle - the border style
|
|
* @param aColor - the border color
|
|
* @param aTableIsLTR - table direction is LTR
|
|
*/
|
|
static void
|
|
GetPaintStyleInfo(const nsIFrame* aFrame,
|
|
mozilla::css::Side aSide,
|
|
uint8_t& aStyle,
|
|
nscolor& aColor,
|
|
bool aTableIsLTR)
|
|
{
|
|
GetColorAndStyle(aFrame, aSide, aStyle, aColor, aTableIsLTR);
|
|
if (NS_STYLE_BORDER_STYLE_INSET == aStyle) {
|
|
aStyle = NS_STYLE_BORDER_STYLE_RIDGE;
|
|
}
|
|
else if (NS_STYLE_BORDER_STYLE_OUTSET == aStyle) {
|
|
aStyle = NS_STYLE_BORDER_STYLE_GROOVE;
|
|
}
|
|
}
|
|
|
|
/** return the border style, border color and the width in pixel for a given
|
|
* frame and side
|
|
* @param aFrame - query the info for this frame
|
|
* @param aSide - the side of the frame
|
|
* @param aStyle - the border style
|
|
* @param aColor - the border color
|
|
* @param aTableIsLTR - table direction is LTR
|
|
* @param aWidth - the border width in px.
|
|
* @param aTwipsToPixels - conversion factor from twips to pixel
|
|
*/
|
|
static void
|
|
GetColorAndStyle(const nsIFrame* aFrame,
|
|
mozilla::css::Side aSide,
|
|
uint8_t& aStyle,
|
|
nscolor& aColor,
|
|
bool aTableIsLTR,
|
|
BCPixelSize& aWidth)
|
|
{
|
|
GetColorAndStyle(aFrame, aSide, aStyle, aColor, aTableIsLTR);
|
|
if ((NS_STYLE_BORDER_STYLE_NONE == aStyle) ||
|
|
(NS_STYLE_BORDER_STYLE_HIDDEN == aStyle)) {
|
|
aWidth = 0;
|
|
return;
|
|
}
|
|
const nsStyleBorder* styleData = aFrame->StyleBorder();
|
|
nscoord width;
|
|
if(!aTableIsLTR) { // revert the directions
|
|
if (NS_SIDE_RIGHT == aSide) {
|
|
aSide = NS_SIDE_LEFT;
|
|
}
|
|
else if (NS_SIDE_LEFT == aSide) {
|
|
aSide = NS_SIDE_RIGHT;
|
|
}
|
|
}
|
|
width = styleData->GetComputedBorderWidth(aSide);
|
|
aWidth = nsPresContext::AppUnitsToIntCSSPixels(width);
|
|
}
|
|
|
|
class nsDelayedCalcBCBorders : public nsRunnable {
|
|
public:
|
|
nsDelayedCalcBCBorders(nsIFrame* aFrame) :
|
|
mFrame(aFrame) {}
|
|
|
|
NS_IMETHOD Run() MOZ_OVERRIDE {
|
|
if (mFrame) {
|
|
nsTableFrame* tableFrame = static_cast <nsTableFrame*>(mFrame.GetFrame());
|
|
if (tableFrame->NeedToCalcBCBorders()) {
|
|
tableFrame->CalcBCBorders();
|
|
}
|
|
}
|
|
return NS_OK;
|
|
}
|
|
private:
|
|
nsWeakFrame mFrame;
|
|
};
|
|
|
|
bool
|
|
nsTableFrame::BCRecalcNeeded(nsStyleContext* aOldStyleContext,
|
|
nsStyleContext* aNewStyleContext)
|
|
{
|
|
// Attention: the old style context is the one we're forgetting,
|
|
// and hence possibly completely bogus for GetStyle* purposes.
|
|
// We use PeekStyleData instead.
|
|
|
|
const nsStyleBorder* oldStyleData = aOldStyleContext->PeekStyleBorder();
|
|
if (!oldStyleData)
|
|
return false;
|
|
|
|
const nsStyleBorder* newStyleData = aNewStyleContext->StyleBorder();
|
|
nsChangeHint change = newStyleData->CalcDifference(*oldStyleData);
|
|
if (!change)
|
|
return false;
|
|
if (change & nsChangeHint_NeedReflow)
|
|
return true; // the caller only needs to mark the bc damage area
|
|
if (change & nsChangeHint_RepaintFrame) {
|
|
// we need to recompute the borders and the caller needs to mark
|
|
// the bc damage area
|
|
// XXX In principle this should only be necessary for border style changes
|
|
// However the bc painting code tries to maximize the drawn border segments
|
|
// so it stores in the cellmap where a new border segment starts and this
|
|
// introduces a unwanted cellmap data dependence on color
|
|
nsCOMPtr<nsIRunnable> evt = new nsDelayedCalcBCBorders(this);
|
|
NS_DispatchToCurrentThread(evt);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
// Compare two border segments, this comparison depends whether the two
|
|
// segments meet at a corner and whether the second segment is horizontal.
|
|
// The return value is whichever of aBorder1 or aBorder2 dominates.
|
|
static const BCCellBorder&
|
|
CompareBorders(bool aIsCorner, // Pass true for corner calculations
|
|
const BCCellBorder& aBorder1,
|
|
const BCCellBorder& aBorder2,
|
|
bool aSecondIsHorizontal,
|
|
bool* aFirstDominates = nullptr)
|
|
{
|
|
bool firstDominates = true;
|
|
|
|
if (NS_STYLE_BORDER_STYLE_HIDDEN == aBorder1.style) {
|
|
firstDominates = (aIsCorner) ? false : true;
|
|
}
|
|
else if (NS_STYLE_BORDER_STYLE_HIDDEN == aBorder2.style) {
|
|
firstDominates = (aIsCorner) ? true : false;
|
|
}
|
|
else if (aBorder1.width < aBorder2.width) {
|
|
firstDominates = false;
|
|
}
|
|
else if (aBorder1.width == aBorder2.width) {
|
|
if (styleToPriority[aBorder1.style] < styleToPriority[aBorder2.style]) {
|
|
firstDominates = false;
|
|
}
|
|
else if (styleToPriority[aBorder1.style] == styleToPriority[aBorder2.style]) {
|
|
if (aBorder1.owner == aBorder2.owner) {
|
|
firstDominates = !aSecondIsHorizontal;
|
|
}
|
|
else if (aBorder1.owner < aBorder2.owner) {
|
|
firstDominates = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (aFirstDominates)
|
|
*aFirstDominates = firstDominates;
|
|
|
|
if (firstDominates)
|
|
return aBorder1;
|
|
return aBorder2;
|
|
}
|
|
|
|
/** calc the dominant border by considering the table, row/col group, row/col,
|
|
* cell.
|
|
* Depending on whether the side is vertical or horizontal and whether
|
|
* adjacent frames are taken into account the ownership of a single border
|
|
* segment is defined. The return value is the dominating border
|
|
* The cellmap stores only top and left borders for each cellmap position.
|
|
* If the cell border is owned by the cell that is left of the border
|
|
* it will be an adjacent owner aka eAjaCellOwner. See celldata.h for the other
|
|
* scenarios with a adjacent owner.
|
|
* @param xxxFrame - the frame for style information, might be zero if
|
|
* it should not be considered
|
|
* @param aSide - side of the frames that should be considered
|
|
* @param aAja - the border comparison takes place from the point of
|
|
* a frame that is adjacent to the cellmap entry, for
|
|
* when a cell owns its lower border it will be the
|
|
* adjacent owner as in the cellmap only top and left
|
|
* borders are stored.
|
|
* @param aTwipsToPixels - conversion factor as borders need to be drawn pixel
|
|
* aligned.
|
|
*/
|
|
static BCCellBorder
|
|
CompareBorders(const nsIFrame* aTableFrame,
|
|
const nsIFrame* aColGroupFrame,
|
|
const nsIFrame* aColFrame,
|
|
const nsIFrame* aRowGroupFrame,
|
|
const nsIFrame* aRowFrame,
|
|
const nsIFrame* aCellFrame,
|
|
bool aTableIsLTR,
|
|
mozilla::css::Side aSide,
|
|
bool aAja)
|
|
{
|
|
BCCellBorder border, tempBorder;
|
|
bool horizontal = (NS_SIDE_TOP == aSide) || (NS_SIDE_BOTTOM == aSide);
|
|
|
|
// start with the table as dominant if present
|
|
if (aTableFrame) {
|
|
GetColorAndStyle(aTableFrame, aSide, border.style, border.color, aTableIsLTR, border.width);
|
|
border.owner = eTableOwner;
|
|
if (NS_STYLE_BORDER_STYLE_HIDDEN == border.style) {
|
|
return border;
|
|
}
|
|
}
|
|
// see if the colgroup is dominant
|
|
if (aColGroupFrame) {
|
|
GetColorAndStyle(aColGroupFrame, aSide, tempBorder.style, tempBorder.color, aTableIsLTR, tempBorder.width);
|
|
tempBorder.owner = (aAja && !horizontal) ? eAjaColGroupOwner : eColGroupOwner;
|
|
// pass here and below false for aSecondIsHorizontal as it is only used for corner calculations.
|
|
border = CompareBorders(!CELL_CORNER, border, tempBorder, false);
|
|
if (NS_STYLE_BORDER_STYLE_HIDDEN == border.style) {
|
|
return border;
|
|
}
|
|
}
|
|
// see if the col is dominant
|
|
if (aColFrame) {
|
|
GetColorAndStyle(aColFrame, aSide, tempBorder.style, tempBorder.color, aTableIsLTR, tempBorder.width);
|
|
tempBorder.owner = (aAja && !horizontal) ? eAjaColOwner : eColOwner;
|
|
border = CompareBorders(!CELL_CORNER, border, tempBorder, false);
|
|
if (NS_STYLE_BORDER_STYLE_HIDDEN == border.style) {
|
|
return border;
|
|
}
|
|
}
|
|
// see if the rowgroup is dominant
|
|
if (aRowGroupFrame) {
|
|
GetColorAndStyle(aRowGroupFrame, aSide, tempBorder.style, tempBorder.color, aTableIsLTR, tempBorder.width);
|
|
tempBorder.owner = (aAja && horizontal) ? eAjaRowGroupOwner : eRowGroupOwner;
|
|
border = CompareBorders(!CELL_CORNER, border, tempBorder, false);
|
|
if (NS_STYLE_BORDER_STYLE_HIDDEN == border.style) {
|
|
return border;
|
|
}
|
|
}
|
|
// see if the row is dominant
|
|
if (aRowFrame) {
|
|
GetColorAndStyle(aRowFrame, aSide, tempBorder.style, tempBorder.color, aTableIsLTR, tempBorder.width);
|
|
tempBorder.owner = (aAja && horizontal) ? eAjaRowOwner : eRowOwner;
|
|
border = CompareBorders(!CELL_CORNER, border, tempBorder, false);
|
|
if (NS_STYLE_BORDER_STYLE_HIDDEN == border.style) {
|
|
return border;
|
|
}
|
|
}
|
|
// see if the cell is dominant
|
|
if (aCellFrame) {
|
|
GetColorAndStyle(aCellFrame, aSide, tempBorder.style, tempBorder.color, aTableIsLTR, tempBorder.width);
|
|
tempBorder.owner = (aAja) ? eAjaCellOwner : eCellOwner;
|
|
border = CompareBorders(!CELL_CORNER, border, tempBorder, false);
|
|
}
|
|
return border;
|
|
}
|
|
|
|
static bool
|
|
Perpendicular(mozilla::css::Side aSide1,
|
|
mozilla::css::Side aSide2)
|
|
{
|
|
switch (aSide1) {
|
|
case NS_SIDE_TOP:
|
|
return (NS_SIDE_BOTTOM != aSide2);
|
|
case NS_SIDE_RIGHT:
|
|
return (NS_SIDE_LEFT != aSide2);
|
|
case NS_SIDE_BOTTOM:
|
|
return (NS_SIDE_TOP != aSide2);
|
|
default: // NS_SIDE_LEFT
|
|
return (NS_SIDE_RIGHT != aSide2);
|
|
}
|
|
}
|
|
|
|
// XXX allocate this as number-of-cols+1 instead of number-of-cols+1 * number-of-rows+1
|
|
struct BCCornerInfo
|
|
{
|
|
BCCornerInfo() { ownerColor = 0; ownerWidth = subWidth = ownerElem = subSide =
|
|
subElem = hasDashDot = numSegs = bevel = 0; ownerSide = NS_SIDE_TOP;
|
|
ownerStyle = 0xFF; subStyle = NS_STYLE_BORDER_STYLE_SOLID; }
|
|
void Set(mozilla::css::Side aSide,
|
|
BCCellBorder border);
|
|
|
|
void Update(mozilla::css::Side aSide,
|
|
BCCellBorder border);
|
|
|
|
nscolor ownerColor; // color of borderOwner
|
|
uint16_t ownerWidth; // pixel width of borderOwner
|
|
uint16_t subWidth; // pixel width of the largest border intersecting the border perpendicular
|
|
// to ownerSide
|
|
uint32_t ownerSide:2; // mozilla::css::Side (e.g NS_SIDE_TOP, NS_SIDE_RIGHT, etc) of the border
|
|
// owning the corner relative to the corner
|
|
uint32_t ownerElem:3; // elem type (e.g. eTable, eGroup, etc) owning the corner
|
|
uint32_t ownerStyle:8; // border style of ownerElem
|
|
uint32_t subSide:2; // side of border with subWidth relative to the corner
|
|
uint32_t subElem:3; // elem type (e.g. eTable, eGroup, etc) of sub owner
|
|
uint32_t subStyle:8; // border style of subElem
|
|
uint32_t hasDashDot:1; // does a dashed, dotted segment enter the corner, they cannot be beveled
|
|
uint32_t numSegs:3; // number of segments entering corner
|
|
uint32_t bevel:1; // is the corner beveled (uses the above two fields together with subWidth)
|
|
uint32_t unused:1;
|
|
};
|
|
|
|
void
|
|
BCCornerInfo::Set(mozilla::css::Side aSide,
|
|
BCCellBorder aBorder)
|
|
{
|
|
ownerElem = aBorder.owner;
|
|
ownerStyle = aBorder.style;
|
|
ownerWidth = aBorder.width;
|
|
ownerColor = aBorder.color;
|
|
ownerSide = aSide;
|
|
hasDashDot = 0;
|
|
numSegs = 0;
|
|
if (aBorder.width > 0) {
|
|
numSegs++;
|
|
hasDashDot = (NS_STYLE_BORDER_STYLE_DASHED == aBorder.style) ||
|
|
(NS_STYLE_BORDER_STYLE_DOTTED == aBorder.style);
|
|
}
|
|
bevel = 0;
|
|
subWidth = 0;
|
|
// the following will get set later
|
|
subSide = ((aSide == NS_SIDE_LEFT) || (aSide == NS_SIDE_RIGHT)) ? NS_SIDE_TOP : NS_SIDE_LEFT;
|
|
subElem = eTableOwner;
|
|
subStyle = NS_STYLE_BORDER_STYLE_SOLID;
|
|
}
|
|
|
|
void
|
|
BCCornerInfo::Update(mozilla::css::Side aSide,
|
|
BCCellBorder aBorder)
|
|
{
|
|
bool existingWins = false;
|
|
if (0xFF == ownerStyle) { // initial value indiating that it hasn't been set yet
|
|
Set(aSide, aBorder);
|
|
}
|
|
else {
|
|
bool horizontal = (NS_SIDE_LEFT == aSide) || (NS_SIDE_RIGHT == aSide); // relative to the corner
|
|
BCCellBorder oldBorder, tempBorder;
|
|
oldBorder.owner = (BCBorderOwner) ownerElem;
|
|
oldBorder.style = ownerStyle;
|
|
oldBorder.width = ownerWidth;
|
|
oldBorder.color = ownerColor;
|
|
|
|
mozilla::css::Side oldSide = mozilla::css::Side(ownerSide);
|
|
|
|
tempBorder = CompareBorders(CELL_CORNER, oldBorder, aBorder, horizontal, &existingWins);
|
|
|
|
ownerElem = tempBorder.owner;
|
|
ownerStyle = tempBorder.style;
|
|
ownerWidth = tempBorder.width;
|
|
ownerColor = tempBorder.color;
|
|
if (existingWins) { // existing corner is dominant
|
|
if (::Perpendicular(mozilla::css::Side(ownerSide), aSide)) {
|
|
// see if the new sub info replaces the old
|
|
BCCellBorder subBorder;
|
|
subBorder.owner = (BCBorderOwner) subElem;
|
|
subBorder.style = subStyle;
|
|
subBorder.width = subWidth;
|
|
subBorder.color = 0; // we are not interested in subBorder color
|
|
bool firstWins;
|
|
|
|
tempBorder = CompareBorders(CELL_CORNER, subBorder, aBorder, horizontal, &firstWins);
|
|
|
|
subElem = tempBorder.owner;
|
|
subStyle = tempBorder.style;
|
|
subWidth = tempBorder.width;
|
|
if (!firstWins) {
|
|
subSide = aSide;
|
|
}
|
|
}
|
|
}
|
|
else { // input args are dominant
|
|
ownerSide = aSide;
|
|
if (::Perpendicular(oldSide, mozilla::css::Side(ownerSide))) {
|
|
subElem = oldBorder.owner;
|
|
subStyle = oldBorder.style;
|
|
subWidth = oldBorder.width;
|
|
subSide = oldSide;
|
|
}
|
|
}
|
|
if (aBorder.width > 0) {
|
|
numSegs++;
|
|
if (!hasDashDot && ((NS_STYLE_BORDER_STYLE_DASHED == aBorder.style) ||
|
|
(NS_STYLE_BORDER_STYLE_DOTTED == aBorder.style))) {
|
|
hasDashDot = 1;
|
|
}
|
|
}
|
|
|
|
// bevel the corner if only two perpendicular non dashed/dotted segments enter the corner
|
|
bevel = (2 == numSegs) && (subWidth > 1) && (0 == hasDashDot);
|
|
}
|
|
}
|
|
|
|
struct BCCorners
|
|
{
|
|
BCCorners(int32_t aNumCorners,
|
|
int32_t aStartIndex);
|
|
|
|
~BCCorners() { delete [] corners; }
|
|
|
|
BCCornerInfo& operator [](int32_t i) const
|
|
{ NS_ASSERTION((i >= startIndex) && (i <= endIndex), "program error");
|
|
return corners[clamped(i, startIndex, endIndex) - startIndex]; }
|
|
|
|
int32_t startIndex;
|
|
int32_t endIndex;
|
|
BCCornerInfo* corners;
|
|
};
|
|
|
|
BCCorners::BCCorners(int32_t aNumCorners,
|
|
int32_t aStartIndex)
|
|
{
|
|
NS_ASSERTION((aNumCorners > 0) && (aStartIndex >= 0), "program error");
|
|
startIndex = aStartIndex;
|
|
endIndex = aStartIndex + aNumCorners - 1;
|
|
corners = new BCCornerInfo[aNumCorners];
|
|
}
|
|
|
|
|
|
struct BCCellBorders
|
|
{
|
|
BCCellBorders(int32_t aNumBorders,
|
|
int32_t aStartIndex);
|
|
|
|
~BCCellBorders() { delete [] borders; }
|
|
|
|
BCCellBorder& operator [](int32_t i) const
|
|
{ NS_ASSERTION((i >= startIndex) && (i <= endIndex), "program error");
|
|
return borders[clamped(i, startIndex, endIndex) - startIndex]; }
|
|
|
|
int32_t startIndex;
|
|
int32_t endIndex;
|
|
BCCellBorder* borders;
|
|
};
|
|
|
|
BCCellBorders::BCCellBorders(int32_t aNumBorders,
|
|
int32_t aStartIndex)
|
|
{
|
|
NS_ASSERTION((aNumBorders > 0) && (aStartIndex >= 0), "program error");
|
|
startIndex = aStartIndex;
|
|
endIndex = aStartIndex + aNumBorders - 1;
|
|
borders = new BCCellBorder[aNumBorders];
|
|
}
|
|
|
|
// this function sets the new border properties and returns true if the border
|
|
// segment will start a new segment and not be accumulated into the previous
|
|
// segment.
|
|
static bool
|
|
SetBorder(const BCCellBorder& aNewBorder,
|
|
BCCellBorder& aBorder)
|
|
{
|
|
bool changed = (aNewBorder.style != aBorder.style) ||
|
|
(aNewBorder.width != aBorder.width) ||
|
|
(aNewBorder.color != aBorder.color);
|
|
aBorder.color = aNewBorder.color;
|
|
aBorder.width = aNewBorder.width;
|
|
aBorder.style = aNewBorder.style;
|
|
aBorder.owner = aNewBorder.owner;
|
|
|
|
return changed;
|
|
}
|
|
|
|
// this function will set the horizontal border. It will return true if the
|
|
// existing segment will not be continued. Having a vertical owner of a corner
|
|
// should also start a new segment.
|
|
static bool
|
|
SetHorBorder(const BCCellBorder& aNewBorder,
|
|
const BCCornerInfo& aCorner,
|
|
BCCellBorder& aBorder)
|
|
{
|
|
bool startSeg = ::SetBorder(aNewBorder, aBorder);
|
|
if (!startSeg) {
|
|
startSeg = ((NS_SIDE_LEFT != aCorner.ownerSide) && (NS_SIDE_RIGHT != aCorner.ownerSide));
|
|
}
|
|
return startSeg;
|
|
}
|
|
|
|
// Make the damage area larger on the top and bottom by at least one row and on the left and right
|
|
// at least one column. This is done so that adjacent elements are part of the border calculations.
|
|
// The extra segments and borders outside the actual damage area will not be updated in the cell map,
|
|
// because they in turn would need info from adjacent segments outside the damage area to be accurate.
|
|
void
|
|
nsTableFrame::ExpandBCDamageArea(nsIntRect& aRect) const
|
|
{
|
|
int32_t numRows = GetRowCount();
|
|
int32_t numCols = GetColCount();
|
|
|
|
int32_t dStartX = aRect.x;
|
|
int32_t dEndX = aRect.XMost() - 1;
|
|
int32_t dStartY = aRect.y;
|
|
int32_t dEndY = aRect.YMost() - 1;
|
|
|
|
// expand the damage area in each direction
|
|
if (dStartX > 0) {
|
|
dStartX--;
|
|
}
|
|
if (dEndX < (numCols - 1)) {
|
|
dEndX++;
|
|
}
|
|
if (dStartY > 0) {
|
|
dStartY--;
|
|
}
|
|
if (dEndY < (numRows - 1)) {
|
|
dEndY++;
|
|
}
|
|
// Check the damage area so that there are no cells spanning in or out. If there are any then
|
|
// make the damage area as big as the table, similarly to the way the cell map decides whether
|
|
// to rebuild versus expand. This could be optimized to expand to the smallest area that contains
|
|
// no spanners, but it may not be worth the effort in general, and it would need to be done in the
|
|
// cell map as well.
|
|
bool haveSpanner = false;
|
|
if ((dStartX > 0) || (dEndX < (numCols - 1)) || (dStartY > 0) || (dEndY < (numRows - 1))) {
|
|
nsTableCellMap* tableCellMap = GetCellMap(); if (!tableCellMap) ABORT0();
|
|
// Get the ordered row groups
|
|
RowGroupArray rowGroups;
|
|
OrderRowGroups(rowGroups);
|
|
|
|
// Scope outside loop to be used as hint.
|
|
nsCellMap* cellMap = nullptr;
|
|
for (uint32_t rgX = 0; rgX < rowGroups.Length(); rgX++) {
|
|
nsTableRowGroupFrame* rgFrame = rowGroups[rgX];
|
|
int32_t rgStartY = rgFrame->GetStartRowIndex();
|
|
int32_t rgEndY = rgStartY + rgFrame->GetRowCount() - 1;
|
|
if (dEndY < rgStartY)
|
|
break;
|
|
cellMap = tableCellMap->GetMapFor(rgFrame, cellMap);
|
|
if (!cellMap) ABORT0();
|
|
// check for spanners from above and below
|
|
if ((dStartY > 0) && (dStartY >= rgStartY) && (dStartY <= rgEndY)) {
|
|
if (uint32_t(dStartY - rgStartY) >= cellMap->mRows.Length())
|
|
ABORT0();
|
|
const nsCellMap::CellDataArray& row =
|
|
cellMap->mRows[dStartY - rgStartY];
|
|
for (int32_t x = dStartX; x <= dEndX; x++) {
|
|
CellData* cellData = row.SafeElementAt(x);
|
|
if (cellData && (cellData->IsRowSpan())) {
|
|
haveSpanner = true;
|
|
break;
|
|
}
|
|
}
|
|
if (dEndY < rgEndY) {
|
|
if (uint32_t(dEndY + 1 - rgStartY) >= cellMap->mRows.Length())
|
|
ABORT0();
|
|
const nsCellMap::CellDataArray& row2 =
|
|
cellMap->mRows[dEndY + 1 - rgStartY];
|
|
for (int32_t x = dStartX; x <= dEndX; x++) {
|
|
CellData* cellData = row2.SafeElementAt(x);
|
|
if (cellData && (cellData->IsRowSpan())) {
|
|
haveSpanner = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// check for spanners on the left and right
|
|
int32_t iterStartY = -1;
|
|
int32_t iterEndY = -1;
|
|
if ((dStartY >= rgStartY) && (dStartY <= rgEndY)) {
|
|
// the damage area starts in the row group
|
|
iterStartY = dStartY;
|
|
iterEndY = std::min(dEndY, rgEndY);
|
|
}
|
|
else if ((dEndY >= rgStartY) && (dEndY <= rgEndY)) {
|
|
// the damage area ends in the row group
|
|
iterStartY = rgStartY;
|
|
iterEndY = dEndY;
|
|
}
|
|
else if ((rgStartY >= dStartY) && (rgEndY <= dEndY)) {
|
|
// the damage area contains the row group
|
|
iterStartY = rgStartY;
|
|
iterEndY = rgEndY;
|
|
}
|
|
if ((iterStartY >= 0) && (iterEndY >= 0)) {
|
|
for (int32_t y = iterStartY; y <= iterEndY; y++) {
|
|
if (uint32_t(y - rgStartY) >= cellMap->mRows.Length())
|
|
ABORT0();
|
|
const nsCellMap::CellDataArray& row =
|
|
cellMap->mRows[y - rgStartY];
|
|
CellData* cellData = row.SafeElementAt(dStartX);
|
|
if (cellData && (cellData->IsColSpan())) {
|
|
haveSpanner = true;
|
|
break;
|
|
}
|
|
if (dEndX < (numCols - 1)) {
|
|
cellData = row.SafeElementAt(dEndX + 1);
|
|
if (cellData && (cellData->IsColSpan())) {
|
|
haveSpanner = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (haveSpanner) {
|
|
// make the damage area the whole table
|
|
aRect.x = 0;
|
|
aRect.y = 0;
|
|
aRect.width = numCols;
|
|
aRect.height = numRows;
|
|
}
|
|
else {
|
|
aRect.x = dStartX;
|
|
aRect.y = dStartY;
|
|
aRect.width = 1 + dEndX - dStartX;
|
|
aRect.height = 1 + dEndY - dStartY;
|
|
}
|
|
}
|
|
|
|
|
|
#define ADJACENT true
|
|
#define HORIZONTAL true
|
|
|
|
void
|
|
BCMapCellInfo::SetTableTopLeftContBCBorder()
|
|
{
|
|
BCCellBorder currentBorder;
|
|
//calculate continuous top first row & rowgroup border: special case
|
|
//because it must include the table in the collapse
|
|
if (mTopRow) {
|
|
currentBorder = CompareBorders(mTableFrame, nullptr, nullptr, mRowGroup,
|
|
mTopRow, nullptr, mTableIsLTR,
|
|
NS_SIDE_TOP, !ADJACENT);
|
|
mTopRow->SetContinuousBCBorderWidth(NS_SIDE_TOP, currentBorder.width);
|
|
}
|
|
if (mCgAtRight && mColGroup) {
|
|
//calculate continuous top colgroup border once per colgroup
|
|
currentBorder = CompareBorders(mTableFrame, mColGroup, nullptr, mRowGroup,
|
|
mTopRow, nullptr, mTableIsLTR,
|
|
NS_SIDE_TOP, !ADJACENT);
|
|
mColGroup->SetContinuousBCBorderWidth(NS_SIDE_TOP, currentBorder.width);
|
|
}
|
|
if (0 == mColIndex) {
|
|
currentBorder = CompareBorders(mTableFrame, mColGroup, mLeftCol, nullptr,
|
|
nullptr, nullptr, mTableIsLTR, NS_SIDE_LEFT,
|
|
!ADJACENT);
|
|
mTableFrame->SetContinuousLeftBCBorderWidth(currentBorder.width);
|
|
}
|
|
}
|
|
|
|
void
|
|
BCMapCellInfo::SetRowGroupLeftContBCBorder()
|
|
{
|
|
BCCellBorder currentBorder;
|
|
//get row group continuous borders
|
|
if (mRgAtBottom && mRowGroup) { //once per row group, so check for bottom
|
|
currentBorder = CompareBorders(mTableFrame, mColGroup, mLeftCol, mRowGroup,
|
|
nullptr, nullptr, mTableIsLTR, NS_SIDE_LEFT,
|
|
!ADJACENT);
|
|
mRowGroup->SetContinuousBCBorderWidth(mStartSide, currentBorder.width);
|
|
}
|
|
}
|
|
|
|
void
|
|
BCMapCellInfo::SetRowGroupRightContBCBorder()
|
|
{
|
|
BCCellBorder currentBorder;
|
|
//get row group continuous borders
|
|
if (mRgAtBottom && mRowGroup) { //once per mRowGroup, so check for bottom
|
|
currentBorder = CompareBorders(mTableFrame, mColGroup, mRightCol, mRowGroup,
|
|
nullptr, nullptr, mTableIsLTR, NS_SIDE_RIGHT,
|
|
ADJACENT);
|
|
mRowGroup->SetContinuousBCBorderWidth(mEndSide, currentBorder.width);
|
|
}
|
|
}
|
|
|
|
void
|
|
BCMapCellInfo::SetColumnTopRightContBCBorder()
|
|
{
|
|
BCCellBorder currentBorder;
|
|
//calculate column continuous borders
|
|
//we only need to do this once, so we'll do it only on the first row
|
|
currentBorder = CompareBorders(mTableFrame, mCurrentColGroupFrame,
|
|
mCurrentColFrame, mRowGroup, mTopRow, nullptr,
|
|
mTableIsLTR, NS_SIDE_TOP, !ADJACENT);
|
|
((nsTableColFrame*) mCurrentColFrame)->SetContinuousBCBorderWidth(NS_SIDE_TOP,
|
|
currentBorder.width);
|
|
if (mNumTableCols == GetCellEndColIndex() + 1) {
|
|
currentBorder = CompareBorders(mTableFrame, mCurrentColGroupFrame,
|
|
mCurrentColFrame, nullptr, nullptr, nullptr,
|
|
mTableIsLTR, NS_SIDE_RIGHT, !ADJACENT);
|
|
}
|
|
else {
|
|
currentBorder = CompareBorders(nullptr, mCurrentColGroupFrame,
|
|
mCurrentColFrame, nullptr,nullptr, nullptr,
|
|
mTableIsLTR, NS_SIDE_RIGHT, !ADJACENT);
|
|
}
|
|
mCurrentColFrame->SetContinuousBCBorderWidth(NS_SIDE_RIGHT,
|
|
currentBorder.width);
|
|
}
|
|
|
|
void
|
|
BCMapCellInfo::SetColumnBottomContBCBorder()
|
|
{
|
|
BCCellBorder currentBorder;
|
|
//get col continuous border
|
|
currentBorder = CompareBorders(mTableFrame, mCurrentColGroupFrame,
|
|
mCurrentColFrame, mRowGroup, mBottomRow,
|
|
nullptr, mTableIsLTR, NS_SIDE_BOTTOM, ADJACENT);
|
|
mCurrentColFrame->SetContinuousBCBorderWidth(NS_SIDE_BOTTOM,
|
|
currentBorder.width);
|
|
}
|
|
|
|
void
|
|
BCMapCellInfo::SetColGroupBottomContBCBorder()
|
|
{
|
|
BCCellBorder currentBorder;
|
|
if (mColGroup) {
|
|
currentBorder = CompareBorders(mTableFrame, mColGroup, nullptr, mRowGroup,
|
|
mBottomRow, nullptr, mTableIsLTR,
|
|
NS_SIDE_BOTTOM, ADJACENT);
|
|
mColGroup->SetContinuousBCBorderWidth(NS_SIDE_BOTTOM, currentBorder.width);
|
|
}
|
|
}
|
|
|
|
void
|
|
BCMapCellInfo::SetRowGroupBottomContBCBorder()
|
|
{
|
|
BCCellBorder currentBorder;
|
|
if (mRowGroup) {
|
|
currentBorder = CompareBorders(mTableFrame, nullptr, nullptr, mRowGroup,
|
|
mBottomRow, nullptr, mTableIsLTR,
|
|
NS_SIDE_BOTTOM, ADJACENT);
|
|
mRowGroup->SetContinuousBCBorderWidth(NS_SIDE_BOTTOM, currentBorder.width);
|
|
}
|
|
}
|
|
|
|
void
|
|
BCMapCellInfo::SetInnerRowGroupBottomContBCBorder(const nsIFrame* aNextRowGroup,
|
|
nsTableRowFrame* aNextRow)
|
|
{
|
|
BCCellBorder currentBorder, adjacentBorder;
|
|
|
|
const nsIFrame* rowgroup = (mRgAtBottom) ? mRowGroup : nullptr;
|
|
currentBorder = CompareBorders(nullptr, nullptr, nullptr, rowgroup, mBottomRow,
|
|
nullptr, mTableIsLTR, NS_SIDE_BOTTOM, ADJACENT);
|
|
|
|
adjacentBorder = CompareBorders(nullptr, nullptr, nullptr, aNextRowGroup,
|
|
aNextRow, nullptr, mTableIsLTR, NS_SIDE_TOP,
|
|
!ADJACENT);
|
|
currentBorder = CompareBorders(false, currentBorder, adjacentBorder,
|
|
HORIZONTAL);
|
|
if (aNextRow) {
|
|
aNextRow->SetContinuousBCBorderWidth(NS_SIDE_TOP, currentBorder.width);
|
|
}
|
|
if (mRgAtBottom && mRowGroup) {
|
|
mRowGroup->SetContinuousBCBorderWidth(NS_SIDE_BOTTOM, currentBorder.width);
|
|
}
|
|
}
|
|
|
|
void
|
|
BCMapCellInfo::SetRowLeftContBCBorder()
|
|
{
|
|
//get row continuous borders
|
|
if (mCurrentRowFrame) {
|
|
BCCellBorder currentBorder;
|
|
currentBorder = CompareBorders(mTableFrame, mColGroup, mLeftCol, mRowGroup,
|
|
mCurrentRowFrame, nullptr, mTableIsLTR,
|
|
NS_SIDE_LEFT, !ADJACENT);
|
|
mCurrentRowFrame->SetContinuousBCBorderWidth(mStartSide,
|
|
currentBorder.width);
|
|
}
|
|
}
|
|
|
|
void
|
|
BCMapCellInfo::SetRowRightContBCBorder()
|
|
{
|
|
if (mCurrentRowFrame) {
|
|
BCCellBorder currentBorder;
|
|
currentBorder = CompareBorders(mTableFrame, mColGroup, mRightCol, mRowGroup,
|
|
mCurrentRowFrame, nullptr, mTableIsLTR,
|
|
NS_SIDE_RIGHT, ADJACENT);
|
|
mCurrentRowFrame->SetContinuousBCBorderWidth(mEndSide,
|
|
currentBorder.width);
|
|
}
|
|
}
|
|
void
|
|
BCMapCellInfo::SetTableTopBorderWidth(BCPixelSize aWidth)
|
|
{
|
|
mTableBCData->mTopBorderWidth = std::max(mTableBCData->mTopBorderWidth, aWidth);
|
|
}
|
|
|
|
void
|
|
BCMapCellInfo::SetTableLeftBorderWidth(int32_t aRowY, BCPixelSize aWidth)
|
|
{
|
|
// update the left/right first cell border
|
|
if (aRowY == 0) {
|
|
if (mTableIsLTR) {
|
|
mTableBCData->mLeftCellBorderWidth = aWidth;
|
|
}
|
|
else {
|
|
mTableBCData->mRightCellBorderWidth = aWidth;
|
|
}
|
|
}
|
|
mTableBCData->mLeftBorderWidth = std::max(mTableBCData->mLeftBorderWidth,
|
|
aWidth);
|
|
}
|
|
|
|
void
|
|
BCMapCellInfo::SetTableRightBorderWidth(int32_t aRowY, BCPixelSize aWidth)
|
|
{
|
|
// update the left/right first cell border
|
|
if (aRowY == 0) {
|
|
if (mTableIsLTR) {
|
|
mTableBCData->mRightCellBorderWidth = aWidth;
|
|
}
|
|
else {
|
|
mTableBCData->mLeftCellBorderWidth = aWidth;
|
|
}
|
|
}
|
|
mTableBCData->mRightBorderWidth = std::max(mTableBCData->mRightBorderWidth,
|
|
aWidth);
|
|
}
|
|
|
|
void
|
|
BCMapCellInfo::SetRightBorderWidths(BCPixelSize aWidth)
|
|
{
|
|
// update the borders of the cells and cols affected
|
|
if (mCell) {
|
|
mCell->SetBorderWidth(mEndSide, std::max(aWidth,
|
|
mCell->GetBorderWidth(mEndSide)));
|
|
}
|
|
if (mRightCol) {
|
|
BCPixelSize half = BC_BORDER_LEFT_HALF(aWidth);
|
|
mRightCol->SetRightBorderWidth(std::max(nscoord(half),
|
|
mRightCol->GetRightBorderWidth()));
|
|
}
|
|
}
|
|
|
|
void
|
|
BCMapCellInfo::SetBottomBorderWidths(BCPixelSize aWidth)
|
|
{
|
|
// update the borders of the affected cells and rows
|
|
if (mCell) {
|
|
mCell->SetBorderWidth(NS_SIDE_BOTTOM, std::max(aWidth,
|
|
mCell->GetBorderWidth(NS_SIDE_BOTTOM)));
|
|
}
|
|
if (mBottomRow) {
|
|
BCPixelSize half = BC_BORDER_TOP_HALF(aWidth);
|
|
mBottomRow->SetBottomBCBorderWidth(std::max(nscoord(half),
|
|
mBottomRow->GetBottomBCBorderWidth()));
|
|
}
|
|
}
|
|
void
|
|
BCMapCellInfo::SetTopBorderWidths(BCPixelSize aWidth)
|
|
{
|
|
if (mCell) {
|
|
mCell->SetBorderWidth(NS_SIDE_TOP, std::max(aWidth,
|
|
mCell->GetBorderWidth(NS_SIDE_TOP)));
|
|
}
|
|
if (mTopRow) {
|
|
BCPixelSize half = BC_BORDER_BOTTOM_HALF(aWidth);
|
|
mTopRow->SetTopBCBorderWidth(std::max(nscoord(half),
|
|
mTopRow->GetTopBCBorderWidth()));
|
|
}
|
|
}
|
|
void
|
|
BCMapCellInfo::SetLeftBorderWidths(BCPixelSize aWidth)
|
|
{
|
|
if (mCell) {
|
|
mCell->SetBorderWidth(mStartSide, std::max(aWidth,
|
|
mCell->GetBorderWidth(mStartSide)));
|
|
}
|
|
if (mLeftCol) {
|
|
BCPixelSize half = BC_BORDER_RIGHT_HALF(aWidth);
|
|
mLeftCol->SetLeftBorderWidth(std::max(nscoord(half),
|
|
mLeftCol->GetLeftBorderWidth()));
|
|
}
|
|
}
|
|
|
|
void
|
|
BCMapCellInfo::SetTableBottomBorderWidth(BCPixelSize aWidth)
|
|
{
|
|
mTableBCData->mBottomBorderWidth = std::max(mTableBCData->mBottomBorderWidth,
|
|
aWidth);
|
|
}
|
|
|
|
void
|
|
BCMapCellInfo::SetColumn(int32_t aColX)
|
|
{
|
|
mCurrentColFrame = mTableFrame->GetColFrame(aColX);
|
|
if (!mCurrentColFrame) {
|
|
NS_ERROR("null mCurrentColFrame");
|
|
}
|
|
mCurrentColGroupFrame = static_cast<nsTableColGroupFrame*>
|
|
(mCurrentColFrame->GetParent());
|
|
if (!mCurrentColGroupFrame) {
|
|
NS_ERROR("null mCurrentColGroupFrame");
|
|
}
|
|
}
|
|
|
|
void
|
|
BCMapCellInfo::IncrementRow(bool aResetToTopRowOfCell)
|
|
{
|
|
mCurrentRowFrame = (aResetToTopRowOfCell) ? mTopRow :
|
|
mCurrentRowFrame->GetNextRow();
|
|
}
|
|
|
|
BCCellBorder
|
|
BCMapCellInfo::GetTopEdgeBorder()
|
|
{
|
|
return CompareBorders(mTableFrame, mCurrentColGroupFrame, mCurrentColFrame,
|
|
mRowGroup, mTopRow, mCell, mTableIsLTR, NS_SIDE_TOP,
|
|
!ADJACENT);
|
|
}
|
|
|
|
BCCellBorder
|
|
BCMapCellInfo::GetBottomEdgeBorder()
|
|
{
|
|
return CompareBorders(mTableFrame, mCurrentColGroupFrame, mCurrentColFrame,
|
|
mRowGroup, mBottomRow, mCell, mTableIsLTR,
|
|
NS_SIDE_BOTTOM, ADJACENT);
|
|
}
|
|
BCCellBorder
|
|
BCMapCellInfo::GetLeftEdgeBorder()
|
|
{
|
|
return CompareBorders(mTableFrame, mColGroup, mLeftCol, mRowGroup,
|
|
mCurrentRowFrame, mCell, mTableIsLTR, NS_SIDE_LEFT,
|
|
!ADJACENT);
|
|
}
|
|
BCCellBorder
|
|
BCMapCellInfo::GetRightEdgeBorder()
|
|
{
|
|
return CompareBorders(mTableFrame, mColGroup, mRightCol, mRowGroup,
|
|
mCurrentRowFrame, mCell, mTableIsLTR, NS_SIDE_RIGHT,
|
|
ADJACENT);
|
|
}
|
|
BCCellBorder
|
|
BCMapCellInfo::GetRightInternalBorder()
|
|
{
|
|
const nsIFrame* cg = (mCgAtRight) ? mColGroup : nullptr;
|
|
return CompareBorders(nullptr, cg, mRightCol, nullptr, nullptr, mCell,
|
|
mTableIsLTR, NS_SIDE_RIGHT, ADJACENT);
|
|
}
|
|
|
|
BCCellBorder
|
|
BCMapCellInfo::GetLeftInternalBorder()
|
|
{
|
|
const nsIFrame* cg = (mCgAtLeft) ? mColGroup : nullptr;
|
|
return CompareBorders(nullptr, cg, mLeftCol, nullptr, nullptr, mCell,
|
|
mTableIsLTR, NS_SIDE_LEFT, !ADJACENT);
|
|
}
|
|
|
|
BCCellBorder
|
|
BCMapCellInfo::GetBottomInternalBorder()
|
|
{
|
|
const nsIFrame* rg = (mRgAtBottom) ? mRowGroup : nullptr;
|
|
return CompareBorders(nullptr, nullptr, nullptr, rg, mBottomRow, mCell,
|
|
mTableIsLTR, NS_SIDE_BOTTOM, ADJACENT);
|
|
}
|
|
|
|
BCCellBorder
|
|
BCMapCellInfo::GetTopInternalBorder()
|
|
{
|
|
const nsIFrame* rg = (mRgAtTop) ? mRowGroup : nullptr;
|
|
return CompareBorders(nullptr, nullptr, nullptr, rg, mTopRow, mCell,
|
|
mTableIsLTR, NS_SIDE_TOP, !ADJACENT);
|
|
}
|
|
|
|
/* Here is the order for storing border edges in the cell map as a cell is processed. There are
|
|
n=colspan top and bottom border edges per cell and n=rowspan left and right border edges per cell.
|
|
|
|
1) On the top edge of the table, store the top edge. Never store the top edge otherwise, since
|
|
a bottom edge from a cell above will take care of it.
|
|
2) On the left edge of the table, store the left edge. Never store the left edge othewise, since
|
|
a right edge from a cell to the left will take care of it.
|
|
3) Store the right edge (or edges if a row span)
|
|
4) Store the bottom edge (or edges if a col span)
|
|
|
|
Since corners are computed with only an array of BCCornerInfo indexed by the number-of-cols, corner
|
|
calculations are somewhat complicated. Using an array with number-of-rows * number-of-col entries
|
|
would simplify this, but at an extra in memory cost of nearly 12 bytes per cell map entry. Collapsing
|
|
borders already have about an extra 8 byte per cell map entry overhead (this could be
|
|
reduced to 4 bytes if we are willing to not store border widths in nsTableCellFrame), Here are the
|
|
rules in priority order for storing cornes in the cell map as a cell is processed. top-left means the
|
|
left endpoint of the border edge on the top of the cell. There are n=colspan top and bottom border
|
|
edges per cell and n=rowspan left and right border edges per cell.
|
|
|
|
1) On the top edge of the table, store the top-left corner, unless on the left edge of the table.
|
|
Never store the top-right corner, since it will get stored as a right-top corner.
|
|
2) On the left edge of the table, store the left-top corner. Never store the left-bottom corner,
|
|
since it will get stored as a bottom-left corner.
|
|
3) Store the right-top corner if (a) it is the top right corner of the table or (b) it is not on
|
|
the top edge of the table. Never store the right-bottom corner since it will get stored as a
|
|
bottom-right corner.
|
|
4) Store the bottom-right corner, if it is the bottom right corner of the table. Never store it
|
|
otherwise, since it will get stored as either a right-top corner by a cell below or
|
|
a bottom-left corner from a cell to the right.
|
|
5) Store the bottom-left corner, if (a) on the bottom edge of the table or (b) if the left edge hits
|
|
the top side of a colspan in its interior. Never store the corner otherwise, since it will
|
|
get stored as a right-top corner by a cell from below.
|
|
|
|
XXX the BC-RTL hack - The correct fix would be a rewrite as described in bug 203686.
|
|
In order to draw borders in rtl conditions somehow correct, the existing structure which relies
|
|
heavily on the assumption that the next cell sibling will be on the right side, has been modified.
|
|
We flip the border during painting and during style lookup. Look for tableIsLTR for places where
|
|
the flipping is done.
|
|
*/
|
|
|
|
|
|
|
|
// Calc the dominant border at every cell edge and corner within the current damage area
|
|
void
|
|
nsTableFrame::CalcBCBorders()
|
|
{
|
|
NS_ASSERTION(IsBorderCollapse(),
|
|
"calling CalcBCBorders on separated-border table");
|
|
nsTableCellMap* tableCellMap = GetCellMap(); if (!tableCellMap) ABORT0();
|
|
int32_t numRows = GetRowCount();
|
|
int32_t numCols = GetColCount();
|
|
if (!numRows || !numCols)
|
|
return; // nothing to do
|
|
|
|
// Get the property holding the table damage area and border widths
|
|
BCPropertyData* propData = GetBCProperty();
|
|
if (!propData) ABORT0();
|
|
|
|
|
|
|
|
// calculate an expanded damage area
|
|
nsIntRect damageArea(propData->mDamageArea);
|
|
ExpandBCDamageArea(damageArea);
|
|
|
|
// segments that are on the table border edges need
|
|
// to be initialized only once
|
|
bool tableBorderReset[4];
|
|
for (uint32_t sideX = NS_SIDE_TOP; sideX <= NS_SIDE_LEFT; sideX++) {
|
|
tableBorderReset[sideX] = false;
|
|
}
|
|
|
|
// vertical borders indexed in x-direction (cols)
|
|
BCCellBorders lastVerBorders(damageArea.width + 1, damageArea.x);
|
|
if (!lastVerBorders.borders) ABORT0();
|
|
BCCellBorder lastTopBorder, lastBottomBorder;
|
|
// horizontal borders indexed in x-direction (cols)
|
|
BCCellBorders lastBottomBorders(damageArea.width + 1, damageArea.x);
|
|
if (!lastBottomBorders.borders) ABORT0();
|
|
bool startSeg;
|
|
bool gotRowBorder = false;
|
|
|
|
BCMapCellInfo info(this), ajaInfo(this);
|
|
|
|
BCCellBorder currentBorder, adjacentBorder;
|
|
BCCorners topCorners(damageArea.width + 1, damageArea.x);
|
|
if (!topCorners.corners) ABORT0();
|
|
BCCorners bottomCorners(damageArea.width + 1, damageArea.x);
|
|
if (!bottomCorners.corners) ABORT0();
|
|
|
|
BCMapCellIterator iter(this, damageArea);
|
|
for (iter.First(info); !iter.mAtEnd; iter.Next(info)) {
|
|
// see if lastTopBorder, lastBottomBorder need to be reset
|
|
if (iter.IsNewRow()) {
|
|
gotRowBorder = false;
|
|
lastTopBorder.Reset(info.mRowIndex, info.mRowSpan);
|
|
lastBottomBorder.Reset(info.GetCellEndRowIndex() + 1, info.mRowSpan);
|
|
}
|
|
else if (info.mColIndex > damageArea.x) {
|
|
lastBottomBorder = lastBottomBorders[info.mColIndex - 1];
|
|
if (info.mRowIndex >
|
|
(lastBottomBorder.rowIndex - lastBottomBorder.rowSpan)) {
|
|
// the top border's left edge butts against the middle of a rowspan
|
|
lastTopBorder.Reset(info.mRowIndex, info.mRowSpan);
|
|
}
|
|
if (lastBottomBorder.rowIndex > (info.GetCellEndRowIndex() + 1)) {
|
|
// the bottom border's left edge butts against the middle of a rowspan
|
|
lastBottomBorder.Reset(info.GetCellEndRowIndex() + 1, info.mRowSpan);
|
|
}
|
|
}
|
|
|
|
// find the dominant border considering the cell's top border and the table,
|
|
// row group, row if the border is at the top of the table, otherwise it was
|
|
// processed in a previous row
|
|
if (0 == info.mRowIndex) {
|
|
if (!tableBorderReset[NS_SIDE_TOP]) {
|
|
propData->mTopBorderWidth = 0;
|
|
tableBorderReset[NS_SIDE_TOP] = true;
|
|
}
|
|
for (int32_t colX = info.mColIndex; colX <= info.GetCellEndColIndex();
|
|
colX++) {
|
|
info.SetColumn(colX);
|
|
currentBorder = info.GetTopEdgeBorder();
|
|
// update/store the top left & top right corners of the seg
|
|
BCCornerInfo& tlCorner = topCorners[colX]; // top left
|
|
if (0 == colX) {
|
|
// we are on right hand side of the corner
|
|
tlCorner.Set(NS_SIDE_RIGHT, currentBorder);
|
|
}
|
|
else {
|
|
tlCorner.Update(NS_SIDE_RIGHT, currentBorder);
|
|
tableCellMap->SetBCBorderCorner(eTopLeft, *iter.mCellMap, 0, 0, colX,
|
|
mozilla::css::Side(tlCorner.ownerSide),
|
|
tlCorner.subWidth,
|
|
tlCorner.bevel);
|
|
}
|
|
topCorners[colX + 1].Set(NS_SIDE_LEFT, currentBorder); // top right
|
|
// update lastTopBorder and see if a new segment starts
|
|
startSeg = SetHorBorder(currentBorder, tlCorner, lastTopBorder);
|
|
// store the border segment in the cell map
|
|
tableCellMap->SetBCBorderEdge(NS_SIDE_TOP, *iter.mCellMap, 0, 0, colX,
|
|
1, currentBorder.owner,
|
|
currentBorder.width, startSeg);
|
|
|
|
info.SetTableTopBorderWidth(currentBorder.width);
|
|
info.SetTopBorderWidths(currentBorder.width);
|
|
info.SetColumnTopRightContBCBorder();
|
|
}
|
|
info.SetTableTopLeftContBCBorder();
|
|
}
|
|
else {
|
|
// see if the top border needs to be the start of a segment due to a
|
|
// vertical border owning the corner
|
|
if (info.mColIndex > 0) {
|
|
BCData& data = info.mCellData->mData;
|
|
if (!data.IsTopStart()) {
|
|
mozilla::css::Side cornerSide;
|
|
bool bevel;
|
|
data.GetCorner(cornerSide, bevel);
|
|
if ((NS_SIDE_TOP == cornerSide) || (NS_SIDE_BOTTOM == cornerSide)) {
|
|
data.SetTopStart(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// find the dominant border considering the cell's left border and the
|
|
// table, col group, col if the border is at the left of the table,
|
|
// otherwise it was processed in a previous col
|
|
if (0 == info.mColIndex) {
|
|
if (!tableBorderReset[NS_SIDE_LEFT]) {
|
|
propData->mLeftBorderWidth = 0;
|
|
tableBorderReset[NS_SIDE_LEFT] = true;
|
|
}
|
|
info.mCurrentRowFrame = nullptr;
|
|
for (int32_t rowY = info.mRowIndex; rowY <= info.GetCellEndRowIndex();
|
|
rowY++) {
|
|
info.IncrementRow(rowY == info.mRowIndex);
|
|
currentBorder = info.GetLeftEdgeBorder();
|
|
BCCornerInfo& tlCorner = (0 == rowY) ? topCorners[0] : bottomCorners[0];
|
|
tlCorner.Update(NS_SIDE_BOTTOM, currentBorder);
|
|
tableCellMap->SetBCBorderCorner(eTopLeft, *iter.mCellMap,
|
|
iter.mRowGroupStart, rowY, 0,
|
|
mozilla::css::Side(tlCorner.ownerSide),
|
|
tlCorner.subWidth,
|
|
tlCorner.bevel);
|
|
bottomCorners[0].Set(NS_SIDE_TOP, currentBorder); // bottom left
|
|
|
|
// update lastVerBordersBorder and see if a new segment starts
|
|
startSeg = SetBorder(currentBorder, lastVerBorders[0]);
|
|
// store the border segment in the cell map
|
|
tableCellMap->SetBCBorderEdge(NS_SIDE_LEFT, *iter.mCellMap,
|
|
iter.mRowGroupStart, rowY, info.mColIndex,
|
|
1, currentBorder.owner,
|
|
currentBorder.width, startSeg);
|
|
info.SetTableLeftBorderWidth(rowY , currentBorder.width);
|
|
info.SetLeftBorderWidths(currentBorder.width);
|
|
info.SetRowLeftContBCBorder();
|
|
}
|
|
info.SetRowGroupLeftContBCBorder();
|
|
}
|
|
|
|
// find the dominant border considering the cell's right border, adjacent
|
|
// cells and the table, row group, row
|
|
if (info.mNumTableCols == info.GetCellEndColIndex() + 1) {
|
|
// touches right edge of table
|
|
if (!tableBorderReset[NS_SIDE_RIGHT]) {
|
|
propData->mRightBorderWidth = 0;
|
|
tableBorderReset[NS_SIDE_RIGHT] = true;
|
|
}
|
|
info.mCurrentRowFrame = nullptr;
|
|
for (int32_t rowY = info.mRowIndex; rowY <= info.GetCellEndRowIndex();
|
|
rowY++) {
|
|
info.IncrementRow(rowY == info.mRowIndex);
|
|
currentBorder = info.GetRightEdgeBorder();
|
|
// update/store the top right & bottom right corners
|
|
BCCornerInfo& trCorner = (0 == rowY) ?
|
|
topCorners[info.GetCellEndColIndex() + 1] :
|
|
bottomCorners[info.GetCellEndColIndex() + 1];
|
|
trCorner.Update(NS_SIDE_BOTTOM, currentBorder); // top right
|
|
tableCellMap->SetBCBorderCorner(eTopRight, *iter.mCellMap,
|
|
iter.mRowGroupStart, rowY,
|
|
info.GetCellEndColIndex(),
|
|
mozilla::css::Side(trCorner.ownerSide),
|
|
trCorner.subWidth,
|
|
trCorner.bevel);
|
|
BCCornerInfo& brCorner = bottomCorners[info.GetCellEndColIndex() + 1];
|
|
brCorner.Set(NS_SIDE_TOP, currentBorder); // bottom right
|
|
tableCellMap->SetBCBorderCorner(eBottomRight, *iter.mCellMap,
|
|
iter.mRowGroupStart, rowY,
|
|
info.GetCellEndColIndex(),
|
|
mozilla::css::Side(brCorner.ownerSide),
|
|
brCorner.subWidth,
|
|
brCorner.bevel);
|
|
// update lastVerBorders and see if a new segment starts
|
|
startSeg = SetBorder(currentBorder,
|
|
lastVerBorders[info.GetCellEndColIndex() + 1]);
|
|
// store the border segment in the cell map and update cellBorders
|
|
tableCellMap->SetBCBorderEdge(NS_SIDE_RIGHT, *iter.mCellMap,
|
|
iter.mRowGroupStart, rowY,
|
|
info.GetCellEndColIndex(), 1,
|
|
currentBorder.owner, currentBorder.width,
|
|
startSeg);
|
|
info.SetTableRightBorderWidth(rowY, currentBorder.width);
|
|
info.SetRightBorderWidths(currentBorder.width);
|
|
info.SetRowRightContBCBorder();
|
|
}
|
|
info.SetRowGroupRightContBCBorder();
|
|
}
|
|
else {
|
|
int32_t segLength = 0;
|
|
BCMapCellInfo priorAjaInfo(this);
|
|
for (int32_t rowY = info.mRowIndex; rowY <= info.GetCellEndRowIndex();
|
|
rowY += segLength) {
|
|
iter.PeekRight(info, rowY, ajaInfo);
|
|
currentBorder = info.GetRightInternalBorder();
|
|
adjacentBorder = ajaInfo.GetLeftInternalBorder();
|
|
currentBorder = CompareBorders(!CELL_CORNER, currentBorder,
|
|
adjacentBorder, !HORIZONTAL);
|
|
|
|
segLength = std::max(1, ajaInfo.mRowIndex + ajaInfo.mRowSpan - rowY);
|
|
segLength = std::min(segLength, info.mRowIndex + info.mRowSpan - rowY);
|
|
|
|
// update lastVerBorders and see if a new segment starts
|
|
startSeg = SetBorder(currentBorder,
|
|
lastVerBorders[info.GetCellEndColIndex() + 1]);
|
|
// store the border segment in the cell map and update cellBorders
|
|
if (info.GetCellEndColIndex() < damageArea.XMost() &&
|
|
rowY >= damageArea.y && rowY < damageArea.YMost()) {
|
|
tableCellMap->SetBCBorderEdge(NS_SIDE_RIGHT, *iter.mCellMap,
|
|
iter.mRowGroupStart, rowY,
|
|
info.GetCellEndColIndex(), segLength,
|
|
currentBorder.owner,
|
|
currentBorder.width, startSeg);
|
|
info.SetRightBorderWidths(currentBorder.width);
|
|
ajaInfo.SetLeftBorderWidths(currentBorder.width);
|
|
}
|
|
// update the top right corner
|
|
bool hitsSpanOnRight = (rowY > ajaInfo.mRowIndex) &&
|
|
(rowY < ajaInfo.mRowIndex + ajaInfo.mRowSpan);
|
|
BCCornerInfo* trCorner = ((0 == rowY) || hitsSpanOnRight) ?
|
|
&topCorners[info.GetCellEndColIndex() + 1] :
|
|
&bottomCorners[info.GetCellEndColIndex() + 1];
|
|
trCorner->Update(NS_SIDE_BOTTOM, currentBorder);
|
|
// if this is not the first time through,
|
|
// consider the segment to the right
|
|
if (rowY != info.mRowIndex) {
|
|
currentBorder = priorAjaInfo.GetBottomInternalBorder();
|
|
adjacentBorder = ajaInfo.GetTopInternalBorder();
|
|
currentBorder = CompareBorders(!CELL_CORNER, currentBorder,
|
|
adjacentBorder, HORIZONTAL);
|
|
trCorner->Update(NS_SIDE_RIGHT, currentBorder);
|
|
}
|
|
// store the top right corner in the cell map
|
|
if (info.GetCellEndColIndex() < damageArea.XMost() &&
|
|
rowY >= damageArea.y) {
|
|
if (0 != rowY) {
|
|
tableCellMap->SetBCBorderCorner(eTopRight, *iter.mCellMap,
|
|
iter.mRowGroupStart, rowY,
|
|
info.GetCellEndColIndex(),
|
|
mozilla::css::Side(trCorner->ownerSide),
|
|
trCorner->subWidth,
|
|
trCorner->bevel);
|
|
}
|
|
// store any corners this cell spans together with the aja cell
|
|
for (int32_t rX = rowY + 1; rX < rowY + segLength; rX++) {
|
|
tableCellMap->SetBCBorderCorner(eBottomRight, *iter.mCellMap,
|
|
iter.mRowGroupStart, rX,
|
|
info.GetCellEndColIndex(),
|
|
mozilla::css::Side(trCorner->ownerSide),
|
|
trCorner->subWidth, false);
|
|
}
|
|
}
|
|
// update bottom right corner, topCorners, bottomCorners
|
|
hitsSpanOnRight = (rowY + segLength <
|
|
ajaInfo.mRowIndex + ajaInfo.mRowSpan);
|
|
BCCornerInfo& brCorner = (hitsSpanOnRight) ?
|
|
topCorners[info.GetCellEndColIndex() + 1] :
|
|
bottomCorners[info.GetCellEndColIndex() + 1];
|
|
brCorner.Set(NS_SIDE_TOP, currentBorder);
|
|
priorAjaInfo = ajaInfo;
|
|
}
|
|
}
|
|
for (int32_t colX = info.mColIndex + 1; colX <= info.GetCellEndColIndex();
|
|
colX++) {
|
|
lastVerBorders[colX].Reset(0,1);
|
|
}
|
|
|
|
// find the dominant border considering the cell's bottom border, adjacent
|
|
// cells and the table, row group, row
|
|
if (info.mNumTableRows == info.GetCellEndRowIndex() + 1) {
|
|
// touches bottom edge of table
|
|
if (!tableBorderReset[NS_SIDE_BOTTOM]) {
|
|
propData->mBottomBorderWidth = 0;
|
|
tableBorderReset[NS_SIDE_BOTTOM] = true;
|
|
}
|
|
for (int32_t colX = info.mColIndex; colX <= info.GetCellEndColIndex();
|
|
colX++) {
|
|
info.SetColumn(colX);
|
|
currentBorder = info.GetBottomEdgeBorder();
|
|
// update/store the bottom left & bottom right corners
|
|
BCCornerInfo& blCorner = bottomCorners[colX]; // bottom left
|
|
blCorner.Update(NS_SIDE_RIGHT, currentBorder);
|
|
tableCellMap->SetBCBorderCorner(eBottomLeft, *iter.mCellMap,
|
|
iter.mRowGroupStart,
|
|
info.GetCellEndRowIndex(),
|
|
colX,
|
|
mozilla::css::Side(blCorner.ownerSide),
|
|
blCorner.subWidth, blCorner.bevel);
|
|
BCCornerInfo& brCorner = bottomCorners[colX + 1]; // bottom right
|
|
brCorner.Update(NS_SIDE_LEFT, currentBorder);
|
|
if (info.mNumTableCols == colX + 1) { // lower right corner of the table
|
|
tableCellMap->SetBCBorderCorner(eBottomRight, *iter.mCellMap,
|
|
iter.mRowGroupStart,
|
|
info.GetCellEndRowIndex(),colX,
|
|
mozilla::css::Side(brCorner.ownerSide),
|
|
brCorner.subWidth,
|
|
brCorner.bevel, true);
|
|
}
|
|
// update lastBottomBorder and see if a new segment starts
|
|
startSeg = SetHorBorder(currentBorder, blCorner, lastBottomBorder);
|
|
if (!startSeg) {
|
|
// make sure that we did not compare apples to oranges i.e. the
|
|
// current border should be a continuation of the lastBottomBorder,
|
|
// as it is a bottom border
|
|
// add 1 to the info.GetCellEndRowIndex()
|
|
startSeg = (lastBottomBorder.rowIndex !=
|
|
(info.GetCellEndRowIndex() + 1));
|
|
}
|
|
// store the border segment in the cell map and update cellBorders
|
|
tableCellMap->SetBCBorderEdge(NS_SIDE_BOTTOM, *iter.mCellMap,
|
|
iter.mRowGroupStart,
|
|
info.GetCellEndRowIndex(),
|
|
colX, 1, currentBorder.owner,
|
|
currentBorder.width, startSeg);
|
|
// update lastBottomBorders
|
|
lastBottomBorder.rowIndex = info.GetCellEndRowIndex() + 1;
|
|
lastBottomBorder.rowSpan = info.mRowSpan;
|
|
lastBottomBorders[colX] = lastBottomBorder;
|
|
|
|
info.SetBottomBorderWidths(currentBorder.width);
|
|
info.SetTableBottomBorderWidth(currentBorder.width);
|
|
info.SetColumnBottomContBCBorder();
|
|
}
|
|
info.SetRowGroupBottomContBCBorder();
|
|
info.SetColGroupBottomContBCBorder();
|
|
}
|
|
else {
|
|
int32_t segLength = 0;
|
|
for (int32_t colX = info.mColIndex; colX <= info.GetCellEndColIndex();
|
|
colX += segLength) {
|
|
iter.PeekBottom(info, colX, ajaInfo);
|
|
currentBorder = info.GetBottomInternalBorder();
|
|
adjacentBorder = ajaInfo.GetTopInternalBorder();
|
|
currentBorder = CompareBorders(!CELL_CORNER, currentBorder,
|
|
adjacentBorder, HORIZONTAL);
|
|
segLength = std::max(1, ajaInfo.mColIndex + ajaInfo.mColSpan - colX);
|
|
segLength = std::min(segLength, info.mColIndex + info.mColSpan - colX);
|
|
|
|
// update, store the bottom left corner
|
|
BCCornerInfo& blCorner = bottomCorners[colX]; // bottom left
|
|
bool hitsSpanBelow = (colX > ajaInfo.mColIndex) &&
|
|
(colX < ajaInfo.mColIndex + ajaInfo.mColSpan);
|
|
bool update = true;
|
|
if ((colX == info.mColIndex) && (colX > damageArea.x)) {
|
|
int32_t prevRowIndex = lastBottomBorders[colX - 1].rowIndex;
|
|
if (prevRowIndex > info.GetCellEndRowIndex() + 1) {
|
|
// hits a rowspan on the right
|
|
update = false;
|
|
// the corner was taken care of during the cell on the left
|
|
}
|
|
else if (prevRowIndex < info.GetCellEndRowIndex() + 1) {
|
|
// spans below the cell to the left
|
|
topCorners[colX] = blCorner;
|
|
blCorner.Set(NS_SIDE_RIGHT, currentBorder);
|
|
update = false;
|
|
}
|
|
}
|
|
if (update) {
|
|
blCorner.Update(NS_SIDE_RIGHT, currentBorder);
|
|
}
|
|
if (info.GetCellEndRowIndex() < damageArea.YMost() &&
|
|
(colX >= damageArea.x)) {
|
|
if (hitsSpanBelow) {
|
|
tableCellMap->SetBCBorderCorner(eBottomLeft, *iter.mCellMap,
|
|
iter.mRowGroupStart,
|
|
info.GetCellEndRowIndex(), colX,
|
|
mozilla::css::Side(blCorner.ownerSide),
|
|
blCorner.subWidth, blCorner.bevel);
|
|
}
|
|
// store any corners this cell spans together with the aja cell
|
|
for (int32_t cX = colX + 1; cX < colX + segLength; cX++) {
|
|
BCCornerInfo& corner = bottomCorners[cX];
|
|
corner.Set(NS_SIDE_RIGHT, currentBorder);
|
|
tableCellMap->SetBCBorderCorner(eBottomLeft, *iter.mCellMap,
|
|
iter.mRowGroupStart,
|
|
info.GetCellEndRowIndex(), cX,
|
|
mozilla::css::Side(corner.ownerSide),
|
|
corner.subWidth,
|
|
false);
|
|
}
|
|
}
|
|
// update lastBottomBorders and see if a new segment starts
|
|
startSeg = SetHorBorder(currentBorder, blCorner, lastBottomBorder);
|
|
if (!startSeg) {
|
|
// make sure that we did not compare apples to oranges i.e. the
|
|
// current border should be a continuation of the lastBottomBorder,
|
|
// as it is a bottom border
|
|
// add 1 to the info.GetCellEndRowIndex()
|
|
startSeg = (lastBottomBorder.rowIndex !=
|
|
info.GetCellEndRowIndex() + 1);
|
|
}
|
|
lastBottomBorder.rowIndex = info.GetCellEndRowIndex() + 1;
|
|
lastBottomBorder.rowSpan = info.mRowSpan;
|
|
for (int32_t cX = colX; cX < colX + segLength; cX++) {
|
|
lastBottomBorders[cX] = lastBottomBorder;
|
|
}
|
|
|
|
// store the border segment the cell map and update cellBorders
|
|
if (info.GetCellEndRowIndex() < damageArea.YMost() &&
|
|
(colX >= damageArea.x) &&
|
|
(colX < damageArea.XMost())) {
|
|
tableCellMap->SetBCBorderEdge(NS_SIDE_BOTTOM, *iter.mCellMap,
|
|
iter.mRowGroupStart,
|
|
info.GetCellEndRowIndex(),
|
|
colX, segLength, currentBorder.owner,
|
|
currentBorder.width, startSeg);
|
|
info.SetBottomBorderWidths(currentBorder.width);
|
|
ajaInfo.SetTopBorderWidths(currentBorder.width);
|
|
}
|
|
// update bottom right corner
|
|
BCCornerInfo& brCorner = bottomCorners[colX + segLength];
|
|
brCorner.Update(NS_SIDE_LEFT, currentBorder);
|
|
}
|
|
if (!gotRowBorder && 1 == info.mRowSpan &&
|
|
(ajaInfo.mTopRow || info.mRgAtBottom)) {
|
|
//get continuous row/row group border
|
|
//we need to check the row group's bottom border if this is
|
|
//the last row in the row group, but only a cell with rowspan=1
|
|
//will know whether *this* row is at the bottom
|
|
const nsIFrame* nextRowGroup = (ajaInfo.mRgAtTop) ? ajaInfo.mRowGroup :
|
|
nullptr;
|
|
info.SetInnerRowGroupBottomContBCBorder(nextRowGroup, ajaInfo.mTopRow);
|
|
gotRowBorder = true;
|
|
}
|
|
}
|
|
|
|
// see if the cell to the right had a rowspan and its lower left border
|
|
// needs be joined with this one's bottom
|
|
// if there is a cell to the right and the cell to right was a rowspan
|
|
if ((info.mNumTableCols != info.GetCellEndColIndex() + 1) &&
|
|
(lastBottomBorders[info.GetCellEndColIndex() + 1].rowSpan > 1)) {
|
|
BCCornerInfo& corner = bottomCorners[info.GetCellEndColIndex() + 1];
|
|
if ((NS_SIDE_TOP != corner.ownerSide) &&
|
|
(NS_SIDE_BOTTOM != corner.ownerSide)) {
|
|
// not a vertical owner
|
|
BCCellBorder& thisBorder = lastBottomBorder;
|
|
BCCellBorder& nextBorder = lastBottomBorders[info.mColIndex + 1];
|
|
if ((thisBorder.color == nextBorder.color) &&
|
|
(thisBorder.width == nextBorder.width) &&
|
|
(thisBorder.style == nextBorder.style)) {
|
|
// set the flag on the next border indicating it is not the start of a
|
|
// new segment
|
|
if (iter.mCellMap) {
|
|
tableCellMap->ResetTopStart(NS_SIDE_BOTTOM, *iter.mCellMap,
|
|
info.GetCellEndRowIndex(),
|
|
info.GetCellEndColIndex() + 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} // for (iter.First(info); info.mCell; iter.Next(info)) {
|
|
// reset the bc flag and damage area
|
|
SetNeedToCalcBCBorders(false);
|
|
propData->mDamageArea = nsIntRect(0,0,0,0);
|
|
#ifdef DEBUG_TABLE_CELLMAP
|
|
mCellMap->Dump();
|
|
#endif
|
|
}
|
|
|
|
class BCPaintBorderIterator;
|
|
|
|
struct BCVerticalSeg
|
|
{
|
|
BCVerticalSeg();
|
|
|
|
void Start(BCPaintBorderIterator& aIter,
|
|
BCBorderOwner aBorderOwner,
|
|
BCPixelSize aVerSegWidth,
|
|
BCPixelSize aHorSegHeight);
|
|
|
|
void Initialize(BCPaintBorderIterator& aIter);
|
|
void GetBottomCorner(BCPaintBorderIterator& aIter,
|
|
BCPixelSize aHorSegHeight);
|
|
|
|
|
|
void Paint(BCPaintBorderIterator& aIter,
|
|
nsRenderingContext& aRenderingContext,
|
|
BCPixelSize aHorSegHeight);
|
|
void AdvanceOffsetY();
|
|
void IncludeCurrentBorder(BCPaintBorderIterator& aIter);
|
|
|
|
|
|
union {
|
|
nsTableColFrame* mCol;
|
|
int32_t mColWidth;
|
|
};
|
|
nscoord mOffsetX; // x-offset with respect to the table edge
|
|
nscoord mOffsetY; // y-offset with respect to the table edge
|
|
nscoord mLength; // vertical length including corners
|
|
BCPixelSize mWidth; // width in pixels
|
|
|
|
nsTableCellFrame* mAjaCell; // previous sibling to the first cell
|
|
// where the segment starts, it can be
|
|
// the owner of a segment
|
|
nsTableCellFrame* mFirstCell; // cell at the start of the segment
|
|
nsTableRowGroupFrame* mFirstRowGroup; // row group at the start of the segment
|
|
nsTableRowFrame* mFirstRow; // row at the start of the segment
|
|
nsTableCellFrame* mLastCell; // cell at the current end of the
|
|
// segment
|
|
|
|
|
|
uint8_t mOwner; // owner of the border, defines the
|
|
// style
|
|
mozilla::css::Side mTopBevelSide; // direction to bevel at the top
|
|
nscoord mTopBevelOffset; // how much to bevel at the top
|
|
BCPixelSize mBottomHorSegHeight; // height of the crossing
|
|
//horizontal border
|
|
nscoord mBottomOffset; // how much longer is the segment due
|
|
// to the horizontal border, by this
|
|
// amount the next segment needs to be
|
|
// shifted.
|
|
bool mIsBottomBevel; // should we bevel at the bottom
|
|
};
|
|
|
|
struct BCHorizontalSeg
|
|
{
|
|
BCHorizontalSeg();
|
|
|
|
void Start(BCPaintBorderIterator& aIter,
|
|
BCBorderOwner aBorderOwner,
|
|
BCPixelSize aBottomVerSegWidth,
|
|
BCPixelSize aHorSegHeight);
|
|
void GetRightCorner(BCPaintBorderIterator& aIter,
|
|
BCPixelSize aLeftSegWidth);
|
|
void AdvanceOffsetX(int32_t aIncrement);
|
|
void IncludeCurrentBorder(BCPaintBorderIterator& aIter);
|
|
void Paint(BCPaintBorderIterator& aIter,
|
|
nsRenderingContext& aRenderingContext);
|
|
|
|
nscoord mOffsetX; // x-offset with respect to the table edge
|
|
nscoord mOffsetY; // y-offset with respect to the table edge
|
|
nscoord mLength; // horizontal length including corners
|
|
BCPixelSize mWidth; // border width in pixels
|
|
nscoord mLeftBevelOffset; // how much to bevel at the left
|
|
mozilla::css::Side mLeftBevelSide; // direction to bevel at the left
|
|
bool mIsRightBevel; // should we bevel at the right end
|
|
nscoord mRightBevelOffset; // how much to bevel at the right
|
|
mozilla::css::Side mRightBevelSide; // direction to bevel at the right
|
|
nscoord mEndOffset; // how much longer is the segment due
|
|
// to the vertical border, by this
|
|
// amount the next segment needs to be
|
|
// shifted.
|
|
uint8_t mOwner; // owner of the border, defines the
|
|
// style
|
|
nsTableCellFrame* mFirstCell; // cell at the start of the segment
|
|
nsTableCellFrame* mAjaCell; // neighboring cell to the first cell
|
|
// where the segment starts, it can be
|
|
// the owner of a segment
|
|
};
|
|
|
|
// Iterates over borders (left border, corner, top border) in the cell map within a damage area
|
|
// from left to right, top to bottom. All members are in terms of the 1st in flow frames, except
|
|
// where suffixed by InFlow.
|
|
class BCPaintBorderIterator
|
|
{
|
|
public:
|
|
|
|
|
|
BCPaintBorderIterator(nsTableFrame* aTable);
|
|
~BCPaintBorderIterator() { if (mVerInfo) {
|
|
delete [] mVerInfo;
|
|
}}
|
|
void Reset();
|
|
|
|
/**
|
|
* Determine the damage area in terms of rows and columns and finalize
|
|
* mInitialOffsetX and mInitialOffsetY.
|
|
* @param aDirtyRect - dirty rect in table coordinates
|
|
* @return - true if we need to paint something given dirty rect
|
|
*/
|
|
bool SetDamageArea(const nsRect& aDamageRect);
|
|
void First();
|
|
void Next();
|
|
void AccumulateOrPaintHorizontalSegment(nsRenderingContext& aRenderingContext);
|
|
void AccumulateOrPaintVerticalSegment(nsRenderingContext& aRenderingContext);
|
|
void ResetVerInfo();
|
|
void StoreColumnWidth(int32_t aIndex);
|
|
bool VerticalSegmentOwnsCorner();
|
|
|
|
nsTableFrame* mTable;
|
|
nsTableFrame* mTableFirstInFlow;
|
|
nsTableCellMap* mTableCellMap;
|
|
nsCellMap* mCellMap;
|
|
bool mTableIsLTR;
|
|
int32_t mColInc; // +1 for ltr -1 for rtl
|
|
const nsStyleBackground* mTableBgColor;
|
|
nsTableFrame::RowGroupArray mRowGroups;
|
|
|
|
nsTableRowGroupFrame* mPrevRg;
|
|
nsTableRowGroupFrame* mRg;
|
|
bool mIsRepeatedHeader;
|
|
bool mIsRepeatedFooter;
|
|
nsTableRowGroupFrame* mStartRg; // first row group in the damagearea
|
|
int32_t mRgIndex; // current row group index in the
|
|
// mRowgroups array
|
|
int32_t mFifRgFirstRowIndex; // start row index of the first in
|
|
// flow of the row group
|
|
int32_t mRgFirstRowIndex; // row index of the first row in the
|
|
// row group
|
|
int32_t mRgLastRowIndex; // row index of the last row in the row
|
|
// group
|
|
int32_t mNumTableRows; // number of rows in the table and all
|
|
// continuations
|
|
int32_t mNumTableCols; // number of columns in the table
|
|
int32_t mColIndex; // with respect to the table
|
|
int32_t mRowIndex; // with respect to the table
|
|
int32_t mRepeatedHeaderRowIndex; // row index in a repeated
|
|
//header, it's equivalent to
|
|
// mRowIndex when we're in a repeated
|
|
// header, and set to the last row
|
|
// index of a repeated header when
|
|
// we're not
|
|
bool mIsNewRow;
|
|
bool mAtEnd; // the iterator cycled over all
|
|
// borders
|
|
nsTableRowFrame* mPrevRow;
|
|
nsTableRowFrame* mRow;
|
|
nsTableRowFrame* mStartRow; //first row in a inside the damagearea
|
|
|
|
|
|
// cell properties
|
|
nsTableCellFrame* mPrevCell;
|
|
nsTableCellFrame* mCell;
|
|
BCCellData* mPrevCellData;
|
|
BCCellData* mCellData;
|
|
BCData* mBCData;
|
|
|
|
bool IsTableTopMost() {return (mRowIndex == 0) && !mTable->GetPrevInFlow();}
|
|
bool IsTableRightMost() {return (mColIndex >= mNumTableCols);}
|
|
bool IsTableBottomMost() {return (mRowIndex >= mNumTableRows) && !mTable->GetNextInFlow();}
|
|
bool IsTableLeftMost() {return (mColIndex == 0);}
|
|
bool IsDamageAreaTopMost() {return (mRowIndex == mDamageArea.y);}
|
|
bool IsDamageAreaRightMost() {return (mColIndex >= mDamageArea.XMost());}
|
|
bool IsDamageAreaBottomMost() {return (mRowIndex >= mDamageArea.YMost());}
|
|
bool IsDamageAreaLeftMost() {return (mColIndex == mDamageArea.x);}
|
|
int32_t GetRelativeColIndex() {return (mColIndex - mDamageArea.x);}
|
|
|
|
nsIntRect mDamageArea; // damageArea in cellmap coordinates
|
|
bool IsAfterRepeatedHeader() { return !mIsRepeatedHeader && (mRowIndex == (mRepeatedHeaderRowIndex + 1));}
|
|
bool StartRepeatedFooter() {return mIsRepeatedFooter && (mRowIndex == mRgFirstRowIndex) && (mRowIndex != mDamageArea.y);}
|
|
nscoord mInitialOffsetX; // offsetX of the first border with
|
|
// respect to the table
|
|
nscoord mInitialOffsetY; // offsetY of the first border with
|
|
// respect to the table
|
|
nscoord mNextOffsetY; // offsetY of the next segment
|
|
BCVerticalSeg* mVerInfo; // this array is used differently when
|
|
// horizontal and vertical borders are drawn
|
|
// When horizontal border are drawn we cache
|
|
// the column widths and the width of the
|
|
// vertical borders that arrive from top
|
|
// When we draw vertical borders we store
|
|
// lengths and width for vertical borders
|
|
// before they are drawn while we move over
|
|
// the columns in the damage area
|
|
// It has one more elements than columns are
|
|
//in the table.
|
|
BCHorizontalSeg mHorSeg; // the horizontal segment while we
|
|
// move over the colums
|
|
BCPixelSize mPrevHorSegHeight; // the height of the previous
|
|
// horizontal border
|
|
|
|
private:
|
|
|
|
bool SetNewRow(nsTableRowFrame* aRow = nullptr);
|
|
bool SetNewRowGroup();
|
|
void SetNewData(int32_t aRowIndex, int32_t aColIndex);
|
|
|
|
};
|
|
|
|
|
|
|
|
BCPaintBorderIterator::BCPaintBorderIterator(nsTableFrame* aTable)
|
|
{
|
|
mTable = aTable;
|
|
mVerInfo = nullptr;
|
|
nsMargin childAreaOffset = mTable->GetChildAreaOffset(nullptr);
|
|
mTableFirstInFlow = static_cast<nsTableFrame*>(mTable->FirstInFlow());
|
|
mTableCellMap = mTable->GetCellMap();
|
|
// y position of first row in damage area
|
|
mInitialOffsetY = mTable->GetPrevInFlow() ? 0 : childAreaOffset.top;
|
|
mNumTableRows = mTable->GetRowCount();
|
|
mNumTableCols = mTable->GetColCount();
|
|
|
|
// Get the ordered row groups
|
|
mTable->OrderRowGroups(mRowGroups);
|
|
// initialize to a non existing index
|
|
mRepeatedHeaderRowIndex = -99;
|
|
|
|
mTableIsLTR = mTable->StyleVisibility()->mDirection ==
|
|
NS_STYLE_DIRECTION_LTR;
|
|
mColInc = (mTableIsLTR) ? 1 : -1;
|
|
|
|
nsIFrame* bgFrame =
|
|
nsCSSRendering::FindNonTransparentBackgroundFrame(aTable);
|
|
mTableBgColor = bgFrame->StyleBackground();
|
|
}
|
|
|
|
bool
|
|
BCPaintBorderIterator::SetDamageArea(const nsRect& aDirtyRect)
|
|
{
|
|
|
|
uint32_t startRowIndex, endRowIndex, startColIndex, endColIndex;
|
|
startRowIndex = endRowIndex = startColIndex = endColIndex = 0;
|
|
bool done = false;
|
|
bool haveIntersect = false;
|
|
// find startRowIndex, endRowIndex
|
|
nscoord rowY = mInitialOffsetY;
|
|
for (uint32_t rgX = 0; rgX < mRowGroups.Length() && !done; rgX++) {
|
|
nsTableRowGroupFrame* rgFrame = mRowGroups[rgX];
|
|
for (nsTableRowFrame* rowFrame = rgFrame->GetFirstRow(); rowFrame;
|
|
rowFrame = rowFrame->GetNextRow()) {
|
|
// conservatively estimate the half border widths outside the row
|
|
nscoord topBorderHalf = (mTable->GetPrevInFlow()) ? 0 :
|
|
nsPresContext::CSSPixelsToAppUnits(rowFrame->GetTopBCBorderWidth() + 1);
|
|
nscoord bottomBorderHalf = (mTable->GetNextInFlow()) ? 0 :
|
|
nsPresContext::CSSPixelsToAppUnits(rowFrame->GetBottomBCBorderWidth() + 1);
|
|
// get the row rect relative to the table rather than the row group
|
|
nsSize rowSize = rowFrame->GetSize();
|
|
if (haveIntersect) {
|
|
if (aDirtyRect.YMost() >= (rowY - topBorderHalf)) {
|
|
nsTableRowFrame* fifRow =
|
|
static_cast<nsTableRowFrame*>(rowFrame->FirstInFlow());
|
|
endRowIndex = fifRow->GetRowIndex();
|
|
}
|
|
else done = true;
|
|
}
|
|
else {
|
|
if ((rowY + rowSize.height + bottomBorderHalf) >= aDirtyRect.y) {
|
|
mStartRg = rgFrame;
|
|
mStartRow = rowFrame;
|
|
nsTableRowFrame* fifRow =
|
|
static_cast<nsTableRowFrame*>(rowFrame->FirstInFlow());
|
|
startRowIndex = endRowIndex = fifRow->GetRowIndex();
|
|
haveIntersect = true;
|
|
}
|
|
else {
|
|
mInitialOffsetY += rowSize.height;
|
|
}
|
|
}
|
|
rowY += rowSize.height;
|
|
}
|
|
}
|
|
mNextOffsetY = mInitialOffsetY;
|
|
|
|
// XXX comment refers to the obsolete NS_FRAME_OUTSIDE_CHILDREN flag
|
|
// XXX but I don't understand it, so not changing it for now
|
|
// outer table borders overflow the table, so the table might be
|
|
// target to other areas as the NS_FRAME_OUTSIDE_CHILDREN is set
|
|
// on the table
|
|
if (!haveIntersect)
|
|
return false;
|
|
// find startColIndex, endColIndex, startColX
|
|
haveIntersect = false;
|
|
if (0 == mNumTableCols)
|
|
return false;
|
|
int32_t leftCol, rightCol; // columns are in the range [leftCol, rightCol)
|
|
|
|
nsMargin childAreaOffset = mTable->GetChildAreaOffset(nullptr);
|
|
if (mTableIsLTR) {
|
|
mInitialOffsetX = childAreaOffset.left; // x position of first col in
|
|
// damage area
|
|
leftCol = 0;
|
|
rightCol = mNumTableCols;
|
|
} else {
|
|
// x position of first col in damage area
|
|
mInitialOffsetX = mTable->GetRect().width - childAreaOffset.right;
|
|
leftCol = mNumTableCols-1;
|
|
rightCol = -1;
|
|
}
|
|
nscoord x = 0;
|
|
int32_t colX;
|
|
for (colX = leftCol; colX != rightCol; colX += mColInc) {
|
|
nsTableColFrame* colFrame = mTableFirstInFlow->GetColFrame(colX);
|
|
if (!colFrame) ABORT1(false);
|
|
// get the col rect relative to the table rather than the col group
|
|
nsSize size = colFrame->GetSize();
|
|
if (haveIntersect) {
|
|
// conservatively estimate the left half border width outside the col
|
|
nscoord leftBorderHalf =
|
|
nsPresContext::CSSPixelsToAppUnits(colFrame->GetLeftBorderWidth() + 1);
|
|
if (aDirtyRect.XMost() >= (x - leftBorderHalf)) {
|
|
endColIndex = colX;
|
|
}
|
|
else break;
|
|
}
|
|
else {
|
|
// conservatively estimate the right half border width outside the col
|
|
nscoord rightBorderHalf =
|
|
nsPresContext::CSSPixelsToAppUnits(colFrame->GetRightBorderWidth() + 1);
|
|
if ((x + size.width + rightBorderHalf) >= aDirtyRect.x) {
|
|
startColIndex = endColIndex = colX;
|
|
haveIntersect = true;
|
|
}
|
|
else {
|
|
mInitialOffsetX += mColInc * size.width;
|
|
}
|
|
}
|
|
x += size.width;
|
|
}
|
|
if (!mTableIsLTR) {
|
|
uint32_t temp;
|
|
mInitialOffsetX = mTable->GetRect().width - childAreaOffset.right;
|
|
temp = startColIndex; startColIndex = endColIndex; endColIndex = temp;
|
|
for (uint32_t column = 0; column < startColIndex; column++) {
|
|
nsTableColFrame* colFrame = mTableFirstInFlow->GetColFrame(column);
|
|
if (!colFrame) ABORT1(false);
|
|
nsSize size = colFrame->GetSize();
|
|
mInitialOffsetX += mColInc * size.width;
|
|
}
|
|
}
|
|
if (!haveIntersect)
|
|
return false;
|
|
mDamageArea = nsIntRect(startColIndex, startRowIndex,
|
|
1 + DeprecatedAbs<int32_t>(endColIndex - startColIndex),
|
|
1 + endRowIndex - startRowIndex);
|
|
|
|
Reset();
|
|
mVerInfo = new BCVerticalSeg[mDamageArea.width + 1];
|
|
if (!mVerInfo)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void
|
|
BCPaintBorderIterator::Reset()
|
|
{
|
|
mAtEnd = true; // gets reset when First() is called
|
|
mRg = mStartRg;
|
|
mPrevRow = nullptr;
|
|
mRow = mStartRow;
|
|
mRowIndex = 0;
|
|
mColIndex = 0;
|
|
mRgIndex = -1;
|
|
mPrevCell = nullptr;
|
|
mCell = nullptr;
|
|
mPrevCellData = nullptr;
|
|
mCellData = nullptr;
|
|
mBCData = nullptr;
|
|
ResetVerInfo();
|
|
}
|
|
|
|
/**
|
|
* Set the iterator data to a new cellmap coordinate
|
|
* @param aRowIndex - the row index
|
|
* @param aColIndex - the col index
|
|
*/
|
|
void
|
|
BCPaintBorderIterator::SetNewData(int32_t aY,
|
|
int32_t aX)
|
|
{
|
|
if (!mTableCellMap || !mTableCellMap->mBCInfo) ABORT0();
|
|
|
|
mColIndex = aX;
|
|
mRowIndex = aY;
|
|
mPrevCellData = mCellData;
|
|
if (IsTableRightMost() && IsTableBottomMost()) {
|
|
mCell = nullptr;
|
|
mBCData = &mTableCellMap->mBCInfo->mLowerRightCorner;
|
|
}
|
|
else if (IsTableRightMost()) {
|
|
mCellData = nullptr;
|
|
mBCData = &mTableCellMap->mBCInfo->mRightBorders.ElementAt(aY);
|
|
}
|
|
else if (IsTableBottomMost()) {
|
|
mCellData = nullptr;
|
|
mBCData = &mTableCellMap->mBCInfo->mBottomBorders.ElementAt(aX);
|
|
}
|
|
else {
|
|
if (uint32_t(mRowIndex - mFifRgFirstRowIndex) < mCellMap->mRows.Length()) {
|
|
mBCData = nullptr;
|
|
mCellData =
|
|
(BCCellData*)mCellMap->mRows[mRowIndex - mFifRgFirstRowIndex].SafeElementAt(mColIndex);
|
|
if (mCellData) {
|
|
mBCData = &mCellData->mData;
|
|
if (!mCellData->IsOrig()) {
|
|
if (mCellData->IsRowSpan()) {
|
|
aY -= mCellData->GetRowSpanOffset();
|
|
}
|
|
if (mCellData->IsColSpan()) {
|
|
aX -= mCellData->GetColSpanOffset();
|
|
}
|
|
if ((aX >= 0) && (aY >= 0)) {
|
|
mCellData = (BCCellData*)mCellMap->mRows[aY - mFifRgFirstRowIndex][aX];
|
|
}
|
|
}
|
|
if (mCellData->IsOrig()) {
|
|
mPrevCell = mCell;
|
|
mCell = mCellData->GetCellFrame();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the iterator to a new row
|
|
* @param aRow - the new row frame, if null the iterator will advance to the
|
|
* next row
|
|
*/
|
|
bool
|
|
BCPaintBorderIterator::SetNewRow(nsTableRowFrame* aRow)
|
|
{
|
|
mPrevRow = mRow;
|
|
mRow = (aRow) ? aRow : mRow->GetNextRow();
|
|
if (mRow) {
|
|
mIsNewRow = true;
|
|
mRowIndex = mRow->GetRowIndex();
|
|
mColIndex = mDamageArea.x;
|
|
mPrevHorSegHeight = 0;
|
|
if (mIsRepeatedHeader) {
|
|
mRepeatedHeaderRowIndex = mRowIndex;
|
|
}
|
|
}
|
|
else {
|
|
mAtEnd = true;
|
|
}
|
|
return !mAtEnd;
|
|
}
|
|
|
|
/**
|
|
* Advance the iterator to the next row group
|
|
*/
|
|
bool
|
|
BCPaintBorderIterator::SetNewRowGroup()
|
|
{
|
|
|
|
mRgIndex++;
|
|
|
|
mIsRepeatedHeader = false;
|
|
mIsRepeatedFooter = false;
|
|
|
|
NS_ASSERTION(mRgIndex >= 0, "mRgIndex out of bounds");
|
|
if (uint32_t(mRgIndex) < mRowGroups.Length()) {
|
|
mPrevRg = mRg;
|
|
mRg = mRowGroups[mRgIndex];
|
|
nsTableRowGroupFrame* fifRg =
|
|
static_cast<nsTableRowGroupFrame*>(mRg->FirstInFlow());
|
|
mFifRgFirstRowIndex = fifRg->GetStartRowIndex();
|
|
mRgFirstRowIndex = mRg->GetStartRowIndex();
|
|
mRgLastRowIndex = mRgFirstRowIndex + mRg->GetRowCount() - 1;
|
|
|
|
if (SetNewRow(mRg->GetFirstRow())) {
|
|
mCellMap = mTableCellMap->GetMapFor(fifRg, nullptr);
|
|
if (!mCellMap) ABORT1(false);
|
|
}
|
|
if (mRg && mTable->GetPrevInFlow() && !mRg->GetPrevInFlow()) {
|
|
// if mRowGroup doesn't have a prev in flow, then it may be a repeated
|
|
// header or footer
|
|
const nsStyleDisplay* display = mRg->StyleDisplay();
|
|
if (mRowIndex == mDamageArea.y) {
|
|
mIsRepeatedHeader = (NS_STYLE_DISPLAY_TABLE_HEADER_GROUP == display->mDisplay);
|
|
}
|
|
else {
|
|
mIsRepeatedFooter = (NS_STYLE_DISPLAY_TABLE_FOOTER_GROUP == display->mDisplay);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
mAtEnd = true;
|
|
}
|
|
return !mAtEnd;
|
|
}
|
|
|
|
/**
|
|
* Move the iterator to the first position in the damageArea
|
|
*/
|
|
void
|
|
BCPaintBorderIterator::First()
|
|
{
|
|
if (!mTable || (mDamageArea.x >= mNumTableCols) ||
|
|
(mDamageArea.y >= mNumTableRows)) ABORT0();
|
|
|
|
mAtEnd = false;
|
|
|
|
uint32_t numRowGroups = mRowGroups.Length();
|
|
for (uint32_t rgY = 0; rgY < numRowGroups; rgY++) {
|
|
nsTableRowGroupFrame* rowG = mRowGroups[rgY];
|
|
int32_t start = rowG->GetStartRowIndex();
|
|
int32_t end = start + rowG->GetRowCount() - 1;
|
|
if ((mDamageArea.y >= start) && (mDamageArea.y <= end)) {
|
|
mRgIndex = rgY - 1; // SetNewRowGroup increments rowGroupIndex
|
|
if (SetNewRowGroup()) {
|
|
while ((mRowIndex < mDamageArea.y) && !mAtEnd) {
|
|
SetNewRow();
|
|
}
|
|
if (!mAtEnd) {
|
|
SetNewData(mDamageArea.y, mDamageArea.x);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
mAtEnd = true;
|
|
}
|
|
|
|
/**
|
|
* Advance the iterator to the next position
|
|
*/
|
|
void
|
|
BCPaintBorderIterator::Next()
|
|
{
|
|
if (mAtEnd) ABORT0();
|
|
mIsNewRow = false;
|
|
|
|
mColIndex++;
|
|
if (mColIndex > mDamageArea.XMost()) {
|
|
mRowIndex++;
|
|
if (mRowIndex == mDamageArea.YMost()) {
|
|
mColIndex = mDamageArea.x;
|
|
}
|
|
else if (mRowIndex < mDamageArea.YMost()) {
|
|
if (mRowIndex <= mRgLastRowIndex) {
|
|
SetNewRow();
|
|
}
|
|
else {
|
|
SetNewRowGroup();
|
|
}
|
|
}
|
|
else {
|
|
mAtEnd = true;
|
|
}
|
|
}
|
|
if (!mAtEnd) {
|
|
SetNewData(mRowIndex, mColIndex);
|
|
}
|
|
}
|
|
|
|
// XXX if CalcVerCornerOffset and CalcHorCornerOffset remain similar, combine
|
|
// them
|
|
/** Compute the vertical offset of a vertical border segment
|
|
* @param aCornerOwnerSide - which side owns the corner
|
|
* @param aCornerSubWidth - how wide is the nonwinning side of the corner
|
|
* @param aHorWidth - how wide is the horizontal edge of the corner
|
|
* @param aIsStartOfSeg - does this corner start a new segment
|
|
* @param aIsBevel - is this corner beveled
|
|
* @return - offset in twips
|
|
*/
|
|
static nscoord
|
|
CalcVerCornerOffset(mozilla::css::Side aCornerOwnerSide,
|
|
BCPixelSize aCornerSubWidth,
|
|
BCPixelSize aHorWidth,
|
|
bool aIsStartOfSeg,
|
|
bool aIsBevel)
|
|
{
|
|
nscoord offset = 0;
|
|
// XXX These should be replaced with appropriate side-specific macros (which?)
|
|
BCPixelSize smallHalf, largeHalf;
|
|
if ((NS_SIDE_TOP == aCornerOwnerSide) ||
|
|
(NS_SIDE_BOTTOM == aCornerOwnerSide)) {
|
|
DivideBCBorderSize(aCornerSubWidth, smallHalf, largeHalf);
|
|
if (aIsBevel) {
|
|
offset = (aIsStartOfSeg) ? -largeHalf : smallHalf;
|
|
}
|
|
else {
|
|
offset = (NS_SIDE_TOP == aCornerOwnerSide) ? smallHalf : -largeHalf;
|
|
}
|
|
}
|
|
else {
|
|
DivideBCBorderSize(aHorWidth, smallHalf, largeHalf);
|
|
if (aIsBevel) {
|
|
offset = (aIsStartOfSeg) ? -largeHalf : smallHalf;
|
|
}
|
|
else {
|
|
offset = (aIsStartOfSeg) ? smallHalf : -largeHalf;
|
|
}
|
|
}
|
|
return nsPresContext::CSSPixelsToAppUnits(offset);
|
|
}
|
|
|
|
/** Compute the horizontal offset of a horizontal border segment
|
|
* @param aCornerOwnerSide - which side owns the corner
|
|
* @param aCornerSubWidth - how wide is the nonwinning side of the corner
|
|
* @param aVerWidth - how wide is the vertical edge of the corner
|
|
* @param aIsStartOfSeg - does this corner start a new segment
|
|
* @param aIsBevel - is this corner beveled
|
|
* @param aTableIsLTR - direction, the computation depends on ltr or rtl
|
|
* @return - offset in twips
|
|
*/
|
|
static nscoord
|
|
CalcHorCornerOffset(mozilla::css::Side aCornerOwnerSide,
|
|
BCPixelSize aCornerSubWidth,
|
|
BCPixelSize aVerWidth,
|
|
bool aIsStartOfSeg,
|
|
bool aIsBevel,
|
|
bool aTableIsLTR)
|
|
{
|
|
nscoord offset = 0;
|
|
// XXX These should be replaced with appropriate side-specific macros (which?)
|
|
BCPixelSize smallHalf, largeHalf;
|
|
if ((NS_SIDE_LEFT == aCornerOwnerSide) ||
|
|
(NS_SIDE_RIGHT == aCornerOwnerSide)) {
|
|
if (aTableIsLTR) {
|
|
DivideBCBorderSize(aCornerSubWidth, smallHalf, largeHalf);
|
|
}
|
|
else {
|
|
DivideBCBorderSize(aCornerSubWidth, largeHalf, smallHalf);
|
|
}
|
|
if (aIsBevel) {
|
|
offset = (aIsStartOfSeg) ? -largeHalf : smallHalf;
|
|
}
|
|
else {
|
|
offset = (NS_SIDE_LEFT == aCornerOwnerSide) ? smallHalf : -largeHalf;
|
|
}
|
|
}
|
|
else {
|
|
if (aTableIsLTR) {
|
|
DivideBCBorderSize(aVerWidth, smallHalf, largeHalf);
|
|
}
|
|
else {
|
|
DivideBCBorderSize(aVerWidth, largeHalf, smallHalf);
|
|
}
|
|
if (aIsBevel) {
|
|
offset = (aIsStartOfSeg) ? -largeHalf : smallHalf;
|
|
}
|
|
else {
|
|
offset = (aIsStartOfSeg) ? smallHalf : -largeHalf;
|
|
}
|
|
}
|
|
return nsPresContext::CSSPixelsToAppUnits(offset);
|
|
}
|
|
|
|
BCVerticalSeg::BCVerticalSeg()
|
|
{
|
|
mCol = nullptr;
|
|
mFirstCell = mLastCell = mAjaCell = nullptr;
|
|
mOffsetX = mOffsetY = mLength = mWidth = mTopBevelOffset = 0;
|
|
mTopBevelSide = NS_SIDE_TOP;
|
|
mOwner = eCellOwner;
|
|
}
|
|
|
|
/**
|
|
* Start a new vertical segment
|
|
* @param aIter - iterator containing the structural information
|
|
* @param aBorderOwner - determines the border style
|
|
* @param aVerSegWidth - the width of segment in pixel
|
|
* @param aHorSegHeight - the width of the horizontal segment joining the corner
|
|
* at the start
|
|
*/
|
|
void
|
|
BCVerticalSeg::Start(BCPaintBorderIterator& aIter,
|
|
BCBorderOwner aBorderOwner,
|
|
BCPixelSize aVerSegWidth,
|
|
BCPixelSize aHorSegHeight)
|
|
{
|
|
mozilla::css::Side ownerSide = NS_SIDE_TOP;
|
|
bool bevel = false;
|
|
|
|
|
|
nscoord cornerSubWidth = (aIter.mBCData) ?
|
|
aIter.mBCData->GetCorner(ownerSide, bevel) : 0;
|
|
|
|
bool topBevel = (aVerSegWidth > 0) ? bevel : false;
|
|
BCPixelSize maxHorSegHeight = std::max(aIter.mPrevHorSegHeight, aHorSegHeight);
|
|
nscoord offset = CalcVerCornerOffset(ownerSide, cornerSubWidth,
|
|
maxHorSegHeight, true,
|
|
topBevel);
|
|
|
|
mTopBevelOffset = topBevel ?
|
|
nsPresContext::CSSPixelsToAppUnits(maxHorSegHeight): 0;
|
|
// XXX this assumes that only corners where 2 segments join can be beveled
|
|
mTopBevelSide = (aHorSegHeight > 0) ? NS_SIDE_RIGHT : NS_SIDE_LEFT;
|
|
mOffsetY += offset;
|
|
mLength = -offset;
|
|
mWidth = aVerSegWidth;
|
|
mOwner = aBorderOwner;
|
|
mFirstCell = aIter.mCell;
|
|
mFirstRowGroup = aIter.mRg;
|
|
mFirstRow = aIter.mRow;
|
|
if (aIter.GetRelativeColIndex() > 0) {
|
|
mAjaCell = aIter.mVerInfo[aIter.GetRelativeColIndex() - 1].mLastCell;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Initialize the vertical segments with information that will persist for any
|
|
* vertical segment in this column
|
|
* @param aIter - iterator containing the structural information
|
|
*/
|
|
void
|
|
BCVerticalSeg::Initialize(BCPaintBorderIterator& aIter)
|
|
{
|
|
int32_t relColIndex = aIter.GetRelativeColIndex();
|
|
mCol = aIter.IsTableRightMost() ? aIter.mVerInfo[relColIndex - 1].mCol :
|
|
aIter.mTableFirstInFlow->GetColFrame(aIter.mColIndex);
|
|
if (!mCol) ABORT0();
|
|
if (0 == relColIndex) {
|
|
mOffsetX = aIter.mInitialOffsetX;
|
|
}
|
|
// set colX for the next column
|
|
if (!aIter.IsDamageAreaRightMost()) {
|
|
aIter.mVerInfo[relColIndex + 1].mOffsetX = mOffsetX +
|
|
aIter.mColInc * mCol->GetSize().width;
|
|
}
|
|
mOffsetY = aIter.mInitialOffsetY;
|
|
mLastCell = aIter.mCell;
|
|
}
|
|
|
|
/**
|
|
* Compute the offsets for the bottom corner of a vertical segment
|
|
* @param aIter - iterator containing the structural information
|
|
* @param aHorSegHeight - the width of the horizontal segment joining the corner
|
|
* at the start
|
|
*/
|
|
void
|
|
BCVerticalSeg::GetBottomCorner(BCPaintBorderIterator& aIter,
|
|
BCPixelSize aHorSegHeight)
|
|
{
|
|
mozilla::css::Side ownerSide = NS_SIDE_TOP;
|
|
nscoord cornerSubWidth = 0;
|
|
bool bevel = false;
|
|
if (aIter.mBCData) {
|
|
cornerSubWidth = aIter.mBCData->GetCorner(ownerSide, bevel);
|
|
}
|
|
mIsBottomBevel = (mWidth > 0) ? bevel : false;
|
|
mBottomHorSegHeight = std::max(aIter.mPrevHorSegHeight, aHorSegHeight);
|
|
mBottomOffset = CalcVerCornerOffset(ownerSide, cornerSubWidth,
|
|
mBottomHorSegHeight,
|
|
false, mIsBottomBevel);
|
|
mLength += mBottomOffset;
|
|
}
|
|
|
|
/**
|
|
* Paint the vertical segment
|
|
* @param aIter - iterator containing the structural information
|
|
* @param aRenderingContext - the rendering context
|
|
* @param aHorSegHeight - the width of the horizontal segment joining the corner
|
|
* at the start
|
|
*/
|
|
void
|
|
BCVerticalSeg::Paint(BCPaintBorderIterator& aIter,
|
|
nsRenderingContext& aRenderingContext,
|
|
BCPixelSize aHorSegHeight)
|
|
{
|
|
// get the border style, color and paint the segment
|
|
mozilla::css::Side side = (aIter.IsDamageAreaRightMost()) ? NS_SIDE_RIGHT :
|
|
NS_SIDE_LEFT;
|
|
int32_t relColIndex = aIter.GetRelativeColIndex();
|
|
nsTableColFrame* col = mCol; if (!col) ABORT0();
|
|
nsTableCellFrame* cell = mFirstCell; // ???
|
|
nsIFrame* owner = nullptr;
|
|
uint8_t style = NS_STYLE_BORDER_STYLE_SOLID;
|
|
nscolor color = 0xFFFFFFFF;
|
|
|
|
switch (mOwner) {
|
|
case eTableOwner:
|
|
owner = aIter.mTable;
|
|
break;
|
|
case eAjaColGroupOwner:
|
|
side = NS_SIDE_RIGHT;
|
|
if (!aIter.IsTableRightMost() && (relColIndex > 0)) {
|
|
col = aIter.mVerInfo[relColIndex - 1].mCol;
|
|
} // and fall through
|
|
case eColGroupOwner:
|
|
if (col) {
|
|
owner = col->GetParent();
|
|
}
|
|
break;
|
|
case eAjaColOwner:
|
|
side = NS_SIDE_RIGHT;
|
|
if (!aIter.IsTableRightMost() && (relColIndex > 0)) {
|
|
col = aIter.mVerInfo[relColIndex - 1].mCol;
|
|
} // and fall through
|
|
case eColOwner:
|
|
owner = col;
|
|
break;
|
|
case eAjaRowGroupOwner:
|
|
NS_ERROR("a neighboring rowgroup can never own a vertical border");
|
|
// and fall through
|
|
case eRowGroupOwner:
|
|
NS_ASSERTION(aIter.IsTableLeftMost() || aIter.IsTableRightMost(),
|
|
"row group can own border only at table edge");
|
|
owner = mFirstRowGroup;
|
|
break;
|
|
case eAjaRowOwner:
|
|
NS_ASSERTION(false, "program error"); // and fall through
|
|
case eRowOwner:
|
|
NS_ASSERTION(aIter.IsTableLeftMost() || aIter.IsTableRightMost(),
|
|
"row can own border only at table edge");
|
|
owner = mFirstRow;
|
|
break;
|
|
case eAjaCellOwner:
|
|
side = NS_SIDE_RIGHT;
|
|
cell = mAjaCell; // and fall through
|
|
case eCellOwner:
|
|
owner = cell;
|
|
break;
|
|
}
|
|
if (owner) {
|
|
::GetPaintStyleInfo(owner, side, style, color, aIter.mTableIsLTR);
|
|
}
|
|
BCPixelSize smallHalf, largeHalf;
|
|
DivideBCBorderSize(mWidth, smallHalf, largeHalf);
|
|
nsRect segRect(mOffsetX - nsPresContext::CSSPixelsToAppUnits(largeHalf),
|
|
mOffsetY,
|
|
nsPresContext::CSSPixelsToAppUnits(mWidth), mLength);
|
|
nscoord bottomBevelOffset = (mIsBottomBevel) ?
|
|
nsPresContext::CSSPixelsToAppUnits(mBottomHorSegHeight) : 0;
|
|
mozilla::css::Side bottomBevelSide = ((aHorSegHeight > 0) ^ !aIter.mTableIsLTR) ?
|
|
NS_SIDE_RIGHT : NS_SIDE_LEFT;
|
|
mozilla::css::Side topBevelSide = ((mTopBevelSide == NS_SIDE_RIGHT) ^ !aIter.mTableIsLTR)?
|
|
NS_SIDE_RIGHT : NS_SIDE_LEFT;
|
|
nsCSSRendering::DrawTableBorderSegment(aRenderingContext, style, color,
|
|
aIter.mTableBgColor, segRect,
|
|
nsPresContext::AppUnitsPerCSSPixel(),
|
|
topBevelSide, mTopBevelOffset,
|
|
bottomBevelSide, bottomBevelOffset);
|
|
}
|
|
|
|
/**
|
|
* Advance the start point of a segment
|
|
*/
|
|
void
|
|
BCVerticalSeg::AdvanceOffsetY()
|
|
{
|
|
mOffsetY += mLength - mBottomOffset;
|
|
}
|
|
|
|
/**
|
|
* Accumulate the current segment
|
|
*/
|
|
void
|
|
BCVerticalSeg::IncludeCurrentBorder(BCPaintBorderIterator& aIter)
|
|
{
|
|
mLastCell = aIter.mCell;
|
|
mLength += aIter.mRow->GetRect().height;
|
|
}
|
|
|
|
BCHorizontalSeg::BCHorizontalSeg()
|
|
{
|
|
mOffsetX = mOffsetY = mLength = mWidth = mLeftBevelOffset = 0;
|
|
mLeftBevelSide = NS_SIDE_TOP;
|
|
mFirstCell = mAjaCell = nullptr;
|
|
}
|
|
|
|
/** Initialize a horizontal border segment for painting
|
|
* @param aIter - iterator storing the current and adjacent frames
|
|
* @param aBorderOwner - which frame owns the border
|
|
* @param aBottomVerSegWidth - vertical segment width coming from up
|
|
* @param aHorSegHeight - the height of the segment
|
|
+ */
|
|
void
|
|
BCHorizontalSeg::Start(BCPaintBorderIterator& aIter,
|
|
BCBorderOwner aBorderOwner,
|
|
BCPixelSize aBottomVerSegWidth,
|
|
BCPixelSize aHorSegHeight)
|
|
{
|
|
mozilla::css::Side cornerOwnerSide = NS_SIDE_TOP;
|
|
bool bevel = false;
|
|
|
|
mOwner = aBorderOwner;
|
|
nscoord cornerSubWidth = (aIter.mBCData) ?
|
|
aIter.mBCData->GetCorner(cornerOwnerSide,
|
|
bevel) : 0;
|
|
|
|
bool leftBevel = (aHorSegHeight > 0) ? bevel : false;
|
|
int32_t relColIndex = aIter.GetRelativeColIndex();
|
|
nscoord maxVerSegWidth = std::max(aIter.mVerInfo[relColIndex].mWidth,
|
|
aBottomVerSegWidth);
|
|
nscoord offset = CalcHorCornerOffset(cornerOwnerSide, cornerSubWidth,
|
|
maxVerSegWidth, true, leftBevel,
|
|
aIter.mTableIsLTR);
|
|
mLeftBevelOffset = (leftBevel && (aHorSegHeight > 0)) ? maxVerSegWidth : 0;
|
|
// XXX this assumes that only corners where 2 segments join can be beveled
|
|
mLeftBevelSide = (aBottomVerSegWidth > 0) ? NS_SIDE_BOTTOM : NS_SIDE_TOP;
|
|
if (aIter.mTableIsLTR) {
|
|
mOffsetX += offset;
|
|
}
|
|
else {
|
|
mOffsetX -= offset;
|
|
}
|
|
mLength = -offset;
|
|
mWidth = aHorSegHeight;
|
|
mFirstCell = aIter.mCell;
|
|
mAjaCell = (aIter.IsDamageAreaTopMost()) ? nullptr :
|
|
aIter.mVerInfo[relColIndex].mLastCell;
|
|
}
|
|
|
|
/**
|
|
* Compute the offsets for the right corner of a horizontal segment
|
|
* @param aIter - iterator containing the structural information
|
|
* @param aLeftSegWidth - the width of the vertical segment joining the corner
|
|
* at the start
|
|
*/
|
|
void
|
|
BCHorizontalSeg::GetRightCorner(BCPaintBorderIterator& aIter,
|
|
BCPixelSize aLeftSegWidth)
|
|
{
|
|
mozilla::css::Side ownerSide = NS_SIDE_TOP;
|
|
nscoord cornerSubWidth = 0;
|
|
bool bevel = false;
|
|
if (aIter.mBCData) {
|
|
cornerSubWidth = aIter.mBCData->GetCorner(ownerSide, bevel);
|
|
}
|
|
|
|
mIsRightBevel = (mWidth > 0) ? bevel : 0;
|
|
int32_t relColIndex = aIter.GetRelativeColIndex();
|
|
nscoord verWidth = std::max(aIter.mVerInfo[relColIndex].mWidth, aLeftSegWidth);
|
|
mEndOffset = CalcHorCornerOffset(ownerSide, cornerSubWidth, verWidth,
|
|
false, mIsRightBevel, aIter.mTableIsLTR);
|
|
mLength += mEndOffset;
|
|
mRightBevelOffset = (mIsRightBevel) ?
|
|
nsPresContext::CSSPixelsToAppUnits(verWidth) : 0;
|
|
mRightBevelSide = (aLeftSegWidth > 0) ? NS_SIDE_BOTTOM : NS_SIDE_TOP;
|
|
}
|
|
|
|
/**
|
|
* Paint the horizontal segment
|
|
* @param aIter - iterator containing the structural information
|
|
* @param aRenderingContext - the rendering context
|
|
*/
|
|
void
|
|
BCHorizontalSeg::Paint(BCPaintBorderIterator& aIter,
|
|
nsRenderingContext& aRenderingContext)
|
|
{
|
|
// get the border style, color and paint the segment
|
|
mozilla::css::Side side = (aIter.IsDamageAreaBottomMost()) ? NS_SIDE_BOTTOM :
|
|
NS_SIDE_TOP;
|
|
nsIFrame* rg = aIter.mRg; if (!rg) ABORT0();
|
|
nsIFrame* row = aIter.mRow; if (!row) ABORT0();
|
|
nsIFrame* cell = mFirstCell;
|
|
nsIFrame* col;
|
|
nsIFrame* owner = nullptr;
|
|
|
|
uint8_t style = NS_STYLE_BORDER_STYLE_SOLID;
|
|
nscolor color = 0xFFFFFFFF;
|
|
|
|
|
|
switch (mOwner) {
|
|
case eTableOwner:
|
|
owner = aIter.mTable;
|
|
break;
|
|
case eAjaColGroupOwner:
|
|
NS_ERROR("neighboring colgroups can never own a horizontal border");
|
|
// and fall through
|
|
case eColGroupOwner:
|
|
NS_ASSERTION(aIter.IsTableTopMost() || aIter.IsTableBottomMost(),
|
|
"col group can own border only at the table edge");
|
|
col = aIter.mTableFirstInFlow->GetColFrame(aIter.mColIndex - 1);
|
|
if (!col) ABORT0();
|
|
owner = col->GetParent();
|
|
break;
|
|
case eAjaColOwner:
|
|
NS_ERROR("neighboring column can never own a horizontal border");
|
|
// and fall through
|
|
case eColOwner:
|
|
NS_ASSERTION(aIter.IsTableTopMost() || aIter.IsTableBottomMost(),
|
|
"col can own border only at the table edge");
|
|
owner = aIter.mTableFirstInFlow->GetColFrame(aIter.mColIndex - 1);
|
|
break;
|
|
case eAjaRowGroupOwner:
|
|
side = NS_SIDE_BOTTOM;
|
|
rg = (aIter.IsTableBottomMost()) ? aIter.mRg : aIter.mPrevRg;
|
|
// and fall through
|
|
case eRowGroupOwner:
|
|
owner = rg;
|
|
break;
|
|
case eAjaRowOwner:
|
|
side = NS_SIDE_BOTTOM;
|
|
row = (aIter.IsTableBottomMost()) ? aIter.mRow : aIter.mPrevRow;
|
|
// and fall through
|
|
case eRowOwner:
|
|
owner = row;
|
|
break;
|
|
case eAjaCellOwner:
|
|
side = NS_SIDE_BOTTOM;
|
|
// if this is null due to the damage area origin-y > 0, then the border
|
|
// won't show up anyway
|
|
cell = mAjaCell;
|
|
// and fall through
|
|
case eCellOwner:
|
|
owner = cell;
|
|
break;
|
|
}
|
|
if (owner) {
|
|
::GetPaintStyleInfo(owner, side, style, color, aIter.mTableIsLTR);
|
|
}
|
|
BCPixelSize smallHalf, largeHalf;
|
|
DivideBCBorderSize(mWidth, smallHalf, largeHalf);
|
|
nsRect segRect(mOffsetX,
|
|
mOffsetY - nsPresContext::CSSPixelsToAppUnits(largeHalf),
|
|
mLength,
|
|
nsPresContext::CSSPixelsToAppUnits(mWidth));
|
|
if (aIter.mTableIsLTR) {
|
|
nsCSSRendering::DrawTableBorderSegment(aRenderingContext, style, color,
|
|
aIter.mTableBgColor, segRect,
|
|
nsPresContext::AppUnitsPerCSSPixel(),
|
|
mLeftBevelSide,
|
|
nsPresContext::CSSPixelsToAppUnits(mLeftBevelOffset),
|
|
mRightBevelSide, mRightBevelOffset);
|
|
}
|
|
else {
|
|
segRect.x -= segRect.width;
|
|
nsCSSRendering::DrawTableBorderSegment(aRenderingContext, style, color,
|
|
aIter.mTableBgColor, segRect,
|
|
nsPresContext::AppUnitsPerCSSPixel(),
|
|
mRightBevelSide, mRightBevelOffset,
|
|
mLeftBevelSide,
|
|
nsPresContext::CSSPixelsToAppUnits(mLeftBevelOffset));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Advance the start point of a segment
|
|
*/
|
|
void
|
|
BCHorizontalSeg::AdvanceOffsetX(int32_t aIncrement)
|
|
{
|
|
mOffsetX += aIncrement * (mLength - mEndOffset);
|
|
}
|
|
|
|
/**
|
|
* Accumulate the current segment
|
|
*/
|
|
void
|
|
BCHorizontalSeg::IncludeCurrentBorder(BCPaintBorderIterator& aIter)
|
|
{
|
|
mLength += aIter.mVerInfo[aIter.GetRelativeColIndex()].mColWidth;
|
|
}
|
|
|
|
/**
|
|
* store the column width information while painting horizontal segment
|
|
*/
|
|
void
|
|
BCPaintBorderIterator::StoreColumnWidth(int32_t aIndex)
|
|
{
|
|
if (IsTableRightMost()) {
|
|
mVerInfo[aIndex].mColWidth = mVerInfo[aIndex - 1].mColWidth;
|
|
}
|
|
else {
|
|
nsTableColFrame* col = mTableFirstInFlow->GetColFrame(mColIndex);
|
|
if (!col) ABORT0();
|
|
mVerInfo[aIndex].mColWidth = col->GetSize().width;
|
|
}
|
|
}
|
|
/**
|
|
* Determine if a vertical segment owns the corder
|
|
*/
|
|
bool
|
|
BCPaintBorderIterator::VerticalSegmentOwnsCorner()
|
|
{
|
|
mozilla::css::Side cornerOwnerSide = NS_SIDE_TOP;
|
|
bool bevel = false;
|
|
if (mBCData) {
|
|
mBCData->GetCorner(cornerOwnerSide, bevel);
|
|
}
|
|
// unitialized ownerside, bevel
|
|
return (NS_SIDE_TOP == cornerOwnerSide) ||
|
|
(NS_SIDE_BOTTOM == cornerOwnerSide);
|
|
}
|
|
|
|
/**
|
|
* Paint if necessary a horizontal segment, otherwise accumulate it
|
|
* @param aRenderingContext - the rendering context
|
|
*/
|
|
void
|
|
BCPaintBorderIterator::AccumulateOrPaintHorizontalSegment(nsRenderingContext& aRenderingContext)
|
|
{
|
|
|
|
int32_t relColIndex = GetRelativeColIndex();
|
|
// store the current col width if it hasn't been already
|
|
if (mVerInfo[relColIndex].mColWidth < 0) {
|
|
StoreColumnWidth(relColIndex);
|
|
}
|
|
|
|
BCBorderOwner borderOwner = eCellOwner;
|
|
BCBorderOwner ignoreBorderOwner;
|
|
bool isSegStart = true;
|
|
bool ignoreSegStart;
|
|
|
|
nscoord leftSegWidth =
|
|
mBCData ? mBCData->GetLeftEdge(ignoreBorderOwner, ignoreSegStart) : 0;
|
|
nscoord topSegHeight =
|
|
mBCData ? mBCData->GetTopEdge(borderOwner, isSegStart) : 0;
|
|
|
|
if (mIsNewRow || (IsDamageAreaLeftMost() && IsDamageAreaBottomMost())) {
|
|
// reset for every new row and on the bottom of the last row
|
|
mHorSeg.mOffsetY = mNextOffsetY;
|
|
mNextOffsetY = mNextOffsetY + mRow->GetSize().height;
|
|
mHorSeg.mOffsetX = mInitialOffsetX;
|
|
mHorSeg.Start(*this, borderOwner, leftSegWidth, topSegHeight);
|
|
}
|
|
|
|
if (!IsDamageAreaLeftMost() && (isSegStart || IsDamageAreaRightMost() ||
|
|
VerticalSegmentOwnsCorner())) {
|
|
// paint the previous seg or the current one if IsDamageAreaRightMost()
|
|
if (mHorSeg.mLength > 0) {
|
|
mHorSeg.GetRightCorner(*this, leftSegWidth);
|
|
if (mHorSeg.mWidth > 0) {
|
|
mHorSeg.Paint(*this, aRenderingContext);
|
|
}
|
|
mHorSeg.AdvanceOffsetX(mColInc);
|
|
}
|
|
mHorSeg.Start(*this, borderOwner, leftSegWidth, topSegHeight);
|
|
}
|
|
mHorSeg.IncludeCurrentBorder(*this);
|
|
mVerInfo[relColIndex].mWidth = leftSegWidth;
|
|
mVerInfo[relColIndex].mLastCell = mCell;
|
|
}
|
|
/**
|
|
* Paint if necessary a vertical segment, otherwise it
|
|
* @param aRenderingContext - the rendering context
|
|
*/
|
|
void
|
|
BCPaintBorderIterator::AccumulateOrPaintVerticalSegment(nsRenderingContext& aRenderingContext)
|
|
{
|
|
BCBorderOwner borderOwner = eCellOwner;
|
|
BCBorderOwner ignoreBorderOwner;
|
|
bool isSegStart = true;
|
|
bool ignoreSegStart;
|
|
|
|
nscoord verSegWidth =
|
|
mBCData ? mBCData->GetLeftEdge(borderOwner, isSegStart) : 0;
|
|
nscoord horSegHeight =
|
|
mBCData ? mBCData->GetTopEdge(ignoreBorderOwner, ignoreSegStart) : 0;
|
|
|
|
int32_t relColIndex = GetRelativeColIndex();
|
|
BCVerticalSeg& verSeg = mVerInfo[relColIndex];
|
|
if (!verSeg.mCol) { // on the first damaged row and the first segment in the
|
|
// col
|
|
verSeg.Initialize(*this);
|
|
verSeg.Start(*this, borderOwner, verSegWidth, horSegHeight);
|
|
}
|
|
|
|
if (!IsDamageAreaTopMost() && (isSegStart || IsDamageAreaBottomMost() ||
|
|
IsAfterRepeatedHeader() ||
|
|
StartRepeatedFooter())) {
|
|
// paint the previous seg or the current one if IsDamageAreaBottomMost()
|
|
if (verSeg.mLength > 0) {
|
|
verSeg.GetBottomCorner(*this, horSegHeight);
|
|
if (verSeg.mWidth > 0) {
|
|
verSeg.Paint(*this, aRenderingContext, horSegHeight);
|
|
}
|
|
verSeg.AdvanceOffsetY();
|
|
}
|
|
verSeg.Start(*this, borderOwner, verSegWidth, horSegHeight);
|
|
}
|
|
verSeg.IncludeCurrentBorder(*this);
|
|
mPrevHorSegHeight = horSegHeight;
|
|
}
|
|
|
|
/**
|
|
* Reset the vertical information cache
|
|
*/
|
|
void
|
|
BCPaintBorderIterator::ResetVerInfo()
|
|
{
|
|
if (mVerInfo) {
|
|
memset(mVerInfo, 0, mDamageArea.width * sizeof(BCVerticalSeg));
|
|
// XXX reinitialize properly
|
|
for (int32_t xIndex = 0; xIndex < mDamageArea.width; xIndex++) {
|
|
mVerInfo[xIndex].mColWidth = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Method to paint BCBorders, this does not use currently display lists although
|
|
* it will do this in future
|
|
* @param aRenderingContext - the rendering context
|
|
* @param aDirtyRect - inside this rectangle the BC Borders will redrawn
|
|
*/
|
|
void
|
|
nsTableFrame::PaintBCBorders(nsRenderingContext& aRenderingContext,
|
|
const nsRect& aDirtyRect)
|
|
{
|
|
// We first transfer the aDirtyRect into cellmap coordinates to compute which
|
|
// cell borders need to be painted
|
|
BCPaintBorderIterator iter(this);
|
|
if (!iter.SetDamageArea(aDirtyRect))
|
|
return;
|
|
|
|
// First, paint all of the vertical borders from top to bottom and left to
|
|
// right as they become complete. They are painted first, since they are less
|
|
// efficient to paint than horizontal segments. They were stored with as few
|
|
// segments as possible (since horizontal borders are painted last and
|
|
// possibly over them). For every cell in a row that fails in the damage are
|
|
// we look up if the current border would start a new segment, if so we paint
|
|
// the previously stored vertical segment and start a new segment. After
|
|
// this we the now active segment with the current border. These
|
|
// segments are stored in mVerInfo to be used on the next row
|
|
for (iter.First(); !iter.mAtEnd; iter.Next()) {
|
|
iter.AccumulateOrPaintVerticalSegment(aRenderingContext);
|
|
}
|
|
|
|
// Next, paint all of the horizontal border segments from top to bottom reuse
|
|
// the mVerInfo array to keep track of col widths and vertical segments for
|
|
// corner calculations
|
|
iter.Reset();
|
|
for (iter.First(); !iter.mAtEnd; iter.Next()) {
|
|
iter.AccumulateOrPaintHorizontalSegment(aRenderingContext);
|
|
}
|
|
}
|
|
|
|
bool nsTableFrame::RowHasSpanningCells(int32_t aRowIndex, int32_t aNumEffCols)
|
|
{
|
|
bool result = false;
|
|
nsTableCellMap* cellMap = GetCellMap();
|
|
NS_PRECONDITION (cellMap, "bad call, cellMap not yet allocated.");
|
|
if (cellMap) {
|
|
result = cellMap->RowHasSpanningCells(aRowIndex, aNumEffCols);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool nsTableFrame::RowIsSpannedInto(int32_t aRowIndex, int32_t aNumEffCols)
|
|
{
|
|
bool result = false;
|
|
nsTableCellMap* cellMap = GetCellMap();
|
|
NS_PRECONDITION (cellMap, "bad call, cellMap not yet allocated.");
|
|
if (cellMap) {
|
|
result = cellMap->RowIsSpannedInto(aRowIndex, aNumEffCols);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/* static */
|
|
void
|
|
nsTableFrame::InvalidateTableFrame(nsIFrame* aFrame,
|
|
const nsRect& aOrigRect,
|
|
const nsRect& aOrigVisualOverflow,
|
|
bool aIsFirstReflow)
|
|
{
|
|
nsIFrame* parent = aFrame->GetParent();
|
|
NS_ASSERTION(parent, "What happened here?");
|
|
|
|
if (parent->GetStateBits() & NS_FRAME_FIRST_REFLOW) {
|
|
// Don't bother; we'll invalidate the parent's overflow rect when
|
|
// we finish reflowing it.
|
|
return;
|
|
}
|
|
|
|
// The part that looks at both the rect and the overflow rect is a
|
|
// bit of a hack. See nsBlockFrame::ReflowLine for an eloquent
|
|
// description of its hackishness.
|
|
//
|
|
// This doesn't really make sense now that we have DLBI.
|
|
// This code can probably be simplified a fair bit.
|
|
nsRect visualOverflow = aFrame->GetVisualOverflowRect();
|
|
if (aIsFirstReflow ||
|
|
aOrigRect.TopLeft() != aFrame->GetPosition() ||
|
|
aOrigVisualOverflow.TopLeft() != visualOverflow.TopLeft()) {
|
|
// Invalidate the old and new overflow rects. Note that if the
|
|
// frame moved, we can't just use aOrigVisualOverflow, since it's in
|
|
// coordinates relative to the old position. So invalidate via
|
|
// aFrame's parent, and reposition that overflow rect to the right
|
|
// place.
|
|
// XXXbz this doesn't handle outlines, does it?
|
|
aFrame->InvalidateFrame();
|
|
parent->InvalidateFrameWithRect(aOrigVisualOverflow + aOrigRect.TopLeft());
|
|
} else if (aOrigRect.Size() != aFrame->GetSize() ||
|
|
aOrigVisualOverflow.Size() != visualOverflow.Size()){
|
|
aFrame->InvalidateFrameWithRect(aOrigVisualOverflow);
|
|
aFrame->InvalidateFrame();
|
|
parent->InvalidateFrameWithRect(aOrigRect);;
|
|
parent->InvalidateFrame();
|
|
}
|
|
}
|