summaryrefslogtreecommitdiffstats
path: root/layout/tables/BasicTableLayoutStrategy.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'layout/tables/BasicTableLayoutStrategy.cpp')
-rw-r--r--layout/tables/BasicTableLayoutStrategy.cpp1060
1 files changed, 1060 insertions, 0 deletions
diff --git a/layout/tables/BasicTableLayoutStrategy.cpp b/layout/tables/BasicTableLayoutStrategy.cpp
new file mode 100644
index 000000000..65835e68e
--- /dev/null
+++ b/layout/tables/BasicTableLayoutStrategy.cpp
@@ -0,0 +1,1060 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+// vim:cindent:ts=4:et:sw=4:
+/* 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/. */
+
+/*
+ * Web-compatible algorithms that determine column and table widths,
+ * used for CSS2's 'table-layout: auto'.
+ */
+
+#include "BasicTableLayoutStrategy.h"
+
+#include <algorithm>
+
+#include "nsTableFrame.h"
+#include "nsTableColFrame.h"
+#include "nsTableCellFrame.h"
+#include "nsLayoutUtils.h"
+#include "nsGkAtoms.h"
+#include "SpanningCellSorter.h"
+#include "nsIContent.h"
+
+using namespace mozilla;
+using namespace mozilla::layout;
+
+namespace css = mozilla::css;
+
+#undef DEBUG_TABLE_STRATEGY
+
+BasicTableLayoutStrategy::BasicTableLayoutStrategy(nsTableFrame *aTableFrame)
+ : nsITableLayoutStrategy(nsITableLayoutStrategy::Auto)
+ , mTableFrame(aTableFrame)
+{
+ MarkIntrinsicISizesDirty();
+}
+
+/* virtual */
+BasicTableLayoutStrategy::~BasicTableLayoutStrategy()
+{
+}
+
+/* virtual */ nscoord
+BasicTableLayoutStrategy::GetMinISize(nsRenderingContext* aRenderingContext)
+{
+ DISPLAY_MIN_WIDTH(mTableFrame, mMinISize);
+ if (mMinISize == NS_INTRINSIC_WIDTH_UNKNOWN) {
+ ComputeIntrinsicISizes(aRenderingContext);
+ }
+ return mMinISize;
+}
+
+/* virtual */ nscoord
+BasicTableLayoutStrategy::GetPrefISize(nsRenderingContext* aRenderingContext,
+ bool aComputingSize)
+{
+ DISPLAY_PREF_WIDTH(mTableFrame, mPrefISize);
+ NS_ASSERTION((mPrefISize == NS_INTRINSIC_WIDTH_UNKNOWN) ==
+ (mPrefISizePctExpand == NS_INTRINSIC_WIDTH_UNKNOWN),
+ "dirtyness out of sync");
+ if (mPrefISize == NS_INTRINSIC_WIDTH_UNKNOWN) {
+ ComputeIntrinsicISizes(aRenderingContext);
+ }
+ return aComputingSize ? mPrefISizePctExpand : mPrefISize;
+}
+
+struct CellISizeInfo {
+ CellISizeInfo(nscoord aMinCoord, nscoord aPrefCoord,
+ float aPrefPercent, bool aHasSpecifiedISize)
+ : hasSpecifiedISize(aHasSpecifiedISize)
+ , minCoord(aMinCoord)
+ , prefCoord(aPrefCoord)
+ , prefPercent(aPrefPercent)
+ {
+ }
+
+ bool hasSpecifiedISize;
+ nscoord minCoord;
+ nscoord prefCoord;
+ float prefPercent;
+};
+
+// Used for both column and cell calculations. The parts needed only
+// for cells are skipped when aIsCell is false.
+static CellISizeInfo
+GetISizeInfo(nsRenderingContext *aRenderingContext,
+ nsIFrame *aFrame, WritingMode aWM, bool aIsCell)
+{
+ nscoord minCoord, prefCoord;
+ const nsStylePosition *stylePos = aFrame->StylePosition();
+ bool isQuirks = aFrame->PresContext()->CompatibilityMode() ==
+ eCompatibility_NavQuirks;
+ nscoord boxSizingToBorderEdge = 0;
+ if (aIsCell) {
+ // If aFrame is a container for font size inflation, then shrink
+ // wrapping inside of it should not apply font size inflation.
+ AutoMaybeDisableFontInflation an(aFrame);
+
+ minCoord = aFrame->GetMinISize(aRenderingContext);
+ prefCoord = aFrame->GetPrefISize(aRenderingContext);
+ // Until almost the end of this function, minCoord and prefCoord
+ // represent the box-sizing based isize values (which mean they
+ // should include inline padding and border width when
+ // box-sizing is set to border-box).
+ // Note that this function returns border-box isize, we add the
+ // outer edges near the end of this function.
+
+ // XXX Should we ignore percentage padding?
+ nsIFrame::IntrinsicISizeOffsetData offsets =
+ aFrame->IntrinsicISizeOffsets();
+
+ // In quirks mode, table cell isize should be content-box,
+ // but bsize should be border box.
+ // Because of this historic anomaly, we do not use quirk.css.
+ // (We can't specify one value of box-sizing for isize and another
+ // for bsize).
+ // For this reason, we also do not use box-sizing for just one of
+ // them, as this may be confusing.
+ if (isQuirks || stylePos->mBoxSizing == StyleBoxSizing::Content) {
+ boxSizingToBorderEdge = offsets.hPadding + offsets.hBorder;
+ }
+ else {
+ // StyleBoxSizing::Border and standards-mode
+ minCoord += offsets.hPadding + offsets.hBorder;
+ prefCoord += offsets.hPadding + offsets.hBorder;
+ }
+ } else {
+ minCoord = 0;
+ prefCoord = 0;
+ }
+ float prefPercent = 0.0f;
+ bool hasSpecifiedISize = false;
+
+ const nsStyleCoord& iSize = stylePos->ISize(aWM);
+ nsStyleUnit unit = iSize.GetUnit();
+ // NOTE: We're ignoring calc() units with percentages here, for lack of a
+ // sensible idea for what to do with them. This means calc() with
+ // percentages is basically handled like 'auto' for table cells and
+ // columns.
+ if (iSize.ConvertsToLength()) {
+ hasSpecifiedISize = true;
+ // Note: since ComputeISizeValue was designed to return content-box
+ // isize, it will (in some cases) subtract the box-sizing edges.
+ // We prevent this unwanted behavior by calling it with
+ // aContentEdgeToBoxSizing and aBoxSizingToMarginEdge set to 0.
+ nscoord c = aFrame->ComputeISizeValue(aRenderingContext, 0, 0, 0, iSize);
+ // Quirk: A cell with "nowrap" set and a coord value for the
+ // isize which is bigger than the intrinsic minimum isize uses
+ // that coord value as the minimum isize.
+ // This is kept up-to-date with dynamic changes to nowrap by code in
+ // nsTableCellFrame::AttributeChanged
+ if (aIsCell && c > minCoord && isQuirks &&
+ aFrame->GetContent()->HasAttr(kNameSpaceID_None,
+ nsGkAtoms::nowrap)) {
+ minCoord = c;
+ }
+ prefCoord = std::max(c, minCoord);
+ } else if (unit == eStyleUnit_Percent) {
+ prefPercent = iSize.GetPercentValue();
+ } else if (unit == eStyleUnit_Enumerated && aIsCell) {
+ switch (iSize.GetIntValue()) {
+ case NS_STYLE_WIDTH_MAX_CONTENT:
+ // 'inline-size' only affects pref isize, not min
+ // isize, so don't change anything
+ break;
+ case NS_STYLE_WIDTH_MIN_CONTENT:
+ prefCoord = minCoord;
+ break;
+ case NS_STYLE_WIDTH_FIT_CONTENT:
+ case NS_STYLE_WIDTH_AVAILABLE:
+ // act just like 'inline-size: auto'
+ break;
+ default:
+ NS_NOTREACHED("unexpected enumerated value");
+ }
+ }
+
+ nsStyleCoord maxISize(stylePos->MaxISize(aWM));
+ if (maxISize.GetUnit() == eStyleUnit_Enumerated) {
+ if (!aIsCell || maxISize.GetIntValue() == NS_STYLE_WIDTH_AVAILABLE) {
+ maxISize.SetNoneValue();
+ } else if (maxISize.GetIntValue() == NS_STYLE_WIDTH_FIT_CONTENT) {
+ // for 'max-inline-size', '-moz-fit-content' is like
+ // '-moz-max-content'
+ maxISize.SetIntValue(NS_STYLE_WIDTH_MAX_CONTENT,
+ eStyleUnit_Enumerated);
+ }
+ }
+ unit = maxISize.GetUnit();
+ // XXX To really implement 'max-inline-size' well, we'd need to store
+ // it separately on the columns.
+ if (maxISize.ConvertsToLength() || unit == eStyleUnit_Enumerated) {
+ nscoord c = aFrame->ComputeISizeValue(aRenderingContext,
+ 0, 0, 0, maxISize);
+ minCoord = std::min(c, minCoord);
+ prefCoord = std::min(c, prefCoord);
+ } else if (unit == eStyleUnit_Percent) {
+ float p = stylePos->MaxISize(aWM).GetPercentValue();
+ if (p < prefPercent) {
+ prefPercent = p;
+ }
+ }
+ // treat calc() with percentages on max-inline-size just like 'none'.
+
+ nsStyleCoord minISize(stylePos->MinISize(aWM));
+ if (minISize.GetUnit() == eStyleUnit_Enumerated) {
+ if (!aIsCell || minISize.GetIntValue() == NS_STYLE_WIDTH_AVAILABLE) {
+ minISize.SetCoordValue(0);
+ } else if (minISize.GetIntValue() == NS_STYLE_WIDTH_FIT_CONTENT) {
+ // for 'min-inline-size', '-moz-fit-content' is like
+ // '-moz-min-content'
+ minISize.SetIntValue(NS_STYLE_WIDTH_MIN_CONTENT,
+ eStyleUnit_Enumerated);
+ }
+ }
+ unit = minISize.GetUnit();
+ if (minISize.ConvertsToLength() || unit == eStyleUnit_Enumerated) {
+ nscoord c = aFrame->ComputeISizeValue(aRenderingContext,
+ 0, 0, 0, minISize);
+ minCoord = std::max(c, minCoord);
+ prefCoord = std::max(c, prefCoord);
+ } else if (unit == eStyleUnit_Percent) {
+ float p = stylePos->MinISize(aWM).GetPercentValue();
+ if (p > prefPercent) {
+ prefPercent = p;
+ }
+ }
+ // treat calc() with percentages on min-inline-size just like '0'.
+
+ // XXX Should col frame have border/padding considered?
+ if (aIsCell) {
+ minCoord += boxSizingToBorderEdge;
+ prefCoord = NSCoordSaturatingAdd(prefCoord, boxSizingToBorderEdge);
+ }
+
+ return CellISizeInfo(minCoord, prefCoord, prefPercent, hasSpecifiedISize);
+}
+
+static inline CellISizeInfo
+GetCellISizeInfo(nsRenderingContext *aRenderingContext,
+ nsTableCellFrame *aCellFrame, WritingMode aWM)
+{
+ return GetISizeInfo(aRenderingContext, aCellFrame, aWM, true);
+}
+
+static inline CellISizeInfo
+GetColISizeInfo(nsRenderingContext *aRenderingContext,
+ nsIFrame *aFrame, WritingMode aWM)
+{
+ return GetISizeInfo(aRenderingContext, aFrame, aWM, false);
+}
+
+
+/**
+ * The algorithm in this function, in addition to meeting the
+ * requirements of Web-compatibility, is also invariant under reordering
+ * of the rows within a table (something that most, but not all, other
+ * browsers are).
+ */
+void
+BasicTableLayoutStrategy::ComputeColumnIntrinsicISizes(nsRenderingContext* aRenderingContext)
+{
+ nsTableFrame *tableFrame = mTableFrame;
+ nsTableCellMap *cellMap = tableFrame->GetCellMap();
+ WritingMode wm = tableFrame->GetWritingMode();
+
+ mozilla::AutoStackArena arena;
+ SpanningCellSorter spanningCells;
+
+ // Loop over the columns to consider the columns and cells *without*
+ // a colspan.
+ int32_t col, col_end;
+ for (col = 0, col_end = cellMap->GetColCount(); col < col_end; ++col) {
+ nsTableColFrame *colFrame = tableFrame->GetColFrame(col);
+ if (!colFrame) {
+ NS_ERROR("column frames out of sync with cell map");
+ continue;
+ }
+ colFrame->ResetIntrinsics();
+ colFrame->ResetSpanIntrinsics();
+
+ // Consider the isizes on the column.
+ CellISizeInfo colInfo = GetColISizeInfo(aRenderingContext,
+ colFrame, wm);
+ colFrame->AddCoords(colInfo.minCoord, colInfo.prefCoord,
+ colInfo.hasSpecifiedISize);
+ colFrame->AddPrefPercent(colInfo.prefPercent);
+
+ // Consider the isizes on the column-group. Note that we follow
+ // what the HTML spec says here, and make the isize apply to
+ // each column in the group, not the group as a whole.
+
+ // If column has isize, column-group doesn't override isize.
+ if (colInfo.minCoord == 0 && colInfo.prefCoord == 0 &&
+ colInfo.prefPercent == 0.0f) {
+ NS_ASSERTION(colFrame->GetParent()->GetType() ==
+ nsGkAtoms::tableColGroupFrame,
+ "expected a column-group");
+ colInfo = GetColISizeInfo(aRenderingContext,
+ colFrame->GetParent(), wm);
+ colFrame->AddCoords(colInfo.minCoord, colInfo.prefCoord,
+ colInfo.hasSpecifiedISize);
+ colFrame->AddPrefPercent(colInfo.prefPercent);
+ }
+
+ // Consider the contents of and the isizes on the cells without
+ // colspans.
+ nsCellMapColumnIterator columnIter(cellMap, col);
+ int32_t row, colSpan;
+ nsTableCellFrame* cellFrame;
+ while ((cellFrame = columnIter.GetNextFrame(&row, &colSpan))) {
+ if (colSpan > 1) {
+ spanningCells.AddCell(colSpan, row, col);
+ continue;
+ }
+
+ CellISizeInfo info = GetCellISizeInfo(aRenderingContext,
+ cellFrame, wm);
+
+ colFrame->AddCoords(info.minCoord, info.prefCoord,
+ info.hasSpecifiedISize);
+ colFrame->AddPrefPercent(info.prefPercent);
+ }
+#ifdef DEBUG_dbaron_off
+ printf("table %p col %d nonspan: min=%d pref=%d spec=%d pct=%f\n",
+ mTableFrame, col, colFrame->GetMinCoord(),
+ colFrame->GetPrefCoord(), colFrame->GetHasSpecifiedCoord(),
+ colFrame->GetPrefPercent());
+#endif
+ }
+#ifdef DEBUG_TABLE_STRATEGY
+ printf("ComputeColumnIntrinsicISizes single\n");
+ mTableFrame->Dump(false, true, false);
+#endif
+
+ // Consider the cells with a colspan that we saved in the loop above
+ // into the spanning cell sorter. We consider these cells by seeing
+ // if they require adding to the isizes resulting only from cells
+ // with a smaller colspan, and therefore we must process them sorted
+ // in increasing order by colspan. For each colspan group, we
+ // accumulate new values to accumulate in the column frame's Span*
+ // members.
+ //
+ // Considering things only relative to the isizes resulting from
+ // cells with smaller colspans (rather than incrementally including
+ // the results from spanning cells, or doing spanning and
+ // non-spanning cells in a single pass) means that layout remains
+ // row-order-invariant and (except for percentage isizes that add to
+ // more than 100%) column-order invariant.
+ //
+ // Starting with smaller colspans makes it more likely that we
+ // satisfy all the constraints given and don't distribute space to
+ // columns where we don't need it.
+ SpanningCellSorter::Item *item;
+ int32_t colSpan;
+ while ((item = spanningCells.GetNext(&colSpan))) {
+ NS_ASSERTION(colSpan > 1,
+ "cell should not have been put in spanning cell sorter");
+ do {
+ int32_t row = item->row;
+ col = item->col;
+ CellData *cellData = cellMap->GetDataAt(row, col);
+ NS_ASSERTION(cellData && cellData->IsOrig(),
+ "bogus result from spanning cell sorter");
+
+ nsTableCellFrame *cellFrame = cellData->GetCellFrame();
+ NS_ASSERTION(cellFrame, "bogus result from spanning cell sorter");
+
+ CellISizeInfo info =
+ GetCellISizeInfo(aRenderingContext, cellFrame, wm);
+
+ if (info.prefPercent > 0.0f) {
+ DistributePctISizeToColumns(info.prefPercent,
+ col, colSpan);
+ }
+ DistributeISizeToColumns(info.minCoord, col, colSpan,
+ BTLS_MIN_ISIZE, info.hasSpecifiedISize);
+ DistributeISizeToColumns(info.prefCoord, col, colSpan,
+ BTLS_PREF_ISIZE, info.hasSpecifiedISize);
+ } while ((item = item->next));
+
+ // Combine the results of the span analysis into the main results,
+ // for each increment of colspan.
+
+ for (col = 0, col_end = cellMap->GetColCount(); col < col_end; ++col) {
+ nsTableColFrame *colFrame = tableFrame->GetColFrame(col);
+ if (!colFrame) {
+ NS_ERROR("column frames out of sync with cell map");
+ continue;
+ }
+
+ colFrame->AccumulateSpanIntrinsics();
+ colFrame->ResetSpanIntrinsics();
+
+#ifdef DEBUG_dbaron_off
+ printf("table %p col %d span %d: min=%d pref=%d spec=%d pct=%f\n",
+ mTableFrame, col, colSpan, colFrame->GetMinCoord(),
+ colFrame->GetPrefCoord(), colFrame->GetHasSpecifiedCoord(),
+ colFrame->GetPrefPercent());
+#endif
+ }
+ }
+
+ // Prevent percentages from adding to more than 100% by (to be
+ // compatible with other browsers) treating any percentages that would
+ // increase the total percentage to more than 100% as the number that
+ // would increase it to only 100% (which is 0% if we've already hit
+ // 100%). This means layout depends on the order of columns.
+ float pct_used = 0.0f;
+ for (col = 0, col_end = cellMap->GetColCount(); col < col_end; ++col) {
+ nsTableColFrame *colFrame = tableFrame->GetColFrame(col);
+ if (!colFrame) {
+ NS_ERROR("column frames out of sync with cell map");
+ continue;
+ }
+
+ colFrame->AdjustPrefPercent(&pct_used);
+ }
+
+#ifdef DEBUG_TABLE_STRATEGY
+ printf("ComputeColumnIntrinsicISizes spanning\n");
+ mTableFrame->Dump(false, true, false);
+#endif
+}
+
+void
+BasicTableLayoutStrategy::ComputeIntrinsicISizes(nsRenderingContext* aRenderingContext)
+{
+ ComputeColumnIntrinsicISizes(aRenderingContext);
+
+ nsTableCellMap *cellMap = mTableFrame->GetCellMap();
+ nscoord min = 0, pref = 0, max_small_pct_pref = 0, nonpct_pref_total = 0;
+ float pct_total = 0.0f; // always from 0.0f - 1.0f
+ int32_t colCount = cellMap->GetColCount();
+ // add a total of (colcount + 1) lots of cellSpacingX for columns where a
+ // cell originates
+ nscoord add = mTableFrame->GetColSpacing(colCount);
+
+ for (int32_t col = 0; col < colCount; ++col) {
+ nsTableColFrame *colFrame = mTableFrame->GetColFrame(col);
+ if (!colFrame) {
+ NS_ERROR("column frames out of sync with cell map");
+ continue;
+ }
+ if (mTableFrame->ColumnHasCellSpacingBefore(col)) {
+ add += mTableFrame->GetColSpacing(col - 1);
+ }
+ min += colFrame->GetMinCoord();
+ pref = NSCoordSaturatingAdd(pref, colFrame->GetPrefCoord());
+
+ // Percentages are of the table, so we have to reverse them for
+ // intrinsic isizes.
+ float p = colFrame->GetPrefPercent();
+ if (p > 0.0f) {
+ nscoord colPref = colFrame->GetPrefCoord();
+ nscoord new_small_pct_expand =
+ (colPref == nscoord_MAX ?
+ nscoord_MAX : nscoord(float(colPref) / p));
+ if (new_small_pct_expand > max_small_pct_pref) {
+ max_small_pct_pref = new_small_pct_expand;
+ }
+ pct_total += p;
+ } else {
+ nonpct_pref_total = NSCoordSaturatingAdd(nonpct_pref_total,
+ colFrame->GetPrefCoord());
+ }
+ }
+
+ nscoord pref_pct_expand = pref;
+
+ // Account for small percentages expanding the preferred isize of
+ // *other* columns.
+ if (max_small_pct_pref > pref_pct_expand) {
+ pref_pct_expand = max_small_pct_pref;
+ }
+
+ // Account for large percentages expanding the preferred isize of
+ // themselves. There's no need to iterate over the columns multiple
+ // times, since when there is such a need, the small percentage
+ // effect is bigger anyway. (I think!)
+ NS_ASSERTION(0.0f <= pct_total && pct_total <= 1.0f,
+ "column percentage inline-sizes not adjusted down to 100%");
+ if (pct_total == 1.0f) {
+ if (nonpct_pref_total > 0) {
+ pref_pct_expand = nscoord_MAX;
+ // XXX Or should I use some smaller value? (Test this using
+ // nested tables!)
+ }
+ } else {
+ nscoord large_pct_pref =
+ (nonpct_pref_total == nscoord_MAX ?
+ nscoord_MAX :
+ nscoord(float(nonpct_pref_total) / (1.0f - pct_total)));
+ if (large_pct_pref > pref_pct_expand)
+ pref_pct_expand = large_pct_pref;
+ }
+
+ // border-spacing isn't part of the basis for percentages
+ if (colCount > 0) {
+ min += add;
+ pref = NSCoordSaturatingAdd(pref, add);
+ pref_pct_expand = NSCoordSaturatingAdd(pref_pct_expand, add);
+ }
+
+ mMinISize = min;
+ mPrefISize = pref;
+ mPrefISizePctExpand = pref_pct_expand;
+}
+
+/* virtual */ void
+BasicTableLayoutStrategy::MarkIntrinsicISizesDirty()
+{
+ mMinISize = NS_INTRINSIC_WIDTH_UNKNOWN;
+ mPrefISize = NS_INTRINSIC_WIDTH_UNKNOWN;
+ mPrefISizePctExpand = NS_INTRINSIC_WIDTH_UNKNOWN;
+ mLastCalcISize = nscoord_MIN;
+}
+
+/* virtual */ void
+BasicTableLayoutStrategy::ComputeColumnISizes(const ReflowInput& aReflowInput)
+{
+ nscoord iSize = aReflowInput.ComputedISize();
+
+ if (mLastCalcISize == iSize) {
+ return;
+ }
+ mLastCalcISize = iSize;
+
+ NS_ASSERTION((mMinISize == NS_INTRINSIC_WIDTH_UNKNOWN) ==
+ (mPrefISize == NS_INTRINSIC_WIDTH_UNKNOWN),
+ "dirtyness out of sync");
+ NS_ASSERTION((mMinISize == NS_INTRINSIC_WIDTH_UNKNOWN) ==
+ (mPrefISizePctExpand == NS_INTRINSIC_WIDTH_UNKNOWN),
+ "dirtyness out of sync");
+ // XXX Is this needed?
+ if (mMinISize == NS_INTRINSIC_WIDTH_UNKNOWN) {
+ ComputeIntrinsicISizes(aReflowInput.mRenderingContext);
+ }
+
+ nsTableCellMap *cellMap = mTableFrame->GetCellMap();
+ int32_t colCount = cellMap->GetColCount();
+ if (colCount <= 0)
+ return; // nothing to do
+
+ DistributeISizeToColumns(iSize, 0, colCount, BTLS_FINAL_ISIZE, false);
+
+#ifdef DEBUG_TABLE_STRATEGY
+ printf("ComputeColumnISizes final\n");
+ mTableFrame->Dump(false, true, false);
+#endif
+}
+
+void
+BasicTableLayoutStrategy::DistributePctISizeToColumns(float aSpanPrefPct,
+ int32_t aFirstCol,
+ int32_t aColCount)
+{
+ // First loop to determine:
+ int32_t nonPctColCount = 0; // number of spanned columns without % isize
+ nscoord nonPctTotalPrefISize = 0; // total pref isize of those columns
+ // and to reduce aSpanPrefPct by columns that already have % isize
+
+ int32_t scol, scol_end;
+ nsTableCellMap *cellMap = mTableFrame->GetCellMap();
+ for (scol = aFirstCol, scol_end = aFirstCol + aColCount;
+ scol < scol_end; ++scol) {
+ nsTableColFrame *scolFrame = mTableFrame->GetColFrame(scol);
+ if (!scolFrame) {
+ NS_ERROR("column frames out of sync with cell map");
+ continue;
+ }
+ float scolPct = scolFrame->GetPrefPercent();
+ if (scolPct == 0.0f) {
+ nonPctTotalPrefISize += scolFrame->GetPrefCoord();
+ if (cellMap->GetNumCellsOriginatingInCol(scol) > 0) {
+ ++nonPctColCount;
+ }
+ } else {
+ aSpanPrefPct -= scolPct;
+ }
+ }
+
+ if (aSpanPrefPct <= 0.0f || nonPctColCount == 0) {
+ // There's no %-isize on the colspan left over to distribute,
+ // or there are no columns to which we could distribute %-isize
+ return;
+ }
+
+ // Second loop, to distribute what remains of aSpanPrefPct
+ // between the non-percent-isize spanned columns
+ const bool spanHasNonPctPref = nonPctTotalPrefISize > 0; // Loop invariant
+ for (scol = aFirstCol, scol_end = aFirstCol + aColCount;
+ scol < scol_end; ++scol) {
+ nsTableColFrame *scolFrame = mTableFrame->GetColFrame(scol);
+ if (!scolFrame) {
+ NS_ERROR("column frames out of sync with cell map");
+ continue;
+ }
+
+ if (scolFrame->GetPrefPercent() == 0.0f) {
+ NS_ASSERTION((!spanHasNonPctPref ||
+ nonPctTotalPrefISize != 0) &&
+ nonPctColCount != 0,
+ "should not be zero if we haven't allocated "
+ "all pref percent");
+
+ float allocatedPct; // % isize to be given to this column
+ if (spanHasNonPctPref) {
+ // Group so we're multiplying by 1.0f when we need
+ // to use up aSpanPrefPct.
+ allocatedPct = aSpanPrefPct *
+ (float(scolFrame->GetPrefCoord()) /
+ float(nonPctTotalPrefISize));
+ } else if (cellMap->GetNumCellsOriginatingInCol(scol) > 0) {
+ // distribute equally when all pref isizes are 0
+ allocatedPct = aSpanPrefPct / float(nonPctColCount);
+ } else {
+ allocatedPct = 0.0f;
+ }
+ // Allocate the percent
+ scolFrame->AddSpanPrefPercent(allocatedPct);
+
+ // To avoid accumulating rounding error from division,
+ // subtract this column's values from the totals.
+ aSpanPrefPct -= allocatedPct;
+ nonPctTotalPrefISize -= scolFrame->GetPrefCoord();
+ if (cellMap->GetNumCellsOriginatingInCol(scol) > 0) {
+ --nonPctColCount;
+ }
+
+ if (!aSpanPrefPct) {
+ // No more span-percent-isize to distribute --> we're done.
+ NS_ASSERTION(spanHasNonPctPref ?
+ nonPctTotalPrefISize == 0 :
+ nonPctColCount == 0,
+ "No more pct inline-size to distribute, "
+ "but there are still cols that need some.");
+ return;
+ }
+ }
+ }
+}
+
+void
+BasicTableLayoutStrategy::DistributeISizeToColumns(nscoord aISize,
+ int32_t aFirstCol,
+ int32_t aColCount,
+ BtlsISizeType aISizeType,
+ bool aSpanHasSpecifiedISize)
+{
+ NS_ASSERTION(aISizeType != BTLS_FINAL_ISIZE ||
+ (aFirstCol == 0 &&
+ aColCount == mTableFrame->GetCellMap()->GetColCount()),
+ "Computing final column isizes, but didn't get full column range");
+
+ nscoord subtract = 0;
+ // aISize initially includes border-spacing for the boundaries in between
+ // each of the columns. We start at aFirstCol + 1 because the first
+ // in-between boundary would be at the left edge of column aFirstCol + 1
+ for (int32_t col = aFirstCol + 1; col < aFirstCol + aColCount; ++col) {
+ if (mTableFrame->ColumnHasCellSpacingBefore(col)) {
+ // border-spacing isn't part of the basis for percentages.
+ subtract += mTableFrame->GetColSpacing(col - 1);
+ }
+ }
+ if (aISizeType == BTLS_FINAL_ISIZE) {
+ // If we're computing final col-isize, then aISize initially includes
+ // border spacing on the table's far istart + far iend edge, too. Need
+ // to subtract those out, too.
+ subtract += (mTableFrame->GetColSpacing(-1) +
+ mTableFrame->GetColSpacing(aColCount));
+ }
+ aISize = NSCoordSaturatingSubtract(aISize, subtract, nscoord_MAX);
+
+ /*
+ * The goal of this function is to distribute |aISize| between the
+ * columns by making an appropriate AddSpanCoords or SetFinalISize
+ * call for each column. (We call AddSpanCoords if we're
+ * distributing a column-spanning cell's minimum or preferred isize
+ * to its spanned columns. We call SetFinalISize if we're
+ * distributing a table's final isize to its columns.)
+ *
+ * The idea is to either assign one of the following sets of isizes
+ * or a weighted average of two adjacent sets of isizes. It is not
+ * possible to assign values smaller than the smallest set of
+ * isizes. However, see below for handling the case of assigning
+ * values larger than the largest set of isizes. From smallest to
+ * largest, these are:
+ *
+ * 1. [guess_min] Assign all columns their min isize.
+ *
+ * 2. [guess_min_pct] Assign all columns with percentage isizes
+ * their percentage isize, and all other columns their min isize.
+ *
+ * 3. [guess_min_spec] Assign all columns with percentage isizes
+ * their percentage isize, all columns with specified coordinate
+ * isizes their pref isize (since it doesn't matter whether it's the
+ * largest contributor to the pref isize that was the specified
+ * contributor), and all other columns their min isize.
+ *
+ * 4. [guess_pref] Assign all columns with percentage isizes their
+ * specified isize, and all other columns their pref isize.
+ *
+ * If |aISize| is *larger* than what we would assign in (4), then we
+ * expand the columns:
+ *
+ * a. if any columns without a specified coordinate isize or
+ * percent isize have nonzero pref isize, in proportion to pref
+ * isize [total_flex_pref]
+ *
+ * b. otherwise, if any columns without a specified coordinate
+ * isize or percent isize, but with cells originating in them,
+ * have zero pref isize, equally between these
+ * [numNonSpecZeroISizeCols]
+ *
+ * c. otherwise, if any columns without percent isize have nonzero
+ * pref isize, in proportion to pref isize [total_fixed_pref]
+ *
+ * d. otherwise, if any columns have nonzero percentage isizes, in
+ * proportion to the percentage isizes [total_pct]
+ *
+ * e. otherwise, equally.
+ */
+
+ // Loop #1 over the columns, to figure out the four values above so
+ // we know which case we're dealing with.
+
+ nscoord guess_min = 0,
+ guess_min_pct = 0,
+ guess_min_spec = 0,
+ guess_pref = 0,
+ total_flex_pref = 0,
+ total_fixed_pref = 0;
+ float total_pct = 0.0f; // 0.0f to 1.0f
+ int32_t numInfiniteISizeCols = 0;
+ int32_t numNonSpecZeroISizeCols = 0;
+
+ int32_t col;
+ nsTableCellMap *cellMap = mTableFrame->GetCellMap();
+ for (col = aFirstCol; col < aFirstCol + aColCount; ++col) {
+ nsTableColFrame *colFrame = mTableFrame->GetColFrame(col);
+ if (!colFrame) {
+ NS_ERROR("column frames out of sync with cell map");
+ continue;
+ }
+ nscoord min_iSize = colFrame->GetMinCoord();
+ guess_min += min_iSize;
+ if (colFrame->GetPrefPercent() != 0.0f) {
+ float pct = colFrame->GetPrefPercent();
+ total_pct += pct;
+ nscoord val = nscoord(float(aISize) * pct);
+ if (val < min_iSize) {
+ val = min_iSize;
+ }
+ guess_min_pct += val;
+ guess_pref = NSCoordSaturatingAdd(guess_pref, val);
+ } else {
+ nscoord pref_iSize = colFrame->GetPrefCoord();
+ if (pref_iSize == nscoord_MAX) {
+ ++numInfiniteISizeCols;
+ }
+ guess_pref = NSCoordSaturatingAdd(guess_pref, pref_iSize);
+ guess_min_pct += min_iSize;
+ if (colFrame->GetHasSpecifiedCoord()) {
+ // we'll add on the rest of guess_min_spec outside the
+ // loop
+ nscoord delta = NSCoordSaturatingSubtract(pref_iSize,
+ min_iSize, 0);
+ guess_min_spec = NSCoordSaturatingAdd(guess_min_spec, delta);
+ total_fixed_pref = NSCoordSaturatingAdd(total_fixed_pref,
+ pref_iSize);
+ } else if (pref_iSize == 0) {
+ if (cellMap->GetNumCellsOriginatingInCol(col) > 0) {
+ ++numNonSpecZeroISizeCols;
+ }
+ } else {
+ total_flex_pref = NSCoordSaturatingAdd(total_flex_pref,
+ pref_iSize);
+ }
+ }
+ }
+ guess_min_spec = NSCoordSaturatingAdd(guess_min_spec, guess_min_pct);
+
+ // Determine what we're flexing:
+ enum Loop2Type {
+ FLEX_PCT_SMALL, // between (1) and (2) above
+ FLEX_FIXED_SMALL, // between (2) and (3) above
+ FLEX_FLEX_SMALL, // between (3) and (4) above
+ FLEX_FLEX_LARGE, // greater than (4) above, case (a)
+ FLEX_FLEX_LARGE_ZERO, // greater than (4) above, case (b)
+ FLEX_FIXED_LARGE, // greater than (4) above, case (c)
+ FLEX_PCT_LARGE, // greater than (4) above, case (d)
+ FLEX_ALL_LARGE // greater than (4) above, case (e)
+ };
+
+ Loop2Type l2t;
+ // These are constants (over columns) for each case's math. We use
+ // a pair of nscoords rather than a float so that we can subtract
+ // each column's allocation so we avoid accumulating rounding error.
+ nscoord space; // the amount of extra isize to allocate
+ union {
+ nscoord c;
+ float f;
+ } basis; // the sum of the statistic over columns to divide it
+ if (aISize < guess_pref) {
+ if (aISizeType != BTLS_FINAL_ISIZE && aISize <= guess_min) {
+ // Return early -- we don't have any extra space to distribute.
+ return;
+ }
+ NS_ASSERTION(!(aISizeType == BTLS_FINAL_ISIZE && aISize < guess_min),
+ "Table inline-size is less than the "
+ "sum of its columns' min inline-sizes");
+ if (aISize < guess_min_pct) {
+ l2t = FLEX_PCT_SMALL;
+ space = aISize - guess_min;
+ basis.c = guess_min_pct - guess_min;
+ } else if (aISize < guess_min_spec) {
+ l2t = FLEX_FIXED_SMALL;
+ space = aISize - guess_min_pct;
+ basis.c = NSCoordSaturatingSubtract(guess_min_spec, guess_min_pct,
+ nscoord_MAX);
+ } else {
+ l2t = FLEX_FLEX_SMALL;
+ space = aISize - guess_min_spec;
+ basis.c = NSCoordSaturatingSubtract(guess_pref, guess_min_spec,
+ nscoord_MAX);
+ }
+ } else {
+ space = NSCoordSaturatingSubtract(aISize, guess_pref, nscoord_MAX);
+ if (total_flex_pref > 0) {
+ l2t = FLEX_FLEX_LARGE;
+ basis.c = total_flex_pref;
+ } else if (numNonSpecZeroISizeCols > 0) {
+ l2t = FLEX_FLEX_LARGE_ZERO;
+ basis.c = numNonSpecZeroISizeCols;
+ } else if (total_fixed_pref > 0) {
+ l2t = FLEX_FIXED_LARGE;
+ basis.c = total_fixed_pref;
+ } else if (total_pct > 0.0f) {
+ l2t = FLEX_PCT_LARGE;
+ basis.f = total_pct;
+ } else {
+ l2t = FLEX_ALL_LARGE;
+ basis.c = aColCount;
+ }
+ }
+
+#ifdef DEBUG_dbaron_off
+ printf("ComputeColumnISizes: %d columns in isize %d,\n"
+ " guesses=[%d,%d,%d,%d], totals=[%d,%d,%f],\n"
+ " l2t=%d, space=%d, basis.c=%d\n",
+ aColCount, aISize,
+ guess_min, guess_min_pct, guess_min_spec, guess_pref,
+ total_flex_pref, total_fixed_pref, total_pct,
+ l2t, space, basis.c);
+#endif
+
+ for (col = aFirstCol; col < aFirstCol + aColCount; ++col) {
+ nsTableColFrame *colFrame = mTableFrame->GetColFrame(col);
+ if (!colFrame) {
+ NS_ERROR("column frames out of sync with cell map");
+ continue;
+ }
+ nscoord col_iSize;
+
+ float pct = colFrame->GetPrefPercent();
+ if (pct != 0.0f) {
+ col_iSize = nscoord(float(aISize) * pct);
+ nscoord col_min = colFrame->GetMinCoord();
+ if (col_iSize < col_min) {
+ col_iSize = col_min;
+ }
+ } else {
+ col_iSize = colFrame->GetPrefCoord();
+ }
+
+ nscoord col_iSize_before_adjust = col_iSize;
+
+ switch (l2t) {
+ case FLEX_PCT_SMALL:
+ col_iSize = col_iSize_before_adjust = colFrame->GetMinCoord();
+ if (pct != 0.0f) {
+ nscoord pct_minus_min =
+ nscoord(float(aISize) * pct) - col_iSize;
+ if (pct_minus_min > 0) {
+ float c = float(space) / float(basis.c);
+ basis.c -= pct_minus_min;
+ col_iSize += NSToCoordRound(float(pct_minus_min) * c);
+ }
+ }
+ break;
+ case FLEX_FIXED_SMALL:
+ if (pct == 0.0f) {
+ NS_ASSERTION(col_iSize == colFrame->GetPrefCoord(),
+ "wrong inline-size assigned");
+ if (colFrame->GetHasSpecifiedCoord()) {
+ nscoord col_min = colFrame->GetMinCoord();
+ nscoord pref_minus_min = col_iSize - col_min;
+ col_iSize = col_iSize_before_adjust = col_min;
+ if (pref_minus_min != 0) {
+ float c = float(space) / float(basis.c);
+ basis.c -= pref_minus_min;
+ col_iSize += NSToCoordRound(
+ float(pref_minus_min) * c);
+ }
+ } else
+ col_iSize = col_iSize_before_adjust =
+ colFrame->GetMinCoord();
+ }
+ break;
+ case FLEX_FLEX_SMALL:
+ if (pct == 0.0f &&
+ !colFrame->GetHasSpecifiedCoord()) {
+ NS_ASSERTION(col_iSize == colFrame->GetPrefCoord(),
+ "wrong inline-size assigned");
+ nscoord col_min = colFrame->GetMinCoord();
+ nscoord pref_minus_min =
+ NSCoordSaturatingSubtract(col_iSize, col_min, 0);
+ col_iSize = col_iSize_before_adjust = col_min;
+ if (pref_minus_min != 0) {
+ float c = float(space) / float(basis.c);
+ // If we have infinite-isize cols, then the standard
+ // adjustment to col_iSize using 'c' won't work,
+ // because basis.c and pref_minus_min are both
+ // nscoord_MAX and will cancel each other out in the
+ // col_iSize adjustment (making us assign all the
+ // space to the first inf-isize col). To correct for
+ // this, we'll also divide by numInfiniteISizeCols to
+ // spread the space equally among the inf-isize cols.
+ if (numInfiniteISizeCols) {
+ if (colFrame->GetPrefCoord() == nscoord_MAX) {
+ c = c / float(numInfiniteISizeCols);
+ --numInfiniteISizeCols;
+ } else {
+ c = 0.0f;
+ }
+ }
+ basis.c = NSCoordSaturatingSubtract(basis.c,
+ pref_minus_min,
+ nscoord_MAX);
+ col_iSize += NSToCoordRound(
+ float(pref_minus_min) * c);
+ }
+ }
+ break;
+ case FLEX_FLEX_LARGE:
+ if (pct == 0.0f &&
+ !colFrame->GetHasSpecifiedCoord()) {
+ NS_ASSERTION(col_iSize == colFrame->GetPrefCoord(),
+ "wrong inline-size assigned");
+ if (col_iSize != 0) {
+ if (space == nscoord_MAX) {
+ basis.c -= col_iSize;
+ col_iSize = nscoord_MAX;
+ } else {
+ float c = float(space) / float(basis.c);
+ basis.c -= col_iSize;
+ col_iSize += NSToCoordRound(float(col_iSize) * c);
+ }
+ }
+ }
+ break;
+ case FLEX_FLEX_LARGE_ZERO:
+ if (pct == 0.0f &&
+ !colFrame->GetHasSpecifiedCoord() &&
+ cellMap->GetNumCellsOriginatingInCol(col) > 0) {
+
+ NS_ASSERTION(col_iSize == 0 &&
+ colFrame->GetPrefCoord() == 0,
+ "Since we're in FLEX_FLEX_LARGE_ZERO case, "
+ "all auto-inline-size cols should have zero "
+ "pref inline-size.");
+ float c = float(space) / float(basis.c);
+ col_iSize += NSToCoordRound(c);
+ --basis.c;
+ }
+ break;
+ case FLEX_FIXED_LARGE:
+ if (pct == 0.0f) {
+ NS_ASSERTION(col_iSize == colFrame->GetPrefCoord(),
+ "wrong inline-size assigned");
+ NS_ASSERTION(colFrame->GetHasSpecifiedCoord() ||
+ colFrame->GetPrefCoord() == 0,
+ "wrong case");
+ if (col_iSize != 0) {
+ float c = float(space) / float(basis.c);
+ basis.c -= col_iSize;
+ col_iSize += NSToCoordRound(float(col_iSize) * c);
+ }
+ }
+ break;
+ case FLEX_PCT_LARGE:
+ NS_ASSERTION(pct != 0.0f || colFrame->GetPrefCoord() == 0,
+ "wrong case");
+ if (pct != 0.0f) {
+ float c = float(space) / basis.f;
+ col_iSize += NSToCoordRound(pct * c);
+ basis.f -= pct;
+ }
+ break;
+ case FLEX_ALL_LARGE:
+ {
+ float c = float(space) / float(basis.c);
+ col_iSize += NSToCoordRound(c);
+ --basis.c;
+ }
+ break;
+ }
+
+ // Only subtract from space if it's a real number.
+ if (space != nscoord_MAX) {
+ NS_ASSERTION(col_iSize != nscoord_MAX,
+ "How is col_iSize nscoord_MAX if space isn't?");
+ NS_ASSERTION(col_iSize_before_adjust != nscoord_MAX,
+ "How is col_iSize_before_adjust nscoord_MAX if space isn't?");
+ space -= col_iSize - col_iSize_before_adjust;
+ }
+
+ NS_ASSERTION(col_iSize >= colFrame->GetMinCoord(),
+ "assigned inline-size smaller than min");
+
+ // Apply the new isize
+ switch (aISizeType) {
+ case BTLS_MIN_ISIZE:
+ {
+ // Note: AddSpanCoords requires both a min and pref isize.
+ // For the pref isize, we'll just pass in our computed
+ // min isize, because the real pref isize will be at least
+ // as big
+ colFrame->AddSpanCoords(col_iSize, col_iSize,
+ aSpanHasSpecifiedISize);
+ }
+ break;
+ case BTLS_PREF_ISIZE:
+ {
+ // Note: AddSpanCoords requires both a min and pref isize.
+ // For the min isize, we'll just pass in 0, because
+ // the real min isize will be at least 0
+ colFrame->AddSpanCoords(0, col_iSize,
+ aSpanHasSpecifiedISize);
+ }
+ break;
+ case BTLS_FINAL_ISIZE:
+ {
+ nscoord old_final = colFrame->GetFinalISize();
+ colFrame->SetFinalISize(col_iSize);
+
+ if (old_final != col_iSize) {
+ mTableFrame->DidResizeColumns();
+ }
+ }
+ break;
+ }
+ }
+ NS_ASSERTION((space == 0 || space == nscoord_MAX) &&
+ ((l2t == FLEX_PCT_LARGE)
+ ? (-0.001f < basis.f && basis.f < 0.001f)
+ : (basis.c == 0 || basis.c == nscoord_MAX)),
+ "didn't subtract all that we added");
+}