mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 1434478 part 1 - [css-grid] Stop back-computing percentage grid gaps when the percentage basis is indefinite. Treat them as zero sized instead. r=dholbert

This commit is contained in:
Mats Palmgren 2018-04-10 00:16:57 +02:00
Родитель 0724b513f9
Коммит 004a0a318d
1 изменённых файлов: 32 добавлений и 124 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

150
layout/generic/nsGridContainerFrame.cpp
Просмотреть файл

@ -8,9 +8,9 @@
#include "nsGridContainerFrame.h"
#include <algorithm> // for std::stable_sort
#include <functional>
#include <limits>
#include <stdlib.h> // for div()
#include "gfxContext.h"
#include "mozilla/AutoRestore.h"
#include "mozilla/ComputedStyle.h"
@ -124,42 +124,6 @@ ResolveToDefiniteSize(const nsStyleCoord& aCoord, nscoord aPercentBasis)
return std::max(nscoord(0), aCoord.ComputeCoordPercentCalc(aPercentBasis));
}
static bool
GetPercentSizeParts(const nsStyleCoord& aCoord, nscoord* aLength, float* aPercent)
{
switch (aCoord.GetUnit()) {
case eStyleUnit_Percent:
*aLength = 0;
*aPercent = aCoord.GetPercentValue();
return true;
case eStyleUnit_Calc: {
nsStyleCoord::Calc* calc = aCoord.GetCalcValue();
*aLength = calc->mLength;
*aPercent = calc->mPercent;
return true;
}
default:
return false;
}
}
static void
ResolvePercentSizeParts(const nsStyleCoord& aCoord, nscoord aPercentBasis,
nscoord* aLength, float* aPercent)
{
MOZ_ASSERT(aCoord.IsCoordPercentCalcUnit());
if (aPercentBasis != NS_UNCONSTRAINEDSIZE) {
*aLength = std::max(nscoord(0),
aCoord.ComputeCoordPercentCalc(aPercentBasis));
*aPercent = 0.0f;
return;
}
if (!GetPercentSizeParts(aCoord, aLength, aPercent)) {
*aLength = aCoord.ToLength();
*aPercent = 0.0f;
}
}
// Synthesize a baseline from a border box. For an alphabetical baseline
// this is the end edge of the border box. For a central baseline it's
// the center of the border box.
@ -930,7 +894,7 @@ struct nsGridContainerFrame::TrackSizingFunctions
return 1;
}
nscoord repeatTrackSize = 0;
// Note that the repeat() track size is included in |sum| in this loop.
// Note that one repeat() track size is included in |sum| in this loop.
nscoord sum = 0;
const nscoord percentBasis = aSize;
for (uint32_t i = 0; i < numTracks; ++i) {
@ -947,54 +911,31 @@ struct nsGridContainerFrame::TrackSizingFunctions
}
nscoord trackSize = ::ResolveToDefiniteSize(*coord, percentBasis);
if (i == mRepeatAutoStart) {
if (percentBasis != NS_UNCONSTRAINEDSIZE) {
// Use a minimum 1px for the repeat() track-size.
if (trackSize < AppUnitsPerCSSPixel()) {
trackSize = AppUnitsPerCSSPixel();
}
}
repeatTrackSize = trackSize;
}
sum += trackSize;
}
nscoord gridGap;
float percentSum = 0.0f;
float gridGapPercent;
ResolvePercentSizeParts(aGridGap, percentBasis, &gridGap, &gridGapPercent);
nscoord gridGap = nsLayoutUtils::ResolveGapToLength(aGridGap, aSize);
if (numTracks > 1) {
// Add grid-gaps for all the tracks including the repeat() track.
sum += gridGap * (numTracks - 1);
percentSum = gridGapPercent * (numTracks - 1);
}
// Calculate the max number of tracks that fits without overflow.
nscoord available = maxFill != NS_UNCONSTRAINEDSIZE ? maxFill : aMinSize;
nscoord size = nsLayoutUtils::AddPercents(sum, percentSum);
if (available - size < 0) {
nscoord spaceToFill = available - sum;
if (spaceToFill <= 0) {
// "if any number of repetitions would overflow, then 1 repetition"
return 1;
}
uint32_t numRepeatTracks = 1;
bool exactFit = false;
while (true) {
sum += gridGap + repeatTrackSize;
percentSum += gridGapPercent;
nscoord newSize = nsLayoutUtils::AddPercents(sum, percentSum);
if (newSize <= size) {
// Adding more repeat-tracks won't make forward progress.
return numRepeatTracks;
}
size = newSize;
nscoord remaining = available - size;
exactFit = remaining == 0;
if (remaining >= 0) {
++numRepeatTracks;
}
if (remaining <= 0) {
break;
}
}
if (!exactFit && maxFill == NS_UNCONSTRAINEDSIZE) {
// Calculate the max number of tracks that fits without overflow.
div_t q = div(spaceToFill, repeatTrackSize + gridGap);
// The +1 here is for the one repeat track we already accounted for above.
uint32_t numRepeatTracks = q.quot + 1;
if (q.rem != 0 && maxFill == NS_UNCONSTRAINEDSIZE) {
// "Otherwise, if the grid container has a definite min size in
// the relevant axis, the number of repetitions is the largest possible
// positive integer that fulfills that minimum requirement."
@ -1639,13 +1580,6 @@ struct nsGridContainerFrame::Tracks
WritingMode aWM,
const LogicalSize& aContainerSize);
/**
* Return the intrinsic size by back-computing percentages as:
* IntrinsicSize = SumOfCoordSizes / (1 - SumOfPercentages).
*/
nscoord BackComputedIntrinsicSize(const TrackSizingFunctions& aFunctions,
const nsStyleCoord& aGridGap) const;
nscoord GridLineEdge(uint32_t aLine, GridLineSide aSide) const
{
if (MOZ_UNLIKELY(mSizes.IsEmpty())) {
@ -1949,11 +1883,10 @@ struct MOZ_STACK_CLASS nsGridContainerFrame::GridReflowInput
}
/**
* Calculate our track sizes. If the given aContentBox block-axis size is
* unconstrained, it is assigned to the resulting intrinsic block-axis size.
* Calculate our track sizes.
*/
void CalculateTrackSizes(const Grid& aGrid,
LogicalSize& aContentBox,
const LogicalSize& aContentBox,
SizingConstraint aConstraint);
/**
@ -2439,7 +2372,7 @@ struct MOZ_STACK_CLASS nsGridContainerFrame::Grid
void
nsGridContainerFrame::GridReflowInput::CalculateTrackSizes(
const Grid& aGrid,
LogicalSize& aContentBox,
const LogicalSize& aContentBox,
SizingConstraint aConstraint)
{
mCols.Initialize(mColFunctions, mGridStyle->mGridColumnGap,
@ -2457,12 +2390,6 @@ nsGridContainerFrame::GridReflowInput::CalculateTrackSizes(
mRows.CalculateSizes(*this, mGridItems, mRowFunctions,
aContentBox.BSize(mWM), &GridArea::mRows,
aConstraint);
if (aContentBox.BSize(mWM) == NS_AUTOHEIGHT) {
aContentBox.BSize(mWM) =
mRows.BackComputedIntrinsicSize(mRowFunctions, mGridStyle->mGridRowGap);
mRows.mGridGap =
::ResolveToDefiniteSize(mGridStyle->mGridRowGap, aContentBox.BSize(mWM));
}
}
/**
@ -3564,7 +3491,7 @@ nsGridContainerFrame::Tracks::Initialize(
aFunctions.MinSizingFor(i),
aFunctions.MaxSizingFor(i));
}
mGridGap = ::ResolveToDefiniteSize(aGridGap, aContentBoxSize);
mGridGap = nsLayoutUtils::ResolveGapToLength(aGridGap, aContentBoxSize);
mContentBoxSize = aContentBoxSize;
}
@ -4834,36 +4761,6 @@ nsGridContainerFrame::Tracks::AlignJustifyContent(
MOZ_ASSERT(!roundingError, "we didn't distribute all rounding error?");
}
nscoord
nsGridContainerFrame::Tracks::BackComputedIntrinsicSize(
const TrackSizingFunctions& aFunctions,
const nsStyleCoord& aGridGap) const
{
// Sum up the current sizes (where percentage tracks were treated as 'auto')
// in 'size'.
nscoord size = 0;
for (size_t i = 0, len = mSizes.Length(); i < len; ++i) {
size += mSizes[i].mBase;
}
// Add grid-gap contributions to 'size' and calculate a 'percent' sum.
float percent = 0.0f;
size_t numTracks = mSizes.Length();
if (numTracks > 1) {
const size_t gridGapCount = numTracks - 1;
nscoord gridGapLength;
float gridGapPercent;
if (::GetPercentSizeParts(aGridGap, &gridGapLength, &gridGapPercent)) {
percent = gridGapCount * gridGapPercent;
} else {
gridGapLength = aGridGap.ToLength();
}
size += gridGapCount * gridGapLength;
}
return std::max(0, nsLayoutUtils::AddPercents(size, percent));
}
void
nsGridContainerFrame::LineRange::ToPositionAndLength(
const nsTArray<TrackSize>& aTrackSizes, nscoord* aPos, nscoord* aLength) const
@ -6051,7 +5948,7 @@ nsGridContainerFrame::Reflow(nsPresContext* aPresContext,
LogicalSize computedSize(wm, computedISize, computedBSize);
nscoord consumedBSize = 0;
nscoord bSize;
nscoord bSize = 0;
if (!prevInFlow) {
Grid grid;
grid.PlaceGridItems(gridReflowInput, aReflowInput.ComputedMinSize(),
@ -6059,7 +5956,12 @@ nsGridContainerFrame::Reflow(nsPresContext* aPresContext,
gridReflowInput.CalculateTrackSizes(grid, computedSize,
SizingConstraint::eNoConstraint);
bSize = computedSize.BSize(wm);
// Note: we can't use GridLineEdge here since we haven't calculated
// the rows' mPosition yet (happens in AlignJustifyContent below).
for (const auto& sz : gridReflowInput.mRows.mSizes) {
bSize += sz.mBase;
}
bSize += gridReflowInput.mRows.SumOfGridGaps();
} else {
consumedBSize = ConsumedBSize(wm);
gridReflowInput.InitializeForContinuation(this, consumedBSize);
@ -6482,8 +6384,14 @@ nsGridContainerFrame::IntrinsicISize(gfxContext* aRenderingContext,
state.mCols.CalculateSizes(state, state.mGridItems, state.mColFunctions,
NS_UNCONSTRAINEDSIZE, &GridArea::mCols,
constraint);
return state.mCols.BackComputedIntrinsicSize(state.mColFunctions,
state.mGridStyle->mGridColumnGap);
state.mCols.mGridGap =
nsLayoutUtils::ResolveGapToLength(state.mGridStyle->mGridColumnGap,
NS_UNCONSTRAINEDSIZE);
nscoord length = 0;
for (const TrackSize& sz : state.mCols.mSizes) {
length += sz.mBase;
}
return length + state.mCols.SumOfGridGaps();
}
nscoord