Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-12-02 18:08:58 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
1de5dd48da
gecko-dev/layout/generic/nsGridContainerFrame.cpp

10300 lines
425 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 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/. */
/* rendering object for CSS "display: grid | inline-grid" */
#include "nsGridContainerFrame.h"
#include <functional>
#include <stdlib.h> // for div()
#include <type_traits>
#include "gfxContext.h"
#include "mozilla/AutoRestore.h"
#include "mozilla/Baseline.h"
#include "mozilla/ComputedStyle.h"
#include "mozilla/CSSAlignUtils.h"
#include "mozilla/dom/Grid.h"
#include "mozilla/dom/GridBinding.h"
#include "mozilla/IntegerRange.h"
#include "mozilla/Maybe.h"
#include "mozilla/PodOperations.h" // for PodZero
#include "mozilla/PresShell.h"
#include "mozilla/StaticPrefs_layout.h"
#include "nsAbsoluteContainingBlock.h"
#include "nsAlgorithm.h" // for clamped()
#include "nsCSSFrameConstructor.h"
#include "nsDisplayList.h"
#include "nsFieldSetFrame.h"
#include "nsHTMLButtonControlFrame.h"
#include "nsGfxScrollFrame.h"
#include "nsHashKeys.h"
#include "nsIFrameInlines.h" // for nsIFrame::GetLogicalNormalPosition (don't remove)
#include "nsLayoutUtils.h"
#include "nsPlaceholderFrame.h"
#include "nsPresContext.h"
#include "nsReadableUtils.h"
#include "nsTableWrapperFrame.h"
using namespace mozilla;
typedef nsAbsoluteContainingBlock::AbsPosReflowFlags AbsPosReflowFlags;
typedef nsGridContainerFrame::TrackSize TrackSize;
typedef mozilla::CSSAlignUtils::AlignJustifyFlags AlignJustifyFlags;
using GridTemplate = StyleGridTemplateComponent;
using TrackListValue =
StyleGenericTrackListValue<LengthPercentage, StyleInteger>;
using TrackRepeat = StyleGenericTrackRepeat<LengthPercentage, StyleInteger>;
using NameList = StyleOwnedSlice<StyleCustomIdent>;
using SizingConstraint = nsGridContainerFrame::SizingConstraint;
using GridItemCachedBAxisMeasurement =
nsGridContainerFrame::CachedBAxisMeasurement;
static mozilla::LazyLogModule gGridContainerLog("GridContainer");
#define GRID_LOG(...) \
MOZ_LOG(gGridContainerLog, LogLevel::Debug, (__VA_ARGS__));
static const int32_t kMaxLine = StyleMAX_GRID_LINE;
static const int32_t kMinLine = StyleMIN_GRID_LINE;
// The maximum line number, in the zero-based translated grid.
static const uint32_t kTranslatedMaxLine = uint32_t(kMaxLine - kMinLine);
static const uint32_t kAutoLine = kTranslatedMaxLine + 3457U;
static const nsFrameState kIsSubgridBits =
(NS_STATE_GRID_IS_COL_SUBGRID | NS_STATE_GRID_IS_ROW_SUBGRID);
namespace mozilla {
template <>
inline Span<const StyleOwnedSlice<StyleCustomIdent>>
GridTemplate::LineNameLists(bool aIsSubgrid) const {
if (IsTrackList()) {
return AsTrackList()->line_names.AsSpan();
}
if (IsSubgrid() && aIsSubgrid) {
// For subgrid, we need to resolve <line-name-list> from each
// StyleGenericLineNameListValue, so return empty.
return {};
}
MOZ_ASSERT(IsNone() || IsMasonry() || (IsSubgrid() && !aIsSubgrid));
return {};
}
template <>
inline const StyleTrackBreadth& StyleTrackSize::GetMax() const {
if (IsBreadth()) {
return AsBreadth();
}
if (IsMinmax()) {
return AsMinmax()._1;
}
MOZ_ASSERT(IsFitContent());
return AsFitContent();
}
template <>
inline const StyleTrackBreadth& StyleTrackSize::GetMin() const {
static const StyleTrackBreadth kAuto = StyleTrackBreadth::Auto();
if (IsBreadth()) {
// <flex> behaves like minmax(auto, <flex>)
return AsBreadth().IsFr() ? kAuto : AsBreadth();
}
if (IsMinmax()) {
return AsMinmax()._0;
}
MOZ_ASSERT(IsFitContent());
return kAuto;
}
} // namespace mozilla
static nscoord ClampToCSSMaxBSize(nscoord aSize,
const ReflowInput* aReflowInput) {
auto maxSize = aReflowInput->ComputedMaxBSize();
if (MOZ_UNLIKELY(maxSize != NS_UNCONSTRAINEDSIZE)) {
MOZ_ASSERT(aReflowInput->ComputedMinBSize() <= maxSize);
aSize = std::min(aSize, maxSize);
}
return aSize;
}
// Same as above and set aStatus INCOMPLETE if aSize wasn't clamped.
// (If we clamp aSize it means our size is less than the break point,
// i.e. we're effectively breaking in our overflow, so we should leave
// aStatus as is (it will likely be set to OVERFLOW_INCOMPLETE later)).
static nscoord ClampToCSSMaxBSize(nscoord aSize,
const ReflowInput* aReflowInput,
nsReflowStatus* aStatus) {
auto maxSize = aReflowInput->ComputedMaxBSize();
if (MOZ_UNLIKELY(maxSize != NS_UNCONSTRAINEDSIZE)) {
MOZ_ASSERT(aReflowInput->ComputedMinBSize() <= maxSize);
if (aSize < maxSize) {
aStatus->SetIncomplete();
} else {
aSize = maxSize;
}
} else {
aStatus->SetIncomplete();
}
return aSize;
}
template <typename Size>
static bool IsPercentOfIndefiniteSize(const Size& aCoord,
nscoord aPercentBasis) {
return aPercentBasis == NS_UNCONSTRAINEDSIZE && aCoord.HasPercent();
}
static nscoord ResolveToDefiniteSize(const StyleTrackBreadth& aBreadth,
nscoord aPercentBasis) {
MOZ_ASSERT(aBreadth.IsBreadth());
if (::IsPercentOfIndefiniteSize(aBreadth.AsBreadth(), aPercentBasis)) {
return nscoord(0);
}
return std::max(nscoord(0), aBreadth.AsBreadth().Resolve(aPercentBasis));
}
// 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.
// https://drafts.csswg.org/css-align-3/#synthesize-baseline
// For a 'first baseline' the measure is from the border-box start edge and
// for a 'last baseline' the measure is from the border-box end edge.
//
// The 'LogicalAxis aAxis' represents the axis (in terms of aWM) that the
// baseline corresponds to. (Typically, baselines are a measurement in the
// block axis; e.g. for English horizontal-tb text, a traditional baseline
// would be a y-axis measurement. But in some cases (e.g. orthogonal WMs), we
// may need to synthesize a baseline in a child's inline axis, which is when
// this function might receive an aAxis of LogicalAxis::Inline. In that case, we
// assume that the writing mode's preference for central vs. alphabetic
// baselines is irrelevant, since that's a choice about its block-axis
// baselines, and we just unconditionally use the alphabetic baseline
// (e.g. border-box bottom edge).
static nscoord SynthesizeBaselineFromBorderBox(BaselineSharingGroup aGroup,
WritingMode aWM,
LogicalAxis aAxis,
nscoord aBorderBoxSize) {
const bool useAlphabeticBaseline =
(aAxis == LogicalAxis::Inline) ? true : aWM.IsAlphabeticalBaseline();
if (aGroup == BaselineSharingGroup::First) {
return useAlphabeticBaseline ? aBorderBoxSize : aBorderBoxSize / 2;
}
MOZ_ASSERT(aGroup == BaselineSharingGroup::Last);
// Round up for central baseline offset, to be consistent with eFirst.
return useAlphabeticBaseline ? 0
: (aBorderBoxSize / 2) + (aBorderBoxSize % 2);
}
// The input sizes for calculating the number of repeat(auto-fill/fit) tracks.
// https://drafts.csswg.org/css-grid/#auto-repeat
struct RepeatTrackSizingInput {
explicit RepeatTrackSizingInput(WritingMode aWM)
: mMin(aWM, 0, 0),
mSize(aWM, NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE),
mMax(aWM, NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE) {}
RepeatTrackSizingInput(const LogicalSize& aMin, const LogicalSize& aSize,
const LogicalSize& aMax)
: mMin(aMin), mSize(aSize), mMax(aMax) {}
// This should be used in intrinsic sizing (i.e. when we can't initialize
// the sizes directly from ReflowInput values).
void InitFromStyle(LogicalAxis aAxis, WritingMode aWM,
const ComputedStyle* aStyle) {
const auto& pos = aStyle->StylePosition();
const bool borderBoxSizing = pos->mBoxSizing == StyleBoxSizing::Border;
nscoord bp = NS_UNCONSTRAINEDSIZE; // a sentinel to calculate it only once
auto adjustForBoxSizing = [borderBoxSizing, aWM, aAxis, aStyle,
&bp](nscoord aSize) {
if (!borderBoxSizing) {
return aSize;
}
if (bp == NS_UNCONSTRAINEDSIZE) {
const auto& padding = aStyle->StylePadding()->mPadding;
LogicalMargin border(aWM, aStyle->StyleBorder()->GetComputedBorder());
// We can use zero percentage basis since this is only called from
// intrinsic sizing code.
const nscoord percentageBasis = 0;
if (aAxis == LogicalAxis::Inline) {
bp = std::max(padding.GetIStart(aWM).Resolve(percentageBasis), 0) +
std::max(padding.GetIEnd(aWM).Resolve(percentageBasis), 0) +
border.IStartEnd(aWM);
} else {
bp = std::max(padding.GetBStart(aWM).Resolve(percentageBasis), 0) +
std::max(padding.GetBEnd(aWM).Resolve(percentageBasis), 0) +
border.BStartEnd(aWM);
}
}
return std::max(aSize - bp, 0);
};
nscoord& min = mMin.Size(aAxis, aWM);
nscoord& size = mSize.Size(aAxis, aWM);
nscoord& max = mMax.Size(aAxis, aWM);
const auto& minCoord =
aAxis == LogicalAxis::Inline ? pos->MinISize(aWM) : pos->MinBSize(aWM);
if (minCoord.ConvertsToLength()) {
min = adjustForBoxSizing(minCoord.ToLength());
}
const auto& maxCoord =
aAxis == LogicalAxis::Inline ? pos->MaxISize(aWM) : pos->MaxBSize(aWM);
if (maxCoord.ConvertsToLength()) {
max = std::max(min, adjustForBoxSizing(maxCoord.ToLength()));
}
const auto& sizeCoord =
aAxis == LogicalAxis::Inline ? pos->ISize(aWM) : pos->BSize(aWM);
if (sizeCoord.ConvertsToLength()) {
size = Clamp(adjustForBoxSizing(sizeCoord.ToLength()), min, max);
}
}
LogicalSize mMin;
LogicalSize mSize;
LogicalSize mMax;
};
enum class GridLineSide {
BeforeGridGap,
AfterGridGap,
};
struct nsGridContainerFrame::TrackSize {
enum StateBits : uint16_t {
// clang-format off
eAutoMinSizing = 0x1,
eMinContentMinSizing = 0x2,
eMaxContentMinSizing = 0x4,
eMinOrMaxContentMinSizing = eMinContentMinSizing | eMaxContentMinSizing,
eIntrinsicMinSizing = eMinOrMaxContentMinSizing | eAutoMinSizing,
eModified = 0x8,
eAutoMaxSizing = 0x10,
eMinContentMaxSizing = 0x20,
eMaxContentMaxSizing = 0x40,
eAutoOrMaxContentMaxSizing = eAutoMaxSizing | eMaxContentMaxSizing,
eIntrinsicMaxSizing = eAutoOrMaxContentMaxSizing | eMinContentMaxSizing,
eFlexMaxSizing = 0x80,
eFrozen = 0x100,
eSkipGrowUnlimited1 = 0x200,
eSkipGrowUnlimited2 = 0x400,
eSkipGrowUnlimited = eSkipGrowUnlimited1 | eSkipGrowUnlimited2,
eBreakBefore = 0x800,
eFitContent = 0x1000,
eInfinitelyGrowable = 0x2000,
// These are only used in the masonry axis. They share the same value
// as *MinSizing above, but that's OK because we don't use those in
// the masonry axis.
//
// This track corresponds to an item margin-box size that is stretching.
eItemStretchSize = 0x1,
// This bit says that we should clamp that size to mLimit.
eClampToLimit = 0x2,
// This bit says that the corresponding item has `auto` margin(s).
eItemHasAutoMargin = 0x4,
// clang-format on
};
StateBits Initialize(nscoord aPercentageBasis, const StyleTrackSize&);
bool IsFrozen() const { return mState & eFrozen; }
#ifdef DEBUG
static void DumpStateBits(StateBits aState);
void Dump() const;
#endif
static bool IsDefiniteMaxSizing(StateBits aStateBits) {
return (aStateBits & (eIntrinsicMaxSizing | eFlexMaxSizing)) == 0;
}
nscoord mBase;
nscoord mLimit;
nscoord mPosition; // zero until we apply 'align/justify-content'
// mBaselineSubtreeSize is the size of a baseline-aligned subtree within
// this track. One subtree per baseline-sharing group (per track).
PerBaseline<nscoord> mBaselineSubtreeSize;
StateBits mState;
};
MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(TrackSize::StateBits)
static_assert(
std::is_trivially_copyable<nsGridContainerFrame::TrackSize>::value,
"Must be trivially copyable");
static_assert(
std::is_trivially_destructible<nsGridContainerFrame::TrackSize>::value,
"Must be trivially destructible");
TrackSize::StateBits nsGridContainerFrame::TrackSize::Initialize(
nscoord aPercentageBasis, const StyleTrackSize& aSize) {
using Tag = StyleTrackBreadth::Tag;
MOZ_ASSERT(mBase == 0 && mLimit == 0 && mState == 0,
"track size data is expected to be initialized to zero");
mBaselineSubtreeSize[BaselineSharingGroup::First] = nscoord(0);
mBaselineSubtreeSize[BaselineSharingGroup::Last] = nscoord(0);
auto& min = aSize.GetMin();
auto& max = aSize.GetMax();
Tag minSizeTag = min.tag;
Tag maxSizeTag = max.tag;
if (aSize.IsFitContent()) {
// In layout, fit-content(size) behaves as minmax(auto, max-content), with
// 'size' as an additional upper-bound.
mState = eFitContent;
minSizeTag = Tag::Auto;
maxSizeTag = Tag::MaxContent;
}
if (::IsPercentOfIndefiniteSize(min, aPercentageBasis)) {
// https://drafts.csswg.org/css-grid/#valdef-grid-template-columns-percentage
// "If the inline or block size of the grid container is indefinite,
// <percentage> values relative to that size are treated as 'auto'."
minSizeTag = Tag::Auto;
}
if (::IsPercentOfIndefiniteSize(max, aPercentageBasis)) {
maxSizeTag = Tag::Auto;
}
// http://dev.w3.org/csswg/css-grid/#algo-init
switch (minSizeTag) {
case Tag::Auto:
mState |= eAutoMinSizing;
break;
case Tag::MinContent:
mState |= eMinContentMinSizing;
break;
case Tag::MaxContent:
mState |= eMaxContentMinSizing;
break;
default:
MOZ_ASSERT(!min.IsFr(), "<flex> min-sizing is invalid as a track size");
mBase = ::ResolveToDefiniteSize(min, aPercentageBasis);
}
switch (maxSizeTag) {
case Tag::Auto:
mState |= eAutoMaxSizing;
mLimit = NS_UNCONSTRAINEDSIZE;
break;
case Tag::MinContent:
case Tag::MaxContent:
mState |= maxSizeTag == Tag::MinContent ? eMinContentMaxSizing
: eMaxContentMaxSizing;
mLimit = NS_UNCONSTRAINEDSIZE;
break;
case Tag::Fr:
mState |= eFlexMaxSizing;
mLimit = mBase;
break;
default:
mLimit = ::ResolveToDefiniteSize(max, aPercentageBasis);
if (mLimit < mBase) {
mLimit = mBase;
}
}
return mState;
}
/**
* A LineRange can be definite or auto - when it's definite it represents
* a consecutive set of tracks between a starting line and an ending line.
* Before it's definite it can also represent an auto position with a span,
* where mStart == kAutoLine and mEnd is the (non-zero positive) span.
* For normal-flow items, the invariant mStart < mEnd holds when both
* lines are definite.
*
* For abs.pos. grid items, mStart and mEnd may both be kAutoLine, meaning
* "attach this side to the grid container containing block edge".
* Additionally, mStart <= mEnd holds when both are definite (non-kAutoLine),
* i.e. the invariant is slightly relaxed compared to normal flow items.
*/
struct nsGridContainerFrame::LineRange {
LineRange(int32_t aStart, int32_t aEnd)
: mUntranslatedStart(aStart), mUntranslatedEnd(aEnd) {
#ifdef DEBUG
if (!IsAutoAuto()) {
if (IsAuto()) {
MOZ_ASSERT(aEnd >= kMinLine && aEnd <= kMaxLine, "invalid span");
} else {
MOZ_ASSERT(aStart >= kMinLine && aStart <= kMaxLine,
"invalid start line");
MOZ_ASSERT(aEnd == int32_t(kAutoLine) ||
(aEnd >= kMinLine && aEnd <= kMaxLine),
"invalid end line");
}
}
#endif
}
bool IsAutoAuto() const { return mStart == kAutoLine && mEnd == kAutoLine; }
bool IsAuto() const { return mStart == kAutoLine; }
bool IsDefinite() const { return mStart != kAutoLine; }
uint32_t Extent() const {
MOZ_ASSERT(mEnd != kAutoLine, "Extent is undefined for abs.pos. 'auto'");
if (IsAuto()) {
MOZ_ASSERT(mEnd >= 1 && mEnd < uint32_t(kMaxLine), "invalid span");
return mEnd;
}
return mEnd - mStart;
}
/**
* Return an object suitable for iterating this range.
*/
auto Range() const { return IntegerRange<uint32_t>(mStart, mEnd); }
/**
* Resolve this auto range to start at aStart, making it definite.
* @param aClampMaxLine the maximum allowed line number (zero-based)
* Precondition: this range IsAuto()
*/
void ResolveAutoPosition(uint32_t aStart, uint32_t aClampMaxLine) {
MOZ_ASSERT(IsAuto(), "Why call me?");
mStart = aStart;
mEnd += aStart;
// Clamp to aClampMaxLine, which is where kMaxLine is in the explicit
// grid in a non-subgrid axis; this implements clamping per
// http://dev.w3.org/csswg/css-grid/#overlarge-grids
// In a subgrid axis it's the end of the grid in that axis.
if (MOZ_UNLIKELY(mStart >= aClampMaxLine)) {
mEnd = aClampMaxLine;
mStart = mEnd - 1;
} else if (MOZ_UNLIKELY(mEnd > aClampMaxLine)) {
mEnd = aClampMaxLine;
}
}
/**
* Translate the lines to account for (empty) removed tracks. This method
* is only for grid items and should only be called after placement.
* aNumRemovedTracks contains a count for each line in the grid how many
* tracks were removed between the start of the grid and that line.
*/
void AdjustForRemovedTracks(const nsTArray<uint32_t>& aNumRemovedTracks) {
MOZ_ASSERT(mStart != kAutoLine, "invalid resolved line for a grid item");
MOZ_ASSERT(mEnd != kAutoLine, "invalid resolved line for a grid item");
uint32_t numRemovedTracks = aNumRemovedTracks[mStart];
MOZ_ASSERT(numRemovedTracks == aNumRemovedTracks[mEnd],
"tracks that a grid item spans can't be removed");
mStart -= numRemovedTracks;
mEnd -= numRemovedTracks;
}
/**
* Translate the lines to account for (empty) removed tracks. This method
* is only for abs.pos. children and should only be called after placement.
* Same as for in-flow items, but we don't touch 'auto' lines here and we
* also need to adjust areas that span into the removed tracks.
*/
void AdjustAbsPosForRemovedTracks(
const nsTArray<uint32_t>& aNumRemovedTracks) {
if (mStart != kAutoLine) {
mStart -= aNumRemovedTracks[mStart];
}
if (mEnd != kAutoLine) {
MOZ_ASSERT(mStart == kAutoLine || mEnd > mStart, "invalid line range");
mEnd -= aNumRemovedTracks[mEnd];
}
}
/**
* Return the contribution of this line range for step 2 in
* http://dev.w3.org/csswg/css-grid/#auto-placement-algo
*/
uint32_t HypotheticalEnd() const { return mEnd; }
/**
* Given an array of track sizes, return the starting position and length
* of the tracks in this line range.
*/
void ToPositionAndLength(const nsTArray<TrackSize>& aTrackSizes,
nscoord* aPos, nscoord* aLength) const;
/**
* Given an array of track sizes, return the length of the tracks in this
* line range.
*/
nscoord ToLength(const nsTArray<TrackSize>& aTrackSizes) const;
/**
* Given an array of track sizes and a grid origin coordinate, adjust the
* abs.pos. containing block along an axis given by aPos and aLength.
* aPos and aLength should already be initialized to the grid container
* containing block for this axis before calling this method.
*/
void ToPositionAndLengthForAbsPos(const Tracks& aTracks, nscoord aGridOrigin,
nscoord* aPos, nscoord* aLength) const;
void Translate(int32_t aOffset) {
MOZ_ASSERT(IsDefinite());
mStart += aOffset;
mEnd += aOffset;
}
/** Swap the start/end sides of this range. */
void ReverseDirection(uint32_t aGridEnd) {
MOZ_ASSERT(IsDefinite());
MOZ_ASSERT(aGridEnd >= mEnd);
uint32_t newStart = aGridEnd - mEnd;
mEnd = aGridEnd - mStart;
mStart = newStart;
}
/**
* @note We'll use the signed member while resolving definite positions
* to line numbers (1-based), which may become negative for implicit lines
* to the top/left of the explicit grid. PlaceGridItems() then translates
* the whole grid to a 0,0 origin and we'll use the unsigned member from
* there on.
*/
union {
uint32_t mStart;
int32_t mUntranslatedStart;
};
union {
uint32_t mEnd;
int32_t mUntranslatedEnd;
};
protected:
LineRange() : mStart(0), mEnd(0) {}
};
/**
* Helper class to construct a LineRange from translated lines.
* The ctor only accepts translated definite line numbers.
*/
struct nsGridContainerFrame::TranslatedLineRange : public LineRange {
TranslatedLineRange(uint32_t aStart, uint32_t aEnd) {
MOZ_ASSERT(aStart < aEnd && aEnd <= kTranslatedMaxLine);
mStart = aStart;
mEnd = aEnd;
}
};
/**
* A GridArea is the area in the grid for a grid item.
* The area is represented by two LineRanges, both of which can be auto
* (@see LineRange) in intermediate steps while the item is being placed.
* @see PlaceGridItems
*/
struct nsGridContainerFrame::GridArea {
GridArea(const LineRange& aCols, const LineRange& aRows)
: mCols(aCols), mRows(aRows) {}
bool IsDefinite() const { return mCols.IsDefinite() && mRows.IsDefinite(); }
LineRange& LineRangeForAxis(LogicalAxis aAxis) {
return aAxis == LogicalAxis::Inline ? mCols : mRows;
}
const LineRange& LineRangeForAxis(LogicalAxis aAxis) const {
return aAxis == LogicalAxis::Inline ? mCols : mRows;
}
LineRange mCols;
LineRange mRows;
};
struct nsGridContainerFrame::GridItemInfo {
/**
* Item state per axis.
*/
enum StateBits : uint16_t {
// Does the item span a flex track?
eIsFlexing = 0x1,
// First or last baseline alignment preference. They are mutually exclusive.
// This does *NOT* represent the baseline alignment group. See the member
// variable for that.
// <https://drafts.csswg.org/css-align-3/#baseline-alignment-preference>
eFirstBaseline = 0x2,
eLastBaseline = 0x4,
eIsBaselineAligned = eFirstBaseline | eLastBaseline,
// One of e[Self|Content]Baseline is set when eIsBaselineAligned is true
eSelfBaseline = 0x8, // is it *-self:[last ]baseline alignment?
// Ditto *-content:[last ]baseline. Mutually exclusive w. eSelfBaseline.
eContentBaseline = 0x10,
// The baseline affects the margin or padding on the item's end side when
// this bit is set. In a grid-axis it's always set for eLastBaseline and
// always unset for eFirstBaseline. In a masonry-axis, it's set for
// baseline groups in the EndStretch set and unset for the StartStretch set.
eEndSideBaseline = 0x20,
eAllBaselineBits = eIsBaselineAligned | eSelfBaseline | eContentBaseline |
eEndSideBaseline,
// Should apply Automatic Minimum Size per:
// https://drafts.csswg.org/css-grid/#min-size-auto
eApplyAutoMinSize = 0x40,
// Clamp per https://drafts.csswg.org/css-grid/#min-size-auto
eClampMarginBoxMinSize = 0x80,
eIsSubgrid = 0x100,
// set on subgrids and items in subgrids if they are adjacent to the grid
// start/end edge (excluding grid-aligned abs.pos. frames)
eStartEdge = 0x200,
eEndEdge = 0x400,
eEdgeBits = eStartEdge | eEndEdge,
// Set if this item was auto-placed in this axis.
eAutoPlacement = 0x800,
// Set if this item is the last item in its track (masonry layout only)
eIsLastItemInMasonryTrack = 0x1000,
};
GridItemInfo(nsIFrame* aFrame, const GridArea& aArea);
GridItemInfo(const GridItemInfo& aOther)
: mFrame(aOther.mFrame), mArea(aOther.mArea) {
mBaselineOffset = aOther.mBaselineOffset;
mState = aOther.mState;
}
GridItemInfo& operator=(const GridItemInfo&) = delete;
static bool BaselineAlignmentAffectsEndSide(StateBits state) {
return state & StateBits::eEndSideBaseline;
}
/**
* Inhibit subgrid layout unless the item is placed in the first "track" in
* a parent masonry-axis, or has definite placement or spans all tracks in
* the parent grid-axis.
* TODO: this is stricter than what the Masonry proposal currently states
* (bug 1627581)
*/
void MaybeInhibitSubgridInMasonry(nsGridContainerFrame* aParent,
uint32_t aGridAxisTrackCount);
/**
* Inhibit subgridding in aAxis for this item.
*/
void InhibitSubgrid(nsGridContainerFrame* aParent, LogicalAxis aAxis);
/**
* Return a copy of this item with its row/column data swapped.
*/
GridItemInfo Transpose() const {
GridItemInfo info(mFrame, GridArea(mArea.mRows, mArea.mCols));
info.mState[LogicalAxis::Block] = mState[LogicalAxis::Inline];
info.mState[LogicalAxis::Inline] = mState[LogicalAxis::Block];
info.mBaselineOffset[LogicalAxis::Block] =
mBaselineOffset[LogicalAxis::Inline];
info.mBaselineOffset[LogicalAxis::Inline] =
mBaselineOffset[LogicalAxis::Block];
return info;
}
/** Swap the start/end sides in aAxis. */
inline void ReverseDirection(LogicalAxis aAxis, uint32_t aGridEnd);
// Is this item a subgrid in the given container axis?
bool IsSubgrid(LogicalAxis aAxis) const {
return mState[aAxis] & StateBits::eIsSubgrid;
}
// Is this item a subgrid in either axis?
bool IsSubgrid() const {
return IsSubgrid(LogicalAxis::Inline) || IsSubgrid(LogicalAxis::Block);
}
// Return the (inner) grid container frame associated with this subgrid item.
nsGridContainerFrame* SubgridFrame() const {
MOZ_ASSERT(IsSubgrid());
nsGridContainerFrame* gridFrame = GetGridContainerFrame(mFrame);
MOZ_ASSERT(gridFrame && gridFrame->IsSubgrid());
return gridFrame;
}
/**
* Adjust our grid areas to account for removed auto-fit tracks in aAxis.
*/
void AdjustForRemovedTracks(LogicalAxis aAxis,
const nsTArray<uint32_t>& aNumRemovedTracks);
/**
* If the item is [align|justify]-self:[last ]baseline aligned in the given
* axis then set aBaselineOffset to the baseline offset and return aAlign.
* Otherwise, return a fallback alignment.
*/
StyleAlignFlags GetSelfBaseline(StyleAlignFlags aAlign, LogicalAxis aAxis,
nscoord* aBaselineOffset) const {
MOZ_ASSERT(aAlign == StyleAlignFlags::BASELINE ||
aAlign == StyleAlignFlags::LAST_BASELINE);
if (!(mState[aAxis] & eSelfBaseline)) {
return aAlign == StyleAlignFlags::BASELINE ? StyleAlignFlags::SELF_START
: StyleAlignFlags::SELF_END;
}
*aBaselineOffset = mBaselineOffset[aAxis];
return aAlign;
}
// Return true if we should apply Automatic Minimum Size to this item.
// https://drafts.csswg.org/css-grid/#min-size-auto
// @note the caller should also check that the item spans at least one track
// that has a min track sizing function that is 'auto' before applying it.
bool ShouldApplyAutoMinSize(WritingMode aContainerWM,
LogicalAxis aContainerAxis,
nscoord aPercentageBasis) const {
const bool isInlineAxis = aContainerAxis == LogicalAxis::Inline;
const auto* pos =
mFrame->IsTableWrapperFrame()
? mFrame->PrincipalChildList().FirstChild()->StylePosition()
: mFrame->StylePosition();
const auto& size =
isInlineAxis ? pos->ISize(aContainerWM) : pos->BSize(aContainerWM);
// max-content and min-content should behave as initial value in block axis.
// FIXME: Bug 567039: moz-fit-content and -moz-available are not supported
// for block size dimension on sizing properties (e.g. height), so we
// treat it as `auto`.
bool isAuto = size.IsAuto() ||
(isInlineAxis ==
aContainerWM.IsOrthogonalTo(mFrame->GetWritingMode()) &&
size.BehavesLikeInitialValueOnBlockAxis());
// NOTE: if we have a definite size then our automatic minimum size
// can't affect our size. Excluding these simplifies applying
// the clamping in the right cases later.
if (!isAuto && !::IsPercentOfIndefiniteSize(size, aPercentageBasis)) {
return false;
}
const auto& minSize = isInlineAxis ? pos->MinISize(aContainerWM)
: pos->MinBSize(aContainerWM);
// max-content and min-content should behave as initial value in block axis.
// FIXME: Bug 567039: moz-fit-content and -moz-available are not supported
// for block size dimension on sizing properties (e.g. height), so we
// treat it as `auto`.
isAuto = minSize.IsAuto() ||
(isInlineAxis ==
aContainerWM.IsOrthogonalTo(mFrame->GetWritingMode()) &&
minSize.BehavesLikeInitialValueOnBlockAxis());
return isAuto && !mFrame->StyleDisplay()->IsScrollableOverflow();
}
#ifdef DEBUG
void Dump() const;
#endif
static bool IsStartRowLessThan(const GridItemInfo* a, const GridItemInfo* b) {
return a->mArea.mRows.mStart < b->mArea.mRows.mStart;
}
// Sorting functions for 'masonry-auto-flow:next'. We sort the items that
// were placed into the first track by the Grid placement algorithm first
// (to honor that placement). All other items will be placed by the Masonry
// layout algorithm (their Grid placement in the masonry axis is irrelevant).
static bool RowMasonryOrdered(const GridItemInfo* a, const GridItemInfo* b) {
return a->mArea.mRows.mStart == 0 && b->mArea.mRows.mStart != 0 &&
!a->mFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW);
}
static bool ColMasonryOrdered(const GridItemInfo* a, const GridItemInfo* b) {
return a->mArea.mCols.mStart == 0 && b->mArea.mCols.mStart != 0 &&
!a->mFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW);
}
// Sorting functions for 'masonry-auto-flow:definite-first'. Similar to
// the above, but here we also sort items with a definite item placement in
// the grid axis in track order before 'auto'-placed items. We also sort all
// continuations first since they use the same placement as their
// first-in-flow (we treat them as "definite" regardless of eAutoPlacement).
static bool RowMasonryDefiniteFirst(const GridItemInfo* a,
const GridItemInfo* b) {
bool isContinuationA = a->mFrame->GetPrevInFlow();
bool isContinuationB = b->mFrame->GetPrevInFlow();
if (isContinuationA != isContinuationB) {
return isContinuationA;
}
auto masonryA = a->mArea.mRows.mStart;
auto gridA = a->mState[LogicalAxis::Inline] & StateBits::eAutoPlacement;
auto masonryB = b->mArea.mRows.mStart;
auto gridB = b->mState[LogicalAxis::Inline] & StateBits::eAutoPlacement;
return (masonryA == 0 ? masonryB != 0 : (masonryB != 0 && gridA < gridB)) &&
!a->mFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW);
}
static bool ColMasonryDefiniteFirst(const GridItemInfo* a,
const GridItemInfo* b) {
MOZ_ASSERT(!a->mFrame->GetPrevInFlow() && !b->mFrame->GetPrevInFlow(),
"fragmentation not supported in inline axis");
auto masonryA = a->mArea.mCols.mStart;
auto gridA = a->mState[LogicalAxis::Block] & StateBits::eAutoPlacement;
auto masonryB = b->mArea.mCols.mStart;
auto gridB = b->mState[LogicalAxis::Block] & StateBits::eAutoPlacement;
return (masonryA == 0 ? masonryB != 0 : (masonryB != 0 && gridA < gridB)) &&
!a->mFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW);
}
// Return true if this items block size is dependent on the size of the
// container it is in.
bool IsBSizeDependentOnContainerSize(WritingMode aContainerWM) const {
const auto IsDependentOnContainerSize = [](const auto& size) -> bool {
return size.HasPercent() || size.IsMozAvailable();
};
const nsStylePosition* stylePos = mFrame->StylePosition();
bool isItemAutoSize =
IsDependentOnContainerSize(stylePos->BSize(aContainerWM)) ||
IsDependentOnContainerSize(stylePos->MinBSize(aContainerWM)) ||
IsDependentOnContainerSize(stylePos->MaxBSize(aContainerWM));
return isItemAutoSize;
}
nsIFrame* const mFrame;
GridArea mArea;
// Offset from the margin edge to the baseline (LogicalAxis index). It's from
// the start edge for first baseline sharing group, otherwise from the end
// edge.
// It's mutable since we update the value fairly late (just before reflowing
// the item).
mutable PerLogicalAxis<nscoord> mBaselineOffset;
// State bits per axis.
mutable PerLogicalAxis<StateBits> mState;
};
using GridItemInfo = nsGridContainerFrame::GridItemInfo;
using ItemState = GridItemInfo::StateBits;
MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(ItemState)
GridItemInfo::GridItemInfo(nsIFrame* aFrame, const GridArea& aArea)
: mFrame(aFrame), mArea(aArea), mBaselineOffset{0, 0} {
mState[LogicalAxis::Block] =
StateBits(mArea.mRows.mStart == kAutoLine ? eAutoPlacement : 0);
mState[LogicalAxis::Inline] =
StateBits(mArea.mCols.mStart == kAutoLine ? eAutoPlacement : 0);
if (auto* gridFrame = GetGridContainerFrame(mFrame)) {
auto parentWM = aFrame->GetParent()->GetWritingMode();
bool isOrthogonal = parentWM.IsOrthogonalTo(gridFrame->GetWritingMode());
if (gridFrame->IsColSubgrid()) {
mState[isOrthogonal ? LogicalAxis::Block : LogicalAxis::Inline] |=
StateBits::eIsSubgrid;
}
if (gridFrame->IsRowSubgrid()) {
mState[isOrthogonal ? LogicalAxis::Inline : LogicalAxis::Block] |=
StateBits::eIsSubgrid;
}
}
}
void GridItemInfo::ReverseDirection(LogicalAxis aAxis, uint32_t aGridEnd) {
mArea.LineRangeForAxis(aAxis).ReverseDirection(aGridEnd);
ItemState& state = mState[aAxis];
ItemState newState = state & ~ItemState::eEdgeBits;
if (state & ItemState::eStartEdge) {
newState |= ItemState::eEndEdge;
}
if (state & ItemState::eEndEdge) {
newState |= ItemState::eStartEdge;
}
state = newState;
}
void GridItemInfo::InhibitSubgrid(nsGridContainerFrame* aParent,
LogicalAxis aAxis) {
MOZ_ASSERT(IsSubgrid(aAxis));
auto bit = NS_STATE_GRID_IS_COL_SUBGRID;
if (aParent->GetWritingMode().IsOrthogonalTo(mFrame->GetWritingMode()) !=
(aAxis == LogicalAxis::Block)) {
bit = NS_STATE_GRID_IS_ROW_SUBGRID;
}
MOZ_ASSERT(SubgridFrame()->HasAnyStateBits(bit));
SubgridFrame()->RemoveStateBits(bit);
mState[aAxis] &= StateBits(~StateBits::eIsSubgrid);
}
void GridItemInfo::MaybeInhibitSubgridInMasonry(nsGridContainerFrame* aParent,
uint32_t aGridAxisTrackCount) {
if (IsSubgrid(LogicalAxis::Inline) &&
aParent->IsMasonry(LogicalAxis::Block) && mArea.mRows.mStart != 0 &&
mArea.mCols.Extent() != aGridAxisTrackCount &&
(mState[LogicalAxis::Inline] & eAutoPlacement)) {
InhibitSubgrid(aParent, LogicalAxis::Inline);
return;
}
if (IsSubgrid(LogicalAxis::Block) &&
aParent->IsMasonry(LogicalAxis::Inline) && mArea.mCols.mStart != 0 &&
mArea.mRows.Extent() != aGridAxisTrackCount &&
(mState[LogicalAxis::Block] & eAutoPlacement)) {
InhibitSubgrid(aParent, LogicalAxis::Block);
}
}
// Each subgrid stores this data about its items etc on a frame property.
struct nsGridContainerFrame::Subgrid {
Subgrid(const GridArea& aArea, bool aIsOrthogonal, WritingMode aCBWM)
: mArea(aArea),
mGridColEnd(0),
mGridRowEnd(0),
mMarginBorderPadding(aCBWM),
mIsOrthogonal(aIsOrthogonal) {}
// Return the relevant line range for the subgrid column axis.
const LineRange& SubgridCols() const {
return mIsOrthogonal ? mArea.mRows : mArea.mCols;
}
// Return the relevant line range for the subgrid row axis.
const LineRange& SubgridRows() const {
return mIsOrthogonal ? mArea.mCols : mArea.mRows;
}
// The subgrid's items.
nsTArray<GridItemInfo> mGridItems;
// The subgrid's abs.pos. items.
nsTArray<GridItemInfo> mAbsPosItems;
// The subgrid's area as a grid item, i.e. in its parent's grid space.
GridArea mArea;
// The (inner) grid size for the subgrid, zero-based.
uint32_t mGridColEnd;
uint32_t mGridRowEnd;
// The margin+border+padding for the subgrid box in its parent grid's WM.
// (This also includes the size of any scrollbars.)
LogicalMargin mMarginBorderPadding;
// Does the subgrid frame have orthogonal writing-mode to its parent grid
// container?
bool mIsOrthogonal;
NS_DECLARE_FRAME_PROPERTY_DELETABLE(Prop, Subgrid)
};
using Subgrid = nsGridContainerFrame::Subgrid;
void GridItemInfo::AdjustForRemovedTracks(
LogicalAxis aAxis, const nsTArray<uint32_t>& aNumRemovedTracks) {
const bool abspos = mFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW);
auto& lines = mArea.LineRangeForAxis(aAxis);
if (abspos) {
lines.AdjustAbsPosForRemovedTracks(aNumRemovedTracks);
} else {
lines.AdjustForRemovedTracks(aNumRemovedTracks);
}
if (IsSubgrid()) {
auto* subgrid = SubgridFrame()->GetProperty(Subgrid::Prop());
if (subgrid) {
auto& lines = subgrid->mArea.LineRangeForAxis(aAxis);
if (abspos) {
lines.AdjustAbsPosForRemovedTracks(aNumRemovedTracks);
} else {
lines.AdjustForRemovedTracks(aNumRemovedTracks);
}
}
}
}
/**
* Track size data for use by subgrids (which don't do sizing of their own
* in a subgridded axis). A non-subgrid container stores its resolved sizes,
* but only if it has any subgrid children. A subgrid always stores one.
* In a subgridded axis, we copy the parent's sizes (see CopyUsedTrackSizes).
*
* This struct us stored on a frame property, which may be null before the track
* sizing step for the given container. A null property is semantically
* equivalent to mCanResolveLineRangeSize being false in both axes.
* @note the axis used to access this data is in the grid container's own
* writing-mode, same as in other track-sizing functions.
*/
struct nsGridContainerFrame::UsedTrackSizes {
UsedTrackSizes() : mCanResolveLineRangeSize{false, false} {}
/**
* Setup mSizes by copying track sizes from aFrame's grid container
* parent when aAxis is subgridded (and recurse if the parent is a subgrid
* that doesn't have sizes yet), or by running the Track Sizing Algo when
* the axis is not subgridded (for a subgrid).
* Set mCanResolveLineRangeSize[aAxis] to true once we have obtained
* sizes for an axis (if it's already true then this method is a NOP).
*/
void ResolveTrackSizesForAxis(nsGridContainerFrame* aFrame, LogicalAxis aAxis,
gfxContext& aRC);
/** Helper function for the above method */
void ResolveSubgridTrackSizesForAxis(nsGridContainerFrame* aFrame,
LogicalAxis aAxis, Subgrid* aSubgrid,
gfxContext& aRC,
nscoord aContentBoxSize);
// This only has valid sizes when mCanResolveLineRangeSize is true in
// the same axis. It may have zero tracks (a grid with only abs.pos.
// subgrids/items may have zero tracks).
PerLogicalAxis<nsTArray<TrackSize>> mSizes;
// True if mSizes can be used to resolve line range sizes in an axis.
PerLogicalAxis<bool> mCanResolveLineRangeSize;
NS_DECLARE_FRAME_PROPERTY_DELETABLE(Prop, UsedTrackSizes)
};
using UsedTrackSizes = nsGridContainerFrame::UsedTrackSizes;
#ifdef DEBUG
void nsGridContainerFrame::GridItemInfo::Dump() const {
auto Dump1 = [this](const char* aMsg, LogicalAxis aAxis) {
auto state = mState[aAxis];
if (!state) {
return;
}
printf("%s", aMsg);
if (state & ItemState::eEdgeBits) {
printf("subgrid-adjacent-edges(");
if (state & ItemState::eStartEdge) {
printf("start ");
}
if (state & ItemState::eEndEdge) {
printf("end");
}
printf(") ");
}
if (state & ItemState::eAutoPlacement) {
printf("masonry-auto ");
}
if (state & ItemState::eIsSubgrid) {
printf("subgrid ");
}
if (state & ItemState::eIsFlexing) {
printf("flexing ");
}
if (state & ItemState::eApplyAutoMinSize) {
printf("auto-min-size ");
}
if (state & ItemState::eClampMarginBoxMinSize) {
printf("clamp ");
}
if (state & ItemState::eIsLastItemInMasonryTrack) {
printf("last-in-track ");
}
if (state & ItemState::eFirstBaseline) {
printf("first baseline %s-alignment ",
(state & ItemState::eSelfBaseline) ? "self" : "content");
}
if (state & ItemState::eLastBaseline) {
printf("last baseline %s-alignment ",
(state & ItemState::eSelfBaseline) ? "self" : "content");
}
if (state & ItemState::eIsBaselineAligned) {
printf("%.2fpx", NSAppUnitsToFloatPixels(mBaselineOffset[aAxis],
AppUnitsPerCSSPixel()));
}
printf("\n");
};
printf("grid-row: %d %d\n", mArea.mRows.mStart, mArea.mRows.mEnd);
Dump1(" grid block-axis: ", LogicalAxis::Block);
printf("grid-column: %d %d\n", mArea.mCols.mStart, mArea.mCols.mEnd);
Dump1(" grid inline-axis: ", LogicalAxis::Inline);
}
#endif
/**
* Encapsulates CSS track-sizing functions.
*/
struct nsGridContainerFrame::TrackSizingFunctions {
private:
TrackSizingFunctions(const GridTemplate& aTemplate,
const StyleImplicitGridTracks& aAutoSizing,
const Maybe<size_t>& aRepeatAutoIndex, bool aIsSubgrid)
: mTemplate(aTemplate),
mTrackListValues(aTemplate.TrackListValues()),
mAutoSizing(aAutoSizing),
mExplicitGridOffset(0),
mRepeatAutoStart(aRepeatAutoIndex.valueOr(0)),
mRepeatAutoEnd(mRepeatAutoStart),
mHasRepeatAuto(aRepeatAutoIndex.isSome()) {
MOZ_ASSERT(!mHasRepeatAuto || !aIsSubgrid,
"a track-list for a subgrid can't have an <auto-repeat> track");
if (!aIsSubgrid) {
ExpandNonRepeatAutoTracks();
}
#ifdef DEBUG
if (mHasRepeatAuto) {
MOZ_ASSERT(mExpandedTracks.Length() >= 1);
const unsigned maxTrack = kMaxLine - 1;
// If the exanded tracks are out of range of the maximum track, we
// can't compare the repeat-auto start. It will be removed later during
// grid item placement in that situation.
if (mExpandedTracks.Length() < maxTrack) {
MOZ_ASSERT(mRepeatAutoStart < mExpandedTracks.Length());
}
}
#endif
}
public:
TrackSizingFunctions(const GridTemplate& aGridTemplate,
const StyleImplicitGridTracks& aAutoSizing,
bool aIsSubgrid)
: TrackSizingFunctions(aGridTemplate, aAutoSizing,
aGridTemplate.RepeatAutoIndex(), aIsSubgrid) {}
private:
enum { ForSubgridFallbackTag };
TrackSizingFunctions(const GridTemplate& aGridTemplate,
const StyleImplicitGridTracks& aAutoSizing,
decltype(ForSubgridFallbackTag))
: TrackSizingFunctions(aGridTemplate, aAutoSizing, Nothing(),
/* aIsSubgrid */ true) {}
public:
/**
* This is used in a subgridded axis to resolve sizes before its parent's
* sizes are known for intrinsic sizing purposes. It copies the slice of
* the nearest non-subgridded axis' track sizing functions spanned by
* the subgrid.
*
* FIXME: this was written before there was a spec... the spec now says:
* "If calculating the layout of a grid item in this step depends on
* the available space in the block axis, assume the available space
* that it would have if any row with a definite max track sizing
* function had that size and all other rows were infinite."
* https://drafts.csswg.org/css-grid-2/#subgrid-sizing
*/
static TrackSizingFunctions ForSubgridFallback(
nsGridContainerFrame* aSubgridFrame, const Subgrid* aSubgrid,
nsGridContainerFrame* aParentGridContainer, LogicalAxis aParentAxis) {
MOZ_ASSERT(aSubgrid);
MOZ_ASSERT(aSubgridFrame->IsSubgrid(aSubgrid->mIsOrthogonal
? GetOrthogonalAxis(aParentAxis)
: aParentAxis));
nsGridContainerFrame* parent = aParentGridContainer;
auto parentAxis = aParentAxis;
LineRange range = aSubgrid->mArea.LineRangeForAxis(parentAxis);
// Find our nearest non-subgridded axis and use its track sizing functions.
while (parent->IsSubgrid(parentAxis)) {
const auto* parentSubgrid = parent->GetProperty(Subgrid::Prop());
auto* grandParent = parent->ParentGridContainerForSubgrid();
auto grandParentWM = grandParent->GetWritingMode();
bool isSameDirInAxis =
parent->GetWritingMode().ParallelAxisStartsOnSameSide(parentAxis,
grandParentWM);
if (MOZ_UNLIKELY(!isSameDirInAxis)) {
auto end = parentAxis == LogicalAxis::Block
? parentSubgrid->mGridRowEnd
: parentSubgrid->mGridColEnd;
range.ReverseDirection(end);
// range is now in the same direction as the grand-parent's axis
}
auto grandParentAxis = parentSubgrid->mIsOrthogonal
? GetOrthogonalAxis(parentAxis)
: parentAxis;
const auto& parentRange =
parentSubgrid->mArea.LineRangeForAxis(grandParentAxis);
range.Translate(parentRange.mStart);
// range is now in the grand-parent's coordinates
parentAxis = grandParentAxis;
parent = grandParent;
}
const auto* pos = parent->StylePosition();
const auto isInlineAxis = parentAxis == LogicalAxis::Inline;
const auto& szf =
isInlineAxis ? pos->mGridTemplateRows : pos->mGridTemplateColumns;
const auto& autoSizing =
isInlineAxis ? pos->mGridAutoColumns : pos->mGridAutoRows;
return TrackSizingFunctions(szf, autoSizing, ForSubgridFallbackTag);
}
/**
* Initialize the number of auto-fill/fit tracks to use.
* This can be zero if no auto-fill/fit track was specified, or if the repeat
* begins after the maximum allowed track.
*/
void InitRepeatTracks(const NonNegativeLengthPercentageOrNormal& aGridGap,
nscoord aMinSize, nscoord aSize, nscoord aMaxSize) {
const uint32_t maxTrack = kMaxLine - 1;
// Check for a repeat after the maximum allowed track.
if (MOZ_UNLIKELY(mRepeatAutoStart >= maxTrack)) {
mHasRepeatAuto = false;
mRepeatAutoStart = 0;
mRepeatAutoEnd = 0;
return;
}
uint32_t repeatTracks =
CalculateRepeatFillCount(aGridGap, aMinSize, aSize, aMaxSize) *
NumRepeatTracks();
// Clamp the number of repeat tracks to the maximum possible track.
repeatTracks = std::min(repeatTracks, maxTrack - mRepeatAutoStart);
SetNumRepeatTracks(repeatTracks);
// Blank out the removed flags for each of these tracks.
mRemovedRepeatTracks.SetLength(repeatTracks);
for (auto& track : mRemovedRepeatTracks) {
track = false;
}
}
uint32_t CalculateRepeatFillCount(
const NonNegativeLengthPercentageOrNormal& aGridGap, nscoord aMinSize,
nscoord aSize, nscoord aMaxSize) const {
if (!mHasRepeatAuto) {
return 0;
}
// At this point no tracks will have been collapsed, so the RepeatEndDelta
// should not be negative.
MOZ_ASSERT(RepeatEndDelta() >= 0);
// Note that this uses NumRepeatTracks and mRepeatAutoStart/End, although
// the result of this method is used to change those values to a fully
// expanded value. Spec quotes are from
// https://drafts.csswg.org/css-grid/#repeat-notation
const uint32_t numTracks = mExpandedTracks.Length() + RepeatEndDelta();
MOZ_ASSERT(numTracks >= 1, "expected at least the repeat() track");
if (MOZ_UNLIKELY(numTracks >= kMaxLine)) {
// The fixed tracks plus an entire repetition is either larger or as
// large as the maximum track, so we do not need to measure how many
// repetitions will fit. This also avoids needing to check for if
// kMaxLine - numTracks would underflow at the end where we clamp the
// result.
return 1;
}
nscoord maxFill = aSize != NS_UNCONSTRAINEDSIZE ? aSize : aMaxSize;
if (maxFill == NS_UNCONSTRAINEDSIZE && aMinSize == 0) {
// "Otherwise, the specified track list repeats only once."
return 1;
}
nscoord repeatTrackSum = 0;
// 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) {
// "treating each track as its max track sizing function if that is
// definite or as its minimum track sizing function otherwise"
// https://drafts.csswg.org/css-grid/#valdef-repeat-auto-fill
const auto& sizingFunction = SizingFor(i);
const auto& maxCoord = sizingFunction.GetMax();
const auto* coord = &maxCoord;
if (!coord->IsBreadth()) {
coord = &sizingFunction.GetMin();
if (!coord->IsBreadth()) {
return 1;
}
}
nscoord trackSize = ::ResolveToDefiniteSize(*coord, percentBasis);
if (i >= mRepeatAutoStart && i < mRepeatAutoEnd) {
// Use a minimum 1px for the repeat() track-size.
if (trackSize < AppUnitsPerCSSPixel()) {
trackSize = AppUnitsPerCSSPixel();
}
repeatTrackSum += trackSize;
}
sum += trackSize;
}
nscoord gridGap = nsLayoutUtils::ResolveGapToLength(aGridGap, aSize);
if (numTracks > 1) {
// Add grid-gaps for all the tracks including the repeat() track.
sum += gridGap * (numTracks - 1);
}
// Calculate the max number of tracks that fits without overflow.
nscoord available = maxFill != NS_UNCONSTRAINEDSIZE ? maxFill : aMinSize;
nscoord spaceToFill = available - sum;
if (spaceToFill <= 0) {
// "if any number of repetitions would overflow, then 1 repetition"
return 1;
}
// Calculate the max number of tracks that fits without overflow.
// Since we already have one repetition in sum, we can simply add one grid
// gap for each element in the repeat.
div_t q = div(spaceToFill, repeatTrackSum + gridGap * NumRepeatTracks());
// 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."
++numRepeatTracks; // one more to ensure the grid is at least min-size
}
// Clamp the number of repeat tracks so that the last line <= kMaxLine.
// (note that |numTracks| already includes one repeat() track)
MOZ_ASSERT(numTracks >= NumRepeatTracks());
const uint32_t maxRepeatTrackCount = kMaxLine - numTracks;
const uint32_t maxRepetitions = maxRepeatTrackCount / NumRepeatTracks();
return std::min(numRepeatTracks, maxRepetitions);
}
/**
* Compute the explicit grid end line number (in a zero-based grid).
* @param aGridTemplateAreasEnd 'grid-template-areas' end line in this axis
*/
uint32_t ComputeExplicitGridEnd(uint32_t aGridTemplateAreasEnd) {
uint32_t end = NumExplicitTracks() + 1;
end = std::max(end, aGridTemplateAreasEnd);
end = std::min(end, uint32_t(kMaxLine));
return end;
}
const StyleTrackSize& SizingFor(uint32_t aTrackIndex) const {
static const StyleTrackSize kAutoTrackSize =
StyleTrackSize::Breadth(StyleTrackBreadth::Auto());
// |aIndex| is the relative index to mAutoSizing. A negative value means it
// is the last Nth element.
auto getImplicitSize = [this](int32_t aIndex) -> const StyleTrackSize& {
MOZ_ASSERT(!(mAutoSizing.Length() == 1 &&
mAutoSizing.AsSpan()[0] == kAutoTrackSize),
"It's impossible to have one track with auto value because we "
"filter out this case during parsing");
if (mAutoSizing.IsEmpty()) {
return kAutoTrackSize;
}
// If multiple track sizes are given, the pattern is repeated as necessary
// to find the size of the implicit tracks.
int32_t i = aIndex % int32_t(mAutoSizing.Length());
if (i < 0) {
i += mAutoSizing.Length();
}
return mAutoSizing.AsSpan()[i];
};
if (MOZ_UNLIKELY(aTrackIndex < mExplicitGridOffset)) {
// The last implicit grid track before the explicit grid receives the
// last specified size, and so on backwards. Therefore we pass the
// negative relative index to imply that we should get the implicit size
// from the last Nth specified grid auto size.
return getImplicitSize(int32_t(aTrackIndex) -
int32_t(mExplicitGridOffset));
}
uint32_t index = aTrackIndex - mExplicitGridOffset;
MOZ_ASSERT(mRepeatAutoStart <= mRepeatAutoEnd);
if (index >= mRepeatAutoStart) {
if (index < mRepeatAutoEnd) {
// Expand the repeat tracks.
const auto& indices = mExpandedTracks[mRepeatAutoStart];
const TrackListValue& value = mTrackListValues[indices.first];
// We expect the default to be used for all track repeats.
MOZ_ASSERT(indices.second == 0);
const auto& repeatTracks = value.AsTrackRepeat().track_sizes.AsSpan();
// Find the repeat track to use, skipping over any collapsed tracks.
const uint32_t finalRepeatIndex = (index - mRepeatAutoStart);
uint32_t repeatWithCollapsed = 0;
// NOTE: We need SizingFor before the final collapsed tracks are known.
// We know that it's invalid to have empty mRemovedRepeatTracks when
// there are any repeat tracks, so we can detect that situation here.
if (mRemovedRepeatTracks.IsEmpty()) {
repeatWithCollapsed = finalRepeatIndex;
} else {
// Count up through the repeat tracks, until we have seen
// finalRepeatIndex number of non-collapsed tracks.
for (uint32_t repeatNoCollapsed = 0;
repeatNoCollapsed < finalRepeatIndex; repeatWithCollapsed++) {
if (!mRemovedRepeatTracks[repeatWithCollapsed]) {
repeatNoCollapsed++;
}
}
// If we stopped iterating on a collapsed track, continue to the next
// non-collapsed track.
while (mRemovedRepeatTracks[repeatWithCollapsed]) {
repeatWithCollapsed++;
}
}
return repeatTracks[repeatWithCollapsed % repeatTracks.Length()];
} else {
// The index is after the repeat auto range, adjust it to skip over the
// repeat value. This will have no effect if there is no auto repeat,
// since then RepeatEndDelta will return zero.
index -= RepeatEndDelta();
}
}
if (index >= mExpandedTracks.Length()) {
return getImplicitSize(index - mExpandedTracks.Length());
}
auto& indices = mExpandedTracks[index];
const TrackListValue& value = mTrackListValues[indices.first];
if (value.IsTrackSize()) {
MOZ_ASSERT(indices.second == 0);
return value.AsTrackSize();
}
return value.AsTrackRepeat().track_sizes.AsSpan()[indices.second];
}
const StyleTrackBreadth& MaxSizingFor(uint32_t aTrackIndex) const {
return SizingFor(aTrackIndex).GetMax();
}
const StyleTrackBreadth& MinSizingFor(uint32_t aTrackIndex) const {
return SizingFor(aTrackIndex).GetMin();
}
uint32_t NumExplicitTracks() const {
return mExpandedTracks.Length() + RepeatEndDelta();
}
uint32_t NumRepeatTracks() const { return mRepeatAutoEnd - mRepeatAutoStart; }
// The difference between mExplicitGridEnd and mSizingFunctions.Length().
int32_t RepeatEndDelta() const {
return mHasRepeatAuto ? int32_t(NumRepeatTracks()) - 1 : 0;
}
void SetNumRepeatTracks(uint32_t aNumRepeatTracks) {
MOZ_ASSERT(mHasRepeatAuto || aNumRepeatTracks == 0);
mRepeatAutoEnd = mRepeatAutoStart + aNumRepeatTracks;
}
// Store mTrackListValues into mExpandedTracks with `repeat(INTEGER, ...)`
// tracks expanded.
void ExpandNonRepeatAutoTracks() {
for (size_t i = 0; i < mTrackListValues.Length(); ++i) {
auto& value = mTrackListValues[i];
if (value.IsTrackSize()) {
mExpandedTracks.EmplaceBack(i, 0);
continue;
}
auto& repeat = value.AsTrackRepeat();
if (!repeat.count.IsNumber()) {
MOZ_ASSERT(i == mRepeatAutoStart);
mRepeatAutoStart = mExpandedTracks.Length();
mRepeatAutoEnd = mRepeatAutoStart + repeat.track_sizes.Length();
mExpandedTracks.EmplaceBack(i, 0);
continue;
}
for (auto j : IntegerRange(repeat.count.AsNumber())) {
Unused << j;
size_t trackSizesCount = repeat.track_sizes.Length();
for (auto k : IntegerRange(trackSizesCount)) {
mExpandedTracks.EmplaceBack(i, k);
}
}
}
if (MOZ_UNLIKELY(mExpandedTracks.Length() > kMaxLine - 1)) {
mExpandedTracks.TruncateLength(kMaxLine - 1);
if (mHasRepeatAuto && mRepeatAutoStart > kMaxLine - 1) {
// The `repeat(auto-fill/fit)` track is outside the clamped grid.
mHasRepeatAuto = false;
}
}
}
// Some style data references, for easy access.
const GridTemplate& mTemplate;
const Span<const TrackListValue> mTrackListValues;
const StyleImplicitGridTracks& mAutoSizing;
// An array from expanded track sizes (without expanding auto-repeat, which is
// included just once at `mRepeatAutoStart`).
//
// Each entry contains two indices, the first into mTrackListValues, and a
// second one inside mTrackListValues' repeat value, if any, or zero
// otherwise.
nsTArray<std::pair<size_t, size_t>> mExpandedTracks;
// Offset from the start of the implicit grid to the first explicit track.
uint32_t mExplicitGridOffset;
// The index of the repeat(auto-fill/fit) track, or zero if there is none.
// Relative to mExplicitGridOffset (repeat tracks are explicit by definition).
uint32_t mRepeatAutoStart;
// The (hypothetical) index of the last such repeat() track.
uint32_t mRepeatAutoEnd;
// True if there is a specified repeat(auto-fill/fit) track.
bool mHasRepeatAuto;
// True if this track (relative to mRepeatAutoStart) is a removed auto-fit.
// Indexed relative to mExplicitGridOffset + mRepeatAutoStart.
nsTArray<bool> mRemovedRepeatTracks;
};
/**
* Utility class to find line names. It provides an interface to lookup line
* names with a dynamic number of repeat(auto-fill/fit) tracks taken into
* account.
*/
class MOZ_STACK_CLASS nsGridContainerFrame::LineNameMap {
public:
/**
* Create a LineNameMap.
* @param aStylePosition the style for the grid container
* @param aImplicitNamedAreas the implicit areas for the grid container
* @param aGridTemplate is the grid-template-rows/columns data for this axis
* @param aParentLineNameMap the parent grid's map parallel to this map, or
* null if this map isn't for a subgrid
* @param aRange the subgrid's range in the parent grid, or null
* @param aIsSameDirection true if our axis progresses in the same direction
* in the subgrid and parent
*/
LineNameMap(const nsStylePosition* aStylePosition,
const ImplicitNamedAreas* aImplicitNamedAreas,
const TrackSizingFunctions& aTracks,
const LineNameMap* aParentLineNameMap, const LineRange* aRange,
bool aIsSameDirection)
: mStylePosition(aStylePosition),
mAreas(aImplicitNamedAreas),
mRepeatAutoStart(aTracks.mRepeatAutoStart),
mRepeatAutoEnd(aTracks.mRepeatAutoEnd),
mRepeatEndDelta(aTracks.RepeatEndDelta()),
mParentLineNameMap(aParentLineNameMap),
mRange(aRange),
mIsSameDirection(aIsSameDirection),
mHasRepeatAuto(aTracks.mHasRepeatAuto) {
if (MOZ_UNLIKELY(aRange)) { // subgrid case
mClampMinLine = 1;
mClampMaxLine = 1 + aRange->Extent();
MOZ_ASSERT(aTracks.mTemplate.IsSubgrid(), "Should be subgrid type");
ExpandRepeatLineNamesForSubgrid(*aTracks.mTemplate.AsSubgrid());
// we've expanded all subgrid auto-fill lines in
// ExpandRepeatLineNamesForSubgrid()
mRepeatAutoStart = 0;
mRepeatAutoEnd = mRepeatAutoStart;
mHasRepeatAuto = false;
} else {
mClampMinLine = kMinLine;
mClampMaxLine = kMaxLine;
if (mHasRepeatAuto) {
mTrackAutoRepeatLineNames =
aTracks.mTemplate.GetRepeatAutoValue()->line_names.AsSpan();
}
ExpandRepeatLineNames(aTracks);
}
if (mHasRepeatAuto) {
// We need mTemplateLinesEnd to be after all line names.
// mExpandedLineNames has one repetition of the repeat(auto-fit/fill)
// track name lists already, so we must subtract the number of repeat
// track name lists to get to the number of non-repeat tracks, minus 2
// because the first and last line name lists are shared with the
// preceding and following non-repeat line name lists. We then add
// mRepeatEndDelta to include the interior line name lists from repeat
// tracks.
mTemplateLinesEnd = mExpandedLineNames.Length() -
(mTrackAutoRepeatLineNames.Length() - 2) +
mRepeatEndDelta;
} else {
mTemplateLinesEnd = mExpandedLineNames.Length();
}
MOZ_ASSERT(mHasRepeatAuto || mRepeatEndDelta <= 0);
MOZ_ASSERT(!mHasRepeatAuto || aRange ||
(mExpandedLineNames.Length() >= 2 &&
mRepeatAutoStart <= mExpandedLineNames.Length()));
}
// Store line names into mExpandedLineNames with `repeat(INTEGER, ...)`
// expanded for non-subgrid.
void ExpandRepeatLineNames(const TrackSizingFunctions& aTracks) {
auto lineNameLists = aTracks.mTemplate.LineNameLists(false);
const auto& trackListValues = aTracks.mTrackListValues;
const NameList* nameListToMerge = nullptr;
// NOTE(emilio): We rely on std::move clearing out the array.
SmallPointerArray<const NameList> names;
const uint32_t end =
std::min<uint32_t>(lineNameLists.Length(), mClampMaxLine + 1);
for (uint32_t i = 0; i < end; ++i) {
if (nameListToMerge) {
names.AppendElement(nameListToMerge);
nameListToMerge = nullptr;
}
names.AppendElement(&lineNameLists[i]);
if (i >= trackListValues.Length()) {
mExpandedLineNames.AppendElement(std::move(names));
continue;
}
const auto& value = trackListValues[i];
if (value.IsTrackSize()) {
mExpandedLineNames.AppendElement(std::move(names));
continue;
}
const auto& repeat = value.AsTrackRepeat();
if (!repeat.count.IsNumber()) {
const auto repeatNames = repeat.line_names.AsSpan();
// If the repeat was truncated due to more than kMaxLine tracks, then
// the repeat will no longer be set on mRepeatAutoStart).
MOZ_ASSERT(!mHasRepeatAuto ||
mRepeatAutoStart == mExpandedLineNames.Length());
MOZ_ASSERT(repeatNames.Length() >= 2);
for (const auto j : IntegerRange(repeatNames.Length() - 1)) {
names.AppendElement(&repeatNames[j]);
mExpandedLineNames.AppendElement(std::move(names));
}
nameListToMerge = &repeatNames[repeatNames.Length() - 1];
continue;
}
for (auto j : IntegerRange(repeat.count.AsNumber())) {
Unused << j;
if (nameListToMerge) {
names.AppendElement(nameListToMerge);
nameListToMerge = nullptr;
}
size_t trackSizesCount = repeat.track_sizes.Length();
auto repeatLineNames = repeat.line_names.AsSpan();
MOZ_ASSERT(repeatLineNames.Length() == trackSizesCount ||
repeatLineNames.Length() == trackSizesCount + 1);
for (auto k : IntegerRange(trackSizesCount)) {
names.AppendElement(&repeatLineNames[k]);
mExpandedLineNames.AppendElement(std::move(names));
}
if (repeatLineNames.Length() == trackSizesCount + 1) {
nameListToMerge = &repeatLineNames[trackSizesCount];
}
}
}
if (MOZ_UNLIKELY(mExpandedLineNames.Length() > uint32_t(mClampMaxLine))) {
mExpandedLineNames.TruncateLength(mClampMaxLine);
}
}
// Store line names into mExpandedLineNames with `repeat(INTEGER, ...)`
// expanded, and all `repeat(...)` expanded for subgrid.
// https://drafts.csswg.org/css-grid/#resolved-track-list-subgrid
void ExpandRepeatLineNamesForSubgrid(
const StyleGenericLineNameList<StyleInteger>& aStyleLineNameList) {
const auto& lineNameList = aStyleLineNameList.line_names.AsSpan();
const uint32_t maxCount = mClampMaxLine + 1;
const uint32_t end = lineNameList.Length();
for (uint32_t i = 0; i < end && mExpandedLineNames.Length() < maxCount;
++i) {
const auto& item = lineNameList[i];
if (item.IsLineNames()) {
// <line-names> case. Just copy it.
SmallPointerArray<const NameList> names;
names.AppendElement(&item.AsLineNames());
mExpandedLineNames.AppendElement(std::move(names));
continue;
}
MOZ_ASSERT(item.IsRepeat());
const auto& repeat = item.AsRepeat();
const auto repeatLineNames = repeat.line_names.AsSpan();
if (repeat.count.IsNumber()) {
// Clone all <line-names>+ (repeated by N) into
// |mExpandedLineNames|.
for (uint32_t repeatCount = 0;
repeatCount < (uint32_t)repeat.count.AsNumber(); ++repeatCount) {
for (const NameList& lineNames : repeatLineNames) {
SmallPointerArray<const NameList> names;
names.AppendElement(&lineNames);
mExpandedLineNames.AppendElement(std::move(names));
if (mExpandedLineNames.Length() >= maxCount) {
break;
}
}
}
continue;
}
MOZ_ASSERT(repeat.count.IsAutoFill(),
"RepeatCount of subgrid is number or auto-fill");
const size_t fillLen = repeatLineNames.Length();
const int32_t extraAutoFillLineCount =
mClampMaxLine -
(int32_t)aStyleLineNameList.expanded_line_names_length;
// Maximum possible number of repeat name lists.
// Note: |expanded_line_names_length| doesn't include auto repeat.
const uint32_t possibleRepeatLength =
std::max<int32_t>(0, extraAutoFillLineCount);
const uint32_t repeatRemainder = possibleRepeatLength % fillLen;
// Note: Expand 'auto-fill' names for subgrid for now since
// HasNameAt() only deals with auto-repeat **tracks** currently.
const size_t len = possibleRepeatLength - repeatRemainder;
for (size_t j = 0; j < len; ++j) {
SmallPointerArray<const NameList> names;
names.AppendElement(&repeatLineNames[j % fillLen]);
mExpandedLineNames.AppendElement(std::move(names));
if (mExpandedLineNames.Length() >= maxCount) {
break;
}
}
}
if (MOZ_UNLIKELY(mExpandedLineNames.Length() > uint32_t(mClampMaxLine))) {
mExpandedLineNames.TruncateLength(mClampMaxLine);
}
}
/**
* Find the aNth occurrence of aName, searching forward if aNth is positive,
* and in reverse if aNth is negative (aNth == 0 is invalid), starting from
* aFromIndex (not inclusive), and return a 1-based line number.
* Also take into account there is an unconditional match at the lines in
* aImplicitLines.
* Return zero if aNth occurrences can't be found. In that case, aNth has
* been decremented with the number of occurrences that were found (if any).
*
* E.g. to search for "A 2" forward from the start of the grid: aName is "A"
* aNth is 2 and aFromIndex is zero. To search for "A -2", aNth is -2 and
* aFromIndex is ExplicitGridEnd + 1 (which is the line "before" the last
* line when we're searching in reverse). For "span A 2", aNth is 2 when
* used on a grid-[row|column]-end property and -2 for a *-start property,
* and aFromIndex is the line (which we should skip) on the opposite property.
*/
uint32_t FindNamedLine(nsAtom* aName, int32_t* aNth, uint32_t aFromIndex,
const nsTArray<uint32_t>& aImplicitLines) const {
MOZ_ASSERT(aName);
MOZ_ASSERT(!aName->IsEmpty());
MOZ_ASSERT(aNth && *aNth != 0);
if (*aNth > 0) {
return FindLine(aName, aNth, aFromIndex, aImplicitLines);
}
int32_t nth = -*aNth;
int32_t line = RFindLine(aName, &nth, aFromIndex, aImplicitLines);
*aNth = -nth;
return line;
}
/**
* Return a set of lines in aImplicitLines which matches the area name aName
* on aSide. For example, for aName "a" and aSide being an end side, it
* returns the line numbers which would match "a-end" in the relevant axis.
* For subgrids it includes searching the relevant axis in all ancestor
* grids too (within this subgrid's spanned area). If an ancestor has
* opposite direction, we switch aSide to the opposite logical side so we
* match on the same physical side as the original subgrid we're resolving
* the name for.
*/
void FindNamedAreas(nsAtom* aName, LogicalSide aSide,
nsTArray<uint32_t>& aImplicitLines) const {
// True if we're currently in a map that has the same direction as 'this'.
bool sameDirectionAsThis = true;
uint32_t min = !mParentLineNameMap ? 1 : mClampMinLine;
uint32_t max = mClampMaxLine;
for (auto* map = this; true;) {
uint32_t line = map->FindNamedArea(aName, aSide, min, max);
if (line > 0) {
if (MOZ_LIKELY(sameDirectionAsThis)) {
line -= min - 1;
} else {
line = max - line + 1;
}
aImplicitLines.AppendElement(line);
}
auto* parent = map->mParentLineNameMap;
if (!parent) {
if (MOZ_UNLIKELY(aImplicitLines.Length() > 1)) {
// Remove duplicates and sort in ascending order.
aImplicitLines.Sort();
for (size_t i = 0; i < aImplicitLines.Length(); ++i) {
uint32_t prev = aImplicitLines[i];
auto j = i + 1;
const auto start = j;
while (j < aImplicitLines.Length() && aImplicitLines[j] == prev) {
++j;
}
if (j != start) {
aImplicitLines.RemoveElementsAt(start, j - start);
}
}
}
return;
}
if (MOZ_UNLIKELY(!map->mIsSameDirection)) {
aSide = GetOppositeSide(aSide);
sameDirectionAsThis = !sameDirectionAsThis;
}
min = map->TranslateToParentMap(min);
max = map->TranslateToParentMap(max);
if (min > max) {
MOZ_ASSERT(!map->mIsSameDirection);
std::swap(min, max);
}
map = parent;
}
}
/**
* Return true if any implicit named areas match aName, in this map or
* in any of our ancestor maps.
*/
bool HasImplicitNamedArea(nsAtom* aName) const {
const auto* map = this;
do {
if (map->mAreas && map->mAreas->has(aName)) {
return true;
}
map = map->mParentLineNameMap;
} while (map);
return false;
}
// For generating line name data for devtools.
nsTArray<nsTArray<StyleCustomIdent>>
GetResolvedLineNamesForComputedGridTrackInfo() const {
nsTArray<nsTArray<StyleCustomIdent>> result;
for (auto& expandedLine : mExpandedLineNames) {
nsTArray<StyleCustomIdent> line;
for (auto* chunk : expandedLine) {
for (auto& name : chunk->AsSpan()) {
line.AppendElement(name);
}
}
result.AppendElement(std::move(line));
}
return result;
}
nsTArray<RefPtr<nsAtom>> GetExplicitLineNamesAtIndex(uint32_t aIndex) const {
nsTArray<RefPtr<nsAtom>> lineNames;
if (aIndex < mTemplateLinesEnd) {
const auto nameLists = GetLineNamesAt(aIndex);
for (const NameList* nameList : nameLists) {
for (const auto& name : nameList->AsSpan()) {
lineNames.AppendElement(name.AsAtom());
}
}
}
return lineNames;
}
const nsTArray<SmallPointerArray<const NameList>>& ExpandedLineNames() const {
return mExpandedLineNames;
}
const Span<const StyleOwnedSlice<StyleCustomIdent>>&
TrackAutoRepeatLineNames() const {
return mTrackAutoRepeatLineNames;
}
bool HasRepeatAuto() const { return mHasRepeatAuto; }
uint32_t NumRepeatTracks() const { return mRepeatAutoEnd - mRepeatAutoStart; }
uint32_t RepeatAutoStart() const { return mRepeatAutoStart; }
// The min/max line number (1-based) for clamping.
int32_t mClampMinLine;
int32_t mClampMaxLine;
private:
// Return true if this map represents a subgridded axis.
bool IsSubgridded() const { return mParentLineNameMap != nullptr; }
/**
* @see FindNamedLine, this function searches forward.
*/
uint32_t FindLine(nsAtom* aName, int32_t* aNth, uint32_t aFromIndex,
const nsTArray<uint32_t>& aImplicitLines) const {
MOZ_ASSERT(aNth && *aNth > 0);
int32_t nth = *aNth;
// For a subgrid we need to search to the end of the grid rather than
// the end of the local name list, since ancestors might match.
const uint32_t end = IsSubgridded() ? mClampMaxLine : mTemplateLinesEnd;
uint32_t line;
uint32_t i = aFromIndex;
for (; i < end; i = line) {
line = i + 1;
if (Contains(i, aName) || aImplicitLines.Contains(line)) {
if (--nth == 0) {
return line;
}
}
}
for (auto implicitLine : aImplicitLines) {
if (implicitLine > i) {
// implicitLine is after the lines we searched above so it's last.
// (grid-template-areas has more tracks than
// grid-template-[rows|columns])
if (--nth == 0) {
return implicitLine;
}
}
}
MOZ_ASSERT(nth > 0, "should have returned a valid line above already");
*aNth = nth;
return 0;
}
/**
* @see FindNamedLine, this function searches in reverse.
*/
uint32_t RFindLine(nsAtom* aName, int32_t* aNth, uint32_t aFromIndex,
const nsTArray<uint32_t>& aImplicitLines) const {
MOZ_ASSERT(aNth && *aNth > 0);
if (MOZ_UNLIKELY(aFromIndex == 0)) {
return 0; // There are no named lines beyond the start of the explicit
// grid.
}
--aFromIndex; // (shift aFromIndex so we can treat it as inclusive)
int32_t nth = *aNth;
// Implicit lines may be beyond the explicit grid so we match those
// first if it's within the mTemplateLinesEnd..aFromIndex range.
// aImplicitLines is presumed sorted.
// For a subgrid we need to search to the end of the grid rather than
// the end of the local name list, since ancestors might match.
const uint32_t end = IsSubgridded() ? mClampMaxLine : mTemplateLinesEnd;
for (auto implicitLine : Reversed(aImplicitLines)) {
if (implicitLine <= end) {
break;
}
if (implicitLine < aFromIndex) {
if (--nth == 0) {
return implicitLine;
}
}
}
for (uint32_t i = std::min(aFromIndex, end); i; --i) {
if (Contains(i - 1, aName) || aImplicitLines.Contains(i)) {
if (--nth == 0) {
return i;
}
}
}
MOZ_ASSERT(nth > 0, "should have returned a valid line above already");
*aNth = nth;
return 0;
}
// Return true if aName exists at aIndex in this map or any parent map.
bool Contains(uint32_t aIndex, nsAtom* aName) const {
const auto* map = this;
while (true) {
if (aIndex < map->mTemplateLinesEnd && map->HasNameAt(aIndex, aName)) {
return true;
}
auto* parent = map->mParentLineNameMap;
if (!parent) {
return false;
}
uint32_t line = map->TranslateToParentMap(aIndex + 1);
MOZ_ASSERT(line >= 1, "expected a 1-based line number");
aIndex = line - 1;
map = parent;
}
MOZ_ASSERT_UNREACHABLE("we always return from inside the loop above");
}
static bool Contains(Span<const StyleCustomIdent> aNames, nsAtom* aName) {
for (auto& name : aNames) {
if (name.AsAtom() == aName) {
return true;
}
}
return false;
}
// Return true if aName exists at aIndex in this map.
bool HasNameAt(const uint32_t aIndex, nsAtom* const aName) const {
const auto nameLists = GetLineNamesAt(aIndex);
for (const NameList* nameList : nameLists) {
if (Contains(nameList->AsSpan(), aName)) {
return true;
}
}
return false;
}
// Get the line names at an index.
// This accounts for auto repeat. The results may be spread over multiple name
// lists returned in the array, which is done to avoid unneccessarily copying
// the arrays to concatenate them.
SmallPointerArray<const NameList> GetLineNamesAt(
const uint32_t aIndex) const {
SmallPointerArray<const NameList> names;
// The index into mExpandedLineNames to use, if aIndex doesn't point to a
// name inside of a auto repeat.
uint32_t repeatAdjustedIndex = aIndex;
// Note: For subgrid, |mHasRepeatAuto| is always false because we have
// expanded it in the constructor of LineNameMap.
if (mHasRepeatAuto) {
// If the index is inside of the auto repeat, use the repeat line
// names. Otherwise, if the index is past the end of the repeat it must
// be adjusted to acount for the repeat tracks.
// mExpandedLineNames has the first and last line name lists from the
// repeat in it already, so we can just ignore aIndex == mRepeatAutoStart
// and treat when aIndex == mRepeatAutoEnd the same as any line after the
// the repeat.
const uint32_t maxRepeatLine = mTrackAutoRepeatLineNames.Length() - 1;
if (aIndex > mRepeatAutoStart && aIndex < mRepeatAutoEnd) {
// The index is inside the auto repeat. Calculate the lines to use,
// including the previous repetitions final names when we roll over
// from one repetition to the next.
const uint32_t repeatIndex =
(aIndex - mRepeatAutoStart) % maxRepeatLine;
if (repeatIndex == 0) {
// The index is at the start of a new repetition. The start of the
// first repetition is intentionally ignored above, so this will
// consider both the end of the previous repetition and the start
// the one that contains aIndex.
names.AppendElement(&mTrackAutoRepeatLineNames[maxRepeatLine]);
}
names.AppendElement(&mTrackAutoRepeatLineNames[repeatIndex]);
return names;
}
if (aIndex != mRepeatAutoStart && aIndex >= mRepeatAutoEnd) {
// Adjust the index to account for the line names of the repeat.
repeatAdjustedIndex -= mRepeatEndDelta;
repeatAdjustedIndex += mTrackAutoRepeatLineNames.Length() - 2;
}
}
MOZ_ASSERT(repeatAdjustedIndex < mExpandedLineNames.Length(),
"Incorrect repeatedAdjustedIndex");
MOZ_ASSERT(names.IsEmpty());
// The index is not inside the repeat tracks, or no repeat tracks exist.
const auto& nameLists = mExpandedLineNames[repeatAdjustedIndex];
for (const NameList* nameList : nameLists) {
names.AppendElement(nameList);
}
return names;
}
// Translate a subgrid line (1-based) to a parent line (1-based).
uint32_t TranslateToParentMap(uint32_t aLine) const {
if (MOZ_LIKELY(mIsSameDirection)) {
return aLine + mRange->mStart;
}
MOZ_ASSERT(mRange->mEnd + 1 >= aLine);
return mRange->mEnd - (aLine - 1) + 1;
}
/**
* Return the 1-based line that match aName in 'grid-template-areas'
* on the side aSide. Clamp the result to aMin..aMax but require
* that some part of the area is inside for it to match.
* Return zero if there is no match.
*/
uint32_t FindNamedArea(nsAtom* aName, LogicalSide aSide, int32_t aMin,
int32_t aMax) const {
if (const NamedArea* area = FindNamedArea(aName)) {
int32_t start = IsBlock(aSide) ? area->rows.start : area->columns.start;
int32_t end = IsBlock(aSide) ? area->rows.end : area->columns.end;
if (IsStart(aSide)) {
if (start >= aMin) {
if (start <= aMax) {
return start;
}
} else if (end >= aMin) {
return aMin;
}
} else {
if (end <= aMax) {
if (end >= aMin) {
return end;
}
} else if (start <= aMax) {
return aMax;
}
}
}
return 0; // no match
}
/**
* A convenience method to lookup a name in 'grid-template-areas'.
* @return null if not found
*/
const NamedArea* FindNamedArea(nsAtom* aName) const {
if (mStylePosition->mGridTemplateAreas.IsNone()) {
return nullptr;
}
const auto areas = mStylePosition->mGridTemplateAreas.AsAreas();
for (const NamedArea& area : areas->areas.AsSpan()) {
if (area.name.AsAtom() == aName) {
return &area;
}
}
return nullptr;
}
// Some style data references, for easy access.
const nsStylePosition* mStylePosition;
const ImplicitNamedAreas* mAreas;
// The expanded list of line-names. Each entry is usually a single NameList,
// but can be multiple in the case where repeat() expands to something that
// has a line name list at the end.
nsTArray<SmallPointerArray<const NameList>> mExpandedLineNames;
// The repeat(auto-fill/fit) track value, if any. (always empty for subgrid)
Span<const StyleOwnedSlice<StyleCustomIdent>> mTrackAutoRepeatLineNames;
// The index of the repeat(auto-fill/fit) track, or zero if there is none.
uint32_t mRepeatAutoStart;
// The index one past the end of the repeat(auto-fill/fit) tracks. Equal to
// mRepeatAutoStart if there are no repeat(auto-fill/fit) tracks.
uint32_t mRepeatAutoEnd;
// The total number of repeat tracks minus 1.
int32_t mRepeatEndDelta;
// The end of the line name lists with repeat(auto-fill/fit) tracks accounted
// for.
uint32_t mTemplateLinesEnd;
// The parent line map, or null if this map isn't for a subgrid.
const LineNameMap* mParentLineNameMap;
// The subgrid's range, or null if this map isn't for a subgrid.
const LineRange* mRange;
// True if the subgrid/parent axes progresses in the same direction.
const bool mIsSameDirection;
// True if there is a specified repeat(auto-fill/fit) track.
bool mHasRepeatAuto;
};
/**
* State for the tracks in one dimension.
*/
struct nsGridContainerFrame::Tracks {
explicit Tracks(LogicalAxis aAxis)
: mContentBoxSize(NS_UNCONSTRAINEDSIZE),
mGridGap(NS_UNCONSTRAINEDSIZE),
mStateUnion(TrackSize::StateBits{0}),
mAxis(aAxis),
mCanResolveLineRangeSize(false),
mIsMasonry(false) {
mBaselineSubtreeAlign[BaselineSharingGroup::First] = StyleAlignFlags::AUTO;
mBaselineSubtreeAlign[BaselineSharingGroup::Last] = StyleAlignFlags::AUTO;
mBaseline[BaselineSharingGroup::First] = NS_INTRINSIC_ISIZE_UNKNOWN;
mBaseline[BaselineSharingGroup::Last] = NS_INTRINSIC_ISIZE_UNKNOWN;
}
void Initialize(const TrackSizingFunctions& aFunctions,
const NonNegativeLengthPercentageOrNormal& aGridGap,
uint32_t aNumTracks, nscoord aContentBoxSize);
/**
* Return the union of the state bits for the tracks in aRange.
*/
TrackSize::StateBits StateBitsForRange(const LineRange& aRange) const;
// Some data we collect for aligning baseline-aligned items.
struct ItemBaselineData {
uint32_t mBaselineTrack;
nscoord mBaseline;
nscoord mSize;
GridItemInfo* mGridItem;
static bool IsBaselineTrackLessThan(const ItemBaselineData& a,
const ItemBaselineData& b) {
return a.mBaselineTrack < b.mBaselineTrack;
}
};
/**
* Calculate baseline offsets for the given set of items.
* Helper for InitialzeItemBaselines.
*/
void CalculateItemBaselines(nsTArray<ItemBaselineData>& aBaselineItems,
BaselineSharingGroup aBaselineGroup);
/**
* Initialize grid item baseline state and offsets.
*/
void InitializeItemBaselines(GridReflowInput& aState,
nsTArray<GridItemInfo>& aGridItems);
/**
* A masonry axis has four baseline alignment sets and each set can have
* a first- and last-baseline alignment group, for a total of eight possible
* baseline alignment groups, as follows:
* set 1: the first item in each `start` or `stretch` grid track
* set 2: the last item in each `start` grid track
* set 3: the last item in each `end` or `stretch` grid track
* set 4: the first item in each `end` grid track
* (`start`/`end`/`stretch` refers to the relevant `align/justify-tracks`
* value of the (grid-axis) start track for the item) Baseline-alignment for
* set 1 and 2 always adjusts the item's padding or margin on the start side,
* and set 3 and 4 on the end side, for both first- and last-baseline groups
* in the set. (This is similar to regular grid which always adjusts
* first-baseline groups on the start side and last-baseline groups on the
* end-side. The crux is that those groups are always aligned to the track's
* start/end side respectively.)
*/
struct BaselineAlignmentSet {
bool MatchTrackAlignment(StyleAlignFlags aTrackAlignment) const {
if (mTrackAlignmentSet == BaselineAlignmentSet::StartStretch) {
return aTrackAlignment == StyleAlignFlags::START ||
(aTrackAlignment == StyleAlignFlags::STRETCH &&
mItemSet == BaselineAlignmentSet::FirstItems);
}
return aTrackAlignment == StyleAlignFlags::END ||
(aTrackAlignment == StyleAlignFlags::STRETCH &&
mItemSet == BaselineAlignmentSet::LastItems);
}
enum ItemSet { FirstItems, LastItems };
ItemSet mItemSet = FirstItems;
enum TrackAlignmentSet { StartStretch, EndStretch };
TrackAlignmentSet mTrackAlignmentSet = StartStretch;
};
void InitializeItemBaselinesInMasonryAxis(
GridReflowInput& aState, nsTArray<GridItemInfo>& aGridItems,
BaselineAlignmentSet aSet, const nsSize& aContainerSize,
nsTArray<nscoord>& aTrackSizes,
nsTArray<ItemBaselineData>& aFirstBaselineItems,
nsTArray<ItemBaselineData>& aLastBaselineItems);
/**
* Apply the additional alignment needed to align the baseline-aligned subtree
* the item belongs to within its baseline track.
*/
void AlignBaselineSubtree(const GridItemInfo& aGridItem) const;
enum class TrackSizingPhase {
IntrinsicMinimums,
ContentBasedMinimums,
MaxContentMinimums,
IntrinsicMaximums,
MaxContentMaximums,
};
// Some data we collect on each item that spans more than one track for step 3
// and 4 of the Track Sizing Algorithm in ResolveIntrinsicSize below.
// https://w3c.github.io/csswg-drafts/css-grid-1/#algo-spanning-items
struct SpanningItemData final {
uint32_t mSpan;
TrackSize::StateBits mState;
LineRange mLineRange;
nscoord mMinSize;
nscoord mMinContentContribution;
nscoord mMaxContentContribution;
nsIFrame* mFrame;
static bool IsSpanLessThan(const SpanningItemData& a,
const SpanningItemData& b) {
return a.mSpan < b.mSpan;
}
template <TrackSizingPhase phase>
nscoord SizeContributionForPhase() const {
switch (phase) {
case TrackSizingPhase::IntrinsicMinimums:
return mMinSize;
case TrackSizingPhase::ContentBasedMinimums:
case TrackSizingPhase::IntrinsicMaximums:
return mMinContentContribution;
case TrackSizingPhase::MaxContentMinimums:
case TrackSizingPhase::MaxContentMaximums:
return mMaxContentContribution;
}
MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("Unexpected phase");
}
#ifdef DEBUG
void Dump() const {
printf(
"SpanningItemData { mSpan: %d, mState: %d, mLineRange: (%d, %d), "
"mMinSize: %d, mMinContentContribution: %d, mMaxContentContribution: "
"%d, mFrame: %p\n",
mSpan, mState, mLineRange.mStart, mLineRange.mEnd, mMinSize,
mMinContentContribution, mMaxContentContribution, mFrame);
}
#endif
};
using FitContentClamper =
std::function<bool(uint32_t aTrack, nscoord aMinSize, nscoord* aSize)>;
// Helper method for ResolveIntrinsicSize.
template <TrackSizingPhase phase>
bool GrowSizeForSpanningItems(
nsTArray<SpanningItemData>::iterator aIter,
nsTArray<SpanningItemData>::iterator aIterEnd,
nsTArray<uint32_t>& aTracks, nsTArray<TrackSize>& aPlan,
nsTArray<TrackSize>& aItemPlan, TrackSize::StateBits aSelector,
const FitContentClamper& aFitContentClamper = nullptr,
bool aNeedInfinitelyGrowableFlag = false);
/**
* Resolve Intrinsic Track Sizes.
* http://dev.w3.org/csswg/css-grid/#algo-content
*/
void ResolveIntrinsicSize(GridReflowInput& aState,
nsTArray<GridItemInfo>& aGridItems,
const TrackSizingFunctions& aFunctions,
LineRange GridArea::*aRange,
nscoord aPercentageBasis,
SizingConstraint aConstraint);
/**
* Helper for ResolveIntrinsicSize. It implements step 1 "size tracks to fit
* non-spanning items" in the spec. Return true if the track has a <flex>
* max-sizing function, false otherwise.
*/
bool ResolveIntrinsicSizeForNonSpanningItems(
GridReflowInput& aState, const TrackSizingFunctions& aFunctions,
nscoord aPercentageBasis, SizingConstraint aConstraint,
const LineRange& aRange, const GridItemInfo& aGridItem);
// Helper method that returns the track size to use in §11.5.1.2
// https://drafts.csswg.org/css-grid/#extra-space
template <TrackSizingPhase phase>
static nscoord StartSizeInDistribution(const TrackSize& aSize) {
switch (phase) {
case TrackSizingPhase::IntrinsicMinimums:
case TrackSizingPhase::ContentBasedMinimums:
case TrackSizingPhase::MaxContentMinimums:
return aSize.mBase;
case TrackSizingPhase::IntrinsicMaximums:
case TrackSizingPhase::MaxContentMaximums:
if (aSize.mLimit == NS_UNCONSTRAINEDSIZE) {
return aSize.mBase;
}
return aSize.mLimit;
}
MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("Unexpected phase");
}
/**
* Collect the tracks which are growable (matching aSelector) into
* aGrowableTracks, and return the amount of space that can be used
* to grow those tracks. This method implements CSS Grid §11.5.1.2.
* https://drafts.csswg.org/css-grid/#extra-space
*/
template <TrackSizingPhase phase>
nscoord CollectGrowable(nscoord aAvailableSpace, const LineRange& aRange,
TrackSize::StateBits aSelector,
nsTArray<uint32_t>& aGrowableTracks) const {
MOZ_ASSERT(aAvailableSpace > 0, "why call me?");
nscoord space = aAvailableSpace - mGridGap * (aRange.Extent() - 1);
for (auto i : aRange.Range()) {
const TrackSize& sz = mSizes[i];
space -= StartSizeInDistribution<phase>(sz);
if (space <= 0) {
return 0;
}
if (sz.mState & aSelector) {
aGrowableTracks.AppendElement(i);
}
}
return aGrowableTracks.IsEmpty() ? 0 : space;
}
template <TrackSizingPhase phase>
void InitializeItemPlan(nsTArray<TrackSize>& aItemPlan,
const nsTArray<uint32_t>& aTracks) const {
for (uint32_t track : aTracks) {
auto& plan = aItemPlan[track];
const TrackSize& sz = mSizes[track];
plan.mBase = StartSizeInDistribution<phase>(sz);
bool unlimited = sz.mState & TrackSize::eInfinitelyGrowable;
plan.mLimit = unlimited ? NS_UNCONSTRAINEDSIZE : sz.mLimit;
plan.mState = sz.mState;
}
}
template <TrackSizingPhase phase>
void InitializePlan(nsTArray<TrackSize>& aPlan) const {
for (size_t i = 0, len = aPlan.Length(); i < len; ++i) {
auto& plan = aPlan[i];
const auto& sz = mSizes[i];
plan.mBase = StartSizeInDistribution<phase>(sz);
MOZ_ASSERT(phase == TrackSizingPhase::MaxContentMaximums ||
!(sz.mState & TrackSize::eInfinitelyGrowable),
"forgot to reset the eInfinitelyGrowable bit?");
plan.mState = sz.mState;
}
}
template <TrackSizingPhase phase>
void CopyPlanToSize(const nsTArray<TrackSize>& aPlan,
bool aNeedInfinitelyGrowableFlag = false) {
for (size_t i = 0, len = mSizes.Length(); i < len; ++i) {
const auto& plan = aPlan[i];
MOZ_ASSERT(plan.mBase >= 0);
auto& sz = mSizes[i];
switch (phase) {
case TrackSizingPhase::IntrinsicMinimums:
case TrackSizingPhase::ContentBasedMinimums:
case TrackSizingPhase::MaxContentMinimums:
sz.mBase = plan.mBase;
break;
case TrackSizingPhase::IntrinsicMaximums:
if (plan.mState & TrackSize::eModified) {
if (sz.mLimit == NS_UNCONSTRAINEDSIZE &&
aNeedInfinitelyGrowableFlag) {
sz.mState |= TrackSize::eInfinitelyGrowable;
}
sz.mLimit = plan.mBase;
}
break;
case TrackSizingPhase::MaxContentMaximums:
if (plan.mState & TrackSize::eModified) {
sz.mLimit = plan.mBase;
}
sz.mState &= ~TrackSize::eInfinitelyGrowable;
break;
}
}
}
/**
* Grow the planned size for tracks in aGrowableTracks up to their limit
* and then freeze them (all aGrowableTracks must be unfrozen on entry).
* Subtract the space added from aAvailableSpace and return that.
*/
nscoord GrowTracksToLimit(nscoord aAvailableSpace, nsTArray<TrackSize>& aPlan,
const nsTArray<uint32_t>& aGrowableTracks,
const FitContentClamper& aFitContentClamper) const {
MOZ_ASSERT(aAvailableSpace > 0 && aGrowableTracks.Length() > 0);
nscoord space = aAvailableSpace;
uint32_t numGrowable = aGrowableTracks.Length();
while (true) {
nscoord spacePerTrack = std::max<nscoord>(space / numGrowable, 1);
for (uint32_t track : aGrowableTracks) {
TrackSize& sz = aPlan[track];
if (sz.IsFrozen()) {
continue;
}
nscoord newBase = sz.mBase + spacePerTrack;
nscoord limit = sz.mLimit;
if (MOZ_UNLIKELY((sz.mState & TrackSize::eFitContent) &&
aFitContentClamper)) {
// Clamp the limit to the fit-content() size, for §12.5.2 step 5/6.
aFitContentClamper(track, sz.mBase, &limit);
}
if (newBase > limit) {
nscoord consumed = limit - sz.mBase;
if (consumed > 0) {
space -= consumed;
sz.mBase = limit;
}
sz.mState |= TrackSize::eFrozen;
if (--numGrowable == 0) {
return space;
}
} else {
sz.mBase = newBase;
space -= spacePerTrack;
}
MOZ_ASSERT(space >= 0);
if (space == 0) {
return 0;
}
}
}
MOZ_ASSERT_UNREACHABLE("we don't exit the loop above except by return");
return 0;
}
/**
* Helper for GrowSelectedTracksUnlimited. For the set of tracks (S) that
* match aMinSizingSelector: if a track in S doesn't match aMaxSizingSelector
* then mark it with aSkipFlag. If all tracks in S were marked then unmark
* them. Return aNumGrowable minus the number of tracks marked. It is
* assumed that aPlan have no aSkipFlag set for tracks in aGrowableTracks
* on entry to this method.
*/
static uint32_t MarkExcludedTracks(nsTArray<TrackSize>& aPlan,
uint32_t aNumGrowable,
const nsTArray<uint32_t>& aGrowableTracks,
TrackSize::StateBits aMinSizingSelector,
TrackSize::StateBits aMaxSizingSelector,
TrackSize::StateBits aSkipFlag) {
bool foundOneSelected = false;
bool foundOneGrowable = false;
uint32_t numGrowable = aNumGrowable;
for (uint32_t track : aGrowableTracks) {
TrackSize& sz = aPlan[track];
const auto state = sz.mState;
if (state & aMinSizingSelector) {
foundOneSelected = true;
if (state & aMaxSizingSelector) {
foundOneGrowable = true;
continue;
}
sz.mState |= aSkipFlag;
MOZ_ASSERT(numGrowable != 0);
--numGrowable;
}
}
// 12.5 "if there are no such tracks, then all affected tracks"
if (foundOneSelected && !foundOneGrowable) {
for (uint32_t track : aGrowableTracks) {
aPlan[track].mState &= ~aSkipFlag;
}
numGrowable = aNumGrowable;
}
return numGrowable;
}
/**
* Mark all tracks in aGrowableTracks with an eSkipGrowUnlimited bit if
* they *shouldn't* grow unlimited in §11.5.1.2.3 "Distribute space beyond
* growth limits" https://drafts.csswg.org/css-grid/#extra-space
* Return the number of tracks that are still growable.
*/
template <TrackSizingPhase phase>
static uint32_t MarkExcludedTracks(nsTArray<TrackSize>& aPlan,
const nsTArray<uint32_t>& aGrowableTracks,
TrackSize::StateBits aSelector) {
uint32_t numGrowable = aGrowableTracks.Length();
if (phase == TrackSizingPhase::IntrinsicMaximums ||
phase == TrackSizingPhase::MaxContentMaximums) {
// "when handling any intrinsic growth limit: all affected tracks"
return numGrowable;
}
MOZ_ASSERT(aSelector == (aSelector & TrackSize::eIntrinsicMinSizing) &&
(aSelector & TrackSize::eMaxContentMinSizing),
"Should only get here for track sizing steps 2.1 to 2.3");
// Note that eMaxContentMinSizing is always included. We do those first:
numGrowable = MarkExcludedTracks(
aPlan, numGrowable, aGrowableTracks, TrackSize::eMaxContentMinSizing,
TrackSize::eMaxContentMaxSizing, TrackSize::eSkipGrowUnlimited1);
// Now mark min-content/auto min-sizing tracks if requested.
auto minOrAutoSelector = aSelector & ~TrackSize::eMaxContentMinSizing;
if (minOrAutoSelector) {
numGrowable = MarkExcludedTracks(
aPlan, numGrowable, aGrowableTracks, minOrAutoSelector,
TrackSize::eIntrinsicMaxSizing, TrackSize::eSkipGrowUnlimited2);
}
return numGrowable;
}
/**
* Increase the planned size for tracks in aGrowableTracks that aren't
* marked with a eSkipGrowUnlimited flag beyond their limit.
* This implements the "Distribute space beyond growth limits" step in
* https://drafts.csswg.org/css-grid/#distribute-extra-space
*/
void GrowSelectedTracksUnlimited(
nscoord aAvailableSpace, nsTArray<TrackSize>& aPlan,
const nsTArray<uint32_t>& aGrowableTracks, uint32_t aNumGrowable,
const FitContentClamper& aFitContentClamper) const {
MOZ_ASSERT(aAvailableSpace > 0 && aGrowableTracks.Length() > 0 &&
aNumGrowable <= aGrowableTracks.Length());
nscoord space = aAvailableSpace;
DebugOnly<bool> didClamp = false;
while (aNumGrowable) {
nscoord spacePerTrack = std::max<nscoord>(space / aNumGrowable, 1);
for (uint32_t track : aGrowableTracks) {
TrackSize& sz = aPlan[track];
if (sz.mState & TrackSize::eSkipGrowUnlimited) {
continue; // an excluded track
}
nscoord delta = spacePerTrack;
nscoord newBase = sz.mBase + delta;
if (MOZ_UNLIKELY((sz.mState & TrackSize::eFitContent) &&
aFitContentClamper)) {
// Clamp newBase to the fit-content() size, for §12.5.2 step 5/6.
if (aFitContentClamper(track, sz.mBase, &newBase)) {
didClamp = true;
delta = newBase - sz.mBase;
MOZ_ASSERT(delta >= 0, "track size shouldn't shrink");
sz.mState |= TrackSize::eSkipGrowUnlimited1;
--aNumGrowable;
}
}
sz.mBase = newBase;
space -= delta;
MOZ_ASSERT(space >= 0);
if (space == 0) {
return;
}
}
}
MOZ_ASSERT(didClamp,
"we don't exit the loop above except by return, "
"unless we clamped some track's size");
}
/**
* Distribute aAvailableSpace to the planned base size for aGrowableTracks
* up to their limits, then distribute the remaining space beyond the limits.
*/
template <TrackSizingPhase phase>
void DistributeToTrackSizes(nscoord aAvailableSpace,
nsTArray<TrackSize>& aPlan,
nsTArray<TrackSize>& aItemPlan,
nsTArray<uint32_t>& aGrowableTracks,
TrackSize::StateBits aSelector,
const FitContentClamper& aFitContentClamper) {
InitializeItemPlan<phase>(aItemPlan, aGrowableTracks);
nscoord space = GrowTracksToLimit(aAvailableSpace, aItemPlan,
aGrowableTracks, aFitContentClamper);
if (space > 0) {
uint32_t numGrowable =
MarkExcludedTracks<phase>(aItemPlan, aGrowableTracks, aSelector);
GrowSelectedTracksUnlimited(space, aItemPlan, aGrowableTracks,
numGrowable, aFitContentClamper);
}
for (uint32_t track : aGrowableTracks) {
nscoord& plannedSize = aPlan[track].mBase;
nscoord itemIncurredSize = aItemPlan[track].mBase;
if (plannedSize < itemIncurredSize) {
plannedSize = itemIncurredSize;
}
}
}
/**
* Distribute aAvailableSize to the tracks. This implements 12.6 at:
* http://dev.w3.org/csswg/css-grid/#algo-grow-tracks
*/
void DistributeFreeSpace(nscoord aAvailableSize) {
const uint32_t numTracks = mSizes.Length();
if (MOZ_UNLIKELY(numTracks == 0 || aAvailableSize <= 0)) {
return;
}
if (aAvailableSize == NS_UNCONSTRAINEDSIZE) {
for (TrackSize& sz : mSizes) {
sz.mBase = sz.mLimit;
}
} else {
// Compute free space and count growable tracks.
nscoord space = aAvailableSize;
uint32_t numGrowable = numTracks;
for (const TrackSize& sz : mSizes) {
space -= sz.mBase;
MOZ_ASSERT(sz.mBase <= sz.mLimit);
if (sz.mBase == sz.mLimit) {
--numGrowable;
}
}
// Distribute the free space evenly to the growable tracks. If not exactly
// divisable the remainder is added to the leading tracks.
while (space > 0 && numGrowable) {
nscoord spacePerTrack = std::max<nscoord>(space / numGrowable, 1);
for (uint32_t i = 0; i < numTracks && space > 0; ++i) {
TrackSize& sz = mSizes[i];
if (sz.mBase == sz.mLimit) {
continue;
}
nscoord newBase = sz.mBase + spacePerTrack;
if (newBase >= sz.mLimit) {
space -= sz.mLimit - sz.mBase;
sz.mBase = sz.mLimit;
--numGrowable;
} else {
space -= spacePerTrack;
sz.mBase = newBase;
}
}
}
}
}
/**
* Implements "12.7.1. Find the Size of an 'fr'".
* http://dev.w3.org/csswg/css-grid/#algo-find-fr-size
* (The returned value is a 'nscoord' divided by a factor - a floating type
* is used to avoid intermediary rounding errors.)
*/
float FindFrUnitSize(const LineRange& aRange,
const nsTArray<uint32_t>& aFlexTracks,
const TrackSizingFunctions& aFunctions,
nscoord aSpaceToFill) const;
/**
* Implements the "find the used flex fraction" part of StretchFlexibleTracks.
* (The returned value is a 'nscoord' divided by a factor - a floating type
* is used to avoid intermediary rounding errors.)
*/
float FindUsedFlexFraction(GridReflowInput& aState,
nsTArray<GridItemInfo>& aGridItems,
const nsTArray<uint32_t>& aFlexTracks,
const TrackSizingFunctions& aFunctions,
nscoord aAvailableSize) const;
/**
* Implements "12.7. Stretch Flexible Tracks"
* http://dev.w3.org/csswg/css-grid/#algo-flex-tracks
*/
void StretchFlexibleTracks(GridReflowInput& aState,
nsTArray<GridItemInfo>& aGridItems,
const TrackSizingFunctions& aFunctions,
nscoord aAvailableSize);
/**
* Implements "12.3. Track Sizing Algorithm"
* http://dev.w3.org/csswg/css-grid/#algo-track-sizing
*/
void CalculateSizes(GridReflowInput& aState,
nsTArray<GridItemInfo>& aGridItems,
const TrackSizingFunctions& aFunctions,
nscoord aContentBoxSize, LineRange GridArea::*aRange,
SizingConstraint aConstraint);
/**
* Apply 'align/justify-content', whichever is relevant for this axis.
* https://drafts.csswg.org/css-align-3/#propdef-align-content
*/
void AlignJustifyContent(const nsStylePosition* aStyle,
StyleContentDistribution aAligmentStyleValue,
WritingMode aWM, nscoord aContentBoxSize,
bool aIsSubgridded);
nscoord GridLineEdge(uint32_t aLine, GridLineSide aSide) const {
if (MOZ_UNLIKELY(mSizes.IsEmpty())) {
// https://drafts.csswg.org/css-grid/#grid-definition
// "... the explicit grid still contains one grid line in each axis."
MOZ_ASSERT(aLine == 0, "We should only resolve line 1 in an empty grid");
return nscoord(0);
}
MOZ_ASSERT(aLine <= mSizes.Length(), "mSizes is too small");
if (aSide == GridLineSide::BeforeGridGap) {
if (aLine == 0) {
return nscoord(0);
}
const TrackSize& sz = mSizes[aLine - 1];
return sz.mPosition + sz.mBase;
}
if (aLine == mSizes.Length()) {
return mContentBoxSize;
}
return mSizes[aLine].mPosition;
}
nscoord SumOfGridTracksAndGaps() {
return SumOfGridTracks() + SumOfGridGaps();
}
nscoord SumOfGridTracks() const {
nscoord result = 0;
for (const TrackSize& size : mSizes) {
result += size.mBase;
}
return result;
}
nscoord SumOfGridGaps() const {
auto len = mSizes.Length();
return MOZ_LIKELY(len > 1) ? (len - 1) * mGridGap : 0;
}
/**
* Break before aRow, i.e. set the eBreakBefore flag on aRow and set the grid
* gap before aRow to zero (and shift all rows after it by the removed gap).
*/
void BreakBeforeRow(uint32_t aRow) {
MOZ_ASSERT(mAxis == LogicalAxis::Block,
"Should only be fragmenting in the block axis (between rows)");
nscoord prevRowEndPos = 0;
if (aRow != 0) {
auto& prevSz = mSizes[aRow - 1];
prevRowEndPos = prevSz.mPosition + prevSz.mBase;
}
auto& sz = mSizes[aRow];
const nscoord gap = sz.mPosition - prevRowEndPos;
sz.mState |= TrackSize::eBreakBefore;
if (gap != 0) {
for (uint32_t i = aRow, len = mSizes.Length(); i < len; ++i) {
mSizes[i].mPosition -= gap;
}
}
}
/**
* Set the size of aRow to aSize and adjust the position of all rows after it.
*/
void ResizeRow(uint32_t aRow, nscoord aNewSize) {
MOZ_ASSERT(mAxis == LogicalAxis::Block,
"Should only be fragmenting in the block axis (between rows)");
MOZ_ASSERT(aNewSize >= 0);
auto& sz = mSizes[aRow];
nscoord delta = aNewSize - sz.mBase;
NS_WARNING_ASSERTION(delta != nscoord(0), "Useless call to ResizeRow");
sz.mBase = aNewSize;
const uint32_t numRows = mSizes.Length();
for (uint32_t r = aRow + 1; r < numRows; ++r) {
mSizes[r].mPosition += delta;
}
}
nscoord ResolveSize(const LineRange& aRange) const {
MOZ_ASSERT(mCanResolveLineRangeSize);
MOZ_ASSERT(aRange.Extent() > 0, "grid items cover at least one track");
nscoord pos, size;
aRange.ToPositionAndLength(mSizes, &pos, &size);
return size;
}
#ifdef DEBUG
void Dump() const;
#endif
CopyableAutoTArray<TrackSize, 32> mSizes;
nscoord mContentBoxSize;
nscoord mGridGap;
// The first(last)-baseline for the first(last) track in this axis.
PerBaseline<nscoord> mBaseline;
// The union of the track min/max-sizing state bits in this axis.
TrackSize::StateBits mStateUnion;
LogicalAxis mAxis;
// Used for aligning a baseline-aligned subtree of items. The only possible
// values are StyleAlignFlags::{START,END,CENTER,AUTO}. AUTO means there are
// no baseline-aligned items in any track in that axis.
// There is one alignment value for each BaselineSharingGroup.
PerBaseline<StyleAlignFlags> mBaselineSubtreeAlign;
// True if track positions and sizes are final in this axis.
bool mCanResolveLineRangeSize;
// True if this axis has masonry layout.
bool mIsMasonry;
};
#ifdef DEBUG
void nsGridContainerFrame::Tracks::Dump() const {
printf("%zu %s %s ", mSizes.Length(), mIsMasonry ? "masonry" : "grid",
mAxis == LogicalAxis::Block ? "rows" : "columns");
TrackSize::DumpStateBits(mStateUnion);
printf("\n");
for (uint32_t i = 0, len = mSizes.Length(); i < len; ++i) {
printf(" %d: ", i);
mSizes[i].Dump();
printf("\n");
}
double px = AppUnitsPerCSSPixel();
printf("Baselines: %.2fpx %2fpx\n",
mBaseline[BaselineSharingGroup::First] / px,
mBaseline[BaselineSharingGroup::Last] / px);
printf("Gap: %.2fpx\n", mGridGap / px);
printf("ContentBoxSize: %.2fpx\n", mContentBoxSize / px);
}
#endif
/**
* Grid data shared by all continuations, owned by the first-in-flow.
* The data is initialized from the first-in-flow's GridReflowInput at
* the end of its reflow. Fragmentation will modify mRows.mSizes -
* the mPosition to remove the row gap at the break boundary, the mState
* by setting the eBreakBefore flag, and mBase is modified when we decide
* to grow a row. mOriginalRowData is setup by the first-in-flow and
* not modified after that. It's used for undoing the changes to mRows.
* mCols, mGridItems, mAbsPosItems are used for initializing the grid
* reflow input for continuations, see GridReflowInput::Initialize below.
*/
struct nsGridContainerFrame::SharedGridData {
SharedGridData()
: mCols(LogicalAxis::Inline),
mRows(LogicalAxis::Block),
mGenerateComputedGridInfo(false) {}
Tracks mCols;
Tracks mRows;
struct RowData {
nscoord mBase; // the original track size
nscoord mGap; // the original gap before a track
};
nsTArray<RowData> mOriginalRowData;
nsTArray<GridItemInfo> mGridItems;
nsTArray<GridItemInfo> mAbsPosItems;
bool mGenerateComputedGridInfo;
/**
* Only set on the first-in-flow. Continuations will Initialize() their
* GridReflowInput from it.
*/
NS_DECLARE_FRAME_PROPERTY_DELETABLE(Prop, SharedGridData)
};
struct MOZ_STACK_CLASS nsGridContainerFrame::GridReflowInput {
GridReflowInput(nsGridContainerFrame* aFrame, const ReflowInput& aRI)
: GridReflowInput(aFrame, *aRI.mRenderingContext, &aRI,
aRI.mStylePosition, aRI.GetWritingMode()) {}
GridReflowInput(nsGridContainerFrame* aFrame, gfxContext& aRC)
: GridReflowInput(aFrame, aRC, nullptr, aFrame->StylePosition(),
aFrame->GetWritingMode()) {}
/**
* Initialize our track sizes and grid item info using the shared
* state from aGridContainerFrame first-in-flow.
*/
void InitializeForContinuation(nsGridContainerFrame* aGridContainerFrame,
nscoord aConsumedBSize) {
MOZ_ASSERT(aGridContainerFrame->GetPrevInFlow(),
"don't call this on the first-in-flow");
MOZ_ASSERT(mGridItems.IsEmpty() && mAbsPosItems.IsEmpty(),
"shouldn't have any item data yet");
// Get the SharedGridData from the first-in-flow. Also calculate the number
// of fragments before this so that we can figure out our start row below.
uint32_t fragment = 0;
nsIFrame* firstInFlow = aGridContainerFrame;
for (auto pif = aGridContainerFrame->GetPrevInFlow(); pif;
pif = pif->GetPrevInFlow()) {
++fragment;
firstInFlow = pif;
}
mSharedGridData = firstInFlow->GetProperty(SharedGridData::Prop());
MOZ_ASSERT(mSharedGridData, "first-in-flow must have SharedGridData");
// Find the start row for this fragment and undo breaks after that row
// since the breaks might be different from the last reflow.
auto& rowSizes = mSharedGridData->mRows.mSizes;
const uint32_t numRows = rowSizes.Length();
mStartRow = numRows;
for (uint32_t row = 0, breakCount = 0; row < numRows; ++row) {
if (rowSizes[row].mState & TrackSize::eBreakBefore) {
if (fragment == ++breakCount) {
mStartRow = row;
mFragBStart = rowSizes[row].mPosition;
// Restore the original size for |row| and grid gaps / state after it.
const auto& origRowData = mSharedGridData->mOriginalRowData;
rowSizes[row].mBase = origRowData[row].mBase;
nscoord prevEndPos = rowSizes[row].mPosition + rowSizes[row].mBase;
while (++row < numRows) {
auto& sz = rowSizes[row];
const auto& orig = origRowData[row];
sz.mPosition = prevEndPos + orig.mGap;
sz.mBase = orig.mBase;
sz.mState &= ~TrackSize::eBreakBefore;
prevEndPos = sz.mPosition + sz.mBase;
}
break;
}
}
}
if (mStartRow == numRows ||
aGridContainerFrame->IsMasonry(LogicalAxis::Block)) {
// All of the grid's rows fit inside of previous grid-container fragments,
// or it's a masonry axis.
mFragBStart = aConsumedBSize;
}
// Copy the shared track state.
// XXX consider temporarily swapping the array elements instead and swapping
// XXX them back after we're done reflowing, for better performance.
// XXX (bug 1252002)
mCols = mSharedGridData->mCols;
mRows = mSharedGridData->mRows;
if (firstInFlow->GetProperty(UsedTrackSizes::Prop())) {
auto* prop = aGridContainerFrame->GetProperty(UsedTrackSizes::Prop());
if (!prop) {
prop = new UsedTrackSizes();
aGridContainerFrame->SetProperty(UsedTrackSizes::Prop(), prop);
}
prop->mCanResolveLineRangeSize = {true, true};
prop->mSizes[LogicalAxis::Inline].Assign(mCols.mSizes);
prop->mSizes[LogicalAxis::Block].Assign(mRows.mSizes);
}
// Copy item data from each child's first-in-flow data in mSharedGridData.
// XXX NOTE: This is O(n^2) in the number of items. (bug 1252186)
mIter.Reset();
for (; !mIter.AtEnd(); mIter.Next()) {
nsIFrame* child = *mIter;
nsIFrame* childFirstInFlow = child->FirstInFlow();
DebugOnly<size_t> len = mGridItems.Length();
for (auto& itemInfo : mSharedGridData->mGridItems) {
if (itemInfo.mFrame == childFirstInFlow) {
auto item =
mGridItems.AppendElement(GridItemInfo(child, itemInfo.mArea));
// Copy the item's baseline data so that the item's last fragment can
// do 'last baseline' alignment if necessary.
item->mState[LogicalAxis::Block] |=
itemInfo.mState[LogicalAxis::Block] & ItemState::eAllBaselineBits;
item->mState[LogicalAxis::Inline] |=
itemInfo.mState[LogicalAxis::Inline] &
ItemState::eAllBaselineBits;
item->mBaselineOffset[LogicalAxis::Block] =
itemInfo.mBaselineOffset[LogicalAxis::Block];
item->mBaselineOffset[LogicalAxis::Inline] =
itemInfo.mBaselineOffset[LogicalAxis::Inline];
item->mState[LogicalAxis::Block] |=
itemInfo.mState[LogicalAxis::Block] & ItemState::eAutoPlacement;
item->mState[LogicalAxis::Inline] |=
itemInfo.mState[LogicalAxis::Inline] & ItemState::eAutoPlacement;
break;
}
}
MOZ_ASSERT(mGridItems.Length() == len + 1, "can't find GridItemInfo");
}
// XXX NOTE: This is O(n^2) in the number of abs.pos. items. (bug 1252186)
const nsFrameList& absPosChildren = aGridContainerFrame->GetChildList(
aGridContainerFrame->GetAbsoluteListID());
for (auto f : absPosChildren) {
nsIFrame* childFirstInFlow = f->FirstInFlow();
DebugOnly<size_t> len = mAbsPosItems.Length();
for (auto& itemInfo : mSharedGridData->mAbsPosItems) {
if (itemInfo.mFrame == childFirstInFlow) {
mAbsPosItems.AppendElement(GridItemInfo(f, itemInfo.mArea));
break;
}
}
MOZ_ASSERT(mAbsPosItems.Length() == len + 1, "can't find GridItemInfo");
}
// Copy in the computed grid info state bit
if (mSharedGridData->mGenerateComputedGridInfo) {
aGridContainerFrame->AddStateBits(NS_STATE_GRID_COMPUTED_INFO);
}
}
/**
* Calculate our track sizes in the given axis.
*/
void CalculateTrackSizesForAxis(LogicalAxis aAxis, const Grid& aGrid,
nscoord aCBSize,
SizingConstraint aConstraint);
/**
* Calculate our track sizes.
*/
void CalculateTrackSizes(const Grid& aGrid, const LogicalSize& aContentBox,
SizingConstraint aConstraint);
/**
* Return the percentage basis for a grid item in its writing-mode.
* If aAxis is LogicalAxis::Inline then we return NS_UNCONSTRAINEDSIZE in
* both axes since we know all track sizes are indefinite at this point
* (we calculate column sizes before row sizes). Otherwise, assert that
* column sizes are known and calculate the size for aGridItem.mArea.mCols
* and use NS_UNCONSTRAINEDSIZE in the other axis.
* @param aAxis the axis we're currently calculating track sizes for
*/
LogicalSize PercentageBasisFor(LogicalAxis aAxis,
const GridItemInfo& aGridItem) const;
/**
* Return the containing block for a grid item occupying aArea.
*/
LogicalRect ContainingBlockFor(const GridArea& aArea) const;
/**
* Return the containing block for an abs.pos. grid item occupying aArea.
* Any 'auto' lines in the grid area will be aligned with grid container
* containing block on that side.
* @param aGridOrigin the origin of the grid
* @param aGridCB the grid container containing block (its padding area)
*/
LogicalRect ContainingBlockForAbsPos(const GridArea& aArea,
const LogicalPoint& aGridOrigin,
const LogicalRect& aGridCB) const;
/**
* Apply `align/justify-content` alignment in our masonry axis.
* This aligns the "masonry box" within our content box size.
*/
void AlignJustifyContentInMasonryAxis(nscoord aMasonryBoxSize,
nscoord aContentBoxSize);
/**
* Apply `align/justify-tracks` alignment in our masonry axis.
*/
void AlignJustifyTracksInMasonryAxis(const LogicalSize& aContentSize,
const nsSize& aContainerSize);
// Recursive helper for CollectSubgridItemsForAxis().
static void CollectSubgridItemsForAxisHelper(
LogicalAxis aAxis, WritingMode aContainerWM,
const LineRange& aRangeInAxis, const LineRange& aRangeInOppositeAxis,
const GridItemInfo& aItem, const nsTArray<GridItemInfo>& aItems,
nsTArray<GridItemInfo>& aResult) {
const auto oppositeAxis = GetOrthogonalAxis(aAxis);
bool itemIsSubgridInOppositeAxis = aItem.IsSubgrid(oppositeAxis);
auto subgridWM = aItem.mFrame->GetWritingMode();
bool isOrthogonal = subgridWM.IsOrthogonalTo(aContainerWM);
bool isSameDirInAxis =
subgridWM.ParallelAxisStartsOnSameSide(aAxis, aContainerWM);
bool isSameDirInOppositeAxis =
subgridWM.ParallelAxisStartsOnSameSide(oppositeAxis, aContainerWM);
if (isOrthogonal) {
// We'll Transpose the area below so these needs to be transposed as well.
std::swap(isSameDirInAxis, isSameDirInOppositeAxis);
}
uint32_t offsetInAxis = aRangeInAxis.mStart;
uint32_t gridEndInAxis = aRangeInAxis.Extent();
uint32_t offsetInOppositeAxis = aRangeInOppositeAxis.mStart;
uint32_t gridEndInOppositeAxis = aRangeInOppositeAxis.Extent();
for (const auto& subgridItem : aItems) {
auto newItem = aResult.AppendElement(
isOrthogonal ? subgridItem.Transpose() : subgridItem);
if (MOZ_UNLIKELY(!isSameDirInAxis)) {
newItem->ReverseDirection(aAxis, gridEndInAxis);
}
newItem->mArea.LineRangeForAxis(aAxis).Translate(offsetInAxis);
if (itemIsSubgridInOppositeAxis) {
if (MOZ_UNLIKELY(!isSameDirInOppositeAxis)) {
newItem->ReverseDirection(oppositeAxis, gridEndInOppositeAxis);
}
LineRange& range = newItem->mArea.LineRangeForAxis(oppositeAxis);
range.Translate(offsetInOppositeAxis);
}
if (newItem->IsSubgrid(aAxis)) {
auto* subgrid =
subgridItem.SubgridFrame()->GetProperty(Subgrid::Prop());
CollectSubgridItemsForAxisHelper(
aAxis, aContainerWM, newItem->mArea.LineRangeForAxis(aAxis),
newItem->mArea.LineRangeForAxis(oppositeAxis), *newItem,
subgrid->mGridItems, aResult);
}
}
}
// Copy all descendant items from all our subgrid children that are subgridded
// in aAxis recursively into aResult. All item grid area's and state are
// translated to our coordinates.
void CollectSubgridItemsForAxis(LogicalAxis aAxis,
nsTArray<GridItemInfo>& aResult) const {
for (const auto& item : mGridItems) {
if (item.IsSubgrid(aAxis)) {
const auto oppositeAxis = GetOrthogonalAxis(aAxis);
auto* subgrid = item.SubgridFrame()->GetProperty(Subgrid::Prop());
CollectSubgridItemsForAxisHelper(
aAxis, mWM, item.mArea.LineRangeForAxis(aAxis),
item.mArea.LineRangeForAxis(oppositeAxis), item,
subgrid->mGridItems, aResult);
}
}
}
/**
* Recursive helper for CopyBaselineMetricsToSubgridItems().
*
* @param aAxis The LogicalAxis for the axis whose baseline metrics we're
* copying here (with respect to the outermost parent grid's
* writing mode).
* @param aContainerWM The writing mode of that outermost parent grid.
* @param aSubgridFrame The subgrid whose subgrid-items we're considering
* in this recursive traversal (whose items we're copying over
* baseline-alignment metrics for).
* @param aContainerGridItems The outermost parent grid's array of
* GridItemInfo objects. (The final portion of this array is
* all for subgrid items, and that's the portion that we're
* recursively iterating over.)
* @param aContainerGridItemsIdx [in/out] The index for the item that we're
* currently considering in aContainerGridItemsIdx. When
* this function returns, this will be the index just beyond the
* last item that we handled here, i.e. the index of the next
* item to be handled.
*/
static void CopyBaselineMetricsToSubgridItemsHelper(
LogicalAxis aAxis, WritingMode aContainerWM, nsIFrame* aSubgridFrame,
const nsTArray<GridItemInfo>& aContainerGridItems,
size_t& aContainerGridItemsIdx) {
// Get the canonical GridItemInfo structs for the grid items that live
// inside of aSubgridFrame:
Subgrid* subgridProp = aSubgridFrame->GetProperty(Subgrid::Prop());
nsTArray<GridItemInfo>& subgridItems = subgridProp->mGridItems;
// Use aSubgridFrame's writing-mode to determine subgridAxis.
// Grids & subgrids store various data on a per-LogicalAxis basis, with
// respect to their own WritingMode. Here, subgridAxis is aSubgridFrame's
// axis that maps to the same physical axis that aAxis does for the
// outermost parent grid.
auto subgridWM = aSubgridFrame->GetWritingMode();
bool isOrthogonal = subgridWM.IsOrthogonalTo(aContainerWM);
LogicalAxis subgridAxis = isOrthogonal ? GetOrthogonalAxis(aAxis) : aAxis;
// Do a parallel walk through (1) subgridItems and (2) the portion of
// aContainerGridItems that starts at offset aContainerGridItems,
// descending to traverse child subgrids own items as we encounter them in
// subgridItems. We expect to have an exact correspondence, because this
// is precisely how we built up this portion of aContainerGridItems in
// CollectSubgridItemsForAxis. (But if we happen to overstep the end of an
// array, or find a GridItemInfo for a frame that we don't expect, we
// gracefully bail out.)
for (auto& subgridItem : subgridItems) {
if (MOZ_UNLIKELY(aContainerGridItemsIdx >=
aContainerGridItems.Length())) {
// We failed to make the same traversal as CollectSubgridItemsForAxis;
// whoops! This shouldn't happen; but if it does, we gracefully bail
// out, instead of crashing.
MOZ_ASSERT_UNREACHABLE("Out-of-bounds aContainerGridItemsIdx");
return;
}
const auto& itemFromContainer =
aContainerGridItems[aContainerGridItemsIdx];
aContainerGridItemsIdx++;
if (MOZ_UNLIKELY(subgridItem.mFrame != itemFromContainer.mFrame)) {
// We failed to make the same traversal as CollectSubgridItemsForAxis;
// whoops! This shouldn't happen; but if it does, we gracefully bail
// out, instead of copying baseline-alignment data for the wrong frame.
MOZ_ASSERT_UNREACHABLE("Found unexpected frame during traversal");
return;
}
// This pattern of bits will be truthy if the item is baseline-aligned in
// this axis (in which case the exact pattern of bits will have some
// additional significance that doesn't matter here, but we do need to
// copy it over).
const auto baselineStateBits =
itemFromContainer.mState[aAxis] & ItemState::eAllBaselineBits;
if (subgridItem.IsSubgrid(subgridAxis)) {
// This item is in fact a nested subgrid. It shouldn't itself be
// baseline-aligned, but we need to make a recursive call to copy
// baseline metrics to its items.
MOZ_ASSERT(!baselineStateBits,
"subgrids themselves can't be baseline-aligned "
"(or self-aligned in any way) in their subgrid axis");
CopyBaselineMetricsToSubgridItemsHelper(
aAxis, aContainerWM, subgridItem.SubgridFrame(),
aContainerGridItems, aContainerGridItemsIdx);
} else if (baselineStateBits) {
// This item is a baseline-aligned grid item (in the subgrid that we're
// traversing). Copy over its baseline metrics.
subgridItem.mState[subgridAxis] |= baselineStateBits;
subgridItem.mBaselineOffset[subgridAxis] =
itemFromContainer.mBaselineOffset[aAxis];
}
}
}
/**
* This function here is responsible for propagating baseline-alignment
* metrics for subgrid-items from mGridItems over to the "canonical"
* GridItemInfo structs for those grid items (which live on the subgrid that
* owns them). The outermost parent grid *computes* those metrics as part of
* doing track sizing, but it does this using *temporary* GridItemInfo
* objects for any grid items that live in subgrids (aka subgrid items). So
* that's why we need to rescue this baseline-alignment information before
* those temporary objects are discarded.
*
* (The temporary subgrid-items all live at the end of mGridItems; they were
* appended there by CollectSubgridItemsForAxis(). So, it's important that
* we perform the exact same traversal that CollectSubgridItemsForAxis() did,
* in order to properly match up the temporary & canonical GridItemInfo
* objects for these subgrid items.)
*/
// traversal that CollectSubgridItemsForAxis (and its recursive helper) does.
void CopyBaselineMetricsToSubgridItems(LogicalAxis aAxis,
size_t aOriginalLength) {
MOZ_ASSERT(aOriginalLength <= mGridItems.Length(),
"aOriginalLength is the length that mGridItems had *before* we "
"appended temporary copies of subgrid items to it, so it's not "
"possible for it to be more than the current length");
// This index 'subgridItemIdx' traverses the final portion of mGridItems,
// the portion that currently has temporary GridItemInfo structs that we
// built for the items that live in our subgrids. (Our caller is about to
// discard this temporary portion of mGridItems, and we're trying to
// transfer some baseline-alignment data to the canonical GridItemInfo
// structs before that happens.)
//
// Our recursive helper updates subgridItemIdx internally. When this index
// reaches mGridItems.Length(), we can stop looping; that means we've
// finished copying out all the data from these temporary structs.
size_t subgridItemIdx = aOriginalLength;
for (size_t i = 0;
(i < aOriginalLength && subgridItemIdx < mGridItems.Length()); i++) {
const auto& item = mGridItems[i];
if (item.IsSubgrid(aAxis)) {
CopyBaselineMetricsToSubgridItemsHelper(aAxis, mWM, item.SubgridFrame(),
mGridItems, subgridItemIdx);
}
}
}
Tracks& TracksFor(LogicalAxis aAxis) {
return aAxis == LogicalAxis::Block ? mRows : mCols;
}
const Tracks& TracksFor(LogicalAxis aAxis) const {
return aAxis == LogicalAxis::Block ? mRows : mCols;
}
CSSOrderAwareFrameIterator mIter;
const nsStylePosition* const mGridStyle;
Tracks mCols;
Tracks mRows;
TrackSizingFunctions mColFunctions;
TrackSizingFunctions mRowFunctions;
/**
* Info about each (normal flow) grid item.
*/
nsTArray<GridItemInfo> mGridItems;
/**
* Info about each grid-aligned abs.pos. child.
*/
nsTArray<GridItemInfo> mAbsPosItems;
/**
* @note mReflowInput may be null when using the 2nd ctor above. In this case
* we'll construct a dummy parent reflow input if we need it to calculate
* min/max-content contributions when sizing tracks.
*/
const ReflowInput* const mReflowInput;
gfxContext& mRenderingContext;
nsGridContainerFrame* const mFrame;
SharedGridData* mSharedGridData; // [weak] owned by mFrame's first-in-flow.
/** Computed border+padding with mSkipSides applied. */
LogicalMargin mBorderPadding;
/**
* BStart of this fragment in "grid space" (i.e. the concatenation of content
* areas of all fragments). Equal to mRows.mSizes[mStartRow].mPosition,
* or, if this fragment starts after the last row, the ConsumedBSize().
*/
nscoord mFragBStart;
/** The start row for this fragment. */
uint32_t mStartRow;
/**
* The start row for the next fragment, if any. If mNextFragmentStartRow ==
* mStartRow then there are no rows in this fragment.
*/
uint32_t mNextFragmentStartRow;
/** Our tentative ApplySkipSides bits. */
LogicalSides mSkipSides;
const WritingMode mWM;
/** Initialized lazily, when we find the fragmentainer. */
bool mInFragmentainer;
private:
GridReflowInput(nsGridContainerFrame* aFrame, gfxContext& aRenderingContext,
const ReflowInput* aReflowInput,
const nsStylePosition* aGridStyle, const WritingMode& aWM)
: mIter(aFrame, FrameChildListID::Principal),
mGridStyle(aGridStyle),
mCols(LogicalAxis::Inline),
mRows(LogicalAxis::Block),
mColFunctions(mGridStyle->mGridTemplateColumns,
mGridStyle->mGridAutoColumns,
aFrame->IsSubgrid(LogicalAxis::Inline)),
mRowFunctions(mGridStyle->mGridTemplateRows, mGridStyle->mGridAutoRows,
aFrame->IsSubgrid(LogicalAxis::Block)),
mReflowInput(aReflowInput),
mRenderingContext(aRenderingContext),
mFrame(aFrame),
mSharedGridData(nullptr),
mBorderPadding(aWM),
mFragBStart(0),
mStartRow(0),
mNextFragmentStartRow(0),
mSkipSides(aFrame->GetWritingMode()),
mWM(aWM),
mInFragmentainer(false) {
MOZ_ASSERT(!aReflowInput || aReflowInput->mFrame == mFrame);
if (aReflowInput) {
mBorderPadding = aReflowInput->ComputedLogicalBorderPadding(mWM);
mSkipSides = aFrame->PreReflowBlockLevelLogicalSkipSides();
mBorderPadding.ApplySkipSides(mSkipSides);
}
mCols.mIsMasonry = aFrame->IsMasonry(LogicalAxis::Inline);
mRows.mIsMasonry = aFrame->IsMasonry(LogicalAxis::Block);
MOZ_ASSERT(!(mCols.mIsMasonry && mRows.mIsMasonry),
"can't have masonry layout in both axes");
}
};
using GridReflowInput = nsGridContainerFrame::GridReflowInput;
/**
* The Grid implements grid item placement and the state of the grid -
* the size of the explicit/implicit grid, which cells are occupied etc.
*/
struct MOZ_STACK_CLASS nsGridContainerFrame::Grid {
explicit Grid(const Grid* aParentGrid = nullptr) : mParentGrid(aParentGrid) {}
/**
* Place all child frames into the grid and expand the (implicit) grid as
* needed. The allocated GridAreas are stored in the GridAreaProperty
* frame property on the child frame.
* @param aRepeatSizing the container's [min-|max-]*size - used to determine
* the number of repeat(auto-fill/fit) tracks.
*/
void PlaceGridItems(GridReflowInput& aState,
const RepeatTrackSizingInput& aRepeatSizing);
void SubgridPlaceGridItems(GridReflowInput& aParentState, Grid* aParentGrid,
const GridItemInfo& aGridItem);
/**
* As above but for an abs.pos. child. Any 'auto' lines will be represented
* by kAutoLine in the LineRange result.
* @param aGridStart the first line in the final, but untranslated grid
* @param aGridEnd the last line in the final, but untranslated grid
*/
LineRange ResolveAbsPosLineRange(const StyleGridLine& aStart,
const StyleGridLine& aEnd,
const LineNameMap& aNameMap,
LogicalAxis aAxis, uint32_t aExplicitGridEnd,
int32_t aGridStart, int32_t aGridEnd,
const nsStylePosition* aStyle);
/**
* Return a GridArea for abs.pos. item with non-auto lines placed at
* a definite line (1-based) with placement errors resolved. One or both
* positions may still be 'auto'.
* @param aChild the abs.pos. grid item to place
* @param aStyle the StylePosition() for the grid container
*/
GridArea PlaceAbsPos(nsIFrame* aChild, const LineNameMap& aColLineNameMap,
const LineNameMap& aRowLineNameMap,
const nsStylePosition* aStyle);
/**
* Find the first column in row aLockedRow starting at aStartCol where aArea
* could be placed without overlapping other items. The returned column may
* cause aArea to overflow the current implicit grid bounds if placed there.
*/
uint32_t FindAutoCol(uint32_t aStartCol, uint32_t aLockedRow,
const GridArea* aArea) const;
/**
* Place aArea in the first column (in row aArea->mRows.mStart) starting at
* aStartCol without overlapping other items. The resulting aArea may
* overflow the current implicit grid bounds.
* @param aClampMaxColLine the maximum allowed column line number (zero-based)
* Pre-condition: aArea->mRows.IsDefinite() is true.
* Post-condition: aArea->IsDefinite() is true.
*/
void PlaceAutoCol(uint32_t aStartCol, GridArea* aArea,
uint32_t aClampMaxColLine) const;
/**
* Find the first row in column aLockedCol starting at aStartRow where aArea
* could be placed without overlapping other items. The returned row may
* cause aArea to overflow the current implicit grid bounds if placed there.
*/
uint32_t FindAutoRow(uint32_t aLockedCol, uint32_t aStartRow,
const GridArea* aArea) const;
/**
* Place aArea in the first row (in column aArea->mCols.mStart) starting at
* aStartRow without overlapping other items. The resulting aArea may
* overflow the current implicit grid bounds.
* @param aClampMaxRowLine the maximum allowed row line number (zero-based)
* Pre-condition: aArea->mCols.IsDefinite() is true.
* Post-condition: aArea->IsDefinite() is true.
*/
void PlaceAutoRow(uint32_t aStartRow, GridArea* aArea,
uint32_t aClampMaxRowLine) const;
/**
* Place aArea in the first column starting at aStartCol,aStartRow without
* causing it to overlap other items or overflow mGridColEnd.
* If there's no such column in aStartRow, continue in position 1,aStartRow+1.
* @param aClampMaxColLine the maximum allowed column line number (zero-based)
* @param aClampMaxRowLine the maximum allowed row line number (zero-based)
* Pre-condition: aArea->mCols.IsAuto() && aArea->mRows.IsAuto() is true.
* Post-condition: aArea->IsDefinite() is true.
*/
void PlaceAutoAutoInRowOrder(uint32_t aStartCol, uint32_t aStartRow,
GridArea* aArea, uint32_t aClampMaxColLine,
uint32_t aClampMaxRowLine) const;
/**
* Place aArea in the first row starting at aStartCol,aStartRow without
* causing it to overlap other items or overflow mGridRowEnd.
* If there's no such row in aStartCol, continue in position aStartCol+1,1.
* @param aClampMaxColLine the maximum allowed column line number (zero-based)
* @param aClampMaxRowLine the maximum allowed row line number (zero-based)
* Pre-condition: aArea->mCols.IsAuto() && aArea->mRows.IsAuto() is true.
* Post-condition: aArea->IsDefinite() is true.
*/
void PlaceAutoAutoInColOrder(uint32_t aStartCol, uint32_t aStartRow,
GridArea* aArea, uint32_t aClampMaxColLine,
uint32_t aClampMaxRowLine) const;
/**
* Return aLine if it's inside the aMin..aMax range (inclusive),
* otherwise return kAutoLine.
*/
static int32_t AutoIfOutside(int32_t aLine, int32_t aMin, int32_t aMax) {
MOZ_ASSERT(aMin <= aMax);
if (aLine < aMin || aLine > aMax) {
return kAutoLine;
}
return aLine;
}
/**
* Inflate the implicit grid to include aArea.
* @param aArea may be definite or auto
*/
void InflateGridFor(const GridArea& aArea) {
mGridColEnd = std::max(mGridColEnd, aArea.mCols.HypotheticalEnd());
mGridRowEnd = std::max(mGridRowEnd, aArea.mRows.HypotheticalEnd());
MOZ_ASSERT(mGridColEnd <= kTranslatedMaxLine &&
mGridRowEnd <= kTranslatedMaxLine);
}
/**
* Calculates the empty tracks in a repeat(auto-fit).
* @param aOutNumEmptyLines Outputs the number of tracks which are empty.
* @param aSizingFunctions Sizing functions for the relevant axis.
* @param aNumGridLines Number of grid lines for the relevant axis.
* @param aIsEmptyFunc Functor to check if a cell is empty. This should be
* mCellMap.IsColEmpty or mCellMap.IsRowEmpty, depending on the axis.
*/
template <typename IsEmptyFuncT>
static Maybe<nsTArray<uint32_t>> CalculateAdjustForAutoFitElements(
uint32_t* aOutNumEmptyTracks, TrackSizingFunctions& aSizingFunctions,
uint32_t aNumGridLines, IsEmptyFuncT aIsEmptyFunc);
/**
* Return a line number for (non-auto) aLine, per:
* http://dev.w3.org/csswg/css-grid/#line-placement
* @param aLine style data for the line (must be non-auto)
* @param aNth a number of lines to find from aFromIndex, negative if the
* search should be in reverse order. In the case aLine has
* a specified line name, it's permitted to pass in zero which
* will be treated as one.
* @param aFromIndex the zero-based index to start counting from
* @param aLineNameList the explicit named lines
* @param aSide the axis+edge we're resolving names for (e.g. if we're
resolving a grid-row-start line, pass LogicalSide::BStart)
* @param aExplicitGridEnd the last line in the explicit grid
* @param aStyle the StylePosition() for the grid container
* @return a definite line (1-based), clamped to
* the mClampMinLine..mClampMaxLine range
*/
int32_t ResolveLine(const StyleGridLine& aLine, int32_t aNth,
uint32_t aFromIndex, const LineNameMap& aNameMap,
LogicalSide aSide, uint32_t aExplicitGridEnd,
const nsStylePosition* aStyle);
/**
* Helper method for ResolveLineRange.
* @see ResolveLineRange
* @return a pair (start,end) of lines
*/
typedef std::pair<int32_t, int32_t> LinePair;
LinePair ResolveLineRangeHelper(const StyleGridLine& aStart,
const StyleGridLine& aEnd,
const LineNameMap& aNameMap,
LogicalAxis aAxis, uint32_t aExplicitGridEnd,
const nsStylePosition* aStyle);
/**
* Return a LineRange based on the given style data. Non-auto lines
* are resolved to a definite line number (1-based) per:
* http://dev.w3.org/csswg/css-grid/#line-placement
* with placement errors corrected per:
* http://dev.w3.org/csswg/css-grid/#grid-placement-errors
* @param aStyle the StylePosition() for the grid container
* @param aStart style data for the start line
* @param aEnd style data for the end line
* @param aLineNameList the explicit named lines
* @param aAxis the axis we're resolving names in
* @param aExplicitGridEnd the last line in the explicit grid
* @param aStyle the StylePosition() for the grid container
*/
LineRange ResolveLineRange(const StyleGridLine& aStart,
const StyleGridLine& aEnd,
const LineNameMap& aNameMap, LogicalAxis aAxis,
uint32_t aExplicitGridEnd,
const nsStylePosition* aStyle);
/**
* Return a GridArea with non-auto lines placed at a definite line (1-based)
* with placement errors resolved. One or both positions may still
* be 'auto'.
* @param aChild the grid item
* @param aStyle the StylePosition() for the grid container
*/
GridArea PlaceDefinite(nsIFrame* aChild, const LineNameMap& aColLineNameMap,
const LineNameMap& aRowLineNameMap,
const nsStylePosition* aStyle);
bool HasImplicitNamedArea(nsAtom* aName) const {
return mAreas && mAreas->has(aName);
}
// Return true if aString ends in aSuffix and has at least one character
// before the suffix. Assign aIndex to where the suffix starts.
static bool IsNameWithSuffix(nsAtom* aString, const nsString& aSuffix,
uint32_t* aIndex) {
if (StringEndsWith(nsDependentAtomString(aString), aSuffix)) {
*aIndex = aString->GetLength() - aSuffix.Length();
return *aIndex != 0;
}
return false;
}
static bool IsNameWithEndSuffix(nsAtom* aString, uint32_t* aIndex) {
return IsNameWithSuffix(aString, u"-end"_ns, aIndex);
}
static bool IsNameWithStartSuffix(nsAtom* aString, uint32_t* aIndex) {
return IsNameWithSuffix(aString, u"-start"_ns, aIndex);
}
// Return the relevant parent LineNameMap for the given subgrid axis aAxis.
const LineNameMap* ParentLineMapForAxis(bool aIsOrthogonal,
LogicalAxis aAxis) const {
if (!mParentGrid) {
return nullptr;
}
bool isRows = aIsOrthogonal == (aAxis == LogicalAxis::Inline);
return isRows ? mParentGrid->mRowNameMap : mParentGrid->mColNameMap;
}
void SetLineMaps(const LineNameMap* aColNameMap,
const LineNameMap* aRowNameMap) {
mColNameMap = aColNameMap;
mRowNameMap = aRowNameMap;
}
/**
* A CellMap holds state for each cell in the grid.
* It's row major. It's sparse in the sense that it only has enough rows to
* cover the last row that has a grid item. Each row only has enough entries
* to cover columns that are occupied *on that row*, i.e. it's not a full
* matrix covering the entire implicit grid. An absent Cell means that it's
* unoccupied by any grid item.
*/
struct CellMap {
struct Cell {
constexpr Cell() : mIsOccupied(false) {}
bool mIsOccupied : 1;
};
void Fill(const GridArea& aGridArea) {
MOZ_ASSERT(aGridArea.IsDefinite());
MOZ_ASSERT(aGridArea.mRows.mStart < aGridArea.mRows.mEnd);
MOZ_ASSERT(aGridArea.mCols.mStart < aGridArea.mCols.mEnd);
const auto numRows = aGridArea.mRows.mEnd;
const auto numCols = aGridArea.mCols.mEnd;
mCells.EnsureLengthAtLeast(numRows);
for (auto i = aGridArea.mRows.mStart; i < numRows; ++i) {
nsTArray<Cell>& cellsInRow = mCells[i];
cellsInRow.EnsureLengthAtLeast(numCols);
for (auto j = aGridArea.mCols.mStart; j < numCols; ++j) {
cellsInRow[j].mIsOccupied = true;
}
}
}
uint32_t IsEmptyCol(uint32_t aCol) const {
for (auto& row : mCells) {
if (aCol < row.Length() && row[aCol].mIsOccupied) {
return false;
}
}
return true;
}
uint32_t IsEmptyRow(uint32_t aRow) const {
if (aRow >= mCells.Length()) {
return true;
}
for (const Cell& cell : mCells[aRow]) {
if (cell.mIsOccupied) {
return false;
}
}
return true;
}
#ifdef DEBUG
void Dump() const {
const size_t numRows = mCells.Length();
for (size_t i = 0; i < numRows; ++i) {
const nsTArray<Cell>& cellsInRow = mCells[i];
const size_t numCols = cellsInRow.Length();
printf("%lu:\t", (unsigned long)i + 1);
for (size_t j = 0; j < numCols; ++j) {
printf(cellsInRow[j].mIsOccupied ? "X " : ". ");
}
printf("\n");
}
}
#endif
nsTArray<nsTArray<Cell>> mCells;
};
/**
* State for each cell in the grid.
*/
CellMap mCellMap;
/**
* @see HasImplicitNamedArea.
*/
ImplicitNamedAreas* mAreas;
/**
* The last column grid line (1-based) in the explicit grid.
* (i.e. the number of explicit columns + 1)
*/
uint32_t mExplicitGridColEnd;
/**
* The last row grid line (1-based) in the explicit grid.
* (i.e. the number of explicit rows + 1)
*/
uint32_t mExplicitGridRowEnd;
// Same for the implicit grid, except these become zero-based after
// resolving definite lines.
uint32_t mGridColEnd;
uint32_t mGridRowEnd;
/**
* Offsets from the start of the implicit grid to the start of the translated
* explicit grid. They are zero if there are no implicit lines before 1,1.
* e.g. "grid-column: span 3 / 1" makes mExplicitGridOffsetCol = 3 and the
* corresponding GridArea::mCols will be 0 / 3 in the zero-based translated
* grid.
*/
uint32_t mExplicitGridOffsetCol;
uint32_t mExplicitGridOffsetRow;
/**
* Our parent grid if any.
*/
const Grid* mParentGrid;
/**
* Our LineNameMaps.
*/
const LineNameMap* mColNameMap;
const LineNameMap* mRowNameMap;
};
/**
* Compute margin+border+padding for aGridItem.mFrame (a subgrid) and store it
* on its Subgrid property (and return that property).
* aPercentageBasis is in the grid item's writing-mode.
*/
static Subgrid* SubgridComputeMarginBorderPadding(
const GridItemInfo& aGridItem, const LogicalSize& aPercentageBasis) {
auto* subgridFrame = aGridItem.SubgridFrame();
auto cbWM = aGridItem.mFrame->GetParent()->GetWritingMode();
auto* subgrid = subgridFrame->GetProperty(Subgrid::Prop());
auto wm = subgridFrame->GetWritingMode();
auto pmPercentageBasis = cbWM.IsOrthogonalTo(wm) ? aPercentageBasis.BSize(wm)
: aPercentageBasis.ISize(wm);
SizeComputationInput sz(subgridFrame, nullptr, cbWM, pmPercentageBasis);
subgrid->mMarginBorderPadding =
sz.ComputedLogicalMargin(cbWM) + sz.ComputedLogicalBorderPadding(cbWM);
if (aGridItem.mFrame == subgridFrame) {
return subgrid;
}
bool scroller = false;
nsIFrame* outerFrame = [&]() -> nsIFrame* {
if (nsHTMLScrollFrame* scrollFrame =
do_QueryFrame(aGridItem.mFrame->GetScrollTargetFrame())) {
scroller = true;
return scrollFrame;
}
if (nsHTMLButtonControlFrame* f = do_QueryFrame(aGridItem.mFrame)) {
return f;
}
return nullptr;
}();
if (outerFrame) {
MOZ_ASSERT(sz.ComputedLogicalMargin(cbWM) == LogicalMargin(cbWM) &&
sz.ComputedLogicalBorder(cbWM) == LogicalMargin(cbWM),
"A scrolled inner frame / button content frame "
"should not have any margin or border / padding!");
// Add the margin and border from the (outer) frame. Padding is factored-in
// for scrollers already (except for the scrollbar gutter), but not for
// button-content.
SizeComputationInput szOuterFrame(outerFrame, nullptr, cbWM,
pmPercentageBasis);
subgrid->mMarginBorderPadding += szOuterFrame.ComputedLogicalMargin(cbWM) +
szOuterFrame.ComputedLogicalBorder(cbWM);
if (scroller) {
nsMargin ssz = static_cast<nsHTMLScrollFrame*>(outerFrame)
->IntrinsicScrollbarGutterSize();
subgrid->mMarginBorderPadding += LogicalMargin(cbWM, ssz);
} else {
subgrid->mMarginBorderPadding +=
szOuterFrame.ComputedLogicalPadding(cbWM);
}
}
if (nsFieldSetFrame* f = do_QueryFrame(aGridItem.mFrame)) {
const auto* inner = f->GetInner();
auto wm = inner->GetWritingMode();
LogicalPoint pos = inner->GetLogicalPosition(aGridItem.mFrame->GetSize());
// The legend is always on the BStart side and it inflates the fieldset's
// "border area" size. The inner frame's b-start pos equals that size.
LogicalMargin offsets(wm, pos.B(wm), 0, 0, 0);
subgrid->mMarginBorderPadding += offsets.ConvertTo(cbWM, wm);
}
return subgrid;
}
static void CopyUsedTrackSizes(nsTArray<TrackSize>& aResult,
const nsGridContainerFrame* aUsedTrackSizesFrame,
const UsedTrackSizes* aUsedTrackSizes,
const nsGridContainerFrame* aSubgridFrame,
const Subgrid* aSubgrid,
LogicalAxis aSubgridAxis) {
MOZ_ASSERT(aSubgridFrame->ParentGridContainerForSubgrid() ==
aUsedTrackSizesFrame);
aResult.SetLength(aSubgridAxis == LogicalAxis::Inline
? aSubgrid->mGridColEnd
: aSubgrid->mGridRowEnd);
auto parentAxis =
aSubgrid->mIsOrthogonal ? GetOrthogonalAxis(aSubgridAxis) : aSubgridAxis;
const auto& parentSizes = aUsedTrackSizes->mSizes[parentAxis];
MOZ_ASSERT(aUsedTrackSizes->mCanResolveLineRangeSize[parentAxis]);
if (parentSizes.IsEmpty()) {
return;
}
const auto& range = aSubgrid->mArea.LineRangeForAxis(parentAxis);
const auto cbwm = aUsedTrackSizesFrame->GetWritingMode();
const auto wm = aSubgridFrame->GetWritingMode();
// Recompute the MBP to resolve percentages against the resolved track sizes.
if (parentAxis == LogicalAxis::Inline) {
// Find the subgrid's grid item frame in its parent grid container. This
// is usually the same as aSubgridFrame but it may also have a ScrollFrame,
// FieldSetFrame etc. We just loop until we see the first ancestor
// GridContainerFrame and pick the last frame we saw before that.
// Note that all subgrids are inside a parent (sub)grid container.
const nsIFrame* outerGridItemFrame = aSubgridFrame;
for (nsIFrame* parent = aSubgridFrame->GetParent();
parent != aUsedTrackSizesFrame; parent = parent->GetParent()) {
MOZ_ASSERT(!parent->IsGridContainerFrame());
outerGridItemFrame = parent;
}
auto sizeInAxis = range.ToLength(aUsedTrackSizes->mSizes[parentAxis]);
LogicalSize pmPercentageBasis =
aSubgrid->mIsOrthogonal ? LogicalSize(wm, nscoord(0), sizeInAxis)
: LogicalSize(wm, sizeInAxis, nscoord(0));
GridItemInfo info(const_cast<nsIFrame*>(outerGridItemFrame),
aSubgrid->mArea);
SubgridComputeMarginBorderPadding(info, pmPercentageBasis);
}
const LogicalMargin& mbp = aSubgrid->mMarginBorderPadding;
nscoord startMBP;
nscoord endMBP;
if (MOZ_LIKELY(cbwm.ParallelAxisStartsOnSameSide(parentAxis, wm))) {
startMBP = mbp.Start(parentAxis, cbwm);
endMBP = mbp.End(parentAxis, cbwm);
uint32_t i = range.mStart;
nscoord startPos = parentSizes[i].mPosition + startMBP;
for (auto& sz : aResult) {
sz = parentSizes[i++];
sz.mPosition -= startPos;
}
} else {
startMBP = mbp.End(parentAxis, cbwm);
endMBP = mbp.Start(parentAxis, cbwm);
uint32_t i = range.mEnd - 1;
const auto& parentEnd = parentSizes[i];
nscoord parentEndPos = parentEnd.mPosition + parentEnd.mBase - startMBP;
for (auto& sz : aResult) {
sz = parentSizes[i--];
sz.mPosition = parentEndPos - (sz.mPosition + sz.mBase);
}
}
auto& startTrack = aResult[0];
startTrack.mPosition = 0;
startTrack.mBase -= startMBP;
if (MOZ_UNLIKELY(startTrack.mBase < nscoord(0))) {
// Our MBP doesn't fit in the start track. Adjust the track position
// to maintain track alignment with our parent.
startTrack.mPosition = startTrack.mBase;
startTrack.mBase = nscoord(0);
}
auto& endTrack = aResult.LastElement();
endTrack.mBase -= endMBP;
if (MOZ_UNLIKELY(endTrack.mBase < nscoord(0))) {
endTrack.mBase = nscoord(0);
}
}
void nsGridContainerFrame::UsedTrackSizes::ResolveTrackSizesForAxis(
nsGridContainerFrame* aFrame, LogicalAxis aAxis, gfxContext& aRC) {
if (mCanResolveLineRangeSize[aAxis]) {
return;
}
if (!aFrame->IsSubgrid()) {
// We can't resolve sizes in this axis at this point. aFrame is the top grid
// container, which will store its final track sizes later once they're
// resolved in this axis (in GridReflowInput::CalculateTrackSizesForAxis).
// The single caller of this method only needs track sizes for
// calculating a CB size and it will treat it as indefinite when
// this happens.
return;
}
auto* parent = aFrame->ParentGridContainerForSubgrid();
auto* parentSizes = parent->GetUsedTrackSizes();
if (!parentSizes) {
parentSizes = new UsedTrackSizes();
parent->SetProperty(UsedTrackSizes::Prop(), parentSizes);
}
auto* subgrid = aFrame->GetProperty(Subgrid::Prop());
const auto parentAxis =
subgrid->mIsOrthogonal ? GetOrthogonalAxis(aAxis) : aAxis;
parentSizes->ResolveTrackSizesForAxis(parent, parentAxis, aRC);
if (!parentSizes->mCanResolveLineRangeSize[parentAxis]) {
if (aFrame->IsSubgrid(aAxis)) {
ResolveSubgridTrackSizesForAxis(aFrame, aAxis, subgrid, aRC,
NS_UNCONSTRAINEDSIZE);
}
return;
}
if (aFrame->IsSubgrid(aAxis)) {
CopyUsedTrackSizes(mSizes[aAxis], parent, parentSizes, aFrame, subgrid,
aAxis);
mCanResolveLineRangeSize[aAxis] = true;
} else {
const auto& range = subgrid->mArea.LineRangeForAxis(parentAxis);
nscoord contentBoxSize = range.ToLength(parentSizes->mSizes[parentAxis]);
auto parentWM = aFrame->GetParent()->GetWritingMode();
contentBoxSize -=
subgrid->mMarginBorderPadding.StartEnd(parentAxis, parentWM);
contentBoxSize = std::max(nscoord(0), contentBoxSize);
ResolveSubgridTrackSizesForAxis(aFrame, aAxis, subgrid, aRC,
contentBoxSize);
}
}
void nsGridContainerFrame::UsedTrackSizes::ResolveSubgridTrackSizesForAxis(
nsGridContainerFrame* aFrame, LogicalAxis aAxis, Subgrid* aSubgrid,
gfxContext& aRC, nscoord aContentBoxSize) {
GridReflowInput state(aFrame, aRC);
state.mGridItems = aSubgrid->mGridItems.Clone();
Grid grid;
grid.mGridColEnd = aSubgrid->mGridColEnd;
grid.mGridRowEnd = aSubgrid->mGridRowEnd;
state.CalculateTrackSizesForAxis(aAxis, grid, aContentBoxSize,
SizingConstraint::NoConstraint);
const auto& tracks = aAxis == LogicalAxis::Inline ? state.mCols : state.mRows;
mSizes[aAxis].Assign(tracks.mSizes);
mCanResolveLineRangeSize[aAxis] = tracks.mCanResolveLineRangeSize;
MOZ_ASSERT(mCanResolveLineRangeSize[aAxis]);
}
void nsGridContainerFrame::GridReflowInput::CalculateTrackSizesForAxis(
LogicalAxis aAxis, const Grid& aGrid, nscoord aContentBoxSize,
SizingConstraint aConstraint) {
auto& tracks = aAxis == LogicalAxis::Inline ? mCols : mRows;
const auto& sizingFunctions =
aAxis == LogicalAxis::Inline ? mColFunctions : mRowFunctions;
const auto& gapStyle = aAxis == LogicalAxis::Inline ? mGridStyle->mColumnGap
: mGridStyle->mRowGap;
if (tracks.mIsMasonry) {
// See comment on nsGridContainerFrame::MasonryLayout().
tracks.Initialize(sizingFunctions, gapStyle, 2, aContentBoxSize);
tracks.mCanResolveLineRangeSize = true;
return;
}
uint32_t gridEnd =
aAxis == LogicalAxis::Inline ? aGrid.mGridColEnd : aGrid.mGridRowEnd;
Maybe<TrackSizingFunctions> fallbackTrackSizing;
bool useParentGaps = false;
const bool isSubgriddedAxis = mFrame->IsSubgrid(aAxis);
if (MOZ_LIKELY(!isSubgriddedAxis)) {
tracks.Initialize(sizingFunctions, gapStyle, gridEnd, aContentBoxSize);
} else {
tracks.mGridGap =
nsLayoutUtils::ResolveGapToLength(gapStyle, aContentBoxSize);
tracks.mContentBoxSize = aContentBoxSize;
const auto* subgrid = mFrame->GetProperty(Subgrid::Prop());
tracks.mSizes.SetLength(gridEnd);
auto* parent = mFrame->ParentGridContainerForSubgrid();
auto parentAxis = subgrid->mIsOrthogonal ? GetOrthogonalAxis(aAxis) : aAxis;
const auto* parentSizes = parent->GetUsedTrackSizes();
if (parentSizes && parentSizes->mCanResolveLineRangeSize[parentAxis]) {
CopyUsedTrackSizes(tracks.mSizes, parent, parentSizes, mFrame, subgrid,
aAxis);
useParentGaps = gapStyle.IsNormal();
} else {
fallbackTrackSizing.emplace(TrackSizingFunctions::ForSubgridFallback(
mFrame, subgrid, parent, parentAxis));
tracks.Initialize(*fallbackTrackSizing, gapStyle, gridEnd,
aContentBoxSize);
}
}
// We run the Track Sizing Algorithm in non-subgridded axes, and in some
// cases in a subgridded axis when our parent track sizes aren't resolved yet.
if (MOZ_LIKELY(!isSubgriddedAxis) || fallbackTrackSizing.isSome()) {
const size_t origGridItemCount = mGridItems.Length();
const bool hasSubgridItems = mFrame->HasSubgridItems(aAxis);
if (hasSubgridItems) {
AutoTArray<GridItemInfo, 8> collectedItems;
CollectSubgridItemsForAxis(aAxis, collectedItems);
mGridItems.AppendElements(collectedItems);
}
tracks.CalculateSizes(
*this, mGridItems,
fallbackTrackSizing ? *fallbackTrackSizing : sizingFunctions,
aContentBoxSize,
aAxis == LogicalAxis::Inline ? &GridArea::mCols : &GridArea::mRows,
aConstraint);
if (hasSubgridItems &&
StaticPrefs::layout_css_grid_subgrid_baselines_enabled()) {
// If any of the subgrid items are baseline-aligned, we've just recorded
// their baseline-alignment offsets in our own copy of their GridItemInfo
// structs. Before we get rid of those copies (via TruncateLength), we
// have to copy these offsets back to the subgrids' versions of the
// GridItemInfo structs.
//
// XXXdholbert This new behavior is behind a pref due to bug 1871719.
CopyBaselineMetricsToSubgridItems(aAxis, origGridItemCount);
}
mGridItems.TruncateLength(origGridItemCount);
}
if (isSubgriddedAxis) {
// XXXdholbert This is a bit hacky, but this is something that
// tracks.CalculateSizes does internally (unconditionally, if there are
// baseline-aligned items), and it seems like subgrids need to do it too,
// or else they hit the "unexpected baseline subtree alignment"
// fatal-assert when aligning their children with the baseline-alignment
// information that they received from the outer grid.
// (This might be entirely unnecessary? Aside from the default ::AUTO
// value, it looks like the ::First entry is always set to ::START and
// the ::Last entry is always set to ::END...)
tracks.mBaselineSubtreeAlign[BaselineSharingGroup::First] =
StyleAlignFlags::START;
tracks.mBaselineSubtreeAlign[BaselineSharingGroup::Last] =
StyleAlignFlags::END;
}
if (aContentBoxSize != NS_UNCONSTRAINEDSIZE) {
auto alignment = mGridStyle->UsedContentAlignment(tracks.mAxis);
tracks.AlignJustifyContent(mGridStyle, alignment, mWM, aContentBoxSize,
isSubgriddedAxis);
} else if (!useParentGaps) {
const nscoord gridGap = tracks.mGridGap;
nscoord pos = 0;
for (TrackSize& sz : tracks.mSizes) {
sz.mPosition = pos;
pos += sz.mBase + gridGap;
}
}
if (aConstraint == SizingConstraint::NoConstraint &&
(mFrame->HasSubgridItems() || mFrame->IsSubgrid())) {
mFrame->StoreUsedTrackSizes(aAxis, tracks.mSizes);
}
// positions and sizes are now final
tracks.mCanResolveLineRangeSize = true;
}
void nsGridContainerFrame::GridReflowInput::CalculateTrackSizes(
const Grid& aGrid, const LogicalSize& aContentBox,
SizingConstraint aConstraint) {
CalculateTrackSizesForAxis(LogicalAxis::Inline, aGrid, aContentBox.ISize(mWM),
aConstraint);
CalculateTrackSizesForAxis(LogicalAxis::Block, aGrid, aContentBox.BSize(mWM),
aConstraint);
}
// Align an item's margin box in its aAxis inside aCBSize.
static void AlignJustifySelf(StyleAlignFlags aAlignment, LogicalAxis aAxis,
AlignJustifyFlags aFlags, nscoord aBaselineAdjust,
nscoord aCBSize, const ReflowInput& aRI,
const LogicalSize& aChildSize,
LogicalPoint* aPos) {
MOZ_ASSERT(aAlignment != StyleAlignFlags::AUTO,
"unexpected 'auto' "
"computed value for normal flow grid item");
// NOTE: this is the resulting frame offset (border box).
nscoord offset = CSSAlignUtils::AlignJustifySelf(
aAlignment, aAxis, aFlags, aBaselineAdjust, aCBSize, aRI, aChildSize);
// Set the position (aPos) for the requested alignment.
if (offset != 0) {
WritingMode wm = aRI.GetWritingMode();
nscoord& pos = aAxis == LogicalAxis::Block ? aPos->B(wm) : aPos->I(wm);
pos += MOZ_LIKELY(aFlags & AlignJustifyFlags::SameSide) ? offset : -offset;
}
}
static void AlignSelf(const nsGridContainerFrame::GridItemInfo& aGridItem,
StyleAlignFlags aAlignSelf, nscoord aCBSize,
const WritingMode aCBWM, const ReflowInput& aRI,
const LogicalSize& aSize, AlignJustifyFlags aFlags,
LogicalPoint* aPos) {
AlignJustifyFlags flags = aFlags;
if (aAlignSelf & StyleAlignFlags::SAFE) {
flags |= AlignJustifyFlags::OverflowSafe;
}
aAlignSelf &= ~StyleAlignFlags::FLAG_BITS;
WritingMode childWM = aRI.GetWritingMode();
if (aCBWM.ParallelAxisStartsOnSameSide(LogicalAxis::Block, childWM)) {
flags |= AlignJustifyFlags::SameSide;
}
// Grid's 'align-self' axis is never parallel to the container's inline axis.
if (aAlignSelf == StyleAlignFlags::LEFT ||
aAlignSelf == StyleAlignFlags::RIGHT) {
aAlignSelf = StyleAlignFlags::START;
}
if (MOZ_LIKELY(aAlignSelf == StyleAlignFlags::NORMAL)) {
aAlignSelf = StyleAlignFlags::STRETCH;
}
nscoord baselineAdjust = 0;
if (aAlignSelf == StyleAlignFlags::BASELINE ||
aAlignSelf == StyleAlignFlags::LAST_BASELINE) {
aAlignSelf = aGridItem.GetSelfBaseline(aAlignSelf, LogicalAxis::Block,
&baselineAdjust);
}
bool isOrthogonal = aCBWM.IsOrthogonalTo(childWM);
LogicalAxis axis = isOrthogonal ? LogicalAxis::Inline : LogicalAxis::Block;
AlignJustifySelf(aAlignSelf, axis, flags, baselineAdjust, aCBSize, aRI, aSize,
aPos);
}
static void JustifySelf(const nsGridContainerFrame::GridItemInfo& aGridItem,
StyleAlignFlags aJustifySelf, nscoord aCBSize,
const WritingMode aCBWM, const ReflowInput& aRI,
const LogicalSize& aSize, AlignJustifyFlags aFlags,
LogicalPoint* aPos) {
AlignJustifyFlags flags = aFlags;
if (aJustifySelf & StyleAlignFlags::SAFE) {
flags |= AlignJustifyFlags::OverflowSafe;
}
aJustifySelf &= ~StyleAlignFlags::FLAG_BITS;
WritingMode childWM = aRI.GetWritingMode();
if (aCBWM.ParallelAxisStartsOnSameSide(LogicalAxis::Inline, childWM)) {
flags |= AlignJustifyFlags::SameSide;
}
if (MOZ_LIKELY(aJustifySelf == StyleAlignFlags::NORMAL)) {
aJustifySelf = StyleAlignFlags::STRETCH;
}
nscoord baselineAdjust = 0;
// Grid's 'justify-self' axis is always parallel to the container's inline
// axis, so justify-self:left|right always applies.
if (aJustifySelf == StyleAlignFlags::LEFT) {
aJustifySelf =
aCBWM.IsBidiLTR() ? StyleAlignFlags::START : StyleAlignFlags::END;
} else if (aJustifySelf == StyleAlignFlags::RIGHT) {
aJustifySelf =
aCBWM.IsBidiLTR() ? StyleAlignFlags::END : StyleAlignFlags::START;
} else if (aJustifySelf == StyleAlignFlags::BASELINE ||
aJustifySelf == StyleAlignFlags::LAST_BASELINE) {
aJustifySelf = aGridItem.GetSelfBaseline(aJustifySelf, LogicalAxis::Inline,
&baselineAdjust);
}
bool isOrthogonal = aCBWM.IsOrthogonalTo(childWM);
LogicalAxis axis = isOrthogonal ? LogicalAxis::Block : LogicalAxis::Inline;
AlignJustifySelf(aJustifySelf, axis, flags, baselineAdjust, aCBSize, aRI,
aSize, aPos);
}
static StyleAlignFlags GetAlignJustifyValue(StyleAlignFlags aAlignment,
const WritingMode aWM,
const bool aIsAlign,
bool* aOverflowSafe) {
*aOverflowSafe = bool(aAlignment & StyleAlignFlags::SAFE);
aAlignment &= ~StyleAlignFlags::FLAG_BITS;
// Map some alignment values to 'start' / 'end'.
if (aAlignment == StyleAlignFlags::LEFT ||
aAlignment == StyleAlignFlags::RIGHT) {
if (aIsAlign) {
// Grid's 'align-content' axis is never parallel to the inline axis.
return StyleAlignFlags::START;
}
bool isStart = aWM.IsBidiLTR() == (aAlignment == StyleAlignFlags::LEFT);
return isStart ? StyleAlignFlags::START : StyleAlignFlags::END;
}
if (aAlignment == StyleAlignFlags::FLEX_START) {
return StyleAlignFlags::START; // same as 'start' for Grid
}
if (aAlignment == StyleAlignFlags::FLEX_END) {
return StyleAlignFlags::END; // same as 'end' for Grid
}
return aAlignment;
}
static Maybe<StyleAlignFlags> GetAlignJustifyFallbackIfAny(
const StyleContentDistribution& aDistribution, const WritingMode aWM,
const bool aIsAlign, bool* aOverflowSafe) {
// TODO: Eventually this should look at aDistribution's fallback alignment,
// see https://github.com/w3c/csswg-drafts/issues/1002.
if (aDistribution.primary == StyleAlignFlags::STRETCH ||
aDistribution.primary == StyleAlignFlags::SPACE_BETWEEN) {
return Some(StyleAlignFlags::START);
}
if (aDistribution.primary == StyleAlignFlags::SPACE_AROUND ||
aDistribution.primary == StyleAlignFlags::SPACE_EVENLY) {
return Some(StyleAlignFlags::CENTER);
}
return Nothing();
}
//----------------------------------------------------------------------
// Frame class boilerplate
// =======================
NS_QUERYFRAME_HEAD(nsGridContainerFrame)
NS_QUERYFRAME_ENTRY(nsGridContainerFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
NS_IMPL_FRAMEARENA_HELPERS(nsGridContainerFrame)
nsContainerFrame* NS_NewGridContainerFrame(PresShell* aPresShell,
ComputedStyle* aStyle) {
return new (aPresShell)
nsGridContainerFrame(aStyle, aPresShell->GetPresContext());
}
//----------------------------------------------------------------------
// nsGridContainerFrame Method Implementations
// ===========================================
/*static*/ const nsRect& nsGridContainerFrame::GridItemCB(nsIFrame* aChild) {
MOZ_ASSERT(aChild->IsAbsolutelyPositioned());
nsRect* cb = aChild->GetProperty(GridItemContainingBlockRect());
MOZ_ASSERT(cb,
"this method must only be called on grid items, and the grid "
"container should've reflowed this item by now and set up cb");
return *cb;
}
void nsGridContainerFrame::AddImplicitNamedAreasInternal(
LineNameList& aNameList,
nsGridContainerFrame::ImplicitNamedAreas*& aAreas) {
for (const auto& nameIdent : aNameList.AsSpan()) {
nsAtom* name = nameIdent.AsAtom();
uint32_t indexOfSuffix;
if (Grid::IsNameWithStartSuffix(name, &indexOfSuffix) ||
Grid::IsNameWithEndSuffix(name, &indexOfSuffix)) {
// Extract the name that was found earlier.
nsDependentSubstring areaName(nsDependentAtomString(name), 0,
indexOfSuffix);
// Lazily create the ImplicitNamedAreas.
if (!aAreas) {
aAreas = new nsGridContainerFrame::ImplicitNamedAreas;
SetProperty(nsGridContainerFrame::ImplicitNamedAreasProperty(), aAreas);
}
RefPtr<nsAtom> name = NS_Atomize(areaName);
auto addPtr = aAreas->lookupForAdd(name);
if (!addPtr) {
if (!aAreas->add(addPtr, name,
nsGridContainerFrame::NamedArea{
StyleAtom(do_AddRef(name)), {0, 0}, {0, 0}})) {
MOZ_CRASH("OOM while adding grid name lists");
}
}
}
}
}
void nsGridContainerFrame::AddImplicitNamedAreas(
Span<LineNameList> aLineNameLists) {
// http://dev.w3.org/csswg/css-grid/#implicit-named-areas
// Note: recording these names for fast lookup later is just an optimization.
ImplicitNamedAreas* areas = GetImplicitNamedAreas();
const uint32_t len = std::min(aLineNameLists.Length(), size_t(kMaxLine));
for (uint32_t i = 0; i < len; ++i) {
AddImplicitNamedAreasInternal(aLineNameLists[i], areas);
}
}
void nsGridContainerFrame::AddImplicitNamedAreas(
Span<StyleLineNameListValue> aLineNameList) {
// http://dev.w3.org/csswg/css-grid/#implicit-named-areas
// Note: recording these names for fast lookup later is just an optimization.
uint32_t count = 0;
ImplicitNamedAreas* areas = GetImplicitNamedAreas();
for (const auto& nameList : aLineNameList) {
if (nameList.IsRepeat()) {
for (const auto& repeatNameList :
nameList.AsRepeat().line_names.AsSpan()) {
AddImplicitNamedAreasInternal(repeatNameList, areas);
++count;
}
} else {
MOZ_ASSERT(nameList.IsLineNames());
AddImplicitNamedAreasInternal(nameList.AsLineNames(), areas);
++count;
}
if (count >= size_t(kMaxLine)) {
break;
}
}
}
void nsGridContainerFrame::InitImplicitNamedAreas(
const nsStylePosition* aStyle) {
ImplicitNamedAreas* areas = GetImplicitNamedAreas();
if (areas) {
// Clear it, but reuse the hashtable itself for now. We'll remove it
// below if it isn't needed anymore.
areas->clear();
}
auto Add = [&](const GridTemplate& aTemplate, bool aIsSubgrid) {
AddImplicitNamedAreas(aTemplate.LineNameLists(aIsSubgrid));
for (auto& value : aTemplate.TrackListValues()) {
if (value.IsTrackRepeat()) {
AddImplicitNamedAreas(value.AsTrackRepeat().line_names.AsSpan());
}
}
if (aIsSubgrid && aTemplate.IsSubgrid()) {
// For subgrid, |aTemplate.LineNameLists(aIsSubgrid)| returns an empty
// list so we have to manually add each item.
AddImplicitNamedAreas(aTemplate.AsSubgrid()->line_names.AsSpan());
}
};
Add(aStyle->mGridTemplateColumns, IsSubgrid(LogicalAxis::Inline));
Add(aStyle->mGridTemplateRows, IsSubgrid(LogicalAxis::Block));
if (areas && areas->count() == 0) {
RemoveProperty(ImplicitNamedAreasProperty());
}
}
int32_t nsGridContainerFrame::Grid::ResolveLine(
const StyleGridLine& aLine, int32_t aNth, uint32_t aFromIndex,
const LineNameMap& aNameMap, LogicalSide aSide, uint32_t aExplicitGridEnd,
const nsStylePosition* aStyle) {
MOZ_ASSERT(!aLine.IsAuto());
int32_t line = 0;
if (aLine.LineName()->IsEmpty()) {
MOZ_ASSERT(aNth != 0, "css-grid 9.2: <integer> must not be zero.");
line = int32_t(aFromIndex) + aNth;
} else {
if (aNth == 0) {
// <integer> was omitted; treat it as 1.
aNth = 1;
}
bool isNameOnly = !aLine.is_span && aLine.line_num == 0;
if (isNameOnly) {
AutoTArray<uint32_t, 16> implicitLines;
aNameMap.FindNamedAreas(aLine.ident.AsAtom(), aSide, implicitLines);
if (!implicitLines.IsEmpty() ||
aNameMap.HasImplicitNamedArea(aLine.LineName())) {
// aName is a named area - look for explicit lines named
// <name>-start/-end depending on which side we're resolving.
// http://dev.w3.org/csswg/css-grid/#grid-placement-slot
nsAutoString lineName(nsDependentAtomString(aLine.LineName()));
if (IsStart(aSide)) {
lineName.AppendLiteral("-start");
} else {
lineName.AppendLiteral("-end");
}
RefPtr<nsAtom> name = NS_Atomize(lineName);
line = aNameMap.FindNamedLine(name, &aNth, aFromIndex, implicitLines);
}
}
if (line == 0) {
// If LineName() ends in -start/-end, try the prefix as a named area.
AutoTArray<uint32_t, 16> implicitLines;
uint32_t index;
bool useStart = IsNameWithStartSuffix(aLine.LineName(), &index);
if (useStart || IsNameWithEndSuffix(aLine.LineName(), &index)) {
auto side = MakeLogicalSide(
GetAxis(aSide), useStart ? LogicalEdge::Start : LogicalEdge::End);
RefPtr<nsAtom> name = NS_Atomize(nsDependentSubstring(
nsDependentAtomString(aLine.LineName()), 0, index));
aNameMap.FindNamedAreas(name, side, implicitLines);
}
line = aNameMap.FindNamedLine(aLine.LineName(), &aNth, aFromIndex,
implicitLines);
}
if (line == 0) {
MOZ_ASSERT(aNth != 0, "we found all N named lines but 'line' is zero!");
int32_t edgeLine;
if (aLine.is_span) {
// http://dev.w3.org/csswg/css-grid/#grid-placement-span-int
// 'span <custom-ident> N'
edgeLine = IsStart(aSide) ? 1 : aExplicitGridEnd;
} else {
// http://dev.w3.org/csswg/css-grid/#grid-placement-int
// '<custom-ident> N'
edgeLine = aNth < 0 ? 1 : aExplicitGridEnd;
}
// "If not enough lines with that name exist, all lines in the implicit
// grid are assumed to have that name..."
line = edgeLine + aNth;
}
}
// Note: at this point, 'line' might be outside of aNameMap's allowed range,
// [mClampMinLin, mClampMaxLine]. This is fine; we'll clamp once we've
// resolved *both* the start and end line -- in particular, we clamp in
// ResolveLineRange(). If we clamped here, it'd be premature -- if one line
// is definite and the other is specified as a span to some named line
// (i.e. we need to perform a name-search that starts from the definite
// line), then it matters whether we clamp the definite line before or after
// that search. See https://bugzilla.mozilla.org/show_bug.cgi?id=1800566#c6
// for more.
return line;
}
nsGridContainerFrame::Grid::LinePair
nsGridContainerFrame::Grid::ResolveLineRangeHelper(
const StyleGridLine& aStart, const StyleGridLine& aEnd,
const LineNameMap& aNameMap, LogicalAxis aAxis, uint32_t aExplicitGridEnd,
const nsStylePosition* aStyle) {
MOZ_ASSERT(int32_t(kAutoLine) > kMaxLine);
if (aStart.is_span) {
if (aEnd.is_span || aEnd.IsAuto()) {
// http://dev.w3.org/csswg/css-grid/#grid-placement-errors
if (aStart.LineName()->IsEmpty()) {
// span <integer> / span *
// span <integer> / auto
return LinePair(kAutoLine, aStart.line_num);
}
// span <custom-ident> / span *
// span <custom-ident> / auto
return LinePair(kAutoLine, 1); // XXX subgrid explicit size instead of 1?
}
uint32_t from = aEnd.line_num < 0 ? aExplicitGridEnd + 1 : 0;
auto end = ResolveLine(aEnd, aEnd.line_num, from, aNameMap,
MakeLogicalSide(aAxis, LogicalEdge::End),
aExplicitGridEnd, aStyle);
int32_t span = aStart.line_num == 0 ? 1 : aStart.line_num;
if (end <= 1) {
// The end is at or before the first explicit line, thus all lines before
// it match <custom-ident> since they're implicit.
int32_t start = std::max(end - span, aNameMap.mClampMinLine);
return LinePair(start, end);
}
auto start = ResolveLine(aStart, -span, end, aNameMap,
MakeLogicalSide(aAxis, LogicalEdge::Start),
aExplicitGridEnd, aStyle);
return LinePair(start, end);
}
int32_t start = kAutoLine;
if (aStart.IsAuto()) {
if (aEnd.IsAuto()) {
// auto / auto
return LinePair(start, 1); // XXX subgrid explicit size instead of 1?
}
if (aEnd.is_span) {
if (aEnd.LineName()->IsEmpty()) {
// auto / span <integer>
MOZ_ASSERT(aEnd.line_num != 0);
return LinePair(start, aEnd.line_num);
}
// http://dev.w3.org/csswg/css-grid/#grid-placement-errors
// auto / span <custom-ident>
return LinePair(start, 1); // XXX subgrid explicit size instead of 1?
}
} else {
uint32_t from = aStart.line_num < 0 ? aExplicitGridEnd + 1 : 0;
start = ResolveLine(aStart, aStart.line_num, from, aNameMap,
MakeLogicalSide(aAxis, LogicalEdge::Start),
aExplicitGridEnd, aStyle);
if (aEnd.IsAuto()) {
// A "definite line / auto" should resolve the auto to 'span 1'.
// The error handling in ResolveLineRange will make that happen and also
// clamp the end line correctly if we return "start / start".
return LinePair(start, start);
}
}
uint32_t from;
int32_t nth = aEnd.line_num == 0 ? 1 : aEnd.line_num;
if (aEnd.is_span) {
if (MOZ_UNLIKELY(start < 0)) {
if (aEnd.LineName()->IsEmpty()) {
return LinePair(start, start + nth);
}
from = 0;
} else {
if (start >= int32_t(aExplicitGridEnd)) {
// The start is at or after the last explicit line, thus all lines
// after it match <custom-ident> since they're implicit.
return LinePair(start, std::min(start + nth, aNameMap.mClampMaxLine));
}
from = start;
}
} else {
from = aEnd.line_num < 0 ? aExplicitGridEnd + 1 : 0;
}
auto end = ResolveLine(aEnd, nth, from, aNameMap,
MakeLogicalSide(aAxis, LogicalEdge::End),
aExplicitGridEnd, aStyle);
if (start == int32_t(kAutoLine)) {
// auto / definite line
start = std::max(aNameMap.mClampMinLine, end - 1);
}
return LinePair(start, end);
}
nsGridContainerFrame::LineRange nsGridContainerFrame::Grid::ResolveLineRange(
const StyleGridLine& aStart, const StyleGridLine& aEnd,
const LineNameMap& aNameMap, LogicalAxis aAxis, uint32_t aExplicitGridEnd,
const nsStylePosition* aStyle) {
LinePair r = ResolveLineRangeHelper(aStart, aEnd, aNameMap, aAxis,
aExplicitGridEnd, aStyle);
MOZ_ASSERT(r.second != int32_t(kAutoLine));
if (r.first == int32_t(kAutoLine)) {
// r.second is a span, clamp it to aNameMap.mClampMaxLine - 1 so that
// the returned range has a HypotheticalEnd <= aNameMap.mClampMaxLine.
// http://dev.w3.org/csswg/css-grid/#overlarge-grids
r.second = std::min(r.second, aNameMap.mClampMaxLine - 1);
} else {
// Clamp the lines to be within our limits, per
// https://www.w3.org/TR/css-grid-2/#overlarge-grids
// Note that our limits here might come from the [kMinLine, kMaxLine]
// extremes; or, they might just be the bounds of a subgrid's explicit
// grid. We use the same clamping approach either way, per
// https://www.w3.org/TR/css-grid-2/#subgrid-implicit ("using the same
// procedure as for clamping placement in an overly-large grid").
//
// Note that these two clamped() assignments might collapse our range to
// have both edges pointing at the same line (spanning 0 tracks); this
// might happen here if e.g. r.first were mClampMaxLine, and r.second gets
// clamped from some higher number down to mClampMaxLine. We'll handle this
// by shifting the inner line (r.first in this hypothetical) inwards by 1,
// in the #grid-placement-errors section; that achieves the outcome of
// the #overlarge-grids clamping spec text that says "its span must be
// truncated to 1" when clamping an item that was completely outside the
// limits.
r.first = clamped(r.first, aNameMap.mClampMinLine, aNameMap.mClampMaxLine);
r.second =
clamped(r.second, aNameMap.mClampMinLine, aNameMap.mClampMaxLine);
// Handle grid placement errors.
// http://dev.w3.org/csswg/css-grid/#grid-placement-errors
if (r.first > r.second) {
std::swap(r.first, r.second);
} else if (r.first == r.second) {
// (This is #grid-placement-errors fixup, but it's also where we ensure
// that any #overlarge-grids fixup that we did above will end up
// truncating the range to a span of 1 rather than 0 -- i.e. sliding
// inwards if needed.)
if (MOZ_UNLIKELY(r.first == aNameMap.mClampMaxLine)) {
r.first = aNameMap.mClampMaxLine - 1;
}
r.second = r.first + 1;
}
}
return LineRange(r.first, r.second);
}
nsGridContainerFrame::GridArea nsGridContainerFrame::Grid::PlaceDefinite(
nsIFrame* aChild, const LineNameMap& aColLineNameMap,
const LineNameMap& aRowLineNameMap, const nsStylePosition* aStyle) {
const nsStylePosition* itemStyle = aChild->StylePosition();
return GridArea(
ResolveLineRange(itemStyle->mGridColumnStart, itemStyle->mGridColumnEnd,
aColLineNameMap, LogicalAxis::Inline,
mExplicitGridColEnd, aStyle),
ResolveLineRange(itemStyle->mGridRowStart, itemStyle->mGridRowEnd,
aRowLineNameMap, LogicalAxis::Block, mExplicitGridRowEnd,
aStyle));
}
nsGridContainerFrame::LineRange
nsGridContainerFrame::Grid::ResolveAbsPosLineRange(
const StyleGridLine& aStart, const StyleGridLine& aEnd,
const LineNameMap& aNameMap, LogicalAxis aAxis, uint32_t aExplicitGridEnd,
int32_t aGridStart, int32_t aGridEnd, const nsStylePosition* aStyle) {
if (aStart.IsAuto()) {
if (aEnd.IsAuto()) {
return LineRange(kAutoLine, kAutoLine);
}
uint32_t from = aEnd.line_num < 0 ? aExplicitGridEnd + 1 : 0;
int32_t end = ResolveLine(aEnd, aEnd.line_num, from, aNameMap,
MakeLogicalSide(aAxis, LogicalEdge::End),
aExplicitGridEnd, aStyle);
if (aEnd.is_span) {
++end;
}
// A line outside the existing grid is treated as 'auto' for abs.pos (10.1).
end = AutoIfOutside(end, aGridStart, aGridEnd);
return LineRange(kAutoLine, end);
}
if (aEnd.IsAuto()) {
uint32_t from = aStart.line_num < 0 ? aExplicitGridEnd + 1 : 0;
int32_t start = ResolveLine(aStart, aStart.line_num, from, aNameMap,
MakeLogicalSide(aAxis, LogicalEdge::Start),
aExplicitGridEnd, aStyle);
if (aStart.is_span) {
start = std::max(aGridEnd - start, aGridStart);
}
start = AutoIfOutside(start, aGridStart, aGridEnd);
return LineRange(start, kAutoLine);
}
LineRange r =
ResolveLineRange(aStart, aEnd, aNameMap, aAxis, aExplicitGridEnd, aStyle);
if (r.IsAuto()) {
MOZ_ASSERT(aStart.is_span && aEnd.is_span,
"span / span is the only case "
"leading to IsAuto here -- we dealt with the other cases above");
// The second span was ignored per 9.2.1. For abs.pos., 10.1 says that this
// case should result in "auto / auto" unlike normal flow grid items.
return LineRange(kAutoLine, kAutoLine);
}
return LineRange(AutoIfOutside(r.mUntranslatedStart, aGridStart, aGridEnd),
AutoIfOutside(r.mUntranslatedEnd, aGridStart, aGridEnd));
}
nsGridContainerFrame::GridArea nsGridContainerFrame::Grid::PlaceAbsPos(
nsIFrame* aChild, const LineNameMap& aColLineNameMap,
const LineNameMap& aRowLineNameMap, const nsStylePosition* aStyle) {
const nsStylePosition* itemStyle = aChild->StylePosition();
int32_t gridColStart = 1 - mExplicitGridOffsetCol;
int32_t gridRowStart = 1 - mExplicitGridOffsetRow;
return GridArea(ResolveAbsPosLineRange(
itemStyle->mGridColumnStart, itemStyle->mGridColumnEnd,
aColLineNameMap, LogicalAxis::Inline, mExplicitGridColEnd,
gridColStart, mGridColEnd, aStyle),
ResolveAbsPosLineRange(
itemStyle->mGridRowStart, itemStyle->mGridRowEnd,
aRowLineNameMap, LogicalAxis::Block, mExplicitGridRowEnd,
gridRowStart, mGridRowEnd, aStyle));
}
uint32_t nsGridContainerFrame::Grid::FindAutoCol(uint32_t aStartCol,
uint32_t aLockedRow,
const GridArea* aArea) const {
const uint32_t extent = aArea->mCols.Extent();
const uint32_t iStart = aLockedRow;
const uint32_t iEnd = iStart + aArea->mRows.Extent();
uint32_t candidate = aStartCol;
for (uint32_t i = iStart; i < iEnd;) {
if (i >= mCellMap.mCells.Length()) {
break;
}
const nsTArray<CellMap::Cell>& cellsInRow = mCellMap.mCells[i];
const uint32_t len = cellsInRow.Length();
const uint32_t lastCandidate = candidate;
// Find the first gap in the current row that's at least 'extent' wide.
// ('gap' tracks how wide the current column gap is.)
for (uint32_t j = candidate, gap = 0; j < len && gap < extent; ++j) {
if (!cellsInRow[j].mIsOccupied) {
++gap;
continue;
}
candidate = j + 1;
gap = 0;
}
if (lastCandidate < candidate && i != iStart) {
// Couldn't fit 'extent' tracks at 'lastCandidate' here so we must
// restart from the beginning with the new 'candidate'.
i = iStart;
} else {
++i;
}
}
return candidate;
}
void nsGridContainerFrame::Grid::PlaceAutoCol(uint32_t aStartCol,
GridArea* aArea,
uint32_t aClampMaxColLine) const {
MOZ_ASSERT(aArea->mRows.IsDefinite() && aArea->mCols.IsAuto());
uint32_t col = FindAutoCol(aStartCol, aArea->mRows.mStart, aArea);
aArea->mCols.ResolveAutoPosition(col, aClampMaxColLine);
MOZ_ASSERT(aArea->IsDefinite());
}
uint32_t nsGridContainerFrame::Grid::FindAutoRow(uint32_t aLockedCol,
uint32_t aStartRow,
const GridArea* aArea) const {
const uint32_t extent = aArea->mRows.Extent();
const uint32_t jStart = aLockedCol;
const uint32_t jEnd = jStart + aArea->mCols.Extent();
const uint32_t iEnd = mCellMap.mCells.Length();
uint32_t candidate = aStartRow;
// Find the first gap in the rows that's at least 'extent' tall.
// ('gap' tracks how tall the current row gap is.)
for (uint32_t i = candidate, gap = 0; i < iEnd && gap < extent; ++i) {
++gap; // tentative, but we may reset it below if a column is occupied
const nsTArray<CellMap::Cell>& cellsInRow = mCellMap.mCells[i];
const uint32_t clampedJEnd = std::min<uint32_t>(jEnd, cellsInRow.Length());
// Check if the current row is unoccupied from jStart to jEnd.
for (uint32_t j = jStart; j < clampedJEnd; ++j) {
if (cellsInRow[j].mIsOccupied) {
// Couldn't fit 'extent' rows at 'candidate' here; we hit something
// at row 'i'. So, try the row after 'i' as our next candidate.
candidate = i + 1;
gap = 0;
break;
}
}
}
return candidate;
}
void nsGridContainerFrame::Grid::PlaceAutoRow(uint32_t aStartRow,
GridArea* aArea,
uint32_t aClampMaxRowLine) const {
MOZ_ASSERT(aArea->mCols.IsDefinite() && aArea->mRows.IsAuto());
uint32_t row = FindAutoRow(aArea->mCols.mStart, aStartRow, aArea);
aArea->mRows.ResolveAutoPosition(row, aClampMaxRowLine);
MOZ_ASSERT(aArea->IsDefinite());
}
void nsGridContainerFrame::Grid::PlaceAutoAutoInRowOrder(
uint32_t aStartCol, uint32_t aStartRow, GridArea* aArea,
uint32_t aClampMaxColLine, uint32_t aClampMaxRowLine) const {
MOZ_ASSERT(aArea->mCols.IsAuto() && aArea->mRows.IsAuto());
const uint32_t colExtent = aArea->mCols.Extent();
const uint32_t gridRowEnd = mGridRowEnd;
const uint32_t gridColEnd = mGridColEnd;
uint32_t col = aStartCol;
uint32_t row = aStartRow;
for (; row < gridRowEnd; ++row) {
col = FindAutoCol(col, row, aArea);
if (col + colExtent <= gridColEnd) {
break;
}
col = 0;
}
MOZ_ASSERT(row < gridRowEnd || col == 0,
"expected column 0 for placing in a new row");
aArea->mCols.ResolveAutoPosition(col, aClampMaxColLine);
aArea->mRows.ResolveAutoPosition(row, aClampMaxRowLine);
MOZ_ASSERT(aArea->IsDefinite());
}
void nsGridContainerFrame::Grid::PlaceAutoAutoInColOrder(
uint32_t aStartCol, uint32_t aStartRow, GridArea* aArea,
uint32_t aClampMaxColLine, uint32_t aClampMaxRowLine) const {
MOZ_ASSERT(aArea->mCols.IsAuto() && aArea->mRows.IsAuto());
const uint32_t rowExtent = aArea->mRows.Extent();
const uint32_t gridRowEnd = mGridRowEnd;
const uint32_t gridColEnd = mGridColEnd;
uint32_t col = aStartCol;
uint32_t row = aStartRow;
for (; col < gridColEnd; ++col) {
row = FindAutoRow(col, row, aArea);
if (row + rowExtent <= gridRowEnd) {
break;
}
row = 0;
}
MOZ_ASSERT(col < gridColEnd || row == 0,
"expected row 0 for placing in a new column");
aArea->mCols.ResolveAutoPosition(col, aClampMaxColLine);
aArea->mRows.ResolveAutoPosition(row, aClampMaxRowLine);
MOZ_ASSERT(aArea->IsDefinite());
}
template <typename IsEmptyFuncT>
Maybe<nsTArray<uint32_t>>
nsGridContainerFrame::Grid::CalculateAdjustForAutoFitElements(
uint32_t* const aOutNumEmptyLines, TrackSizingFunctions& aSizingFunctions,
uint32_t aNumGridLines, IsEmptyFuncT aIsEmptyFunc) {
Maybe<nsTArray<uint32_t>> trackAdjust;
uint32_t& numEmptyLines = *aOutNumEmptyLines;
numEmptyLines = 0;
if (aSizingFunctions.NumRepeatTracks() > 0) {
MOZ_ASSERT(aSizingFunctions.mHasRepeatAuto);
// Since this loop is concerned with just the repeat tracks, we
// iterate from 0..NumRepeatTracks() which is the natural range of
// mRemoveRepeatTracks. This means we have to add
// (mExplicitGridOffset + mRepeatAutoStart) to get a zero-based
// index for arrays like mCellMap/aIsEmptyFunc and trackAdjust. We'll then
// fill out the trackAdjust array for all the remaining lines.
const uint32_t repeatStart = (aSizingFunctions.mExplicitGridOffset +
aSizingFunctions.mRepeatAutoStart);
const uint32_t numRepeats = aSizingFunctions.NumRepeatTracks();
for (uint32_t i = 0; i < numRepeats; ++i) {
if (numEmptyLines) {
MOZ_ASSERT(trackAdjust.isSome());
(*trackAdjust)[repeatStart + i] = numEmptyLines;
}
if (aIsEmptyFunc(repeatStart + i)) {
++numEmptyLines;
if (trackAdjust.isNothing()) {
trackAdjust.emplace(aNumGridLines);
trackAdjust->SetLength(aNumGridLines);
PodZero(trackAdjust->Elements(), trackAdjust->Length());
}
aSizingFunctions.mRemovedRepeatTracks[i] = true;
}
}
// Fill out the trackAdjust array for all the tracks after the repeats.
if (numEmptyLines) {
for (uint32_t line = repeatStart + numRepeats; line < aNumGridLines;
++line) {
(*trackAdjust)[line] = numEmptyLines;
}
}
}
return trackAdjust;
}
void nsGridContainerFrame::Grid::SubgridPlaceGridItems(
GridReflowInput& aParentState, Grid* aParentGrid,
const GridItemInfo& aGridItem) {
MOZ_ASSERT(aGridItem.mArea.IsDefinite() ||
aGridItem.mFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW),
"the subgrid's lines should be resolved by now");
if (aGridItem.IsSubgrid(LogicalAxis::Inline)) {
aParentState.mFrame->AddStateBits(NS_STATE_GRID_HAS_COL_SUBGRID_ITEM);
}
if (aGridItem.IsSubgrid(LogicalAxis::Block)) {
aParentState.mFrame->AddStateBits(NS_STATE_GRID_HAS_ROW_SUBGRID_ITEM);
}
auto* childGrid = aGridItem.SubgridFrame();
const auto* pos = childGrid->StylePosition();
childGrid->NormalizeChildLists();
GridReflowInput state(childGrid, aParentState.mRenderingContext);
childGrid->InitImplicitNamedAreas(pos);
const bool isOrthogonal = aParentState.mWM.IsOrthogonalTo(state.mWM);
// Record the subgrid's GridArea in a frame property.
auto* subgrid = childGrid->GetProperty(Subgrid::Prop());
if (!subgrid) {
subgrid = new Subgrid(aGridItem.mArea, isOrthogonal, aParentState.mWM);
childGrid->SetProperty(Subgrid::Prop(), subgrid);
} else {
subgrid->mArea = aGridItem.mArea;
subgrid->mIsOrthogonal = isOrthogonal;
subgrid->mGridItems.Clear();
subgrid->mAbsPosItems.Clear();
}
// Abs.pos. subgrids may have kAutoLine in their area. Map those to the edge
// line in the parent's grid (zero-based line numbers).
if (MOZ_UNLIKELY(subgrid->mArea.mCols.mStart == kAutoLine)) {
subgrid->mArea.mCols.mStart = 0;
}
if (MOZ_UNLIKELY(subgrid->mArea.mCols.mEnd == kAutoLine)) {
subgrid->mArea.mCols.mEnd = aParentGrid->mGridColEnd - 1;
}
if (MOZ_UNLIKELY(subgrid->mArea.mRows.mStart == kAutoLine)) {
subgrid->mArea.mRows.mStart = 0;
}
if (MOZ_UNLIKELY(subgrid->mArea.mRows.mEnd == kAutoLine)) {
subgrid->mArea.mRows.mEnd = aParentGrid->mGridRowEnd - 1;
}
MOZ_ASSERT((subgrid->mArea.mCols.Extent() > 0 &&
subgrid->mArea.mRows.Extent() > 0) ||
state.mGridItems.IsEmpty(),
"subgrid needs at least one track for its items");
// The min/sz/max sizes are the input to the "repeat-to-fill" algorithm:
// https://drafts.csswg.org/css-grid/#auto-repeat
// They're only used for auto-repeat in a non-subgridded axis so we skip
// computing them otherwise.
RepeatTrackSizingInput repeatSizing(state.mWM);
if (!childGrid->IsColSubgrid() && state.mColFunctions.mHasRepeatAuto) {
repeatSizing.InitFromStyle(LogicalAxis::Inline, state.mWM,
state.mFrame->Style());
}
if (!childGrid->IsRowSubgrid() && state.mRowFunctions.mHasRepeatAuto) {
repeatSizing.InitFromStyle(LogicalAxis::Block, state.mWM,
state.mFrame->Style());
}
PlaceGridItems(state, repeatSizing);
subgrid->mGridItems = std::move(state.mGridItems);
subgrid->mAbsPosItems = std::move(state.mAbsPosItems);
subgrid->mGridColEnd = mGridColEnd;
subgrid->mGridRowEnd = mGridRowEnd;
}
void nsGridContainerFrame::Grid::PlaceGridItems(
GridReflowInput& aState, const RepeatTrackSizingInput& aSizes) {
MOZ_ASSERT(mCellMap.mCells.IsEmpty(), "unexpected entries in cell map");
mAreas = aState.mFrame->GetImplicitNamedAreas();
if (aState.mFrame->HasSubgridItems() || aState.mFrame->IsSubgrid()) {
if (auto* uts = aState.mFrame->GetUsedTrackSizes()) {
uts->mCanResolveLineRangeSize = {false, false};
uts->mSizes[LogicalAxis::Inline].ClearAndRetainStorage();
uts->mSizes[LogicalAxis::Block].ClearAndRetainStorage();
}
}
// SubgridPlaceGridItems will set these if we find any subgrid items.
aState.mFrame->RemoveStateBits(NS_STATE_GRID_HAS_COL_SUBGRID_ITEM |
NS_STATE_GRID_HAS_ROW_SUBGRID_ITEM);
// http://dev.w3.org/csswg/css-grid/#grid-definition
// Initialize the end lines of the Explicit Grid (mExplicitGridCol[Row]End).
// This is determined by the larger of the number of rows/columns defined
// by 'grid-template-areas' and the 'grid-template-rows'/'-columns', plus one.
// Also initialize the Implicit Grid (mGridCol[Row]End) to the same values.
// Note that this is for a grid with a 1,1 origin. We'll change that
// to a 0,0 based grid after placing definite lines.
const nsStylePosition* const gridStyle = aState.mGridStyle;
const auto* areas = gridStyle->mGridTemplateAreas.IsNone()
? nullptr
: &*gridStyle->mGridTemplateAreas.AsAreas();
const LineNameMap* parentLineNameMap = nullptr;
const LineRange* subgridRange = nullptr;
bool subgridAxisIsSameDirection = true;
if (!aState.mFrame->IsColSubgrid()) {
aState.mColFunctions.InitRepeatTracks(
gridStyle->mColumnGap, aSizes.mMin.ISize(aState.mWM),
aSizes.mSize.ISize(aState.mWM), aSizes.mMax.ISize(aState.mWM));
uint32_t areaCols = areas ? areas->width + 1 : 1;
mExplicitGridColEnd = aState.mColFunctions.ComputeExplicitGridEnd(areaCols);
} else {
const auto* subgrid = aState.mFrame->GetProperty(Subgrid::Prop());
subgridRange = &subgrid->SubgridCols();
uint32_t extent = subgridRange->Extent();
mExplicitGridColEnd = extent + 1; // the grid is 1-based at this point
parentLineNameMap =
ParentLineMapForAxis(subgrid->mIsOrthogonal, LogicalAxis::Inline);
auto parentWM =
aState.mFrame->ParentGridContainerForSubgrid()->GetWritingMode();
subgridAxisIsSameDirection =
aState.mWM.ParallelAxisStartsOnSameSide(LogicalAxis::Inline, parentWM);
}
mGridColEnd = mExplicitGridColEnd;
LineNameMap colLineNameMap(gridStyle, mAreas, aState.mColFunctions,
parentLineNameMap, subgridRange,
subgridAxisIsSameDirection);
if (!aState.mFrame->IsRowSubgrid()) {
const Maybe<nscoord> containBSize = aState.mFrame->ContainIntrinsicBSize();
const nscoord repeatTrackSizingBSize = [&] {
// This clamping only applies to auto sizes.
if (containBSize &&
aSizes.mSize.BSize(aState.mWM) == NS_UNCONSTRAINEDSIZE) {
return NS_CSS_MINMAX(*containBSize, aSizes.mMin.BSize(aState.mWM),
aSizes.mMax.BSize(aState.mWM));
}
return aSizes.mSize.BSize(aState.mWM);
}();
aState.mRowFunctions.InitRepeatTracks(
gridStyle->mRowGap, aSizes.mMin.BSize(aState.mWM),
repeatTrackSizingBSize, aSizes.mMax.BSize(aState.mWM));
uint32_t areaRows = areas ? areas->strings.Length() + 1 : 1;
mExplicitGridRowEnd = aState.mRowFunctions.ComputeExplicitGridEnd(areaRows);
parentLineNameMap = nullptr;
subgridRange = nullptr;
} else {
const auto* subgrid = aState.mFrame->GetProperty(Subgrid::Prop());
subgridRange = &subgrid->SubgridRows();
uint32_t extent = subgridRange->Extent();
mExplicitGridRowEnd = extent + 1; // the grid is 1-based at this point
parentLineNameMap =
ParentLineMapForAxis(subgrid->mIsOrthogonal, LogicalAxis::Block);
auto parentWM =
aState.mFrame->ParentGridContainerForSubgrid()->GetWritingMode();
subgridAxisIsSameDirection =
aState.mWM.ParallelAxisStartsOnSameSide(LogicalAxis::Block, parentWM);
}
mGridRowEnd = mExplicitGridRowEnd;
LineNameMap rowLineNameMap(gridStyle, mAreas, aState.mRowFunctions,
parentLineNameMap, subgridRange,
subgridAxisIsSameDirection);
const bool isSubgridOrItemInSubgrid =
aState.mFrame->IsSubgrid() || !!mParentGrid;
auto SetSubgridChildEdgeBits =
[this, isSubgridOrItemInSubgrid](GridItemInfo& aItem) -> void {
if (isSubgridOrItemInSubgrid) {
const auto& area = aItem.mArea;
if (area.mCols.mStart == 0) {
aItem.mState[LogicalAxis::Inline] |= ItemState::eStartEdge;
}
if (area.mCols.mEnd == mGridColEnd) {
aItem.mState[LogicalAxis::Inline] |= ItemState::eEndEdge;
}
if (area.mRows.mStart == 0) {
aItem.mState[LogicalAxis::Block] |= ItemState::eStartEdge;
}
if (area.mRows.mEnd == mGridRowEnd) {
aItem.mState[LogicalAxis::Block] |= ItemState::eEndEdge;
}
}
};
SetLineMaps(&colLineNameMap, &rowLineNameMap);
// http://dev.w3.org/csswg/css-grid/#line-placement
// Resolve definite positions per spec chap 9.2.
int32_t minCol = 1;
int32_t minRow = 1;
aState.mGridItems.ClearAndRetainStorage();
aState.mIter.Reset();
for (; !aState.mIter.AtEnd(); aState.mIter.Next()) {
nsIFrame* child = *aState.mIter;
GridItemInfo* info = aState.mGridItems.AppendElement(GridItemInfo(
child,
PlaceDefinite(child, colLineNameMap, rowLineNameMap, gridStyle)));
MOZ_ASSERT(aState.mIter.ItemIndex() == aState.mGridItems.Length() - 1,
"ItemIndex() is broken");
GridArea& area = info->mArea;
if (area.mCols.IsDefinite()) {
minCol = std::min(minCol, area.mCols.mUntranslatedStart);
}
if (area.mRows.IsDefinite()) {
minRow = std::min(minRow, area.mRows.mUntranslatedStart);
}
}
// Translate the whole grid so that the top-/left-most area is at 0,0.
mExplicitGridOffsetCol = 1 - minCol; // minCol/Row is always <= 1, see above
mExplicitGridOffsetRow = 1 - minRow;
aState.mColFunctions.mExplicitGridOffset = mExplicitGridOffsetCol;
aState.mRowFunctions.mExplicitGridOffset = mExplicitGridOffsetRow;
const int32_t offsetToColZero = int32_t(mExplicitGridOffsetCol) - 1;
const int32_t offsetToRowZero = int32_t(mExplicitGridOffsetRow) - 1;
const bool isRowMasonry = aState.mFrame->IsMasonry(LogicalAxis::Block);
const bool isColMasonry = aState.mFrame->IsMasonry(LogicalAxis::Inline);
const bool isMasonry = isColMasonry || isRowMasonry;
mGridColEnd += offsetToColZero;
mGridRowEnd += offsetToRowZero;
const uint32_t gridAxisTrackCount = isRowMasonry ? mGridColEnd : mGridRowEnd;
aState.mIter.Reset();
for (; !aState.mIter.AtEnd(); aState.mIter.Next()) {
auto& item = aState.mGridItems[aState.mIter.ItemIndex()];
GridArea& area = item.mArea;
if (area.mCols.IsDefinite()) {
area.mCols.mStart = area.mCols.mUntranslatedStart + offsetToColZero;
area.mCols.mEnd = area.mCols.mUntranslatedEnd + offsetToColZero;
}
if (area.mRows.IsDefinite()) {
area.mRows.mStart = area.mRows.mUntranslatedStart + offsetToRowZero;
area.mRows.mEnd = area.mRows.mUntranslatedEnd + offsetToRowZero;
}
if (area.IsDefinite()) {
if (isMasonry) {
item.MaybeInhibitSubgridInMasonry(aState.mFrame, gridAxisTrackCount);
}
if (item.IsSubgrid()) {
Grid grid(this);
grid.SubgridPlaceGridItems(aState, this, item);
}
mCellMap.Fill(area);
InflateGridFor(area);
SetSubgridChildEdgeBits(item);
}
}
// http://dev.w3.org/csswg/css-grid/#auto-placement-algo
// Step 1, place 'auto' items that have one definite position -
// definite row (column) for grid-auto-flow:row (column).
auto flowStyle = gridStyle->mGridAutoFlow;
const bool isRowOrder =
isMasonry ? isRowMasonry : !!(flowStyle & StyleGridAutoFlow::ROW);
const bool isSparse = !(flowStyle & StyleGridAutoFlow::DENSE);
uint32_t clampMaxColLine = colLineNameMap.mClampMaxLine + offsetToColZero;
uint32_t clampMaxRowLine = rowLineNameMap.mClampMaxLine + offsetToRowZero;
// We need 1 cursor per row (or column) if placement is sparse.
{
Maybe<nsTHashMap<nsUint32HashKey, uint32_t>> cursors;
if (isSparse) {
cursors.emplace();
}
auto placeAutoMinorFunc =
isRowOrder ? &Grid::PlaceAutoCol : &Grid::PlaceAutoRow;
uint32_t clampMaxLine = isRowOrder ? clampMaxColLine : clampMaxRowLine;
aState.mIter.Reset();
for (; !aState.mIter.AtEnd(); aState.mIter.Next()) {
auto& item = aState.mGridItems[aState.mIter.ItemIndex()];
GridArea& area = item.mArea;
LineRange& major = isRowOrder ? area.mRows : area.mCols;
LineRange& minor = isRowOrder ? area.mCols : area.mRows;
if (major.IsDefinite() && minor.IsAuto()) {
// Items with 'auto' in the minor dimension only.
const uint32_t cursor = isSparse ? cursors->Get(major.mStart) : 0;
(this->*placeAutoMinorFunc)(cursor, &area, clampMaxLine);
if (isMasonry) {
item.MaybeInhibitSubgridInMasonry(aState.mFrame, gridAxisTrackCount);
}
if (item.IsSubgrid()) {
Grid grid(this);
grid.SubgridPlaceGridItems(aState, this, item);
}
mCellMap.Fill(area);
SetSubgridChildEdgeBits(item);
if (isSparse) {
cursors->InsertOrUpdate(major.mStart, minor.mEnd);
}
}
InflateGridFor(area); // Step 2, inflating for auto items too
}
}
// XXX NOTE possible spec issue.
// XXX It's unclear if the remaining major-dimension auto and
// XXX auto in both dimensions should use the same cursor or not,
// XXX https://www.w3.org/Bugs/Public/show_bug.cgi?id=16044
// XXX seems to indicate it shouldn't.
// XXX http://dev.w3.org/csswg/css-grid/#auto-placement-cursor
// XXX now says it should (but didn't in earlier versions)
// Step 3, place the remaining grid items
uint32_t cursorMajor = 0; // for 'dense' these two cursors will stay at 0,0
uint32_t cursorMinor = 0;
auto placeAutoMajorFunc =
isRowOrder ? &Grid::PlaceAutoRow : &Grid::PlaceAutoCol;
uint32_t clampMaxMajorLine = isRowOrder ? clampMaxRowLine : clampMaxColLine;
aState.mIter.Reset();
for (; !aState.mIter.AtEnd(); aState.mIter.Next()) {
auto& item = aState.mGridItems[aState.mIter.ItemIndex()];
GridArea& area = item.mArea;
MOZ_ASSERT(*aState.mIter == item.mFrame,
"iterator out of sync with aState.mGridItems");
LineRange& major = isRowOrder ? area.mRows : area.mCols;
LineRange& minor = isRowOrder ? area.mCols : area.mRows;
if (major.IsAuto()) {
if (minor.IsDefinite()) {
// Items with 'auto' in the major dimension only.
if (isSparse) {
if (minor.mStart < cursorMinor) {
++cursorMajor;
}
cursorMinor = minor.mStart;
}
(this->*placeAutoMajorFunc)(cursorMajor, &area, clampMaxMajorLine);
if (isSparse) {
cursorMajor = major.mStart;
}
} else {
// Items with 'auto' in both dimensions.
if (isRowOrder) {
PlaceAutoAutoInRowOrder(cursorMinor, cursorMajor, &area,
clampMaxColLine, clampMaxRowLine);
} else {
PlaceAutoAutoInColOrder(cursorMajor, cursorMinor, &area,
clampMaxColLine, clampMaxRowLine);
}
if (isSparse) {
cursorMajor = major.mStart;
cursorMinor = minor.mEnd;
#ifdef DEBUG
uint32_t gridMajorEnd = isRowOrder ? mGridRowEnd : mGridColEnd;
uint32_t gridMinorEnd = isRowOrder ? mGridColEnd : mGridRowEnd;
MOZ_ASSERT(cursorMajor <= gridMajorEnd,
"we shouldn't need to place items further than 1 track "
"past the current end of the grid, in major dimension");
MOZ_ASSERT(cursorMinor <= gridMinorEnd,
"we shouldn't add implicit minor tracks for auto/auto");
#endif
}
}
if (isMasonry) {
item.MaybeInhibitSubgridInMasonry(aState.mFrame, gridAxisTrackCount);
}
if (item.IsSubgrid()) {
Grid grid(this);
grid.SubgridPlaceGridItems(aState, this, item);
}
mCellMap.Fill(area);
InflateGridFor(area);
SetSubgridChildEdgeBits(item);
// XXXmats it might be possible to optimize this a bit for masonry layout
// if this item was placed in the 2nd row && !isSparse, or the 1st row
// is full. Still gotta inflate the grid for all items though to make
// the grid large enough...
}
}
// Force all items into the 1st/2nd track and have span 1 in the masonry axis.
// (See comment on nsGridContainerFrame::MasonryLayout().)
if (isMasonry) {
auto masonryAxis = isRowMasonry ? LogicalAxis::Block : LogicalAxis::Inline;
aState.mIter.Reset();
for (; !aState.mIter.AtEnd(); aState.mIter.Next()) {
auto& item = aState.mGridItems[aState.mIter.ItemIndex()];
auto& masonryRange = item.mArea.LineRangeForAxis(masonryAxis);
masonryRange.mStart = std::min(masonryRange.mStart, 1U);
masonryRange.mEnd = masonryRange.mStart + 1U;
}
}
if (aState.mFrame->IsAbsoluteContainer()) {
// 9.4 Absolutely-positioned Grid Items
// http://dev.w3.org/csswg/css-grid/#abspos-items
// We only resolve definite lines here; we'll align auto positions to the
// grid container later during reflow.
const nsFrameList& children =
aState.mFrame->GetChildList(aState.mFrame->GetAbsoluteListID());
const int32_t offsetToColZero = int32_t(mExplicitGridOffsetCol) - 1;
const int32_t offsetToRowZero = int32_t(mExplicitGridOffsetRow) - 1;
// Untranslate the grid again temporarily while resolving abs.pos. lines.
AutoRestore<uint32_t> zeroOffsetGridColEnd(mGridColEnd);
AutoRestore<uint32_t> zeroOffsetGridRowEnd(mGridRowEnd);
mGridColEnd -= offsetToColZero;
mGridRowEnd -= offsetToRowZero;
aState.mAbsPosItems.ClearAndRetainStorage();
for (nsIFrame* child : children) {
GridItemInfo* info = aState.mAbsPosItems.AppendElement(GridItemInfo(
child,
PlaceAbsPos(child, colLineNameMap, rowLineNameMap, gridStyle)));
GridArea& area = info->mArea;
if (area.mCols.mUntranslatedStart != int32_t(kAutoLine)) {
area.mCols.mStart = area.mCols.mUntranslatedStart + offsetToColZero;
if (isColMasonry) {
// XXXmats clamp any non-auto line to 0 or 1. This is intended to
// allow authors to address the start/end of the masonry box.
// This is experimental at this point though and needs author feedback
// and spec work to sort out what is desired and how it should work.
// See https://github.com/w3c/csswg-drafts/issues/4650
area.mCols.mStart = std::min(area.mCols.mStart, 1U);
}
}
if (area.mCols.mUntranslatedEnd != int32_t(kAutoLine)) {
area.mCols.mEnd = area.mCols.mUntranslatedEnd + offsetToColZero;
if (isColMasonry) {
// ditto
area.mCols.mEnd = std::min(area.mCols.mEnd, 1U);
}
}
if (area.mRows.mUntranslatedStart != int32_t(kAutoLine)) {
area.mRows.mStart = area.mRows.mUntranslatedStart + offsetToRowZero;
if (isRowMasonry) {
// ditto
area.mRows.mStart = std::min(area.mRows.mStart, 1U);
}
}
if (area.mRows.mUntranslatedEnd != int32_t(kAutoLine)) {
area.mRows.mEnd = area.mRows.mUntranslatedEnd + offsetToRowZero;
if (isRowMasonry) {
// ditto
area.mRows.mEnd = std::min(area.mRows.mEnd, 1U);
}
}
if (isMasonry) {
info->MaybeInhibitSubgridInMasonry(aState.mFrame, gridAxisTrackCount);
}
// An abs.pos. subgrid with placement auto/1 or -1/auto technically
// doesn't span any parent tracks. Inhibit subgridding in this case.
if (info->IsSubgrid(LogicalAxis::Inline)) {
if (info->mArea.mCols.mStart == zeroOffsetGridColEnd.SavedValue() ||
info->mArea.mCols.mEnd == 0) {
info->InhibitSubgrid(aState.mFrame, LogicalAxis::Inline);
}
}
if (info->IsSubgrid(LogicalAxis::Block)) {
if (info->mArea.mRows.mStart == zeroOffsetGridRowEnd.SavedValue() ||
info->mArea.mRows.mEnd == 0) {
info->InhibitSubgrid(aState.mFrame, LogicalAxis::Block);
}
}
if (info->IsSubgrid()) {
Grid grid(this);
grid.SubgridPlaceGridItems(aState, this, *info);
}
}
}
// Count empty 'auto-fit' tracks in the repeat() range.
// |colAdjust| will have a count for each line in the grid of how many
// tracks were empty between the start of the grid and that line.
Maybe<nsTArray<uint32_t>> colAdjust;
uint32_t numEmptyCols = 0;
if (aState.mColFunctions.mHasRepeatAuto &&
gridStyle->mGridTemplateColumns.GetRepeatAutoValue()->count.IsAutoFit()) {
const auto& cellMap = mCellMap;
colAdjust = CalculateAdjustForAutoFitElements(
&numEmptyCols, aState.mColFunctions, mGridColEnd + 1,
[&cellMap](uint32_t i) -> bool { return cellMap.IsEmptyCol(i); });
}
// Do similar work for the row tracks, with the same logic.
Maybe<nsTArray<uint32_t>> rowAdjust;
uint32_t numEmptyRows = 0;
if (aState.mRowFunctions.mHasRepeatAuto &&
gridStyle->mGridTemplateRows.GetRepeatAutoValue()->count.IsAutoFit()) {
const auto& cellMap = mCellMap;
rowAdjust = CalculateAdjustForAutoFitElements(
&numEmptyRows, aState.mRowFunctions, mGridRowEnd + 1,
[&cellMap](uint32_t i) -> bool { return cellMap.IsEmptyRow(i); });
}
MOZ_ASSERT((numEmptyCols > 0) == colAdjust.isSome());
MOZ_ASSERT((numEmptyRows > 0) == rowAdjust.isSome());
// Remove the empty 'auto-fit' tracks we found above, if any.
if (numEmptyCols || numEmptyRows) {
// Adjust the line numbers in the grid areas.
for (auto& item : aState.mGridItems) {
if (numEmptyCols) {
item.AdjustForRemovedTracks(LogicalAxis::Inline, *colAdjust);
}
if (numEmptyRows) {
item.AdjustForRemovedTracks(LogicalAxis::Block, *rowAdjust);
}
}
for (auto& item : aState.mAbsPosItems) {
if (numEmptyCols) {
item.AdjustForRemovedTracks(LogicalAxis::Inline, *colAdjust);
}
if (numEmptyRows) {
item.AdjustForRemovedTracks(LogicalAxis::Block, *rowAdjust);
}
}
// Adjust the grid size.
mGridColEnd -= numEmptyCols;
mExplicitGridColEnd -= numEmptyCols;
mGridRowEnd -= numEmptyRows;
mExplicitGridRowEnd -= numEmptyRows;
// Adjust the track mapping to unmap the removed tracks.
auto colRepeatCount = aState.mColFunctions.NumRepeatTracks();
aState.mColFunctions.SetNumRepeatTracks(colRepeatCount - numEmptyCols);
auto rowRepeatCount = aState.mRowFunctions.NumRepeatTracks();
aState.mRowFunctions.SetNumRepeatTracks(rowRepeatCount - numEmptyRows);
}
// Update the line boundaries of the implicit grid areas, if needed.
if (mAreas && aState.mFrame->HasAnyStateBits(NS_STATE_GRID_COMPUTED_INFO)) {
for (auto iter = mAreas->iter(); !iter.done(); iter.next()) {
auto& areaInfo = iter.get().value();
// Resolve the lines for the area. We use the name of the area as the
// name of the lines, knowing that the line placement algorithm will
// add the -start and -end suffixes as appropriate for layout.
StyleGridLine lineStartAndEnd;
lineStartAndEnd.ident._0 = areaInfo.name;
LineRange columnLines =
ResolveLineRange(lineStartAndEnd, lineStartAndEnd, colLineNameMap,
LogicalAxis::Inline, mExplicitGridColEnd, gridStyle);
LineRange rowLines =
ResolveLineRange(lineStartAndEnd, lineStartAndEnd, rowLineNameMap,
LogicalAxis::Block, mExplicitGridRowEnd, gridStyle);
// Put the resolved line indices back into the area structure.
areaInfo.columns.start = columnLines.mStart + mExplicitGridOffsetCol;
areaInfo.columns.end = columnLines.mEnd + mExplicitGridOffsetCol;
areaInfo.rows.start = rowLines.mStart + mExplicitGridOffsetRow;
areaInfo.rows.end = rowLines.mEnd + mExplicitGridOffsetRow;
}
}
}
void nsGridContainerFrame::Tracks::Initialize(
const TrackSizingFunctions& aFunctions,
const NonNegativeLengthPercentageOrNormal& aGridGap, uint32_t aNumTracks,
nscoord aContentBoxSize) {
mSizes.SetLength(aNumTracks);
PodZero(mSizes.Elements(), mSizes.Length());
for (uint32_t i = 0, len = mSizes.Length(); i < len; ++i) {
auto& sz = mSizes[i];
mStateUnion |= sz.Initialize(aContentBoxSize, aFunctions.SizingFor(i));
if (mIsMasonry) {
sz.mBase = aContentBoxSize;
sz.mLimit = aContentBoxSize;
}
}
mGridGap = nsLayoutUtils::ResolveGapToLength(aGridGap, aContentBoxSize);
mContentBoxSize = aContentBoxSize;
}
/**
* Reflow aChild in the given aAvailableSize.
*/
static nscoord MeasuringReflow(nsIFrame* aChild,
const ReflowInput* aReflowInput, gfxContext* aRC,
const LogicalSize& aAvailableSize,
const LogicalSize& aCBSize,
nscoord aIMinSizeClamp = NS_MAXSIZE,
nscoord aBMinSizeClamp = NS_MAXSIZE) {
MOZ_ASSERT(aChild->IsGridItem(), "aChild should be a grid item!");
auto* parent = static_cast<nsGridContainerFrame*>(aChild->GetParent());
nsPresContext* pc = aChild->PresContext();
Maybe<ReflowInput> dummyParentState;
const ReflowInput* rs = aReflowInput;
if (!aReflowInput) {
MOZ_ASSERT(!parent->HasAnyStateBits(NS_FRAME_IN_REFLOW));
dummyParentState.emplace(
pc, parent, aRC,
LogicalSize(parent->GetWritingMode(), 0, NS_UNCONSTRAINEDSIZE),
ReflowInput::InitFlag::DummyParentReflowInput);
rs = dummyParentState.ptr();
}
#ifdef DEBUG
// This will suppress various ABSURD_SIZE warnings for this reflow.
parent->SetProperty(nsContainerFrame::DebugReflowingWithInfiniteISize(),
true);
#endif
auto wm = aChild->GetWritingMode();
ComputeSizeFlags csFlags = ComputeSizeFlag::IsGridMeasuringReflow;
// Shrink-wrap grid items that will be aligned (rather than stretched) in
// their own inline axis.
if (!parent->GridItemShouldStretch(aChild, LogicalAxis::Inline)) {
csFlags += ComputeSizeFlag::ShrinkWrap;
}
if (aAvailableSize.ISize(wm) == INFINITE_ISIZE_COORD) {
csFlags += ComputeSizeFlag::ShrinkWrap;
}
if (aIMinSizeClamp != NS_MAXSIZE) {
csFlags += ComputeSizeFlag::IClampMarginBoxMinSize;
}
if (aBMinSizeClamp != NS_MAXSIZE) {
csFlags += ComputeSizeFlag::BClampMarginBoxMinSize;
aChild->SetProperty(nsIFrame::BClampMarginBoxMinSizeProperty(),
aBMinSizeClamp);
} else {
aChild->RemoveProperty(nsIFrame::BClampMarginBoxMinSizeProperty());
}
ReflowInput childRI(pc, *rs, aChild, aAvailableSize, Some(aCBSize), {}, {},
csFlags);
// FIXME (perf): It would be faster to do this only if the previous reflow of
// the child was not a measuring reflow, and only if the child does some of
// the things that are affected by ComputeSizeFlag::IsGridMeasuringReflow.
childRI.SetBResize(true);
// Not 100% sure this is needed, but be conservative for now:
childRI.mFlags.mIsBResizeForPercentages = true;
ReflowOutput childSize(childRI);
nsReflowStatus childStatus;
const nsIFrame::ReflowChildFlags flags =
nsIFrame::ReflowChildFlags::NoMoveFrame |
nsIFrame::ReflowChildFlags::NoSizeView |
nsIFrame::ReflowChildFlags::NoDeleteNextInFlowChild;
bool found;
GridItemCachedBAxisMeasurement cachedMeasurement =
aChild->GetProperty(GridItemCachedBAxisMeasurement::Prop(), &found);
if (found && cachedMeasurement.IsValidFor(aChild, aCBSize)) {
childSize.BSize(wm) = cachedMeasurement.BSize();
childSize.ISize(wm) = aChild->ISize(wm);
nsContainerFrame::FinishReflowChild(aChild, pc, childSize, &childRI, wm,
LogicalPoint(wm), nsSize(), flags);
GRID_LOG(
"[perf] MeasuringReflow accepted cached value=%d, child=%p, "
"aCBSize.ISize=%d",
cachedMeasurement.BSize(), aChild,
aCBSize.ISize(aChild->GetWritingMode()));
return cachedMeasurement.BSize();
}
parent->ReflowChild(aChild, pc, childSize, childRI, wm, LogicalPoint(wm),
nsSize(), flags, childStatus);
nsContainerFrame::FinishReflowChild(aChild, pc, childSize, &childRI, wm,
LogicalPoint(wm), nsSize(), flags);
#ifdef DEBUG
parent->RemoveProperty(nsContainerFrame::DebugReflowingWithInfiniteISize());
#endif
if (!found &&
GridItemCachedBAxisMeasurement::CanCacheMeasurement(aChild, aCBSize)) {
GridItemCachedBAxisMeasurement cachedMeasurement(aChild, aCBSize,
childSize.BSize(wm));
aChild->SetProperty(GridItemCachedBAxisMeasurement::Prop(),
cachedMeasurement);
GRID_LOG(
"[perf] MeasuringReflow created new cached value=%d, child=%p, "
"aCBSize.ISize=%d",
cachedMeasurement.BSize(), aChild,
aCBSize.ISize(aChild->GetWritingMode()));
} else if (found) {
if (GridItemCachedBAxisMeasurement::CanCacheMeasurement(aChild, aCBSize)) {
cachedMeasurement.Update(aChild, aCBSize, childSize.BSize(wm));
GRID_LOG(
"[perf] MeasuringReflow rejected but updated cached value=%d, "
"child=%p, aCBSize.ISize=%d",
cachedMeasurement.BSize(), aChild,
aCBSize.ISize(aChild->GetWritingMode()));
aChild->SetProperty(GridItemCachedBAxisMeasurement::Prop(),
cachedMeasurement);
} else {
aChild->RemoveProperty(GridItemCachedBAxisMeasurement::Prop());
GRID_LOG(
"[perf] MeasuringReflow rejected and removed cached value, "
"child=%p",
aChild);
}
}
return childSize.BSize(wm);
}
/**
* Reflow aChild in the given aAvailableSize, using aNewContentBoxSize as its
* computed size in aChildAxis.
*/
static void PostReflowStretchChild(
nsIFrame* aChild, const ReflowInput& aReflowInput,
const LogicalSize& aAvailableSize, const LogicalSize& aCBSize,
LogicalAxis aChildAxis, const nscoord aNewContentBoxSize,
nscoord aIMinSizeClamp = NS_MAXSIZE, nscoord aBMinSizeClamp = NS_MAXSIZE) {
nsPresContext* pc = aChild->PresContext();
ComputeSizeFlags csFlags;
if (aIMinSizeClamp != NS_MAXSIZE) {
csFlags += ComputeSizeFlag::IClampMarginBoxMinSize;
}
if (aBMinSizeClamp != NS_MAXSIZE) {
csFlags += ComputeSizeFlag::BClampMarginBoxMinSize;
aChild->SetProperty(nsIFrame::BClampMarginBoxMinSizeProperty(),
aBMinSizeClamp);
} else {
aChild->RemoveProperty(nsIFrame::BClampMarginBoxMinSizeProperty());
}
ReflowInput ri(pc, aReflowInput, aChild, aAvailableSize, Some(aCBSize), {},
{}, csFlags);
if (aChildAxis == LogicalAxis::Block) {
ri.SetComputedBSize(ri.ApplyMinMaxBSize(aNewContentBoxSize));
} else {
ri.SetComputedISize(ri.ApplyMinMaxISize(aNewContentBoxSize));
}
ReflowOutput childSize(ri);
nsReflowStatus childStatus;
const nsIFrame::ReflowChildFlags flags =
nsIFrame::ReflowChildFlags::NoMoveFrame |
nsIFrame::ReflowChildFlags::NoDeleteNextInFlowChild;
auto wm = aChild->GetWritingMode();
nsContainerFrame* parent = aChild->GetParent();
parent->ReflowChild(aChild, pc, childSize, ri, wm, LogicalPoint(wm), nsSize(),
flags, childStatus);
nsContainerFrame::FinishReflowChild(aChild, pc, childSize, &ri, wm,
LogicalPoint(wm), nsSize(), flags);
}
/**
* Return the accumulated margin+border+padding in aAxis for aFrame (a subgrid)
* and its ancestor subgrids.
*/
static LogicalMargin SubgridAccumulatedMarginBorderPadding(
nsIFrame* aFrame, const Subgrid* aSubgrid, WritingMode aResultWM,
LogicalAxis aAxis) {
MOZ_ASSERT(aFrame->IsGridContainerFrame());
auto* subgridFrame = static_cast<nsGridContainerFrame*>(aFrame);
LogicalMargin result(aSubgrid->mMarginBorderPadding);
auto* parent = subgridFrame->ParentGridContainerForSubgrid();
auto subgridCBWM = parent->GetWritingMode();
auto childRange = aSubgrid->mArea.LineRangeForAxis(aAxis);
bool skipStartSide = false;
bool skipEndSide = false;
auto axis = aSubgrid->mIsOrthogonal ? GetOrthogonalAxis(aAxis) : aAxis;
// If aFrame's parent is also a subgrid, then add its MBP on the edges that
// are adjacent (i.e. start or end in the same track), recursively.
// ("parent" refers to the grid-frame we're currently adding MBP for,
// and "grandParent" its parent, as we walk up the chain.)
while (parent->IsSubgrid(axis)) {
auto* parentSubgrid = parent->GetProperty(Subgrid::Prop());
auto* grandParent = parent->ParentGridContainerForSubgrid();
auto parentCBWM = grandParent->GetWritingMode();
if (parentCBWM.IsOrthogonalTo(subgridCBWM)) {
axis = GetOrthogonalAxis(axis);
}
const auto& parentRange = parentSubgrid->mArea.LineRangeForAxis(axis);
bool sameDir = parentCBWM.ParallelAxisStartsOnSameSide(axis, subgridCBWM);
if (sameDir) {
skipStartSide |= childRange.mStart != 0;
skipEndSide |= childRange.mEnd != parentRange.Extent();
} else {
skipEndSide |= childRange.mStart != 0;
skipStartSide |= childRange.mEnd != parentRange.Extent();
}
if (skipStartSide && skipEndSide) {
break;
}
auto mbp =
parentSubgrid->mMarginBorderPadding.ConvertTo(subgridCBWM, parentCBWM);
if (skipStartSide) {
mbp.Start(aAxis, subgridCBWM) = nscoord(0);
}
if (skipEndSide) {
mbp.End(aAxis, subgridCBWM) = nscoord(0);
}
result += mbp;
parent = grandParent;
childRange = parentRange;
}
return result.ConvertTo(aResultWM, subgridCBWM);
}
/**
* Return the [min|max]-content contribution of aChild to its parent (i.e.
* the child's margin-box) in aAxis.
*/
static nscoord ContentContribution(
const GridItemInfo& aGridItem, const GridReflowInput& aState,
gfxContext* aRC, WritingMode aCBWM, LogicalAxis aAxis,
const Maybe<LogicalSize>& aPercentageBasis, IntrinsicISizeType aConstraint,
nscoord aMinSizeClamp = NS_MAXSIZE, uint32_t aFlags = 0) {
nsIFrame* child = aGridItem.mFrame;
nscoord extraMargin = 0;
nsGridContainerFrame::Subgrid* subgrid = nullptr;
if (child->GetParent() != aState.mFrame) {
// |child| is a subgrid descendant, so it contributes its subgrids'
// margin+border+padding for any edge tracks that it spans.
auto* subgridFrame = child->GetParent();
subgrid = subgridFrame->GetProperty(Subgrid::Prop());
const auto itemEdgeBits = aGridItem.mState[aAxis] & ItemState::eEdgeBits;
if (itemEdgeBits) {
LogicalMargin mbp = SubgridAccumulatedMarginBorderPadding(
subgridFrame, subgrid, aCBWM, aAxis);
if (itemEdgeBits & ItemState::eStartEdge) {
extraMargin += mbp.Start(aAxis, aCBWM);
}
if (itemEdgeBits & ItemState::eEndEdge) {
extraMargin += mbp.End(aAxis, aCBWM);
}
}
// It also contributes (half of) the subgrid's gap on its edges (if any)
// subtracted by the non-subgrid ancestor grid container's gap.
// Note that this can also be negative since it's considered a margin.
if (itemEdgeBits != ItemState::eEdgeBits) {
auto subgridAxis = aCBWM.IsOrthogonalTo(subgridFrame->GetWritingMode())
? GetOrthogonalAxis(aAxis)
: aAxis;
auto& gapStyle = subgridAxis == LogicalAxis::Block
? subgridFrame->StylePosition()->mRowGap
: subgridFrame->StylePosition()->mColumnGap;
if (!gapStyle.IsNormal()) {
auto subgridExtent = subgridAxis == LogicalAxis::Block
? subgrid->mGridRowEnd
: subgrid->mGridColEnd;
if (subgridExtent > 1) {
nscoord subgridGap =
nsLayoutUtils::ResolveGapToLength(gapStyle, NS_UNCONSTRAINEDSIZE);
auto& tracks =
aAxis == LogicalAxis::Block ? aState.mRows : aState.mCols;
auto gapDelta = subgridGap - tracks.mGridGap;
if (!itemEdgeBits) {
extraMargin += gapDelta;
} else {
extraMargin += gapDelta / 2;
}
}
}
}
}
PhysicalAxis axis(aCBWM.PhysicalAxis(aAxis));
nscoord size = nsLayoutUtils::IntrinsicForAxis(
axis, aRC, child, aConstraint, aPercentageBasis,
aFlags | nsLayoutUtils::BAIL_IF_REFLOW_NEEDED, aMinSizeClamp);
auto childWM = child->GetWritingMode();
const bool isOrthogonal = childWM.IsOrthogonalTo(aCBWM);
auto childAxis = isOrthogonal ? GetOrthogonalAxis(aAxis) : aAxis;
if (size == NS_INTRINSIC_ISIZE_UNKNOWN && childAxis == LogicalAxis::Block) {
// We need to reflow the child to find its BSize contribution.
// XXX this will give mostly correct results for now (until bug 1174569).
nscoord availISize = INFINITE_ISIZE_COORD;
nscoord availBSize = NS_UNCONSTRAINEDSIZE;
// The next two variables are MinSizeClamp values in the child's axes.
nscoord iMinSizeClamp = NS_MAXSIZE;
nscoord bMinSizeClamp = NS_MAXSIZE;
LogicalSize cbSize(childWM, 0, NS_UNCONSTRAINEDSIZE);
// Below, we try to resolve the child's grid-area size in its inline-axis
// to use as the CB/Available size in the MeasuringReflow that follows.
if (child->GetParent() != aState.mFrame) {
// This item is a child of a subgrid descendant.
auto* subgridFrame =
static_cast<nsGridContainerFrame*>(child->GetParent());
MOZ_ASSERT(subgridFrame->IsGridContainerFrame());
auto* uts = subgridFrame->GetProperty(UsedTrackSizes::Prop());
if (!uts) {
uts = new UsedTrackSizes();
subgridFrame->SetProperty(UsedTrackSizes::Prop(), uts);
}
// The grid-item's inline-axis as expressed in the subgrid's WM.
auto subgridAxis = childWM.IsOrthogonalTo(subgridFrame->GetWritingMode())
? LogicalAxis::Block
: LogicalAxis::Inline;
uts->ResolveTrackSizesForAxis(subgridFrame, subgridAxis, *aRC);
if (uts->mCanResolveLineRangeSize[subgridAxis]) {
auto* subgrid =
subgridFrame->GetProperty(nsGridContainerFrame::Subgrid::Prop());
const GridItemInfo* originalItem = nullptr;
for (const auto& item : subgrid->mGridItems) {
if (item.mFrame == child) {
originalItem = &item;
break;
}
}
MOZ_ASSERT(originalItem, "huh?");
const auto& range = originalItem->mArea.LineRangeForAxis(subgridAxis);
nscoord pos, sz;
range.ToPositionAndLength(uts->mSizes[subgridAxis], &pos, &sz);
if (childWM.IsOrthogonalTo(subgridFrame->GetWritingMode())) {
availBSize = sz;
cbSize.BSize(childWM) = sz;
if (aGridItem.mState[aAxis] & ItemState::eClampMarginBoxMinSize) {
bMinSizeClamp = sz;
}
} else {
availISize = sz;
cbSize.ISize(childWM) = sz;
if (aGridItem.mState[aAxis] & ItemState::eClampMarginBoxMinSize) {
iMinSizeClamp = sz;
}
}
}
} else if (aState.mCols.mCanResolveLineRangeSize) {
nscoord sz = aState.mCols.ResolveSize(aGridItem.mArea.mCols);
if (isOrthogonal) {
availBSize = sz;
cbSize.BSize(childWM) = sz;
if (aGridItem.mState[aAxis] & ItemState::eClampMarginBoxMinSize) {
bMinSizeClamp = sz;
}
} else {
availISize = sz;
cbSize.ISize(childWM) = sz;
if (aGridItem.mState[aAxis] & ItemState::eClampMarginBoxMinSize) {
iMinSizeClamp = sz;
}
}
}
if (isOrthogonal == (aAxis == LogicalAxis::Inline)) {
bMinSizeClamp = aMinSizeClamp;
} else {
iMinSizeClamp = aMinSizeClamp;
}
LogicalSize availableSize(childWM, availISize, availBSize);
size = ::MeasuringReflow(child, aState.mReflowInput, aRC, availableSize,
cbSize, iMinSizeClamp, bMinSizeClamp);
size += child->GetLogicalUsedMargin(childWM).BStartEnd(childWM);
nscoord overflow = size - aMinSizeClamp;
if (MOZ_UNLIKELY(overflow > 0)) {
nscoord contentSize = child->ContentBSize(childWM);
nscoord newContentSize = std::max(nscoord(0), contentSize - overflow);
// XXXmats deal with percentages better, see bug 1300369 comment 27.
size -= contentSize - newContentSize;
}
}
MOZ_ASSERT(aGridItem.mBaselineOffset[aAxis] >= 0,
"baseline offset should be non-negative at this point");
MOZ_ASSERT((aGridItem.mState[aAxis] & ItemState::eIsBaselineAligned) ||
aGridItem.mBaselineOffset[aAxis] == nscoord(0),
"baseline offset should be zero when not baseline-aligned");
size += aGridItem.mBaselineOffset[aAxis];
size += extraMargin;
return std::max(size, 0);
}
struct CachedIntrinsicSizes {
Maybe<nscoord> mMinSize;
Maybe<nscoord> mMinContentContribution;
Maybe<nscoord> mMaxContentContribution;
// The item's percentage basis for intrinsic sizing purposes.
Maybe<LogicalSize> mPercentageBasis;
// "if the grid item spans only grid tracks that have a fixed max track
// sizing function, its automatic minimum size in that dimension is
// further clamped to less than or equal to the size necessary to fit its
// margin box within the resulting grid area (flooring at zero)"
// https://drafts.csswg.org/css-grid/#min-size-auto
// This is the clamp value to use for that:
nscoord mMinSizeClamp = NS_MAXSIZE;
};
static nscoord MinContentContribution(const GridItemInfo& aGridItem,
const GridReflowInput& aState,
gfxContext* aRC, WritingMode aCBWM,
LogicalAxis aAxis,
CachedIntrinsicSizes* aCache) {
if (aCache->mMinContentContribution.isSome()) {
return aCache->mMinContentContribution.value();
}
if (aCache->mPercentageBasis.isNothing()) {
aCache->mPercentageBasis.emplace(
aState.PercentageBasisFor(aAxis, aGridItem));
}
nscoord s = ContentContribution(
aGridItem, aState, aRC, aCBWM, aAxis, aCache->mPercentageBasis,
IntrinsicISizeType::MinISize, aCache->mMinSizeClamp);
aCache->mMinContentContribution.emplace(s);
return s;
}
static nscoord MaxContentContribution(const GridItemInfo& aGridItem,
const GridReflowInput& aState,
gfxContext* aRC, WritingMode aCBWM,
LogicalAxis aAxis,
CachedIntrinsicSizes* aCache) {
if (aCache->mMaxContentContribution.isSome()) {
return aCache->mMaxContentContribution.value();
}
if (aCache->mPercentageBasis.isNothing()) {
aCache->mPercentageBasis.emplace(
aState.PercentageBasisFor(aAxis, aGridItem));
}
nscoord s = ContentContribution(
aGridItem, aState, aRC, aCBWM, aAxis, aCache->mPercentageBasis,
IntrinsicISizeType::PrefISize, aCache->mMinSizeClamp);
aCache->mMaxContentContribution.emplace(s);
return s;
}
// Computes the min-size contribution for a grid item, as defined at
// https://drafts.csswg.org/css-grid/#min-size-contribution
static nscoord MinSize(const GridItemInfo& aGridItem,
const GridReflowInput& aState, gfxContext* aRC,
WritingMode aCBWM, LogicalAxis aAxis,
CachedIntrinsicSizes* aCache) {
if (aCache->mMinSize.isSome()) {
return aCache->mMinSize.value();
}
nsIFrame* child = aGridItem.mFrame;
PhysicalAxis axis(aCBWM.PhysicalAxis(aAxis));
const nsStylePosition* stylePos = child->StylePosition();
StyleSize sizeStyle =
axis == PhysicalAxis::Horizontal ? stylePos->mWidth : stylePos->mHeight;
auto ourInlineAxis =
child->GetWritingMode().PhysicalAxis(LogicalAxis::Inline);
// max-content and min-content should behave as initial value in block axis.
// FIXME: Bug 567039: moz-fit-content and -moz-available are not supported
// for block size dimension on sizing properties (e.g. height), so we
// treat it as `auto`.
if (axis != ourInlineAxis && sizeStyle.BehavesLikeInitialValueOnBlockAxis()) {
sizeStyle = StyleSize::Auto();
}
if (!sizeStyle.IsAuto() && !sizeStyle.HasPercent()) {
nscoord s =
MinContentContribution(aGridItem, aState, aRC, aCBWM, aAxis, aCache);
aCache->mMinSize.emplace(s);
return s;
}
if (aCache->mPercentageBasis.isNothing()) {
aCache->mPercentageBasis.emplace(
aState.PercentageBasisFor(aAxis, aGridItem));
}
// https://drafts.csswg.org/css-grid/#min-size-auto
// This calculates the min-content contribution from either a definite
// min-width (or min-height depending on aAxis), or the "specified /
// transferred size" for min-width:auto if overflow == visible (as min-width:0
// otherwise), or NS_UNCONSTRAINEDSIZE for other min-width intrinsic values
// (which results in always taking the "content size" part below).
MOZ_ASSERT(aGridItem.mBaselineOffset[aAxis] >= 0,
"baseline offset should be non-negative at this point");
MOZ_ASSERT((aGridItem.mState[aAxis] & ItemState::eIsBaselineAligned) ||
aGridItem.mBaselineOffset[aAxis] == nscoord(0),
"baseline offset should be zero when not baseline-aligned");
nscoord sz = aGridItem.mBaselineOffset[aAxis] +
nsLayoutUtils::MinSizeContributionForAxis(
axis, aRC, child, IntrinsicISizeType::MinISize,
*aCache->mPercentageBasis);
const StyleSize& style = axis == PhysicalAxis::Horizontal
? stylePos->mMinWidth
: stylePos->mMinHeight;
// max-content and min-content should behave as initial value in block axis.
// FIXME: Bug 567039: moz-fit-content and -moz-available are not supported
// for block size dimension on sizing properties (e.g. height), so we
// treat it as `auto`.
const bool inInlineAxis = axis == ourInlineAxis;
const bool isAuto =
style.IsAuto() ||
(!inInlineAxis && style.BehavesLikeInitialValueOnBlockAxis());
if ((inInlineAxis && nsIFrame::ToExtremumLength(style)) ||
(isAuto && !child->StyleDisplay()->IsScrollableOverflow())) {
// Now calculate the "content size" part and return whichever is smaller.
MOZ_ASSERT(isAuto || sz == NS_UNCONSTRAINEDSIZE);
sz = std::min(sz, ContentContribution(aGridItem, aState, aRC, aCBWM, aAxis,
aCache->mPercentageBasis,
IntrinsicISizeType::MinISize,
aCache->mMinSizeClamp,
nsLayoutUtils::MIN_INTRINSIC_ISIZE));
}
aCache->mMinSize.emplace(sz);
return sz;
}
void nsGridContainerFrame::Tracks::CalculateSizes(
GridReflowInput& aState, nsTArray<GridItemInfo>& aGridItems,
const TrackSizingFunctions& aFunctions, nscoord aContentBoxSize,
LineRange GridArea::*aRange, SizingConstraint aConstraint) {
nscoord percentageBasis = aContentBoxSize;
if (percentageBasis == NS_UNCONSTRAINEDSIZE) {
percentageBasis = 0;
}
InitializeItemBaselines(aState, aGridItems);
ResolveIntrinsicSize(aState, aGridItems, aFunctions, aRange, percentageBasis,
aConstraint);
if (aConstraint != SizingConstraint::MinContent) {
nscoord freeSpace = aContentBoxSize;
if (freeSpace != NS_UNCONSTRAINEDSIZE) {
freeSpace -= SumOfGridGaps();
}
DistributeFreeSpace(freeSpace);
StretchFlexibleTracks(aState, aGridItems, aFunctions, freeSpace);
}
}
TrackSize::StateBits nsGridContainerFrame::Tracks::StateBitsForRange(
const LineRange& aRange) const {
MOZ_ASSERT(!aRange.IsAuto(), "must have a definite range");
TrackSize::StateBits state = TrackSize::StateBits{0};
for (auto i : aRange.Range()) {
state |= mSizes[i].mState;
}
return state;
}
static void AddSubgridContribution(TrackSize& aSize,
nscoord aMarginBorderPadding) {
if (aSize.mState & TrackSize::eIntrinsicMinSizing) {
aSize.mBase = std::max(aSize.mBase, aMarginBorderPadding);
aSize.mLimit = std::max(aSize.mLimit, aSize.mBase);
}
// XXX maybe eFlexMaxSizing too?
// (once we implement https://github.com/w3c/csswg-drafts/issues/2177)
if (aSize.mState &
(TrackSize::eIntrinsicMaxSizing | TrackSize::eFitContent)) {
aSize.mLimit = std::max(aSize.mLimit, aMarginBorderPadding);
}
}
bool nsGridContainerFrame::Tracks::ResolveIntrinsicSizeForNonSpanningItems(
GridReflowInput& aState, const TrackSizingFunctions& aFunctions,
nscoord aPercentageBasis, SizingConstraint aConstraint,
const LineRange& aRange, const GridItemInfo& aGridItem) {
gfxContext* rc = &aState.mRenderingContext;
WritingMode wm = aState.mWM;
CachedIntrinsicSizes cache;
TrackSize& sz = mSizes[aRange.mStart];
// min sizing
if (sz.mState & TrackSize::eAutoMinSizing) {
nscoord s;
// Check if we need to apply "Automatic Minimum Size" and cache it.
if (aGridItem.ShouldApplyAutoMinSize(wm, mAxis, aPercentageBasis)) {
aGridItem.mState[mAxis] |= ItemState::eApplyAutoMinSize;
// Clamp it if it's spanning a definite track max-sizing function.
if (TrackSize::IsDefiniteMaxSizing(sz.mState)) {
cache.mMinSizeClamp = aFunctions.MaxSizingFor(aRange.mStart)
.AsBreadth()
.Resolve(aPercentageBasis);
aGridItem.mState[mAxis] |= ItemState::eClampMarginBoxMinSize;
}
if (aConstraint != SizingConstraint::MaxContent) {
s = MinContentContribution(aGridItem, aState, rc, wm, mAxis, &cache);
} else {
s = MaxContentContribution(aGridItem, aState, rc, wm, mAxis, &cache);
}
} else {
s = MinSize(aGridItem, aState, rc, wm, mAxis, &cache);
}
sz.mBase = std::max(sz.mBase, s);
} else if (sz.mState & TrackSize::eMinContentMinSizing) {
auto s = MinContentContribution(aGridItem, aState, rc, wm, mAxis, &cache);
sz.mBase = std::max(sz.mBase, s);
} else if (sz.mState & TrackSize::eMaxContentMinSizing) {
auto s = MaxContentContribution(aGridItem, aState, rc, wm, mAxis, &cache);
sz.mBase = std::max(sz.mBase, s);
}
// max sizing
if (sz.mState & TrackSize::eMinContentMaxSizing) {
auto s = MinContentContribution(aGridItem, aState, rc, wm, mAxis, &cache);
if (sz.mLimit == NS_UNCONSTRAINEDSIZE) {
sz.mLimit = s;
} else {
sz.mLimit = std::max(sz.mLimit, s);
}
} else if (sz.mState &
(TrackSize::eAutoMaxSizing | TrackSize::eMaxContentMaxSizing)) {
auto s = MaxContentContribution(aGridItem, aState, rc, wm, mAxis, &cache);
if (sz.mLimit == NS_UNCONSTRAINEDSIZE) {
sz.mLimit = s;
} else {
sz.mLimit = std::max(sz.mLimit, s);
}
if (MOZ_UNLIKELY(sz.mState & TrackSize::eFitContent)) {
// Clamp mLimit to the fit-content() size, for §12.5.1.
nscoord fitContentClamp = aFunctions.SizingFor(aRange.mStart)
.AsFitContent()
.AsBreadth()
.Resolve(aPercentageBasis);
sz.mLimit = std::min(sz.mLimit, fitContentClamp);
}
}
if (sz.mLimit < sz.mBase) {
sz.mLimit = sz.mBase;
}
return sz.mState & TrackSize::eFlexMaxSizing;
}
void nsGridContainerFrame::Tracks::CalculateItemBaselines(
nsTArray<ItemBaselineData>& aBaselineItems,
BaselineSharingGroup aBaselineGroup) {
if (aBaselineItems.IsEmpty()) {
return;
}
// Sort the collected items on their baseline track.
std::sort(aBaselineItems.begin(), aBaselineItems.end(),
ItemBaselineData::IsBaselineTrackLessThan);
MOZ_ASSERT(mSizes.Length() > 0, "having an item implies at least one track");
const uint32_t lastTrack = mSizes.Length() - 1;
nscoord maxBaseline = 0;
nscoord maxDescent = 0;
uint32_t currentTrack = kAutoLine; // guaranteed to not match any item
uint32_t trackStartIndex = 0;
for (uint32_t i = 0, len = aBaselineItems.Length(); true; ++i) {
// Find the maximum baseline and descent in the current track.
if (i != len) {
const ItemBaselineData& item = aBaselineItems[i];
if (currentTrack == item.mBaselineTrack) {
maxBaseline = std::max(maxBaseline, item.mBaseline);
maxDescent = std::max(maxDescent, item.mSize - item.mBaseline);
continue;
}
}
// Iterate the current track again and update the baseline offsets making
// all items baseline-aligned within this group in this track.
for (uint32_t j = trackStartIndex; j < i; ++j) {
const ItemBaselineData& item = aBaselineItems[j];
item.mGridItem->mBaselineOffset[mAxis] = maxBaseline - item.mBaseline;
MOZ_ASSERT(item.mGridItem->mBaselineOffset[mAxis] >= 0);
}
if (i != 0) {
// Store the size of this baseline-aligned subtree.
mSizes[currentTrack].mBaselineSubtreeSize[aBaselineGroup] =
maxBaseline + maxDescent;
// Record the first(last) baseline for the first(last) track.
if (currentTrack == 0 && aBaselineGroup == BaselineSharingGroup::First) {
mBaseline[aBaselineGroup] = maxBaseline;
}
if (currentTrack == lastTrack &&
aBaselineGroup == BaselineSharingGroup::Last) {
mBaseline[aBaselineGroup] = maxBaseline;
}
}
if (i == len) {
break;
}
// Initialize data for the next track with baseline-aligned items.
const ItemBaselineData& item = aBaselineItems[i];
currentTrack = item.mBaselineTrack;
trackStartIndex = i;
maxBaseline = item.mBaseline;
maxDescent = item.mSize - item.mBaseline;
}
}
void nsGridContainerFrame::Tracks::InitializeItemBaselines(
GridReflowInput& aState, nsTArray<GridItemInfo>& aGridItems) {
MOZ_ASSERT(!mIsMasonry);
if (aState.mFrame->IsSubgrid(mAxis)) {
// A grid container's subgridded axis doesn't have a baseline.
return;
}
nsTArray<ItemBaselineData> firstBaselineItems;
nsTArray<ItemBaselineData> lastBaselineItems;
const WritingMode containerWM = aState.mWM;
ComputedStyle* containerStyle = aState.mFrame->Style();
// The physical side of the container's block start side. We use it to match
// against the physical block start side of the child to determine its
// baseline sharing group.
auto containerBlockStartSide =
containerWM.PhysicalSide(MakeLogicalSide(mAxis, LogicalEdge::Start));
for (GridItemInfo& gridItem : aGridItems) {
if (gridItem.IsSubgrid(mAxis)) {
// A subgrid itself is never baseline-aligned.
continue;
}
nsIFrame* child = gridItem.mFrame;
uint32_t baselineTrack = kAutoLine;
auto state = ItemState(0);
const auto childWM = child->GetWritingMode();
const bool isOrthogonal = containerWM.IsOrthogonalTo(childWM);
const bool isInlineAxis = mAxis == LogicalAxis::Inline; // i.e. columns
// XXX update the line below to include orthogonal grid/table boxes
// XXX since they have baselines in both dimensions. And flexbox with
// XXX reversed main/cross axis?
const bool itemHasBaselineParallelToTrack = isInlineAxis == isOrthogonal;
if (itemHasBaselineParallelToTrack) {
// [align|justify]-self:[last ]baseline.
auto selfAlignment =
isOrthogonal
? child->StylePosition()->UsedJustifySelf(containerStyle)._0
: child->StylePosition()->UsedAlignSelf(containerStyle)._0;
selfAlignment &= ~StyleAlignFlags::FLAG_BITS;
if (selfAlignment == StyleAlignFlags::BASELINE) {
state |= ItemState::eFirstBaseline | ItemState::eSelfBaseline;
const GridArea& area = gridItem.mArea;
baselineTrack = isInlineAxis ? area.mCols.mStart : area.mRows.mStart;
} else if (selfAlignment == StyleAlignFlags::LAST_BASELINE) {
state |= ItemState::eLastBaseline | ItemState::eSelfBaseline;
const GridArea& area = gridItem.mArea;
baselineTrack = (isInlineAxis ? area.mCols.mEnd : area.mRows.mEnd) - 1;
}
// [align|justify]-content:[last ]baseline.
// https://drafts.csswg.org/css-align-3/#baseline-align-content
// "[...] and its computed 'align-self' or 'justify-self' (whichever
// affects its block axis) is 'stretch' or 'self-start' ('self-end').
// For this purpose, the 'start', 'end', 'flex-start', and 'flex-end'
// values of 'align-self' are treated as either 'self-start' or
// 'self-end', whichever they end up equivalent to.
auto alignContent = child->StylePosition()->mAlignContent.primary;
alignContent &= ~StyleAlignFlags::FLAG_BITS;
if (alignContent == StyleAlignFlags::BASELINE ||
alignContent == StyleAlignFlags::LAST_BASELINE) {
const auto selfAlignEdge = alignContent == StyleAlignFlags::BASELINE
? StyleAlignFlags::SELF_START
: StyleAlignFlags::SELF_END;
bool validCombo = selfAlignment == StyleAlignFlags::NORMAL ||
selfAlignment == StyleAlignFlags::STRETCH ||
selfAlignment == selfAlignEdge;
if (!validCombo) {
// We're doing alignment in the axis that's orthogonal to mAxis here.
LogicalAxis alignAxis = GetOrthogonalAxis(mAxis);
// |sameSide| is true if the container's start side in this axis is
// the same as the child's start side, in the child's parallel axis.
bool sameSide =
containerWM.ParallelAxisStartsOnSameSide(alignAxis, childWM);
if (selfAlignment == StyleAlignFlags::LEFT) {
selfAlignment = !isInlineAxis || containerWM.IsBidiLTR()
? StyleAlignFlags::START
: StyleAlignFlags::END;
} else if (selfAlignment == StyleAlignFlags::RIGHT) {
selfAlignment = isInlineAxis && containerWM.IsBidiLTR()
? StyleAlignFlags::END
: StyleAlignFlags::START;
}
if (selfAlignment == StyleAlignFlags::START ||
selfAlignment == StyleAlignFlags::FLEX_START) {
validCombo =
sameSide == (alignContent == StyleAlignFlags::BASELINE);
} else if (selfAlignment == StyleAlignFlags::END ||
selfAlignment == StyleAlignFlags::FLEX_END) {
validCombo =
sameSide == (alignContent == StyleAlignFlags::LAST_BASELINE);
}
}
if (validCombo) {
const GridArea& area = gridItem.mArea;
if (alignContent == StyleAlignFlags::BASELINE) {
state |= ItemState::eFirstBaseline | ItemState::eContentBaseline;
baselineTrack =
isInlineAxis ? area.mCols.mStart : area.mRows.mStart;
} else if (alignContent == StyleAlignFlags::LAST_BASELINE) {
state |= ItemState::eLastBaseline | ItemState::eContentBaseline;
baselineTrack =
(isInlineAxis ? area.mCols.mEnd : area.mRows.mEnd) - 1;
}
}
}
}
if (state & ItemState::eIsBaselineAligned) {
// The item is baseline aligned, so calculate the baseline sharing group.
// <https://drafts.csswg.org/css-align-3/#baseline-terms>
BaselineSharingGroup baselineAlignment =
(state & ItemState::eFirstBaseline) ? BaselineSharingGroup::First
: BaselineSharingGroup::Last;
BaselineSharingGroup baselineSharingGroup = [&]() {
{
auto childAxis = isOrthogonal ? GetOrthogonalAxis(mAxis) : mAxis;
auto childBlockStartSide = childWM.PhysicalSide(
MakeLogicalSide(childAxis, LogicalEdge::Start));
bool isFirstBaseline = (state & ItemState::eFirstBaseline) != 0;
const bool containerAndChildHasEqualBaselineSide =
containerBlockStartSide == childBlockStartSide;
return isFirstBaseline == containerAndChildHasEqualBaselineSide
? BaselineSharingGroup::First
: BaselineSharingGroup::Last;
}
}();
// XXXmats if |child| is a descendant of a subgrid then the metrics
// below needs to account for the accumulated MPB somehow...
// XXX available size issue
LogicalSize avail(childWM, INFINITE_ISIZE_COORD, NS_UNCONSTRAINEDSIZE);
auto* rc = &aState.mRenderingContext;
// XXX figure out if we can avoid/merge this reflow with the main reflow.
// XXX (after bug 1174569 is sorted out)
//
// XXX How should we handle percentage padding here? (bug 1330866)
// XXX (see ::ContentContribution and how it deals with percentages)
// XXX What if the true baseline after line-breaking differs from this
// XXX hypothetical baseline based on an infinite inline size?
// XXX Maybe we should just call ::ContentContribution here instead?
// XXX For now we just pass an unconstrined-bsize CB:
LogicalSize cbSize(childWM, 0, NS_UNCONSTRAINEDSIZE);
::MeasuringReflow(child, aState.mReflowInput, rc, avail, cbSize);
nsGridContainerFrame* grid = do_QueryFrame(child);
auto frameSize =
isInlineAxis ? child->ISize(containerWM) : child->BSize(containerWM);
auto margin = child->GetLogicalUsedMargin(containerWM);
auto alignSize =
frameSize + (isInlineAxis ? margin.IStartEnd(containerWM)
: margin.BStartEnd(containerWM));
Maybe<nscoord> baseline;
if (grid) {
baseline.emplace((isOrthogonal == isInlineAxis)
? grid->GetBBaseline(baselineAlignment)
: grid->GetIBaseline(baselineAlignment));
} else {
baseline = child->GetNaturalBaselineBOffset(
childWM, baselineAlignment, BaselineExportContext::Other);
if (!baseline) {
// If baseline alignment is specified on a grid item whose size in
// that axis depends on the size of an intrinsically-sized track, that
// item does not participate in baseline alignment, and instead uses
// its fallback alignment as if that were originally specified.
// https://drafts.csswg.org/css-grid-1/#row-align
// Check if the item crosses any tracks that are intrinsically sized.
auto range = gridItem.mArea.LineRangeForAxis(mAxis).Range();
auto isTrackAutoSize =
std::find_if(range.begin(), range.end(), [&](auto track) {
constexpr auto intrinsicSizeFlags =
TrackSize::eIntrinsicMinSizing |
TrackSize::eIntrinsicMaxSizing | TrackSize::eFitContent |
TrackSize::eFlexMaxSizing;
return (mSizes[track].mState & intrinsicSizeFlags) != 0;
}) != range.end();
// If either the track or the item is not auto sized, then the item
// participates in baseline alignment.
if (!isTrackAutoSize ||
!gridItem.IsBSizeDependentOnContainerSize(containerWM)) {
baseline.emplace(Baseline::SynthesizeBOffsetFromBorderBox(
child, containerWM, baselineAlignment));
}
}
}
if (baseline) {
nscoord finalBaseline = *baseline;
NS_ASSERTION(finalBaseline != NS_INTRINSIC_ISIZE_UNKNOWN,
"about to use an unknown baseline");
nscoord marginAdjust = 0;
if (baselineSharingGroup == BaselineSharingGroup::First) {
marginAdjust = isInlineAxis ? margin.IStart(containerWM)
: margin.BStart(containerWM);
} else {
marginAdjust = isInlineAxis ? margin.IEnd(containerWM)
: margin.BEnd(containerWM);
// This flag is used in ::AlignSelf(...) to check whether the item is
// last baseline aligned, but this flag should go away.
state |= GridItemInfo::eEndSideBaseline;
}
finalBaseline += marginAdjust;
auto& baselineItems =
(baselineSharingGroup == BaselineSharingGroup::First)
? firstBaselineItems
: lastBaselineItems;
baselineItems.AppendElement(ItemBaselineData{
baselineTrack, finalBaseline, alignSize, &gridItem});
} else {
state &= ~ItemState::eAllBaselineBits;
}
}
MOZ_ASSERT(
(state & (ItemState::eFirstBaseline | ItemState::eLastBaseline)) !=
(ItemState::eFirstBaseline | ItemState::eLastBaseline),
"first/last baseline bits are mutually exclusive");
MOZ_ASSERT(
(state & (ItemState::eSelfBaseline | ItemState::eContentBaseline)) !=
(ItemState::eSelfBaseline | ItemState::eContentBaseline),
"*-self and *-content baseline bits are mutually exclusive");
MOZ_ASSERT(
!(state & (ItemState::eFirstBaseline | ItemState::eLastBaseline)) ==
!(state & (ItemState::eSelfBaseline | ItemState::eContentBaseline)),
"first/last bit requires self/content bit and vice versa");
gridItem.mState[mAxis] |= state;
gridItem.mBaselineOffset[mAxis] = nscoord(0);
}
if (firstBaselineItems.IsEmpty() && lastBaselineItems.IsEmpty()) {
return;
}
// TODO: CSS Align spec issue - how to align a baseline subtree in a track?
// https://lists.w3.org/Archives/Public/www-style/2016May/0141.html
mBaselineSubtreeAlign[BaselineSharingGroup::First] = StyleAlignFlags::START;
mBaselineSubtreeAlign[BaselineSharingGroup::Last] = StyleAlignFlags::END;
CalculateItemBaselines(firstBaselineItems, BaselineSharingGroup::First);
CalculateItemBaselines(lastBaselineItems, BaselineSharingGroup::Last);
}
// TODO: we store the wrong baseline group offset in some cases (bug 1632200)
void nsGridContainerFrame::Tracks::InitializeItemBaselinesInMasonryAxis(
GridReflowInput& aState, nsTArray<GridItemInfo>& aGridItems,
BaselineAlignmentSet aSet, const nsSize& aContainerSize,
nsTArray<nscoord>& aTrackSizes,
nsTArray<ItemBaselineData>& aFirstBaselineItems,
nsTArray<ItemBaselineData>& aLastBaselineItems) {
MOZ_ASSERT(mIsMasonry);
WritingMode wm = aState.mWM;
ComputedStyle* containerSC = aState.mFrame->Style();
for (GridItemInfo& gridItem : aGridItems) {
if (gridItem.IsSubgrid(mAxis)) {
// A subgrid itself is never baseline-aligned.
continue;
}
const auto& area = gridItem.mArea;
if (aSet.mItemSet == BaselineAlignmentSet::LastItems) {
// NOTE: eIsLastItemInMasonryTrack is set also if the item is the ONLY
// item in its track; the eIsBaselineAligned check excludes it though
// since it participates in the start baseline groups in that case.
//
// XXX what if it's the only item in THAT baseline group?
// XXX should it participate in the last-item group instead then
// if there are more baseline-aligned items there?
if (!(gridItem.mState[mAxis] & ItemState::eIsLastItemInMasonryTrack) ||
(gridItem.mState[mAxis] & ItemState::eIsBaselineAligned)) {
continue;
}
} else {
if (area.LineRangeForAxis(mAxis).mStart > 0 ||
(gridItem.mState[mAxis] & ItemState::eIsBaselineAligned)) {
continue;
}
}
auto trackAlign =
aState.mGridStyle
->UsedTracksAlignment(
mAxis, area.LineRangeForAxis(GetOrthogonalAxis(mAxis)).mStart)
.primary;
if (!aSet.MatchTrackAlignment(trackAlign)) {
continue;
}
nsIFrame* child = gridItem.mFrame;
uint32_t baselineTrack = kAutoLine;
auto state = ItemState(0);
auto childWM = child->GetWritingMode();
const bool isOrthogonal = wm.IsOrthogonalTo(childWM);
const bool isInlineAxis = mAxis == LogicalAxis::Inline; // i.e. columns
// XXX update the line below to include orthogonal grid/table boxes
// XXX since they have baselines in both dimensions. And flexbox with
// XXX reversed main/cross axis?
const bool itemHasBaselineParallelToTrack = isInlineAxis == isOrthogonal;
if (itemHasBaselineParallelToTrack) {
const auto* pos = child->StylePosition();
// [align|justify]-self:[last ]baseline.
auto selfAlignment = pos->UsedSelfAlignment(mAxis, containerSC);
selfAlignment &= ~StyleAlignFlags::FLAG_BITS;
if (selfAlignment == StyleAlignFlags::BASELINE) {
state |= ItemState::eFirstBaseline | ItemState::eSelfBaseline;
baselineTrack = isInlineAxis ? area.mCols.mStart : area.mRows.mStart;
} else if (selfAlignment == StyleAlignFlags::LAST_BASELINE) {
state |= ItemState::eLastBaseline | ItemState::eSelfBaseline;
baselineTrack = (isInlineAxis ? area.mCols.mEnd : area.mRows.mEnd) - 1;
} else {
// [align|justify]-content:[last ]baseline.
auto childAxis = isOrthogonal ? GetOrthogonalAxis(mAxis) : mAxis;
auto alignContent = pos->UsedContentAlignment(childAxis).primary;
alignContent &= ~StyleAlignFlags::FLAG_BITS;
if (alignContent == StyleAlignFlags::BASELINE) {
state |= ItemState::eFirstBaseline | ItemState::eContentBaseline;
baselineTrack = isInlineAxis ? area.mCols.mStart : area.mRows.mStart;
} else if (alignContent == StyleAlignFlags::LAST_BASELINE) {
state |= ItemState::eLastBaseline | ItemState::eContentBaseline;
baselineTrack =
(isInlineAxis ? area.mCols.mEnd : area.mRows.mEnd) - 1;
}
}
}
if (state & ItemState::eIsBaselineAligned) {
// XXXmats if |child| is a descendant of a subgrid then the metrics
// below needs to account for the accumulated MPB somehow...
nscoord baseline;
nsGridContainerFrame* grid = do_QueryFrame(child);
if (state & ItemState::eFirstBaseline) {
if (grid) {
if (isOrthogonal == isInlineAxis) {
baseline = grid->GetBBaseline(BaselineSharingGroup::First);
} else {
baseline = grid->GetIBaseline(BaselineSharingGroup::First);
}
}
if (grid || nsLayoutUtils::GetFirstLineBaseline(wm, child, &baseline)) {
NS_ASSERTION(baseline != NS_INTRINSIC_ISIZE_UNKNOWN,
"about to use an unknown baseline");
auto frameSize = isInlineAxis ? child->ISize(wm) : child->BSize(wm);
nscoord alignSize;
LogicalPoint pos =
child->GetLogicalNormalPosition(wm, aContainerSize);
baseline += pos.Pos(mAxis, wm);
if (aSet.mTrackAlignmentSet == BaselineAlignmentSet::EndStretch) {
state |= ItemState::eEndSideBaseline;
// Convert to distance from the track end.
baseline =
aTrackSizes[gridItem.mArea
.LineRangeForAxis(GetOrthogonalAxis(mAxis))
.mStart] -
baseline;
}
alignSize = frameSize;
aFirstBaselineItems.AppendElement(ItemBaselineData(
{baselineTrack, baseline, alignSize, &gridItem}));
} else {
state &= ~ItemState::eAllBaselineBits;
}
} else {
if (grid) {
if (isOrthogonal == isInlineAxis) {
baseline = grid->GetBBaseline(BaselineSharingGroup::Last);
} else {
baseline = grid->GetIBaseline(BaselineSharingGroup::Last);
}
}
if (grid || nsLayoutUtils::GetLastLineBaseline(wm, child, &baseline)) {
NS_ASSERTION(baseline != NS_INTRINSIC_ISIZE_UNKNOWN,
"about to use an unknown baseline");
auto frameSize = isInlineAxis ? child->ISize(wm) : child->BSize(wm);
auto m = child->GetLogicalUsedMargin(wm);
if (!grid &&
aSet.mTrackAlignmentSet == BaselineAlignmentSet::EndStretch) {
// Convert to distance from border-box end.
state |= ItemState::eEndSideBaseline;
LogicalPoint pos =
child->GetLogicalNormalPosition(wm, aContainerSize);
baseline += pos.Pos(mAxis, wm);
baseline =
aTrackSizes[gridItem.mArea
.LineRangeForAxis(GetOrthogonalAxis(mAxis))
.mStart] -
baseline;
} else if (grid && aSet.mTrackAlignmentSet ==
BaselineAlignmentSet::StartStretch) {
// Convert to distance from border-box start.
baseline = frameSize - baseline;
}
if (aSet.mItemSet == BaselineAlignmentSet::LastItems &&
aSet.mTrackAlignmentSet == BaselineAlignmentSet::StartStretch) {
LogicalPoint pos =
child->GetLogicalNormalPosition(wm, aContainerSize);
baseline += pos.B(wm);
}
if (aSet.mTrackAlignmentSet == BaselineAlignmentSet::EndStretch) {
state |= ItemState::eEndSideBaseline;
}
auto descent =
baseline + ((state & ItemState::eEndSideBaseline)
? (isInlineAxis ? m.IEnd(wm) : m.BEnd(wm))
: (isInlineAxis ? m.IStart(wm) : m.BStart(wm)));
auto alignSize =
frameSize + (isInlineAxis ? m.IStartEnd(wm) : m.BStartEnd(wm));
aLastBaselineItems.AppendElement(
ItemBaselineData({baselineTrack, descent, alignSize, &gridItem}));
} else {
state &= ~ItemState::eAllBaselineBits;
}
}
}
MOZ_ASSERT(
(state & (ItemState::eFirstBaseline | ItemState::eLastBaseline)) !=
(ItemState::eFirstBaseline | ItemState::eLastBaseline),
"first/last baseline bits are mutually exclusive");
MOZ_ASSERT(
(state & (ItemState::eSelfBaseline | ItemState::eContentBaseline)) !=
(ItemState::eSelfBaseline | ItemState::eContentBaseline),
"*-self and *-content baseline bits are mutually exclusive");
MOZ_ASSERT(
!(state & (ItemState::eFirstBaseline | ItemState::eLastBaseline)) ==
!(state & (ItemState::eSelfBaseline | ItemState::eContentBaseline)),
"first/last bit requires self/content bit and vice versa");
gridItem.mState[mAxis] |= state;
gridItem.mBaselineOffset[mAxis] = nscoord(0);
}
CalculateItemBaselines(aFirstBaselineItems, BaselineSharingGroup::First);
CalculateItemBaselines(aLastBaselineItems, BaselineSharingGroup::Last);
// TODO: make sure the mBaselines (i.e. the baselines we export from
// the grid container) are offset from the correct container edge.
// Also, which of the baselines do we pick to export exactly?
MOZ_ASSERT(aFirstBaselineItems.Length() != 1 ||
aFirstBaselineItems[0].mGridItem->mBaselineOffset[mAxis] == 0,
"a baseline group that contains only one item should not "
"produce a non-zero item baseline offset");
MOZ_ASSERT(aLastBaselineItems.Length() != 1 ||
aLastBaselineItems[0].mGridItem->mBaselineOffset[mAxis] == 0,
"a baseline group that contains only one item should not "
"produce a non-zero item baseline offset");
}
void nsGridContainerFrame::Tracks::AlignBaselineSubtree(
const GridItemInfo& aGridItem) const {
if (mIsMasonry) {
return;
}
auto state = aGridItem.mState[mAxis];
if (!(state & ItemState::eIsBaselineAligned)) {
return;
}
const GridArea& area = aGridItem.mArea;
int32_t baselineTrack;
const bool isFirstBaseline = state & ItemState::eFirstBaseline;
if (isFirstBaseline) {
baselineTrack =
mAxis == LogicalAxis::Block ? area.mRows.mStart : area.mCols.mStart;
} else {
baselineTrack =
(mAxis == LogicalAxis::Block ? area.mRows.mEnd : area.mCols.mEnd) - 1;
}
const TrackSize& sz = mSizes[baselineTrack];
auto baselineGroup = isFirstBaseline ? BaselineSharingGroup::First
: BaselineSharingGroup::Last;
nscoord delta = sz.mBase - sz.mBaselineSubtreeSize[baselineGroup];
const auto subtreeAlign = mBaselineSubtreeAlign[baselineGroup];
if (subtreeAlign == StyleAlignFlags::START) {
if (state & ItemState::eLastBaseline) {
aGridItem.mBaselineOffset[mAxis] += delta;
}
} else if (subtreeAlign == StyleAlignFlags::END) {
if (isFirstBaseline) {
aGridItem.mBaselineOffset[mAxis] += delta;
}
} else if (subtreeAlign == StyleAlignFlags::CENTER) {
aGridItem.mBaselineOffset[mAxis] += delta / 2;
} else {
MOZ_ASSERT_UNREACHABLE("unexpected baseline subtree alignment");
}
}
template <nsGridContainerFrame::Tracks::TrackSizingPhase phase>
bool nsGridContainerFrame::Tracks::GrowSizeForSpanningItems(
nsTArray<SpanningItemData>::iterator aIter,
nsTArray<SpanningItemData>::iterator aIterEnd, nsTArray<uint32_t>& aTracks,
nsTArray<TrackSize>& aPlan, nsTArray<TrackSize>& aItemPlan,
TrackSize::StateBits aSelector, const FitContentClamper& aFitContentClamper,
bool aNeedInfinitelyGrowableFlag) {
constexpr bool isMaxSizingPhase =
phase == TrackSizingPhase::IntrinsicMaximums ||
phase == TrackSizingPhase::MaxContentMaximums;
bool needToUpdateSizes = false;
InitializePlan<phase>(aPlan);
for (; aIter != aIterEnd; ++aIter) {
const SpanningItemData& item = *aIter;
if (!(item.mState & aSelector)) {
continue;
}
if (isMaxSizingPhase) {
for (auto i : item.mLineRange.Range()) {
aPlan[i].mState |= TrackSize::eModified;
}
}
nscoord space = item.SizeContributionForPhase<phase>();
if (space <= 0) {
continue;
}
aTracks.ClearAndRetainStorage();
space = CollectGrowable<phase>(space, item.mLineRange, aSelector, aTracks);
if (space > 0) {
DistributeToTrackSizes<phase>(space, aPlan, aItemPlan, aTracks, aSelector,
aFitContentClamper);
needToUpdateSizes = true;
}
}
if (isMaxSizingPhase) {
needToUpdateSizes = true;
}
if (needToUpdateSizes) {
CopyPlanToSize<phase>(aPlan, aNeedInfinitelyGrowableFlag);
}
return needToUpdateSizes;
}
void nsGridContainerFrame::Tracks::ResolveIntrinsicSize(
GridReflowInput& aState, nsTArray<GridItemInfo>& aGridItems,
const TrackSizingFunctions& aFunctions, LineRange GridArea::*aRange,
nscoord aPercentageBasis, SizingConstraint aConstraint) {
// Resolve Intrinsic Track Sizes
// https://w3c.github.io/csswg-drafts/css-grid-1/#algo-content
// We're also setting eIsFlexing on the item state here to speed up
// FindUsedFlexFraction later.
gfxContext* rc = &aState.mRenderingContext;
WritingMode wm = aState.mWM;
// Data we accumulate when grouping similar sized spans together.
struct PerSpanData {
uint32_t mItemCountWithSameSpan = 0;
TrackSize::StateBits mStateBits = TrackSize::StateBits{0};
};
AutoTArray<PerSpanData, 16> perSpanData;
nsTArray<SpanningItemData> spanningItems;
uint32_t maxSpan = 0; // max span of items in `spanningItems`.
// Setup track selector for step 3.2:
const auto contentBasedMinSelector =
aConstraint == SizingConstraint::MinContent
? TrackSize::eIntrinsicMinSizing
: TrackSize::eMinOrMaxContentMinSizing;
// Setup track selector for step 3.3:
const auto maxContentMinSelector =
aConstraint == SizingConstraint::MaxContent
? (TrackSize::eMaxContentMinSizing | TrackSize::eAutoMinSizing)
: TrackSize::eMaxContentMinSizing;
const auto orthogonalAxis = GetOrthogonalAxis(mAxis);
const bool isMasonryInOtherAxis = aState.mFrame->IsMasonry(orthogonalAxis);
for (auto& gridItem : aGridItems) {
MOZ_ASSERT(!(gridItem.mState[mAxis] &
(ItemState::eApplyAutoMinSize | ItemState::eIsFlexing |
ItemState::eClampMarginBoxMinSize)),
"Why are any of these bits set already?");
const GridArea& area = gridItem.mArea;
const LineRange& lineRange = area.*aRange;
// If we have masonry layout in the other axis then skip this item unless
// it's in the first masonry track, or has definite placement in this axis,
// or spans all tracks in this axis (since that implies it will be placed
// at line 1 regardless of layout results of other items).
if (isMasonryInOtherAxis &&
gridItem.mArea.LineRangeForAxis(orthogonalAxis).mStart != 0 &&
(gridItem.mState[mAxis] & ItemState::eAutoPlacement) &&
gridItem.mArea.LineRangeForAxis(mAxis).Extent() != mSizes.Length()) {
continue;
}
uint32_t span = lineRange.Extent();
if (MOZ_UNLIKELY(gridItem.mState[mAxis] & ItemState::eIsSubgrid)) {
auto itemWM = gridItem.mFrame->GetWritingMode();
auto percentageBasis = aState.PercentageBasisFor(mAxis, gridItem);
if (percentageBasis.ISize(itemWM) == NS_UNCONSTRAINEDSIZE) {
percentageBasis.ISize(itemWM) = nscoord(0);
}
if (percentageBasis.BSize(itemWM) == NS_UNCONSTRAINEDSIZE) {
percentageBasis.BSize(itemWM) = nscoord(0);
}
auto* subgrid =
SubgridComputeMarginBorderPadding(gridItem, percentageBasis);
LogicalMargin mbp = SubgridAccumulatedMarginBorderPadding(
gridItem.SubgridFrame(), subgrid, wm, mAxis);
if (span == 1) {
AddSubgridContribution(mSizes[lineRange.mStart],
mbp.StartEnd(mAxis, wm));
} else {
AddSubgridContribution(mSizes[lineRange.mStart], mbp.Start(mAxis, wm));
AddSubgridContribution(mSizes[lineRange.mEnd - 1], mbp.End(mAxis, wm));
}
continue;
}
if (span == 1) {
// Step 2. Size tracks to fit non-spanning items.
if (ResolveIntrinsicSizeForNonSpanningItems(aState, aFunctions,
aPercentageBasis, aConstraint,
lineRange, gridItem)) {
gridItem.mState[mAxis] |= ItemState::eIsFlexing;
}
} else {
TrackSize::StateBits state = StateBitsForRange(lineRange);
// Check if we need to apply "Automatic Minimum Size" and cache it.
if ((state & TrackSize::eAutoMinSizing) &&
!(state & TrackSize::eFlexMaxSizing) &&
gridItem.ShouldApplyAutoMinSize(wm, mAxis, aPercentageBasis)) {
gridItem.mState[mAxis] |= ItemState::eApplyAutoMinSize;
}
if (state & TrackSize::eFlexMaxSizing) {
gridItem.mState[mAxis] |= ItemState::eIsFlexing;
} else if (state & (TrackSize::eIntrinsicMinSizing |
TrackSize::eIntrinsicMaxSizing)) {
// Collect data for Step 3.
maxSpan = std::max(maxSpan, span);
if (span >= perSpanData.Length()) {
perSpanData.SetLength(2 * span);
}
perSpanData[span].mItemCountWithSameSpan++;
perSpanData[span].mStateBits |= state;
CachedIntrinsicSizes cache;
// Calculate data for "Automatic Minimum Size" clamping, if needed.
if (TrackSize::IsDefiniteMaxSizing(state) &&
(gridItem.mState[mAxis] & ItemState::eApplyAutoMinSize)) {
nscoord minSizeClamp = 0;
for (auto i : lineRange.Range()) {
minSizeClamp += aFunctions.MaxSizingFor(i).AsBreadth().Resolve(
aPercentageBasis);
}
minSizeClamp += mGridGap * (span - 1);
cache.mMinSizeClamp = minSizeClamp;
gridItem.mState[mAxis] |= ItemState::eClampMarginBoxMinSize;
}
// Collect the various grid item size contributions we need.
nscoord minSize = 0;
if (state & TrackSize::eIntrinsicMinSizing) { // for 3.1
minSize = MinSize(gridItem, aState, rc, wm, mAxis, &cache);
}
nscoord minContent = 0;
if (state & (contentBasedMinSelector | // for 3.2
TrackSize::eIntrinsicMaxSizing)) { // for 3.5
minContent =
MinContentContribution(gridItem, aState, rc, wm, mAxis, &cache);
}
nscoord maxContent = 0;
if (state & (maxContentMinSelector | // for 3.3
TrackSize::eAutoOrMaxContentMaxSizing)) { // for 3.6
maxContent =
MaxContentContribution(gridItem, aState, rc, wm, mAxis, &cache);
}
spanningItems.AppendElement(
SpanningItemData({span, state, lineRange, minSize, minContent,
maxContent, gridItem.mFrame}));
}
}
MOZ_ASSERT(!(gridItem.mState[mAxis] & ItemState::eClampMarginBoxMinSize) ||
(gridItem.mState[mAxis] & ItemState::eApplyAutoMinSize),
"clamping only applies to Automatic Minimum Size");
}
// Step 3 - Increase sizes to accommodate spanning items crossing
// content-sized tracks.
if (maxSpan) {
auto fitContentClamper = [&aFunctions, aPercentageBasis](uint32_t aTrack,
nscoord aMinSize,
nscoord* aSize) {
nscoord fitContentLimit = ::ResolveToDefiniteSize(
aFunctions.MaxSizingFor(aTrack), aPercentageBasis);
if (*aSize > fitContentLimit) {
*aSize = std::max(aMinSize, fitContentLimit);
return true;
}
return false;
};
// Sort the collected items on span length, shortest first. There's no need
// for a stable sort here since the sizing isn't order dependent within
// a group of items with the same span length.
std::sort(spanningItems.begin(), spanningItems.end(),
SpanningItemData::IsSpanLessThan);
nsTArray<uint32_t> tracks(maxSpan);
nsTArray<TrackSize> plan(mSizes.Length());
plan.SetLength(mSizes.Length());
nsTArray<TrackSize> itemPlan(mSizes.Length());
itemPlan.SetLength(mSizes.Length());
// Start / end iterator for items of the same span length:
auto spanGroupStart = spanningItems.begin();
auto spanGroupEnd = spanGroupStart;
const auto end = spanningItems.end();
for (; spanGroupStart != end; spanGroupStart = spanGroupEnd) {
const uint32_t span = spanGroupStart->mSpan;
spanGroupEnd = spanGroupStart + perSpanData[span].mItemCountWithSameSpan;
TrackSize::StateBits stateBitsForSpan = perSpanData[span].mStateBits;
bool updatedBase = false; // Did we update any mBase in step 3.1..3.3?
TrackSize::StateBits selector(TrackSize::eIntrinsicMinSizing);
if (stateBitsForSpan & selector) {
// Step 3.1 MinSize to intrinsic min-sizing.
updatedBase =
GrowSizeForSpanningItems<TrackSizingPhase::IntrinsicMinimums>(
spanGroupStart, spanGroupEnd, tracks, plan, itemPlan, selector);
}
selector = contentBasedMinSelector;
if (stateBitsForSpan & selector) {
// Step 3.2 MinContentContribution to min-/max-content (and 'auto' when
// sizing under a min-content constraint) min-sizing.
updatedBase |=
GrowSizeForSpanningItems<TrackSizingPhase::ContentBasedMinimums>(
spanGroupStart, spanGroupEnd, tracks, plan, itemPlan, selector);
}
selector = maxContentMinSelector;
if (stateBitsForSpan & selector) {
// Step 3.3 MaxContentContribution to max-content (and 'auto' when
// sizing under a max-content constraint) min-sizing.
updatedBase |=
GrowSizeForSpanningItems<TrackSizingPhase::MaxContentMinimums>(
spanGroupStart, spanGroupEnd, tracks, plan, itemPlan, selector);
}
if (updatedBase) {
// Step 3.4
for (TrackSize& sz : mSizes) {
if (sz.mBase > sz.mLimit) {
sz.mLimit = sz.mBase;
}
}
}
selector = TrackSize::eIntrinsicMaxSizing;
if (stateBitsForSpan & selector) {
const bool willRunStep3_6 =
stateBitsForSpan & TrackSize::eAutoOrMaxContentMaxSizing;
// Step 3.5 MinContentContribution to intrinsic max-sizing.
GrowSizeForSpanningItems<TrackSizingPhase::IntrinsicMaximums>(
spanGroupStart, spanGroupEnd, tracks, plan, itemPlan, selector,
fitContentClamper, willRunStep3_6);
if (willRunStep3_6) {
// Step 2.6 MaxContentContribution to max-content max-sizing.
selector = TrackSize::eAutoOrMaxContentMaxSizing;
GrowSizeForSpanningItems<TrackSizingPhase::MaxContentMaximums>(
spanGroupStart, spanGroupEnd, tracks, plan, itemPlan, selector,
fitContentClamper);
}
}
}
}
// Step 5 - If any track still has an infinite growth limit, set its growth
// limit to its base size.
for (TrackSize& sz : mSizes) {
if (sz.mLimit == NS_UNCONSTRAINEDSIZE) {
sz.mLimit = sz.mBase;
}
}
}
float nsGridContainerFrame::Tracks::FindFrUnitSize(
const LineRange& aRange, const nsTArray<uint32_t>& aFlexTracks,
const TrackSizingFunctions& aFunctions, nscoord aSpaceToFill) const {
MOZ_ASSERT(aSpaceToFill > 0 && !aFlexTracks.IsEmpty());
float flexFactorSum = 0.0f;
nscoord leftOverSpace = aSpaceToFill;
for (auto i : aRange.Range()) {
const TrackSize& sz = mSizes[i];
if (sz.mState & TrackSize::eFlexMaxSizing) {
flexFactorSum += aFunctions.MaxSizingFor(i).AsFr();
} else {
leftOverSpace -= sz.mBase;
if (leftOverSpace <= 0) {
return 0.0f;
}
}
}
bool restart;
float hypotheticalFrSize;
nsTArray<uint32_t> flexTracks(aFlexTracks.Clone());
uint32_t numFlexTracks = flexTracks.Length();
do {
restart = false;
hypotheticalFrSize = leftOverSpace / std::max(flexFactorSum, 1.0f);
for (uint32_t i = 0, len = flexTracks.Length(); i < len; ++i) {
uint32_t track = flexTracks[i];
if (track == kAutoLine) {
continue; // Track marked as inflexible in a prev. iter of this loop.
}
float flexFactor = aFunctions.MaxSizingFor(track).AsFr();
const nscoord base = mSizes[track].mBase;
if (flexFactor * hypotheticalFrSize < base) {
// 12.7.1.4: Treat this track as inflexible.
flexTracks[i] = kAutoLine;
flexFactorSum -= flexFactor;
leftOverSpace -= base;
--numFlexTracks;
if (numFlexTracks == 0 || leftOverSpace <= 0) {
return 0.0f;
}
restart = true;
// break; XXX (bug 1176621 comment 16) measure which is more common
}
}
} while (restart);
return hypotheticalFrSize;
}
float nsGridContainerFrame::Tracks::FindUsedFlexFraction(
GridReflowInput& aState, nsTArray<GridItemInfo>& aGridItems,
const nsTArray<uint32_t>& aFlexTracks,
const TrackSizingFunctions& aFunctions, nscoord aAvailableSize) const {
if (aAvailableSize != NS_UNCONSTRAINEDSIZE) {
// Use all of the grid tracks and a 'space to fill' of the available space.
const TranslatedLineRange range(0, mSizes.Length());
return FindFrUnitSize(range, aFlexTracks, aFunctions, aAvailableSize);
}
// The used flex fraction is the maximum of:
// ... each flexible track's base size divided by its flex factor (which is
// floored at 1).
float fr = 0.0f;
for (uint32_t track : aFlexTracks) {
float flexFactor = aFunctions.MaxSizingFor(track).AsFr();
float possiblyDividedBaseSize = (flexFactor > 1.0f)
? mSizes[track].mBase / flexFactor
: mSizes[track].mBase;
fr = std::max(fr, possiblyDividedBaseSize);
}
WritingMode wm = aState.mWM;
gfxContext* rc = &aState.mRenderingContext;
// ... the result of 'finding the size of an fr' for each item that spans
// a flex track with its max-content contribution as 'space to fill'
for (const GridItemInfo& item : aGridItems) {
if (item.mState[mAxis] & ItemState::eIsFlexing) {
// XXX optimize: bug 1194446
auto pb = Some(aState.PercentageBasisFor(mAxis, item));
nscoord spaceToFill = ContentContribution(item, aState, rc, wm, mAxis, pb,
IntrinsicISizeType::PrefISize);
const LineRange& range =
mAxis == LogicalAxis::Inline ? item.mArea.mCols : item.mArea.mRows;
MOZ_ASSERT(range.Extent() >= 1);
const auto spannedGaps = range.Extent() - 1;
if (spannedGaps > 0) {
spaceToFill -= mGridGap * spannedGaps;
}
if (spaceToFill <= 0) {
continue;
}
// ... and all its spanned tracks as input.
nsTArray<uint32_t> itemFlexTracks;
for (auto i : range.Range()) {
if (mSizes[i].mState & TrackSize::eFlexMaxSizing) {
itemFlexTracks.AppendElement(i);
}
}
float itemFr =
FindFrUnitSize(range, itemFlexTracks, aFunctions, spaceToFill);
fr = std::max(fr, itemFr);
}
}
return fr;
}
void nsGridContainerFrame::Tracks::StretchFlexibleTracks(
GridReflowInput& aState, nsTArray<GridItemInfo>& aGridItems,
const TrackSizingFunctions& aFunctions, nscoord aAvailableSize) {
if (aAvailableSize <= 0) {
return;
}
nsTArray<uint32_t> flexTracks(mSizes.Length());
for (uint32_t i = 0, len = mSizes.Length(); i < len; ++i) {
if (mSizes[i].mState & TrackSize::eFlexMaxSizing) {
flexTracks.AppendElement(i);
}
}
if (flexTracks.IsEmpty()) {
return;
}
nscoord minSize = 0;
nscoord maxSize = NS_UNCONSTRAINEDSIZE;
if (aState.mReflowInput) {
auto* ri = aState.mReflowInput;
minSize = mAxis == LogicalAxis::Block ? ri->ComputedMinBSize()
: ri->ComputedMinISize();
maxSize = mAxis == LogicalAxis::Block ? ri->ComputedMaxBSize()
: ri->ComputedMaxISize();
}
Maybe<CopyableAutoTArray<TrackSize, 32>> origSizes;
bool applyMinMax = (minSize != 0 || maxSize != NS_UNCONSTRAINEDSIZE) &&
aAvailableSize == NS_UNCONSTRAINEDSIZE;
// We iterate twice at most. The 2nd time if the grid size changed after
// applying a min/max-size (can only occur if aAvailableSize is indefinite).
while (true) {
float fr = FindUsedFlexFraction(aState, aGridItems, flexTracks, aFunctions,
aAvailableSize);
if (fr != 0.0f) {
for (uint32_t i : flexTracks) {
float flexFactor = aFunctions.MaxSizingFor(i).AsFr();
nscoord flexLength = NSToCoordRound(flexFactor * fr);
nscoord& base = mSizes[i].mBase;
if (flexLength > base) {
if (applyMinMax && origSizes.isNothing()) {
origSizes.emplace(mSizes);
}
base = flexLength;
}
}
}
if (applyMinMax) {
applyMinMax = false;
// https://drafts.csswg.org/css-grid/#algo-flex-tracks
// "If using this flex fraction would cause the grid to be smaller than
// the grid container’s min-width/height (or larger than the grid
// container’s max-width/height), then redo this step, treating the free
// space as definite [...]"
const auto sumOfGridGaps = SumOfGridGaps();
nscoord newSize = SumOfGridTracks() + sumOfGridGaps;
if (newSize > maxSize) {
aAvailableSize = maxSize;
} else if (newSize < minSize) {
aAvailableSize = minSize;
}
if (aAvailableSize != NS_UNCONSTRAINEDSIZE) {
aAvailableSize = std::max(0, aAvailableSize - sumOfGridGaps);
// Restart with the original track sizes and definite aAvailableSize.
if (origSizes.isSome()) {
mSizes = std::move(*origSizes);
origSizes.reset();
} // else, no mSizes[].mBase were changed above so it's still correct
if (aAvailableSize == 0) {
break; // zero available size wouldn't change any sizes though...
}
continue;
}
}
break;
}
}
void nsGridContainerFrame::Tracks::AlignJustifyContent(
const nsStylePosition* aStyle, StyleContentDistribution aAligmentStyleValue,
WritingMode aWM, nscoord aContentBoxSize, bool aIsSubgriddedAxis) {
const bool isAlign = mAxis == LogicalAxis::Block;
// Align-/justify-content doesn't apply in a subgridded axis.
// Gap properties do apply though so we need to stretch/position the tracks
// to center-align the gaps with the parent's gaps.
if (MOZ_UNLIKELY(aIsSubgriddedAxis)) {
auto& gap = isAlign ? aStyle->mRowGap : aStyle->mColumnGap;
if (gap.IsNormal()) {
return;
}
auto len = mSizes.Length();
if (len <= 1) {
return;
}
// This stores the gap deltas between the subgrid gap and the gaps in
// the used track sizes (as encoded in its tracks' mPosition):
nsTArray<nscoord> gapDeltas;
const size_t numGaps = len - 1;
gapDeltas.SetLength(numGaps);
for (size_t i = 0; i < numGaps; ++i) {
TrackSize& sz1 = mSizes[i];
TrackSize& sz2 = mSizes[i + 1];
nscoord currentGap = sz2.mPosition - (sz1.mPosition + sz1.mBase);
gapDeltas[i] = mGridGap - currentGap;
}
// Recompute the tracks' size/position so that they end up with
// a subgrid-gap centered on the original track gap.
nscoord currentPos = mSizes[0].mPosition;
nscoord lastHalfDelta(0);
for (size_t i = 0; i < numGaps; ++i) {
TrackSize& sz = mSizes[i];
nscoord delta = gapDeltas[i];
nscoord halfDelta;
nscoord roundingError = NSCoordDivRem(delta, 2, &halfDelta);
auto newSize = sz.mBase - (halfDelta + roundingError) - lastHalfDelta;
lastHalfDelta = halfDelta;
// If the gap delta (in particular 'halfDelta + lastHalfDelta') is larger
// than the current track size, newSize can be negative. Don't let the new
// track size (mBase) be negative.
sz.mBase = std::max(newSize, 0);
sz.mPosition = currentPos;
currentPos += newSize + mGridGap;
}
auto& lastTrack = mSizes.LastElement();
auto newSize = lastTrack.mBase - lastHalfDelta;
lastTrack.mBase = std::max(newSize, 0);
lastTrack.mPosition = currentPos;
return;
}
if (mSizes.IsEmpty()) {
return;
}
bool overflowSafe;
auto alignment = ::GetAlignJustifyValue(aAligmentStyleValue.primary, aWM,
isAlign, &overflowSafe);
if (alignment == StyleAlignFlags::NORMAL) {
alignment = StyleAlignFlags::STRETCH;
// we may need a fallback for 'stretch' below
aAligmentStyleValue = {alignment};
}
// Compute the free space and count auto-sized tracks.
size_t numAutoTracks = 0;
nscoord space;
if (alignment != StyleAlignFlags::START) {
nscoord trackSizeSum = 0;
if (aIsSubgriddedAxis) {
numAutoTracks = mSizes.Length();
} else {
for (const TrackSize& sz : mSizes) {
trackSizeSum += sz.mBase;
if (sz.mState & TrackSize::eAutoMaxSizing) {
++numAutoTracks;
}
}
}
space = aContentBoxSize - trackSizeSum - SumOfGridGaps();
// Use the fallback value instead when applicable.
if (space < 0 ||
(alignment == StyleAlignFlags::SPACE_BETWEEN && mSizes.Length() == 1)) {
auto fallback = ::GetAlignJustifyFallbackIfAny(aAligmentStyleValue, aWM,
isAlign, &overflowSafe);
if (fallback) {
alignment = *fallback;
}
}
if (space == 0 || (space < 0 && overflowSafe)) {
// XXX check that this makes sense also for [last ]baseline (bug 1151204).
alignment = StyleAlignFlags::START;
}
}
// Optimize the cases where we just need to set each track's position.
nscoord pos = 0;
bool distribute = true;
if (alignment == StyleAlignFlags::BASELINE ||
alignment == StyleAlignFlags::LAST_BASELINE) {
NS_WARNING("NYI: 'first/last baseline' (bug 1151204)"); // XXX
alignment = StyleAlignFlags::START;
}
if (alignment == StyleAlignFlags::START) {
distribute = false;
} else if (alignment == StyleAlignFlags::END) {
pos = space;
distribute = false;
} else if (alignment == StyleAlignFlags::CENTER) {
pos = space / 2;
distribute = false;
} else if (alignment == StyleAlignFlags::STRETCH) {
distribute = numAutoTracks != 0;
}
if (!distribute) {
for (TrackSize& sz : mSizes) {
sz.mPosition = pos;
pos += sz.mBase + mGridGap;
}
return;
}
// Distribute free space to/between tracks and set their position.
MOZ_ASSERT(space > 0, "should've handled that on the fallback path above");
nscoord between, roundingError;
if (alignment == StyleAlignFlags::STRETCH) {
MOZ_ASSERT(numAutoTracks > 0, "we handled numAutoTracks == 0 above");
// The outer loop typically only runs once - it repeats only in a masonry
// axis when some stretchable items reach their `max-size`.
// It's O(n^2) worst case; if all items are stretchable with a `max-size`
// and exactly one item reaches its `max-size` each round.
while (space) {
pos = 0;
nscoord spacePerTrack;
roundingError = NSCoordDivRem(space, numAutoTracks, &spacePerTrack);
space = 0;
for (TrackSize& sz : mSizes) {
sz.mPosition = pos;
if (!(sz.mState & TrackSize::eAutoMaxSizing)) {
pos += sz.mBase + mGridGap;
continue;
}
nscoord stretch = spacePerTrack;
if (roundingError) {
roundingError -= 1;
stretch += 1;
}
nscoord newBase = sz.mBase + stretch;
if (mIsMasonry && (sz.mState & TrackSize::eClampToLimit)) {
auto clampedSize = std::min(newBase, sz.mLimit);
auto sizeOverLimit = newBase - clampedSize;
if (sizeOverLimit > 0) {
newBase = clampedSize;
sz.mState &= ~(sz.mState & TrackSize::eAutoMaxSizing);
// This repeats the outer loop to distribute the superfluous space:
space += sizeOverLimit;
if (--numAutoTracks == 0) {
// ... except if we don't have any stretchable items left.
space = 0;
}
}
}
sz.mBase = newBase;
pos += newBase + mGridGap;
}
}
MOZ_ASSERT(!roundingError, "we didn't distribute all rounding error?");
return;
}
if (alignment == StyleAlignFlags::SPACE_BETWEEN) {
MOZ_ASSERT(mSizes.Length() > 1, "should've used a fallback above");
roundingError = NSCoordDivRem(space, mSizes.Length() - 1, &between);
} else if (alignment == StyleAlignFlags::SPACE_AROUND) {
roundingError = NSCoordDivRem(space, mSizes.Length(), &between);
pos = between / 2;
} else if (alignment == StyleAlignFlags::SPACE_EVENLY) {
roundingError = NSCoordDivRem(space, mSizes.Length() + 1, &between);
pos = between;
} else {
MOZ_ASSERT_UNREACHABLE("unknown align-/justify-content value");
between = 0; // just to avoid a compiler warning
roundingError = 0; // just to avoid a compiler warning
}
between += mGridGap;
for (TrackSize& sz : mSizes) {
sz.mPosition = pos;
nscoord spacing = between;
if (roundingError) {
roundingError -= 1;
spacing += 1;
}
pos += sz.mBase + spacing;
}
MOZ_ASSERT(!roundingError, "we didn't distribute all rounding error?");
}
void nsGridContainerFrame::LineRange::ToPositionAndLength(
const nsTArray<TrackSize>& aTrackSizes, nscoord* aPos,
nscoord* aLength) const {
MOZ_ASSERT(mStart != kAutoLine && mEnd != kAutoLine,
"expected a definite LineRange");
MOZ_ASSERT(mStart < mEnd);
nscoord startPos = aTrackSizes[mStart].mPosition;
const TrackSize& sz = aTrackSizes[mEnd - 1];
*aPos = startPos;
*aLength = (sz.mPosition + sz.mBase) - startPos;
}
nscoord nsGridContainerFrame::LineRange::ToLength(
const nsTArray<TrackSize>& aTrackSizes) const {
MOZ_ASSERT(mStart != kAutoLine && mEnd != kAutoLine,
"expected a definite LineRange");
MOZ_ASSERT(mStart < mEnd);
nscoord startPos = aTrackSizes[mStart].mPosition;
const TrackSize& sz = aTrackSizes[mEnd - 1];
return (sz.mPosition + sz.mBase) - startPos;
}
void nsGridContainerFrame::LineRange::ToPositionAndLengthForAbsPos(
const Tracks& aTracks, nscoord aGridOrigin, nscoord* aPos,
nscoord* aLength) const {
// kAutoLine for abspos children contributes the corresponding edge
// of the grid container's padding-box.
if (mEnd == kAutoLine) {
if (mStart == kAutoLine) {
// done
} else {
const nscoord endPos = *aPos + *aLength;
auto side = mStart == aTracks.mSizes.Length()
? GridLineSide::BeforeGridGap
: GridLineSide::AfterGridGap;
nscoord startPos = aTracks.GridLineEdge(mStart, side);
*aPos = aGridOrigin + startPos;
*aLength = std::max(endPos - *aPos, 0);
}
} else {
if (mStart == kAutoLine) {
auto side =
mEnd == 0 ? GridLineSide::AfterGridGap : GridLineSide::BeforeGridGap;
nscoord endPos = aTracks.GridLineEdge(mEnd, side);
*aLength = std::max(aGridOrigin + endPos, 0);
} else if (MOZ_LIKELY(mStart != mEnd)) {
nscoord pos;
ToPositionAndLength(aTracks.mSizes, &pos, aLength);
*aPos = aGridOrigin + pos;
} else {
// The grid area only covers removed 'auto-fit' tracks.
nscoord pos = aTracks.GridLineEdge(mStart, GridLineSide::BeforeGridGap);
*aPos = aGridOrigin + pos;
*aLength = nscoord(0);
}
}
}
LogicalSize nsGridContainerFrame::GridReflowInput::PercentageBasisFor(
LogicalAxis aAxis, const GridItemInfo& aGridItem) const {
auto wm = aGridItem.mFrame->GetWritingMode();
const auto* itemParent = aGridItem.mFrame->GetParent();
if (MOZ_UNLIKELY(itemParent != mFrame)) {
// The item comes from a descendant subgrid. Use the subgrid's
// used track sizes to resolve the grid area size, if present.
MOZ_ASSERT(itemParent->IsGridContainerFrame());
auto* subgridFrame = static_cast<const nsGridContainerFrame*>(itemParent);
MOZ_ASSERT(subgridFrame->IsSubgrid());
if (auto* uts = subgridFrame->GetUsedTrackSizes()) {
auto subgridWM = subgridFrame->GetWritingMode();
LogicalSize cbSize(subgridWM, NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
if (!subgridFrame->IsSubgrid(LogicalAxis::Inline) &&
uts->mCanResolveLineRangeSize[LogicalAxis::Inline]) {
// NOTE: At this point aGridItem.mArea is in this->mFrame coordinates
// and thus may have been transposed. The range values in a non-
// subgridded axis still has its original values in subgridFrame's
// coordinates though.
auto rangeAxis = subgridWM.IsOrthogonalTo(mWM) ? LogicalAxis::Block
: LogicalAxis::Inline;
const auto& range = aGridItem.mArea.LineRangeForAxis(rangeAxis);
cbSize.ISize(subgridWM) =
range.ToLength(uts->mSizes[LogicalAxis::Inline]);
}
if (!subgridFrame->IsSubgrid(LogicalAxis::Block) &&
uts->mCanResolveLineRangeSize[LogicalAxis::Block]) {
auto rangeAxis = subgridWM.IsOrthogonalTo(mWM) ? LogicalAxis::Inline
: LogicalAxis::Block;
const auto& range = aGridItem.mArea.LineRangeForAxis(rangeAxis);
cbSize.BSize(subgridWM) =
range.ToLength(uts->mSizes[LogicalAxis::Block]);
}
return cbSize.ConvertTo(wm, subgridWM);
}
return LogicalSize(wm, NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
}
if (aAxis == LogicalAxis::Inline || !mCols.mCanResolveLineRangeSize) {
return LogicalSize(wm, NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
}
// Note: for now, we only resolve transferred percentages to row sizing.
// We may need to adjust these assertions once we implement bug 1300366.
MOZ_ASSERT(!mRows.mCanResolveLineRangeSize);
nscoord colSize = aGridItem.mArea.mCols.ToLength(mCols.mSizes);
nscoord rowSize = NS_UNCONSTRAINEDSIZE;
return !wm.IsOrthogonalTo(mWM) ? LogicalSize(wm, colSize, rowSize)
: LogicalSize(wm, rowSize, colSize);
}
LogicalRect nsGridContainerFrame::GridReflowInput::ContainingBlockFor(
const GridArea& aArea) const {
nscoord i, b, iSize, bSize;
MOZ_ASSERT(aArea.mCols.Extent() > 0, "grid items cover at least one track");
MOZ_ASSERT(aArea.mRows.Extent() > 0, "grid items cover at least one track");
aArea.mCols.ToPositionAndLength(mCols.mSizes, &i, &iSize);
aArea.mRows.ToPositionAndLength(mRows.mSizes, &b, &bSize);
return LogicalRect(mWM, i, b, iSize, bSize);
}
LogicalRect nsGridContainerFrame::GridReflowInput::ContainingBlockForAbsPos(
const GridArea& aArea, const LogicalPoint& aGridOrigin,
const LogicalRect& aGridCB) const {
nscoord i = aGridCB.IStart(mWM);
nscoord b = aGridCB.BStart(mWM);
nscoord iSize = aGridCB.ISize(mWM);
nscoord bSize = aGridCB.BSize(mWM);
aArea.mCols.ToPositionAndLengthForAbsPos(mCols, aGridOrigin.I(mWM), &i,
&iSize);
aArea.mRows.ToPositionAndLengthForAbsPos(mRows, aGridOrigin.B(mWM), &b,
&bSize);
return LogicalRect(mWM, i, b, iSize, bSize);
}
void nsGridContainerFrame::GridReflowInput::AlignJustifyContentInMasonryAxis(
nscoord aMasonryBoxSize, nscoord aContentBoxSize) {
if (aContentBoxSize == NS_UNCONSTRAINEDSIZE) {
aContentBoxSize = aMasonryBoxSize;
}
auto& masonryAxisTracks = mRows.mIsMasonry ? mRows : mCols;
MOZ_ASSERT(masonryAxisTracks.mSizes.Length() == 2,
"unexpected masonry axis tracks");
const auto masonryAxis = masonryAxisTracks.mAxis;
const auto contentAlignment = mGridStyle->UsedContentAlignment(masonryAxis);
if (contentAlignment.primary == StyleAlignFlags::NORMAL ||
contentAlignment.primary == StyleAlignFlags::STRETCH) {
// Stretch the "masonry box" to the full content box if it's smaller.
nscoord cbSize = std::max(aMasonryBoxSize, aContentBoxSize);
for (auto& sz : masonryAxisTracks.mSizes) {
sz.mBase = cbSize;
}
return;
}
// Save our current track sizes; replace them with one track sized to
// the masonry box and align that within our content box.
auto savedTrackSizes(std::move(masonryAxisTracks.mSizes));
masonryAxisTracks.mSizes.AppendElement(savedTrackSizes[0]);
masonryAxisTracks.mSizes[0].mBase = aMasonryBoxSize;
masonryAxisTracks.AlignJustifyContent(mGridStyle, contentAlignment, mWM,
aContentBoxSize, false);
nscoord masonryBoxOffset = masonryAxisTracks.mSizes[0].mPosition;
// Restore the original track sizes...
masonryAxisTracks.mSizes = std::move(savedTrackSizes);
// ...then reposition and resize all of them to the aligned result.
for (auto& sz : masonryAxisTracks.mSizes) {
sz.mPosition = masonryBoxOffset;
sz.mBase = aMasonryBoxSize;
}
}
// Note: this is called after all items have been positioned/reflowed.
// The masonry-axis tracks have the size of the "masonry box" at this point
// and are positioned according to 'align/justify-content'.
void nsGridContainerFrame::GridReflowInput::AlignJustifyTracksInMasonryAxis(
const LogicalSize& aContentSize, const nsSize& aContainerSize) {
auto& masonryAxisTracks = mRows.mIsMasonry ? mRows : mCols;
MOZ_ASSERT(masonryAxisTracks.mSizes.Length() == 2,
"unexpected masonry axis tracks");
const auto masonryAxis = masonryAxisTracks.mAxis;
auto gridAxis = GetOrthogonalAxis(masonryAxis);
auto& gridAxisTracks = TracksFor(gridAxis);
AutoTArray<TrackSize, 32> savedSizes;
savedSizes.AppendElements(masonryAxisTracks.mSizes);
auto wm = mWM;
nscoord contentAreaStart = mBorderPadding.Start(masonryAxis, wm);
// The offset to the "masonry box" from our content-box start edge.
nscoord masonryBoxOffset = masonryAxisTracks.mSizes[0].mPosition;
nscoord alignmentContainerSize = masonryAxisTracks.mSizes[0].mBase;
for (auto i : IntegerRange(gridAxisTracks.mSizes.Length())) {
auto tracksAlignment = mGridStyle->UsedTracksAlignment(masonryAxis, i);
if (tracksAlignment.primary != StyleAlignFlags::START) {
masonryAxisTracks.mSizes.ClearAndRetainStorage();
for (const auto& item : mGridItems) {
if (item.mArea.LineRangeForAxis(gridAxis).mStart == i) {
const auto* child = item.mFrame;
LogicalRect rect = child->GetLogicalRect(wm, aContainerSize);
TrackSize sz = {0, 0, 0, {0, 0}, TrackSize::StateBits{0}};
const auto& margin = child->GetLogicalUsedMargin(wm);
sz.mPosition = rect.Start(masonryAxis, wm) -
margin.Start(masonryAxis, wm) - contentAreaStart;
sz.mBase =
rect.Size(masonryAxis, wm) + margin.StartEnd(masonryAxis, wm);
// Account for a align-self baseline offset on the end side.
// XXXmats hmm, it seems it would be a lot simpler to just store
// these baseline adjustments into the UsedMarginProperty instead
auto state = item.mState[masonryAxis];
if ((state & ItemState::eSelfBaseline) &&
(state & ItemState::eEndSideBaseline)) {
sz.mBase += item.mBaselineOffset[masonryAxis];
}
if (tracksAlignment.primary == StyleAlignFlags::STRETCH) {
const auto* pos = child->StylePosition();
auto itemAlignment =
pos->UsedSelfAlignment(masonryAxis, mFrame->Style());
if (child->StyleMargin()->HasAuto(masonryAxis, wm)) {
sz.mState |= TrackSize::eAutoMaxSizing;
sz.mState |= TrackSize::eItemHasAutoMargin;
} else if (pos->Size(masonryAxis, wm).IsAuto() &&
(itemAlignment == StyleAlignFlags::NORMAL ||
itemAlignment == StyleAlignFlags::STRETCH)) {
sz.mState |= TrackSize::eAutoMaxSizing;
sz.mState |= TrackSize::eItemStretchSize;
const auto& max = pos->MaxSize(masonryAxis, wm);
if (max.ConvertsToLength()) { // XXX deal with percentages
// XXX add in baselineOffset ? use actual frame size - content
// size?
nscoord boxSizingAdjust =
child->GetLogicalUsedBorderAndPadding(wm).StartEnd(
masonryAxis, wm);
if (pos->mBoxSizing == StyleBoxSizing::Border) {
boxSizingAdjust = 0;
}
sz.mLimit = nsLayoutUtils::ComputeBSizeValue(
aContentSize.Size(masonryAxis, wm), boxSizingAdjust,
max.AsLengthPercentage());
sz.mLimit += margin.StartEnd(masonryAxis, wm);
sz.mState |= TrackSize::eClampToLimit;
}
}
}
masonryAxisTracks.mSizes.AppendElement(std::move(sz));
}
}
masonryAxisTracks.AlignJustifyContent(mGridStyle, tracksAlignment, wm,
alignmentContainerSize, false);
auto iter = mGridItems.begin();
auto end = mGridItems.end();
// We limit the loop to the number of items we found in the current
// grid-axis axis track (in the outer loop) as an optimization.
for (auto r : IntegerRange(masonryAxisTracks.mSizes.Length())) {
GridItemInfo* item = nullptr;
auto& sz = masonryAxisTracks.mSizes[r];
// Find the next item in the current grid-axis axis track.
for (; iter != end; ++iter) {
if (iter->mArea.LineRangeForAxis(gridAxis).mStart == i) {
item = &*iter;
++iter;
break;
}
}
nsIFrame* child = item->mFrame;
const auto childWM = child->GetWritingMode();
auto masonryChildAxis =
childWM.IsOrthogonalTo(wm) ? gridAxis : masonryAxis;
LogicalMargin margin = child->GetLogicalUsedMargin(childWM);
bool forceReposition = false;
if (sz.mState & TrackSize::eItemStretchSize) {
auto size = child->GetLogicalSize().Size(masonryChildAxis, childWM);
auto newSize = sz.mBase - margin.StartEnd(masonryChildAxis, childWM);
if (size != newSize) {
// XXX need to pass aIMinSizeClamp aBMinSizeClamp ?
LogicalSize cb =
ContainingBlockFor(item->mArea).Size(wm).ConvertTo(childWM, wm);
LogicalSize availableSize = cb;
cb.Size(masonryChildAxis, childWM) = alignmentContainerSize;
availableSize.Size(LogicalAxis::Block, childWM) =
NS_UNCONSTRAINEDSIZE;
const auto& bp = child->GetLogicalUsedBorderAndPadding(childWM);
newSize -= bp.StartEnd(masonryChildAxis, childWM);
::PostReflowStretchChild(child, *mReflowInput, availableSize, cb,
masonryChildAxis, newSize);
if (childWM.IsPhysicalRTL()) {
// The NormalPosition of this child is frame-size dependent so we
// need to reset its stored position below.
forceReposition = true;
}
}
} else if (sz.mState & TrackSize::eItemHasAutoMargin) {
// Re-compute the auto-margin(s) in the masonry axis.
auto size = child->GetLogicalSize().Size(masonryChildAxis, childWM);
auto spaceToFill = sz.mBase - size;
if (spaceToFill > nscoord(0)) {
const auto& marginStyle = child->StyleMargin();
if (marginStyle->mMargin.Start(masonryChildAxis, childWM)
.IsAuto()) {
if (marginStyle->mMargin.End(masonryChildAxis, childWM)
.IsAuto()) {
nscoord half;
nscoord roundingError = NSCoordDivRem(spaceToFill, 2, &half);
margin.Start(masonryChildAxis, childWM) = half;
margin.End(masonryChildAxis, childWM) = half + roundingError;
} else {
margin.Start(masonryChildAxis, childWM) = spaceToFill;
}
} else {
MOZ_ASSERT(
marginStyle->mMargin.End(masonryChildAxis, childWM).IsAuto());
margin.End(masonryChildAxis, childWM) = spaceToFill;
}
nsMargin* propValue =
child->GetProperty(nsIFrame::UsedMarginProperty());
if (propValue) {
*propValue = margin.GetPhysicalMargin(childWM);
} else {
child->AddProperty(
nsIFrame::UsedMarginProperty(),
new nsMargin(margin.GetPhysicalMargin(childWM)));
}
}
}
nscoord newPos = contentAreaStart + masonryBoxOffset + sz.mPosition +
margin.Start(masonryChildAxis, childWM);
LogicalPoint pos = child->GetLogicalNormalPosition(wm, aContainerSize);
auto delta = newPos - pos.Pos(masonryAxis, wm);
if (delta != 0 || forceReposition) {
LogicalPoint logicalDelta(wm);
logicalDelta.Pos(masonryAxis, wm) = delta;
child->MovePositionBy(wm, logicalDelta);
}
}
} else if (masonryBoxOffset != nscoord(0)) {
// TODO move placeholders too
auto delta = masonryBoxOffset;
LogicalPoint logicalDelta(wm);
logicalDelta.Pos(masonryAxis, wm) = delta;
for (const auto& item : mGridItems) {
if (item.mArea.LineRangeForAxis(gridAxis).mStart != i) {
continue;
}
item.mFrame->MovePositionBy(wm, logicalDelta);
}
}
}
masonryAxisTracks.mSizes = std::move(savedSizes);
}
/**
* Return a Fragmentainer object if we have a fragmentainer frame in our
* ancestor chain of containing block (CB) reflow inputs. We'll only
* continue traversing the ancestor chain as long as the CBs have
* the same writing-mode and have overflow:visible.
*/
Maybe<nsGridContainerFrame::Fragmentainer>
nsGridContainerFrame::GetNearestFragmentainer(
const GridReflowInput& aState) const {
Maybe<nsGridContainerFrame::Fragmentainer> data;
const ReflowInput* gridRI = aState.mReflowInput;
if (!gridRI->IsInFragmentedContext()) {
return data;
}
WritingMode wm = aState.mWM;
const ReflowInput* cbRI = gridRI->mCBReflowInput;
for (; cbRI; cbRI = cbRI->mCBReflowInput) {
nsIScrollableFrame* sf = do_QueryFrame(cbRI->mFrame);
if (sf) {
break;
}
if (wm.IsOrthogonalTo(cbRI->GetWritingMode())) {
break;
}
LayoutFrameType frameType = cbRI->mFrame->Type();
if ((frameType == LayoutFrameType::Canvas &&
PresContext()->IsPaginated()) ||
frameType == LayoutFrameType::ColumnSet) {
data.emplace();
data->mIsTopOfPage = gridRI->mFlags.mIsTopOfPage;
if (gridRI->AvailableBSize() != NS_UNCONSTRAINEDSIZE) {
data->mToFragmentainerEnd = aState.mFragBStart +
gridRI->AvailableBSize() -
aState.mBorderPadding.BStart(wm);
} else {
// This occurs when nsColumnSetFrame reflows its last column in
// unconstrained available block-size.
data->mToFragmentainerEnd = NS_UNCONSTRAINEDSIZE;
}
const auto numRows = aState.mRows.mSizes.Length();
data->mCanBreakAtStart =
numRows > 0 && aState.mRows.mSizes[0].mPosition > 0;
nscoord bSize = gridRI->ComputedBSize();
data->mIsAutoBSize = bSize == NS_UNCONSTRAINEDSIZE;
if (data->mIsAutoBSize) {
bSize = gridRI->ComputedMinBSize();
} else {
bSize = gridRI->ApplyMinMaxBSize(bSize);
}
nscoord gridEnd =
aState.mRows.GridLineEdge(numRows, GridLineSide::BeforeGridGap);
data->mCanBreakAtEnd = bSize > gridEnd && bSize > aState.mFragBStart;
break;
}
}
return data;
}
void nsGridContainerFrame::ReflowInFlowChild(
nsIFrame* aChild, const GridItemInfo* aGridItemInfo, nsSize aContainerSize,
const Maybe<nscoord>& aStretchBSize, const Fragmentainer* aFragmentainer,
const GridReflowInput& aState, const LogicalRect& aContentArea,
ReflowOutput& aDesiredSize, nsReflowStatus& aStatus) {
nsPresContext* pc = PresContext();
ComputedStyle* containerSC = Style();
WritingMode wm = aState.mReflowInput->GetWritingMode();
const bool isGridItem = !!aGridItemInfo;
MOZ_ASSERT(isGridItem == !aChild->IsPlaceholderFrame());
LogicalRect cb(wm);
WritingMode childWM = aChild->GetWritingMode();
bool isConstrainedBSize = false;
nscoord toFragmentainerEnd;
// The part of the child's grid area that's in previous container fragments.
nscoord consumedGridAreaBSize = 0;
const bool isOrthogonal = wm.IsOrthogonalTo(childWM);
if (MOZ_LIKELY(isGridItem)) {
MOZ_ASSERT(aGridItemInfo->mFrame == aChild);
const GridArea& area = aGridItemInfo->mArea;
MOZ_ASSERT(area.IsDefinite());
cb = aState.ContainingBlockFor(area);
if (aFragmentainer && !wm.IsOrthogonalTo(childWM)) {
// |gridAreaBOffset| is the offset of the child's grid area in this
// container fragment (if negative, that distance is the child CB size
// consumed in previous container fragments). Note that cb.BStart
// (initially) and aState.mFragBStart are in "global" grid coordinates
// (like all track positions).
nscoord gridAreaBOffset = cb.BStart(wm) - aState.mFragBStart;
consumedGridAreaBSize = std::max(0, -gridAreaBOffset);
cb.BStart(wm) = std::max(0, gridAreaBOffset);
if (aFragmentainer->mToFragmentainerEnd != NS_UNCONSTRAINEDSIZE) {
toFragmentainerEnd = aFragmentainer->mToFragmentainerEnd -
aState.mFragBStart - cb.BStart(wm);
toFragmentainerEnd = std::max(toFragmentainerEnd, 0);
isConstrainedBSize = true;
}
}
cb += aContentArea.Origin(wm);
aState.mRows.AlignBaselineSubtree(*aGridItemInfo);
aState.mCols.AlignBaselineSubtree(*aGridItemInfo);
// Setup [align|justify]-content:[last ]baseline related frame properties.
// These are added to the padding in SizeComputationInput::InitOffsets.
// (a negative value signals the value is for 'last baseline' and should be
// added to the (logical) end padding)
typedef const FramePropertyDescriptor<SmallValueHolder<nscoord>>* Prop;
auto SetProp = [aGridItemInfo, aChild](LogicalAxis aGridAxis, Prop aProp) {
auto state = aGridItemInfo->mState[aGridAxis];
auto baselineAdjust = (state & ItemState::eContentBaseline)
? aGridItemInfo->mBaselineOffset[aGridAxis]
: nscoord(0);
if (baselineAdjust < nscoord(0)) {
// This happens when the subtree overflows its track.
// XXX spec issue? it's unclear how to handle this.
baselineAdjust = nscoord(0);
} else if (state & ItemState::eLastBaseline) {
// FIXME: We're not setting the ItemState::eEndSideBaseline flag any
// more as the new baseline sharing group calculation handles most of
// the cases we need. For non-masonry grids this flag was always set
// for LAST_BASELINE items, so we're just mimicking that behavior here.
// That said, masonry grids might not work 100% any more..
baselineAdjust = -baselineAdjust;
}
if (baselineAdjust != nscoord(0)) {
aChild->SetProperty(aProp, baselineAdjust);
} else {
aChild->RemoveProperty(aProp);
}
};
SetProp(LogicalAxis::Block,
isOrthogonal ? IBaselinePadProperty() : BBaselinePadProperty());
SetProp(LogicalAxis::Inline,
isOrthogonal ? BBaselinePadProperty() : IBaselinePadProperty());
} else {
// By convention, for frames that perform CSS Box Alignment, we position
// placeholder children at the start corner of their alignment container,
// and in this case that's usually the grid's content-box.
// ("Usually" - the exception is when the grid *also* forms the
// abs.pos. containing block. In that case, the alignment container isn't
// the content-box -- it's some grid area instead. But that case doesn't
// require any special handling here, because we handle it later using a
// special flag (ReflowInput::InitFlag::StaticPosIsCBOrigin) which will make
// us ignore the placeholder's position entirely.)
cb = aContentArea;
aChild->AddStateBits(PLACEHOLDER_STATICPOS_NEEDS_CSSALIGN);
}
LogicalSize reflowSize(cb.Size(wm));
if (isConstrainedBSize) {
reflowSize.BSize(wm) = toFragmentainerEnd;
}
LogicalSize childCBSize = reflowSize.ConvertTo(childWM, wm);
// Setup the ClampMarginBoxMinSize reflow flags and property, if needed.
ComputeSizeFlags csFlags;
if (aGridItemInfo) {
const auto childIAxisInWM =
isOrthogonal ? LogicalAxis::Block : LogicalAxis::Inline;
// Clamp during reflow if we're stretching in that axis.
if (GridItemShouldStretch(aChild, LogicalAxis::Inline)) {
if (aGridItemInfo->mState[childIAxisInWM] &
ItemState::eClampMarginBoxMinSize) {
csFlags += ComputeSizeFlag::IClampMarginBoxMinSize;
}
} else {
csFlags += ComputeSizeFlag::ShrinkWrap;
}
const auto childBAxisInWM = GetOrthogonalAxis(childIAxisInWM);
if (GridItemShouldStretch(aChild, LogicalAxis::Block) &&
aGridItemInfo->mState[childBAxisInWM] &
ItemState::eClampMarginBoxMinSize) {
csFlags += ComputeSizeFlag::BClampMarginBoxMinSize;
aChild->SetProperty(BClampMarginBoxMinSizeProperty(),
childCBSize.BSize(childWM));
} else {
aChild->RemoveProperty(BClampMarginBoxMinSizeProperty());
}
if ((aGridItemInfo->mState[childIAxisInWM] &
ItemState::eApplyAutoMinSize)) {
csFlags += ComputeSizeFlag::IApplyAutoMinSize;
}
}
if (!isConstrainedBSize) {
childCBSize.BSize(childWM) = NS_UNCONSTRAINEDSIZE;
}
LogicalSize percentBasis(cb.Size(wm).ConvertTo(childWM, wm));
ReflowInput childRI(pc, *aState.mReflowInput, aChild, childCBSize,
Some(percentBasis), {}, {}, csFlags);
childRI.mFlags.mIsTopOfPage =
aFragmentainer ? aFragmentainer->mIsTopOfPage : false;
// FIXME (perf): It would be faster to do this only if the previous reflow of
// the child was a measuring reflow, and only if the child does some of the
// things that are affected by ComputeSizeFlag::IsGridMeasuringReflow.
childRI.SetBResize(true);
childRI.mFlags.mIsBResizeForPercentages = true;
// If the child is stretching in its block axis, and we might be fragmenting
// it in that axis, then setup a frame property to tell
// nsBlockFrame::ComputeFinalSize the size.
if (isConstrainedBSize && !wm.IsOrthogonalTo(childWM)) {
const bool stretch = childRI.mStylePosition->BSize(childWM).IsAuto() &&
GridItemShouldStretch(aChild, LogicalAxis::Block);
if (stretch) {
aChild->SetProperty(FragStretchBSizeProperty(), *aStretchBSize);
} else {
aChild->RemoveProperty(FragStretchBSizeProperty());
}
}
// We need the width of the child before we can correctly convert
// the writing-mode of its origin, so we reflow at (0, 0) using a dummy
// aContainerSize, and then pass the correct position to FinishReflowChild.
ReflowOutput childSize(childRI);
const nsSize dummyContainerSize;
ReflowChild(aChild, pc, childSize, childRI, childWM, LogicalPoint(childWM),
dummyContainerSize, ReflowChildFlags::Default, aStatus);
LogicalPoint childPos = cb.Origin(wm).ConvertTo(
childWM, wm, aContainerSize - childSize.PhysicalSize());
// Apply align/justify-self and reflow again if that affects the size.
if (MOZ_LIKELY(isGridItem)) {
LogicalSize size = childSize.Size(childWM); // from the ReflowChild()
auto applyItemSelfAlignment = [&](LogicalAxis aAxis, nscoord aCBSize) {
auto align =
childRI.mStylePosition->UsedSelfAlignment(aAxis, containerSC);
auto state = aGridItemInfo->mState[aAxis];
auto flags = AlignJustifyFlags::NoFlags;
if (IsMasonry(aAxis)) {
// In a masonry axis, we inhibit applying 'stretch' and auto-margins
// here since AlignJustifyTracksInMasonryAxis deals with that.
// The only other {align,justify}-{self,content} values that have an
// effect are '[last] baseline', the rest behave as 'start'.
if (MOZ_LIKELY(!(state & ItemState::eSelfBaseline))) {
align = {StyleAlignFlags::START};
} else {
auto group = (state & ItemState::eFirstBaseline)
? BaselineSharingGroup::First
: BaselineSharingGroup::Last;
auto itemStart = aGridItemInfo->mArea.LineRangeForAxis(aAxis).mStart;
aCBSize = aState.TracksFor(aAxis)
.mSizes[itemStart]
.mBaselineSubtreeSize[group];
}
flags = AlignJustifyFlags::IgnoreAutoMargins;
} else if (state & ItemState::eContentBaseline) {
align = {(state & ItemState::eFirstBaseline)
? StyleAlignFlags::SELF_START
: StyleAlignFlags::SELF_END};
}
if (aAxis == LogicalAxis::Block) {
AlignSelf(*aGridItemInfo, align, aCBSize, wm, childRI, size, flags,
&childPos);
} else {
JustifySelf(*aGridItemInfo, align, aCBSize, wm, childRI, size, flags,
&childPos);
}
};
if (aStatus.IsComplete()) {
applyItemSelfAlignment(LogicalAxis::Block,
cb.BSize(wm) - consumedGridAreaBSize);
}
applyItemSelfAlignment(LogicalAxis::Inline, cb.ISize(wm));
} // else, nsAbsoluteContainingBlock.cpp will handle align/justify-self.
FinishReflowChild(aChild, pc, childSize, &childRI, childWM, childPos,
aContainerSize, ReflowChildFlags::ApplyRelativePositioning);
ConsiderChildOverflow(aDesiredSize.mOverflowAreas, aChild);
}
nscoord nsGridContainerFrame::ReflowInFragmentainer(
GridReflowInput& aState, const LogicalRect& aContentArea,
ReflowOutput& aDesiredSize, nsReflowStatus& aStatus,
Fragmentainer& aFragmentainer, const nsSize& aContainerSize) {
MOZ_ASSERT(aStatus.IsEmpty());
MOZ_ASSERT(aState.mReflowInput);
// Collect our grid items and sort them in row order. Collect placeholders
// and put them in a separate array.
nsTArray<const GridItemInfo*> sortedItems(aState.mGridItems.Length());
nsTArray<nsIFrame*> placeholders(aState.mAbsPosItems.Length());
aState.mIter.Reset(CSSOrderAwareFrameIterator::ChildFilter::IncludeAll);
for (; !aState.mIter.AtEnd(); aState.mIter.Next()) {
nsIFrame* child = *aState.mIter;
if (!child->IsPlaceholderFrame()) {
const GridItemInfo* info = &aState.mGridItems[aState.mIter.ItemIndex()];
sortedItems.AppendElement(info);
} else {
placeholders.AppendElement(child);
}
}
// NOTE: We don't need stable_sort here, except in Masonry layout. There are
// no dependencies on having content order between items on the same row in
// the code below in the non-Masonry case.
if (IsMasonry()) {
std::stable_sort(sortedItems.begin(), sortedItems.end(),
GridItemInfo::IsStartRowLessThan);
} else {
std::sort(sortedItems.begin(), sortedItems.end(),
GridItemInfo::IsStartRowLessThan);
}
// Reflow our placeholder children; they must all be complete.
for (auto child : placeholders) {
nsReflowStatus childStatus;
ReflowInFlowChild(child, nullptr, aContainerSize, Nothing(),
&aFragmentainer, aState, aContentArea, aDesiredSize,
childStatus);
MOZ_ASSERT(childStatus.IsComplete(),
"nsPlaceholderFrame should never need to be fragmented");
}
// The available size for children - we'll set this to the edge of the last
// row in most cases below, but for now use the full size.
nscoord childAvailableSize = aFragmentainer.mToFragmentainerEnd;
const uint32_t startRow = aState.mStartRow;
const uint32_t numRows = aState.mRows.mSizes.Length();
bool isBDBClone = aState.mReflowInput->mStyleBorder->mBoxDecorationBreak ==
StyleBoxDecorationBreak::Clone;
nscoord bpBEnd = aState.mBorderPadding.BEnd(aState.mWM);
// Set |endRow| to the first row that doesn't fit.
uint32_t endRow = numRows;
for (uint32_t row = startRow; row < numRows; ++row) {
auto& sz = aState.mRows.mSizes[row];
const nscoord bEnd = sz.mPosition + sz.mBase;
nscoord remainingAvailableSize = childAvailableSize - bEnd;
if (remainingAvailableSize < 0 ||
(isBDBClone && remainingAvailableSize < bpBEnd)) {
endRow = row;
break;
}
}
// Check for forced breaks on the items if available block-size for children
// is constrained. That is, ignore forced breaks if available block-size for
// children is unconstrained since our parent expected us to be fully
// complete.
bool isForcedBreak = false;
const bool avoidBreakInside = ShouldAvoidBreakInside(*aState.mReflowInput);
if (childAvailableSize != NS_UNCONSTRAINEDSIZE) {
const bool isTopOfPage = aFragmentainer.mIsTopOfPage;
for (const GridItemInfo* info : sortedItems) {
uint32_t itemStartRow = info->mArea.mRows.mStart;
if (itemStartRow == endRow) {
break;
}
const auto* disp = info->mFrame->StyleDisplay();
if (disp->BreakBefore()) {
// Propagate break-before on the first row to the container unless we're
// already at top-of-page.
if ((itemStartRow == 0 && !isTopOfPage) || avoidBreakInside) {
aStatus.SetInlineLineBreakBeforeAndReset();
return aState.mFragBStart;
}
if ((itemStartRow > startRow ||
(itemStartRow == startRow && !isTopOfPage)) &&
itemStartRow < endRow) {
endRow = itemStartRow;
isForcedBreak = true;
// reset any BREAK_AFTER we found on an earlier item
aStatus.Reset();
break; // we're done since the items are sorted in row order
}
}
uint32_t itemEndRow = info->mArea.mRows.mEnd;
if (disp->BreakAfter()) {
if (itemEndRow != numRows) {
if (itemEndRow > startRow && itemEndRow < endRow) {
endRow = itemEndRow;
isForcedBreak = true;
// No "break;" here since later items with break-after may have
// a shorter span.
}
} else {
// Propagate break-after on the last row to the container, we may
// still find a break-before on this row though (and reset aStatus).
aStatus.SetInlineLineBreakAfter(); // tentative
}
}
}
// Consume at least one row in each fragment until we have consumed them
// all. Except for the first row if there's a break opportunity before it.
if (startRow == endRow && startRow != numRows &&
(startRow != 0 || !aFragmentainer.mCanBreakAtStart)) {
++endRow;
}
// Honor break-inside:avoid if we can't fit all rows.
if (avoidBreakInside && endRow < numRows) {
aStatus.SetInlineLineBreakBeforeAndReset();
return aState.mFragBStart;
}
}
// Calculate the block-size including this fragment.
nscoord bEndRow =
aState.mRows.GridLineEdge(endRow, GridLineSide::BeforeGridGap);
nscoord bSize;
if (aFragmentainer.mIsAutoBSize) {
// We only apply min-bsize once all rows are complete (when bsize is auto).
if (endRow < numRows) {
bSize = bEndRow;
auto clampedBSize = ClampToCSSMaxBSize(bSize, aState.mReflowInput);
if (MOZ_UNLIKELY(clampedBSize != bSize)) {
// We apply max-bsize in all fragments though.
bSize = clampedBSize;
} else if (!isBDBClone) {
// The max-bsize won't make this fragment COMPLETE, so the block-end
// border will be in a later fragment.
bpBEnd = 0;
}
} else {
bSize = aState.mReflowInput->ApplyMinMaxBSize(bEndRow);
}
} else {
bSize = aState.mReflowInput->ApplyMinMaxBSize(
aState.mReflowInput->ComputedBSize());
}
// Check for overflow and set aStatus INCOMPLETE if so.
bool overflow = bSize + bpBEnd > childAvailableSize;
if (overflow) {
if (avoidBreakInside) {
aStatus.SetInlineLineBreakBeforeAndReset();
return aState.mFragBStart;
}
bool breakAfterLastRow = endRow == numRows && aFragmentainer.mCanBreakAtEnd;
if (breakAfterLastRow) {
MOZ_ASSERT(bEndRow < bSize, "bogus aFragmentainer.mCanBreakAtEnd");
nscoord availableSize = childAvailableSize;
if (isBDBClone) {
availableSize -= bpBEnd;
}
// Pretend we have at least 1px available size, otherwise we'll never make
// progress in consuming our bSize.
availableSize =
std::max(availableSize, aState.mFragBStart + AppUnitsPerCSSPixel());
// Fill the fragmentainer, but not more than our desired block-size and
// at least to the size of the last row (even if that overflows).
nscoord newBSize = std::min(bSize, availableSize);
newBSize = std::max(newBSize, bEndRow);
// If it's just the border+padding that is overflowing and we have
// box-decoration-break:clone then we are technically COMPLETE. There's
// no point in creating another zero-bsize fragment in this case.
if (newBSize < bSize || !isBDBClone) {
aStatus.SetIncomplete();
}
bSize = newBSize;
} else if (bSize <= bEndRow && startRow + 1 < endRow) {
if (endRow == numRows) {
// We have more than one row in this fragment, so we can break before
// the last row instead.
--endRow;
bEndRow =
aState.mRows.GridLineEdge(endRow, GridLineSide::BeforeGridGap);
bSize = bEndRow;
if (aFragmentainer.mIsAutoBSize) {
bSize = ClampToCSSMaxBSize(bSize, aState.mReflowInput);
}
}
aStatus.SetIncomplete();
} else if (endRow < numRows) {
bSize = ClampToCSSMaxBSize(bEndRow, aState.mReflowInput, &aStatus);
} // else - no break opportunities.
} else {
// Even though our block-size fits we need to honor forced breaks, or if
// a row doesn't fit in an auto-sized container (unless it's constrained
// by a max-bsize which make us overflow-incomplete).
if (endRow < numRows &&
(isForcedBreak || (aFragmentainer.mIsAutoBSize && bEndRow == bSize))) {
bSize = ClampToCSSMaxBSize(bEndRow, aState.mReflowInput, &aStatus);
}
}
// If we can't fit all rows then we're at least overflow-incomplete.
if (endRow < numRows) {
childAvailableSize = bEndRow;
if (aStatus.IsComplete()) {
aStatus.SetOverflowIncomplete();
aStatus.SetNextInFlowNeedsReflow();
}
} else {
// Children always have the full size of the rows in this fragment.
childAvailableSize = std::max(childAvailableSize, bEndRow);
}
return ReflowRowsInFragmentainer(aState, aContentArea, aDesiredSize, aStatus,
aFragmentainer, aContainerSize, sortedItems,
startRow, endRow, bSize, childAvailableSize);
}
nscoord nsGridContainerFrame::ReflowRowsInFragmentainer(
GridReflowInput& aState, const LogicalRect& aContentArea,
ReflowOutput& aDesiredSize, nsReflowStatus& aStatus,
Fragmentainer& aFragmentainer, const nsSize& aContainerSize,
const nsTArray<const GridItemInfo*>& aSortedItems, uint32_t aStartRow,
uint32_t aEndRow, nscoord aBSize, nscoord aAvailableSize) {
FrameHashtable pushedItems;
FrameHashtable incompleteItems;
FrameHashtable overflowIncompleteItems;
Maybe<nsTArray<nscoord>> masonryAxisPos;
const auto rowCount = aState.mRows.mSizes.Length();
nscoord masonryAxisGap;
const auto wm = aState.mWM;
const bool isColMasonry = IsMasonry(LogicalAxis::Inline);
if (isColMasonry) {
for (auto& sz : aState.mCols.mSizes) {
sz.mPosition = 0;
}
masonryAxisGap = nsLayoutUtils::ResolveGapToLength(
aState.mGridStyle->mColumnGap, aContentArea.ISize(wm));
aState.mCols.mGridGap = masonryAxisGap;
masonryAxisPos.emplace(rowCount);
masonryAxisPos->SetLength(rowCount);
PodZero(masonryAxisPos->Elements(), rowCount);
}
bool isBDBClone = aState.mReflowInput->mStyleBorder->mBoxDecorationBreak ==
StyleBoxDecorationBreak::Clone;
bool didGrowRow = false;
// As we walk across rows, we track whether the current row is at the top
// of its grid-fragment, to help decide whether we can break before it. When
// this function starts, our row is at the top of the current fragment if:
// - we're starting with a nonzero row (i.e. we're a continuation)
// OR:
// - we're starting with the first row, & we're not allowed to break before
// it (which makes it effectively at the top of its grid-fragment).
bool isRowTopOfPage = aStartRow != 0 || !aFragmentainer.mCanBreakAtStart;
const bool isStartRowTopOfPage = isRowTopOfPage;
// Save our full available size for later.
const nscoord gridAvailableSize = aFragmentainer.mToFragmentainerEnd;
// Propagate the constrained size to our children.
aFragmentainer.mToFragmentainerEnd = aAvailableSize;
// Reflow the items in row order up to |aEndRow| and push items after that.
uint32_t row = 0;
// |i| is intentionally signed, so we can set it to -1 to restart the loop.
for (int32_t i = 0, len = aSortedItems.Length(); i < len; ++i) {
const GridItemInfo* const info = aSortedItems[i];
nsIFrame* child = info->mFrame;
row = info->mArea.mRows.mStart;
MOZ_ASSERT(child->GetPrevInFlow() ? row < aStartRow : row >= aStartRow,
"unexpected child start row");
if (row >= aEndRow) {
pushedItems.Insert(child);
continue;
}
bool rowCanGrow = false;
nscoord maxRowSize = 0;
if (row >= aStartRow) {
if (row > aStartRow) {
isRowTopOfPage = false;
}
// Can we grow this row? Only consider span=1 items per spec...
rowCanGrow = !didGrowRow && info->mArea.mRows.Extent() == 1;
if (rowCanGrow) {
auto& sz = aState.mRows.mSizes[row];
// and only min-/max-content rows or flex rows in an auto-sized
// container
rowCanGrow = (sz.mState & TrackSize::eMinOrMaxContentMinSizing) ||
((sz.mState & TrackSize::eFlexMaxSizing) &&
aFragmentainer.mIsAutoBSize);
if (rowCanGrow) {
if (isBDBClone) {
maxRowSize = gridAvailableSize - aState.mBorderPadding.BEnd(wm);
} else {
maxRowSize = gridAvailableSize;
}
maxRowSize -= sz.mPosition;
// ...and only if there is space for it to grow.
rowCanGrow = maxRowSize > sz.mBase;
}
}
}
if (isColMasonry) {
const auto& cols = info->mArea.mCols;
MOZ_ASSERT((cols.mStart == 0 || cols.mStart == 1) && cols.Extent() == 1);
aState.mCols.mSizes[cols.mStart].mPosition = masonryAxisPos.ref()[row];
}
// aFragmentainer.mIsTopOfPage is propagated to the child reflow input.
// When it's false the child may request InlineBreak::Before. We set it
// to false when the row is growable (as determined in the CSS Grid
// Fragmentation spec) and there is a non-zero space between it and the
// fragmentainer end (that can be used to grow it). If the child reports
// a forced break in this case, we grow this row to fill the fragment and
// restart the loop. We also restart the loop with |aEndRow = row|
// (but without growing any row) for a InlineBreak::Before child if it spans
// beyond the last row in this fragment. This is to avoid fragmenting it.
// We only restart the loop once.
aFragmentainer.mIsTopOfPage = isRowTopOfPage && !rowCanGrow;
nsReflowStatus childStatus;
// Pass along how much to stretch this fragment, in case it's needed.
nscoord bSize =
aState.mRows.GridLineEdge(std::min(aEndRow, info->mArea.mRows.mEnd),
GridLineSide::BeforeGridGap) -
aState.mRows.GridLineEdge(std::max(aStartRow, row),
GridLineSide::AfterGridGap);
ReflowInFlowChild(child, info, aContainerSize, Some(bSize), &aFragmentainer,
aState, aContentArea, aDesiredSize, childStatus);
MOZ_ASSERT(childStatus.IsInlineBreakBefore() ||
!childStatus.IsFullyComplete() || !child->GetNextInFlow(),
"fully-complete reflow should destroy any NIFs");
if (childStatus.IsInlineBreakBefore()) {
MOZ_ASSERT(
!child->GetPrevInFlow(),
"continuations should never report InlineBreak::Before status");
MOZ_ASSERT(!aFragmentainer.mIsTopOfPage,
"got IsInlineBreakBefore() at top of page");
if (!didGrowRow) {
if (rowCanGrow) {
// Grow this row and restart with the next row as |aEndRow|.
aState.mRows.ResizeRow(row, maxRowSize);
if (aState.mSharedGridData) {
aState.mSharedGridData->mRows.ResizeRow(row, maxRowSize);
}
didGrowRow = true;
aEndRow = row + 1; // growing this row makes the next one not fit
i = -1; // i == 0 after the next loop increment
isRowTopOfPage = isStartRowTopOfPage;
overflowIncompleteItems.Clear();
incompleteItems.Clear();
nscoord bEndRow =
aState.mRows.GridLineEdge(aEndRow, GridLineSide::BeforeGridGap);
aFragmentainer.mToFragmentainerEnd = bEndRow;
if (aFragmentainer.mIsAutoBSize) {
aBSize = ClampToCSSMaxBSize(bEndRow, aState.mReflowInput, &aStatus);
} else if (aStatus.IsIncomplete()) {
aBSize = aState.mReflowInput->ApplyMinMaxBSize(
aState.mReflowInput->ComputedBSize());
aBSize = std::min(bEndRow, aBSize);
}
continue;
}
if (!isRowTopOfPage) {
// We can break before this row - restart with it as the new end row.
aEndRow = row;
aBSize =
aState.mRows.GridLineEdge(aEndRow, GridLineSide::BeforeGridGap);
i = -1; // i == 0 after the next loop increment
isRowTopOfPage = isStartRowTopOfPage;
overflowIncompleteItems.Clear();
incompleteItems.Clear();
aStatus.SetIncomplete();
continue;
}
NS_ERROR("got InlineBreak::Before at top-of-page");
childStatus.Reset();
} else {
// We got InlineBreak::Before again after growing the row - this can
// happen if the child isn't splittable, e.g. some form controls.
childStatus.Reset();
if (child->GetNextInFlow()) {
// The child already has a fragment, so we know it's splittable.
childStatus.SetIncomplete();
} // else, report that it's complete
}
} else if (childStatus.IsInlineBreakAfter()) {
MOZ_ASSERT_UNREACHABLE("unexpected child reflow status");
}
MOZ_ASSERT(!childStatus.IsInlineBreakBefore(),
"should've handled InlineBreak::Before above");
if (childStatus.IsIncomplete()) {
incompleteItems.Insert(child);
} else if (!childStatus.IsFullyComplete()) {
overflowIncompleteItems.Insert(child);
}
if (isColMasonry) {
auto childWM = child->GetWritingMode();
auto childAxis = !childWM.IsOrthogonalTo(wm) ? LogicalAxis::Inline
: LogicalAxis::Block;
auto normalPos = child->GetLogicalNormalPosition(wm, aContainerSize);
auto sz =
childAxis == LogicalAxis::Block ? child->BSize() : child->ISize();
auto pos = normalPos.Pos(LogicalAxis::Inline, wm) + sz +
child->GetLogicalUsedMargin(childWM).End(childAxis, childWM);
masonryAxisPos.ref()[row] =
pos + masonryAxisGap - aContentArea.Start(LogicalAxis::Inline, wm);
}
}
// Record a break before |aEndRow|.
aState.mNextFragmentStartRow = aEndRow;
if (aEndRow < rowCount) {
aState.mRows.BreakBeforeRow(aEndRow);
if (aState.mSharedGridData) {
aState.mSharedGridData->mRows.BreakBeforeRow(aEndRow);
}
}
const bool childrenMoved = PushIncompleteChildren(
pushedItems, incompleteItems, overflowIncompleteItems);
if (childrenMoved && aStatus.IsComplete()) {
aStatus.SetOverflowIncomplete();
aStatus.SetNextInFlowNeedsReflow();
}
if (!pushedItems.IsEmpty()) {
AddStateBits(NS_STATE_GRID_DID_PUSH_ITEMS);
// NOTE since we messed with our child list here, we intentionally
// make aState.mIter invalid to avoid any use of it after this point.
aState.mIter.Invalidate();
}
if (!incompleteItems.IsEmpty()) {
// NOTE since we messed with our child list here, we intentionally
// make aState.mIter invalid to avoid any use of it after this point.
aState.mIter.Invalidate();
}
if (isColMasonry) {
nscoord maxSize = 0;
for (auto pos : masonryAxisPos.ref()) {
maxSize = std::max(maxSize, pos);
}
maxSize = std::max(nscoord(0), maxSize - masonryAxisGap);
aState.AlignJustifyContentInMasonryAxis(maxSize, aContentArea.ISize(wm));
}
return aBSize;
}
// Here's a brief overview of how Masonry layout is implemented:
// We setup two synthetic tracks in the Masonry axis so that the Reflow code
// can treat it the same as for normal grid layout. The first track is
// fixed (during item placement/layout) at the content box start and contains
// the start items for each grid-axis track. The second track contains
// all other items and is moved to the position where we want to position
// the currently laid out item (like a sliding window as we place items).
// Once item layout is done, the tracks are resized to be the size of
// the "masonry box", which is the offset from the content box start to
// the margin-box end of the item that is furthest away (this happens in
// AlignJustifyContentInMasonryAxis() called at the end of this method).
// This is to prepare for AlignJustifyTracksInMasonryAxis, which is called
// later by our caller.
// Both tracks store their first-/last-baseline group offsets as usual.
// The first-baseline of the start track, and the last-baseline of the last
// track (if they exist) are exported as the grid container's baselines, or
// we fall back to picking an item's baseline (all this is per normal grid
// layout). There's a slight difference in which items belongs to which
// group though - see InitializeItemBaselinesInMasonryAxis for details.
// This method returns the "masonry box" size (in the masonry axis).
nscoord nsGridContainerFrame::MasonryLayout(GridReflowInput& aState,
const LogicalRect& aContentArea,
SizingConstraint aConstraint,
ReflowOutput& aDesiredSize,
nsReflowStatus& aStatus,
Fragmentainer* aFragmentainer,
const nsSize& aContainerSize) {
using BaselineAlignmentSet = Tracks::BaselineAlignmentSet;
auto recordAutoPlacement = [this, &aState](GridItemInfo* aItem,
LogicalAxis aGridAxis) {
// When we're auto-placing an item in a continuation we need to record
// the placement in mSharedGridData.
if (MOZ_UNLIKELY(aState.mSharedGridData && GetPrevInFlow()) &&
(aItem->mState[aGridAxis] & ItemState::eAutoPlacement)) {
auto* child = aItem->mFrame;
MOZ_RELEASE_ASSERT(!child->GetPrevInFlow(),
"continuations should never be auto-placed");
for (auto& sharedItem : aState.mSharedGridData->mGridItems) {
if (sharedItem.mFrame == child) {
sharedItem.mArea.LineRangeForAxis(aGridAxis) =
aItem->mArea.LineRangeForAxis(aGridAxis);
MOZ_ASSERT(sharedItem.mState[aGridAxis] & ItemState::eAutoPlacement);
sharedItem.mState[aGridAxis] &= ~ItemState::eAutoPlacement;
break;
}
}
}
aItem->mState[aGridAxis] &= ~ItemState::eAutoPlacement;
};
// Collect our grid items and sort them in grid order.
nsTArray<GridItemInfo*> sortedItems(aState.mGridItems.Length());
aState.mIter.Reset(CSSOrderAwareFrameIterator::ChildFilter::IncludeAll);
size_t absposIndex = 0;
const LogicalAxis masonryAxis =
IsMasonry(LogicalAxis::Block) ? LogicalAxis::Block : LogicalAxis::Inline;
const auto wm = aState.mWM;
for (; !aState.mIter.AtEnd(); aState.mIter.Next()) {
nsIFrame* child = *aState.mIter;
if (MOZ_LIKELY(!child->IsPlaceholderFrame())) {
GridItemInfo* item = &aState.mGridItems[aState.mIter.ItemIndex()];
sortedItems.AppendElement(item);
} else if (aConstraint == SizingConstraint::NoConstraint) {
// (we only collect placeholders in the NoConstraint case since they
// don't affect intrinsic sizing in any way)
GridItemInfo* item = nullptr;
auto* ph = static_cast<nsPlaceholderFrame*>(child);
if (ph->GetOutOfFlowFrame()->GetParent() == this) {
item = &aState.mAbsPosItems[absposIndex++];
MOZ_RELEASE_ASSERT(item->mFrame == ph->GetOutOfFlowFrame());
auto masonryStart = item->mArea.LineRangeForAxis(masonryAxis).mStart;
// If the item was placed by the author at line 1 (masonryStart == 0)
// then include it to be placed at the masonry-box start. If it's
// auto-placed and has an `auto` inset value in the masonry axis then
// we include it to be placed after the last grid item with the same
// grid-axis start track.
// XXXmats this is all a bit experimental at this point, pending a spec
if (masonryStart == 0 ||
(masonryStart == kAutoLine && item->mFrame->StylePosition()
->mOffset.Start(masonryAxis, wm)
.IsAuto())) {
sortedItems.AppendElement(item);
} else {
item = nullptr;
}
}
if (!item) {
// It wasn't included above - just reflow it and be done with it.
nsReflowStatus childStatus;
ReflowInFlowChild(child, nullptr, aContainerSize, Nothing(), nullptr,
aState, aContentArea, aDesiredSize, childStatus);
}
}
}
const auto masonryAutoFlow = aState.mGridStyle->mMasonryAutoFlow;
const bool definiteFirst =
masonryAutoFlow.order == StyleMasonryItemOrder::DefiniteFirst;
if (masonryAxis == LogicalAxis::Block) {
std::stable_sort(sortedItems.begin(), sortedItems.end(),
definiteFirst ? GridItemInfo::RowMasonryDefiniteFirst
: GridItemInfo::RowMasonryOrdered);
} else {
std::stable_sort(sortedItems.begin(), sortedItems.end(),
definiteFirst ? GridItemInfo::ColMasonryDefiniteFirst
: GridItemInfo::ColMasonryOrdered);
}
FrameHashtable pushedItems;
FrameHashtable incompleteItems;
FrameHashtable overflowIncompleteItems;
nscoord toFragmentainerEnd = nscoord_MAX;
nscoord fragStartPos = aState.mFragBStart;
const bool avoidBreakInside =
aFragmentainer && ShouldAvoidBreakInside(*aState.mReflowInput);
const bool isTopOfPageAtStart =
aFragmentainer && aFragmentainer->mIsTopOfPage;
if (aFragmentainer) {
toFragmentainerEnd = std::max(0, aFragmentainer->mToFragmentainerEnd);
}
const LogicalAxis gridAxis = GetOrthogonalAxis(masonryAxis);
const auto gridAxisTrackCount = aState.TracksFor(gridAxis).mSizes.Length();
auto& masonryTracks = aState.TracksFor(masonryAxis);
auto& masonrySizes = masonryTracks.mSizes;
MOZ_ASSERT(masonrySizes.Length() == 2);
for (auto& sz : masonrySizes) {
sz.mPosition = fragStartPos;
}
// The current running position for each grid-axis track where the next item
// should be positioned. When an item is placed we'll update the tracks it
// spans to the end of its margin box + 'gap'.
nsTArray<nscoord> currentPos(gridAxisTrackCount);
currentPos.SetLength(gridAxisTrackCount);
for (auto& sz : currentPos) {
sz = fragStartPos;
}
nsTArray<nscoord> lastPos(currentPos.Clone());
nsTArray<GridItemInfo*> lastItems(gridAxisTrackCount);
lastItems.SetLength(gridAxisTrackCount);
PodZero(lastItems.Elements(), gridAxisTrackCount);
const nscoord gap = nsLayoutUtils::ResolveGapToLength(
masonryAxis == LogicalAxis::Block ? aState.mGridStyle->mRowGap
: aState.mGridStyle->mColumnGap,
masonryTracks.mContentBoxSize);
masonryTracks.mGridGap = gap;
uint32_t cursor = 0;
const auto containerToMasonryBoxOffset =
fragStartPos - aContentArea.Start(masonryAxis, wm);
const bool isPack = masonryAutoFlow.placement == StyleMasonryPlacement::Pack;
bool didAlignStartAlignedFirstItems = false;
// Return true if any of the lastItems in aRange are baseline-aligned in
// the masonry axis.
auto lastItemHasBaselineAlignment = [&](const LineRange& aRange) {
for (auto i : aRange.Range()) {
if (auto* child = lastItems[i] ? lastItems[i]->mFrame : nullptr) {
const auto& pos = child->StylePosition();
auto selfAlignment = pos->UsedSelfAlignment(masonryAxis, this->Style());
if (selfAlignment == StyleAlignFlags::BASELINE ||
selfAlignment == StyleAlignFlags::LAST_BASELINE) {
return true;
}
auto childAxis = masonryAxis;
if (child->GetWritingMode().IsOrthogonalTo(wm)) {
childAxis = gridAxis;
}
auto contentAlignment = pos->UsedContentAlignment(childAxis).primary;
if (contentAlignment == StyleAlignFlags::BASELINE ||
contentAlignment == StyleAlignFlags::LAST_BASELINE) {
return true;
}
}
}
return false;
};
// Resolve aItem's placement, unless it's definite already. Return its
// masonry axis position with that placement.
auto placeItem = [&](GridItemInfo* aItem) -> nscoord {
auto& masonryAxisRange = aItem->mArea.LineRangeForAxis(masonryAxis);
MOZ_ASSERT(masonryAxisRange.mStart != 0, "item placement is already final");
auto& gridAxisRange = aItem->mArea.LineRangeForAxis(gridAxis);
bool isAutoPlaced = aItem->mState[gridAxis] & ItemState::eAutoPlacement;
uint32_t start = isAutoPlaced ? 0 : gridAxisRange.mStart;
if (isAutoPlaced && !isPack) {
start = cursor;
isAutoPlaced = false;
}
const uint32_t extent = gridAxisRange.Extent();
if (start + extent > gridAxisTrackCount) {
// Note that this will only happen to auto-placed items since the grid is
// always wide enough to fit other items.
start = 0;
}
// This keeps track of the smallest `maxPosForRange` value that
// we discover in the loop below:
nscoord minPos = nscoord_MAX;
MOZ_ASSERT(extent <= gridAxisTrackCount);
const uint32_t iEnd = gridAxisTrackCount + 1 - extent;
for (uint32_t i = start; i < iEnd; ++i) {
// Find the max `currentPos` value for the tracks that we would span
// if we were to use `i` as our start track:
nscoord maxPosForRange = 0;
for (auto j = i, jEnd = j + extent; j < jEnd; ++j) {
maxPosForRange = std::max(currentPos[j], maxPosForRange);
}
if (maxPosForRange < minPos) {
minPos = maxPosForRange;
start = i;
}
if (!isAutoPlaced) {
break;
}
}
gridAxisRange.mStart = start;
gridAxisRange.mEnd = start + extent;
bool isFirstItem = true;
for (uint32_t i : gridAxisRange.Range()) {
if (lastItems[i]) {
isFirstItem = false;
break;
}
}
// If this is the first item in its spanned grid tracks, then place it in
// the first masonry track. Otherwise, place it in the second masonry track.
masonryAxisRange.mStart = isFirstItem ? 0 : 1;
masonryAxisRange.mEnd = masonryAxisRange.mStart + 1;
return minPos;
};
// Handle the resulting reflow status after reflowing aItem.
// This may set aStatus to BreakBefore which the caller is expected
// to handle by returning from MasonryLayout.
// @return true if this item should consume all remaining space
auto handleChildStatus = [&](GridItemInfo* aItem,
const nsReflowStatus& aChildStatus) {
bool result = false;
if (MOZ_UNLIKELY(aFragmentainer)) {
auto* child = aItem->mFrame;
if (!aChildStatus.IsComplete() || aChildStatus.IsInlineBreakBefore() ||
aChildStatus.IsInlineBreakAfter() ||
child->StyleDisplay()->BreakAfter()) {
if (!isTopOfPageAtStart && avoidBreakInside) {
aStatus.SetInlineLineBreakBeforeAndReset();
return result;
}
result = true;
}
if (aChildStatus.IsInlineBreakBefore()) {
aStatus.SetIncomplete();
pushedItems.Insert(child);
} else if (aChildStatus.IsIncomplete()) {
recordAutoPlacement(aItem, gridAxis);
aStatus.SetIncomplete();
incompleteItems.Insert(child);
} else if (!aChildStatus.IsFullyComplete()) {
recordAutoPlacement(aItem, gridAxis);
overflowIncompleteItems.Insert(child);
}
}
return result;
};
// @return the distance from the masonry-box start to the end of the margin-
// box of aChild
auto offsetToMarginBoxEnd = [&](nsIFrame* aChild) {
auto childWM = aChild->GetWritingMode();
auto childAxis = !childWM.IsOrthogonalTo(wm) ? masonryAxis : gridAxis;
auto normalPos = aChild->GetLogicalNormalPosition(wm, aContainerSize);
auto sz =
childAxis == LogicalAxis::Block ? aChild->BSize() : aChild->ISize();
return containerToMasonryBoxOffset + normalPos.Pos(masonryAxis, wm) + sz +
aChild->GetLogicalUsedMargin(childWM).End(childAxis, childWM);
};
// Apply baseline alignment to items belonging to the given set.
nsTArray<Tracks::ItemBaselineData> firstBaselineItems;
nsTArray<Tracks::ItemBaselineData> lastBaselineItems;
auto applyBaselineAlignment = [&](BaselineAlignmentSet aSet) {
firstBaselineItems.ClearAndRetainStorage();
lastBaselineItems.ClearAndRetainStorage();
masonryTracks.InitializeItemBaselinesInMasonryAxis(
aState, aState.mGridItems, aSet, aContainerSize, currentPos,
firstBaselineItems, lastBaselineItems);
bool didBaselineAdjustment = false;
nsTArray<Tracks::ItemBaselineData>* baselineItems[] = {&firstBaselineItems,
&lastBaselineItems};
for (const auto* items : baselineItems) {
for (const auto& data : *items) {
GridItemInfo* item = data.mGridItem;
MOZ_ASSERT((item->mState[masonryAxis] & ItemState::eIsBaselineAligned));
nscoord baselineOffset = item->mBaselineOffset[masonryAxis];
if (baselineOffset == nscoord(0)) {
continue; // no adjustment needed for this item
}
didBaselineAdjustment = true;
auto* child = item->mFrame;
auto masonryAxisStart =
item->mArea.LineRangeForAxis(masonryAxis).mStart;
auto gridAxisRange = item->mArea.LineRangeForAxis(gridAxis);
masonrySizes[masonryAxisStart].mPosition =
aSet.mItemSet == BaselineAlignmentSet::LastItems
? lastPos[gridAxisRange.mStart]
: fragStartPos;
bool consumeAllSpace = false;
const auto state = item->mState[masonryAxis];
if ((state & ItemState::eContentBaseline) ||
MOZ_UNLIKELY(aFragmentainer)) {
if (MOZ_UNLIKELY(aFragmentainer)) {
aFragmentainer->mIsTopOfPage =
isTopOfPageAtStart &&
masonrySizes[masonryAxisStart].mPosition == fragStartPos;
}
nsReflowStatus childStatus;
ReflowInFlowChild(child, item, aContainerSize, Nothing(),
aFragmentainer, aState, aContentArea, aDesiredSize,
childStatus);
consumeAllSpace = handleChildStatus(item, childStatus);
if (aStatus.IsInlineBreakBefore()) {
return false;
}
} else if (!(state & ItemState::eEndSideBaseline)) {
// `align/justify-self` baselines on the start side can be handled by
// just moving the frame (except in a fragmentainer in which case we
// reflow it above instead since it might make it INCOMPLETE).
LogicalPoint logicalDelta(wm);
logicalDelta.Pos(masonryAxis, wm) = baselineOffset;
child->MovePositionBy(wm, logicalDelta);
}
if ((state & ItemState::eEndSideBaseline) && !consumeAllSpace) {
// Account for an end-side baseline adjustment.
for (uint32_t i : gridAxisRange.Range()) {
currentPos[i] += baselineOffset;
}
} else {
nscoord pos = consumeAllSpace ? toFragmentainerEnd
: offsetToMarginBoxEnd(child);
pos += gap;
for (uint32_t i : gridAxisRange.Range()) {
currentPos[i] = pos;
}
}
}
}
return didBaselineAdjustment;
};
// Place and reflow items. We'll use two fake tracks in the masonry axis.
// The first contains items that were placed there by the regular grid
// placement algo (PlaceGridItems) and we may add some items here if there
// are still empty slots. The second track contains all other items.
// Both tracks always have the size of the content box in the masonry axis.
// The position of the first track is always at the start. The position
// of the second track is updated as we go to a position where we want
// the current item to be positioned.
for (GridItemInfo* item : sortedItems) {
auto* child = item->mFrame;
auto& masonryRange = item->mArea.LineRangeForAxis(masonryAxis);
auto& gridRange = item->mArea.LineRangeForAxis(gridAxis);
nsReflowStatus childStatus;
if (MOZ_UNLIKELY(child->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW))) {
auto contentArea = aContentArea;
nscoord pos = nscoord_MAX;
// XXXmats take mEnd into consideration...
if (gridRange.mStart == kAutoLine) {
for (auto p : currentPos) {
pos = std::min(p, pos);
}
} else if (gridRange.mStart < currentPos.Length()) {
pos = currentPos[gridRange.mStart];
} else if (currentPos.Length() > 0) {
pos = currentPos.LastElement();
}
if (pos == nscoord_MAX) {
pos = nscoord(0);
}
contentArea.Start(masonryAxis, wm) = pos;
child = child->GetPlaceholderFrame();
ReflowInFlowChild(child, nullptr, aContainerSize, Nothing(), nullptr,
aState, contentArea, aDesiredSize, childStatus);
} else {
MOZ_ASSERT(gridRange.Extent() > 0 &&
gridRange.Extent() <= gridAxisTrackCount);
MOZ_ASSERT((masonryRange.mStart == 0 || masonryRange.mStart == 1) &&
masonryRange.Extent() == 1);
if (masonryRange.mStart != 0) {
masonrySizes[1].mPosition = placeItem(item);
}
// If this is the first item NOT in the first track and if any of
// the grid-axis tracks we span has a baseline-aligned item then we
// need to do that baseline alignment now since it may affect
// the placement of this and later items.
if (!didAlignStartAlignedFirstItems &&
aConstraint == SizingConstraint::NoConstraint &&
masonryRange.mStart != 0 && lastItemHasBaselineAlignment(gridRange)) {
didAlignStartAlignedFirstItems = true;
if (applyBaselineAlignment({BaselineAlignmentSet::FirstItems,
BaselineAlignmentSet::StartStretch})) {
// Baseline alignment resized some items - redo our placement.
masonrySizes[1].mPosition = placeItem(item);
}
if (aStatus.IsInlineBreakBefore()) {
return fragStartPos;
}
}
for (uint32_t i : gridRange.Range()) {
lastItems[i] = item;
}
cursor = gridRange.mEnd;
if (cursor >= gridAxisTrackCount) {
cursor = 0;
}
nscoord pos;
if (aConstraint == SizingConstraint::NoConstraint) {
const auto* disp = child->StyleDisplay();
if (MOZ_UNLIKELY(aFragmentainer)) {
aFragmentainer->mIsTopOfPage =
isTopOfPageAtStart &&
masonrySizes[masonryRange.mStart].mPosition == fragStartPos;
if (!aFragmentainer->mIsTopOfPage &&
(disp->BreakBefore() ||
masonrySizes[masonryRange.mStart].mPosition >=
toFragmentainerEnd)) {
childStatus.SetInlineLineBreakBeforeAndReset();
}
}
if (!childStatus.IsInlineBreakBefore()) {
ReflowInFlowChild(child, item, aContainerSize, Nothing(),
aFragmentainer, aState, aContentArea, aDesiredSize,
childStatus);
}
bool consumeAllSpace = handleChildStatus(item, childStatus);
if (aStatus.IsInlineBreakBefore()) {
return fragStartPos;
}
pos =
consumeAllSpace ? toFragmentainerEnd : offsetToMarginBoxEnd(child);
} else {
LogicalSize percentBasis(
aState.PercentageBasisFor(LogicalAxis::Inline, *item));
IntrinsicISizeType type = aConstraint == SizingConstraint::MaxContent
? IntrinsicISizeType::PrefISize
: IntrinsicISizeType::MinISize;
auto sz =
::ContentContribution(*item, aState, &aState.mRenderingContext, wm,
masonryAxis, Some(percentBasis), type);
pos = sz + masonrySizes[masonryRange.mStart].mPosition;
}
pos += gap;
for (uint32_t i : gridRange.Range()) {
lastPos[i] = currentPos[i];
currentPos[i] = pos;
}
}
}
// Do the remaining baseline alignment sets.
if (aConstraint == SizingConstraint::NoConstraint) {
for (auto*& item : lastItems) {
if (item) {
item->mState[masonryAxis] |= ItemState::eIsLastItemInMasonryTrack;
}
}
BaselineAlignmentSet baselineSets[] = {
{BaselineAlignmentSet::FirstItems, BaselineAlignmentSet::StartStretch},
{BaselineAlignmentSet::FirstItems, BaselineAlignmentSet::EndStretch},
{BaselineAlignmentSet::LastItems, BaselineAlignmentSet::StartStretch},
{BaselineAlignmentSet::LastItems, BaselineAlignmentSet::EndStretch},
};
for (uint32_t i = 0; i < ArrayLength(baselineSets); ++i) {
if (i == 0 && didAlignStartAlignedFirstItems) {
continue;
}
applyBaselineAlignment(baselineSets[i]);
}
}
const bool childrenMoved = PushIncompleteChildren(
pushedItems, incompleteItems, overflowIncompleteItems);
if (childrenMoved && aStatus.IsComplete()) {
aStatus.SetOverflowIncomplete();
aStatus.SetNextInFlowNeedsReflow();
}
if (!pushedItems.IsEmpty()) {
AddStateBits(NS_STATE_GRID_DID_PUSH_ITEMS);
// NOTE since we messed with our child list here, we intentionally
// make aState.mIter invalid to avoid any use of it after this point.
aState.mIter.Invalidate();
}
if (!incompleteItems.IsEmpty()) {
// NOTE since we messed with our child list here, we intentionally
// make aState.mIter invalid to avoid any use of it after this point.
aState.mIter.Invalidate();
}
nscoord masonryBoxSize = 0;
for (auto pos : currentPos) {
masonryBoxSize = std::max(masonryBoxSize, pos);
}
masonryBoxSize = std::max(nscoord(0), masonryBoxSize - gap);
if (aConstraint == SizingConstraint::NoConstraint) {
aState.AlignJustifyContentInMasonryAxis(masonryBoxSize,
masonryTracks.mContentBoxSize);
}
return masonryBoxSize;
}
nsGridContainerFrame* nsGridContainerFrame::ParentGridContainerForSubgrid()
const {
MOZ_ASSERT(IsSubgrid());
nsIFrame* p = GetParent();
while (p->GetContent() == GetContent()) {
p = p->GetParent();
}
MOZ_ASSERT(p->IsGridContainerFrame());
auto* parent = static_cast<nsGridContainerFrame*>(p);
MOZ_ASSERT(parent->HasSubgridItems());
return parent;
}
nscoord nsGridContainerFrame::ReflowChildren(GridReflowInput& aState,
const LogicalRect& aContentArea,
const nsSize& aContainerSize,
ReflowOutput& aDesiredSize,
nsReflowStatus& aStatus) {
WritingMode wm = aState.mReflowInput->GetWritingMode();
nscoord bSize = aContentArea.BSize(wm);
MOZ_ASSERT(aState.mReflowInput);
MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
if (HidesContentForLayout()) {
return bSize;
}
OverflowAreas ocBounds;
nsReflowStatus ocStatus;
if (GetPrevInFlow()) {
ReflowOverflowContainerChildren(PresContext(), *aState.mReflowInput,
ocBounds, ReflowChildFlags::Default,
ocStatus, MergeSortedFrameListsFor);
}
Maybe<Fragmentainer> fragmentainer = GetNearestFragmentainer(aState);
// MasonryLayout() can only handle fragmentation in the masonry-axis,
// so we let ReflowInFragmentainer() deal with grid-axis fragmentation
// in the else-clause below.
if (IsMasonry() &&
!(IsMasonry(LogicalAxis::Inline) && fragmentainer.isSome())) {
aState.mInFragmentainer = fragmentainer.isSome();
nscoord sz = MasonryLayout(
aState, aContentArea, SizingConstraint::NoConstraint, aDesiredSize,
aStatus, fragmentainer.ptrOr(nullptr), aContainerSize);
if (IsMasonry(LogicalAxis::Block)) {
bSize = aState.mReflowInput->ComputedBSize();
if (bSize == NS_UNCONSTRAINEDSIZE) {
bSize = aState.mReflowInput->ApplyMinMaxBSize(sz);
}
}
} else if (MOZ_UNLIKELY(fragmentainer.isSome())) {
if (IsMasonry(LogicalAxis::Inline) && !GetPrevInFlow()) {
// First we do an unconstrained reflow to resolve the item placement
// which is then kept as-is in the constrained reflow below.
MasonryLayout(aState, aContentArea, SizingConstraint::NoConstraint,
aDesiredSize, aStatus, nullptr, aContainerSize);
}
aState.mInFragmentainer = true;
bSize = ReflowInFragmentainer(aState, aContentArea, aDesiredSize, aStatus,
*fragmentainer, aContainerSize);
} else {
aState.mIter.Reset(CSSOrderAwareFrameIterator::ChildFilter::IncludeAll);
for (; !aState.mIter.AtEnd(); aState.mIter.Next()) {
nsIFrame* child = *aState.mIter;
const GridItemInfo* info = nullptr;
if (!child->IsPlaceholderFrame()) {
info = &aState.mGridItems[aState.mIter.ItemIndex()];
}
ReflowInFlowChild(child, info, aContainerSize, Nothing(), nullptr, aState,
aContentArea, aDesiredSize, aStatus);
MOZ_ASSERT(aStatus.IsComplete(),
"child should be complete in unconstrained reflow");
}
}
// Merge overflow container bounds and status.
aDesiredSize.mOverflowAreas.UnionWith(ocBounds);
aStatus.MergeCompletionStatusFrom(ocStatus);
if (IsAbsoluteContainer()) {
const nsFrameList& children = GetChildList(GetAbsoluteListID());
if (!children.IsEmpty()) {
// 'gridOrigin' is the origin of the grid (the start of the first track),
// with respect to the grid container's padding-box (CB).
LogicalMargin pad(aState.mReflowInput->ComputedLogicalPadding(wm));
const LogicalPoint gridOrigin(wm, pad.IStart(wm), pad.BStart(wm));
const LogicalRect gridCB(wm, 0, 0,
aContentArea.ISize(wm) + pad.IStartEnd(wm),
bSize + pad.BStartEnd(wm));
const nsSize gridCBPhysicalSize = gridCB.Size(wm).GetPhysicalSize(wm);
size_t i = 0;
for (nsIFrame* child : children) {
MOZ_ASSERT(i < aState.mAbsPosItems.Length());
MOZ_ASSERT(aState.mAbsPosItems[i].mFrame == child);
GridArea& area = aState.mAbsPosItems[i].mArea;
LogicalRect itemCB =
aState.ContainingBlockForAbsPos(area, gridOrigin, gridCB);
// nsAbsoluteContainingBlock::Reflow uses physical coordinates.
nsRect* cb = child->GetProperty(GridItemContainingBlockRect());
if (!cb) {
cb = new nsRect;
child->SetProperty(GridItemContainingBlockRect(), cb);
}
*cb = itemCB.GetPhysicalRect(wm, gridCBPhysicalSize);
++i;
}
// We pass a dummy rect as CB because each child has its own CB rect.
// The eIsGridContainerCB flag tells nsAbsoluteContainingBlock::Reflow to
// use those instead.
nsRect dummyRect;
AbsPosReflowFlags flags =
AbsPosReflowFlags::CBWidthAndHeightChanged; // XXX could be optimized
flags |= AbsPosReflowFlags::ConstrainHeight;
flags |= AbsPosReflowFlags::IsGridContainerCB;
GetAbsoluteContainingBlock()->Reflow(
this, PresContext(), *aState.mReflowInput, aStatus, dummyRect, flags,
&aDesiredSize.mOverflowAreas);
}
}
return bSize;
}
void nsGridContainerFrame::Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) {
if (IsHiddenByContentVisibilityOfInFlowParentForLayout()) {
return;
}
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsGridContainerFrame");
MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
if (IsFrameTreeTooDeep(aReflowInput, aDesiredSize, aStatus)) {
return;
}
NormalizeChildLists();
#ifdef DEBUG
mDidPushItemsBitMayLie = false;
SanityCheckChildListsBeforeReflow();
#endif // DEBUG
for (auto& perAxisBaseline : mBaseline) {
for (auto& baseline : perAxisBaseline) {
baseline = NS_INTRINSIC_ISIZE_UNKNOWN;
}
}
const nsStylePosition* stylePos = aReflowInput.mStylePosition;
auto prevInFlow = static_cast<nsGridContainerFrame*>(GetPrevInFlow());
if (MOZ_LIKELY(!prevInFlow)) {
InitImplicitNamedAreas(stylePos);
} else {
MOZ_ASSERT(prevInFlow->HasAnyStateBits(kIsSubgridBits) ==
HasAnyStateBits(kIsSubgridBits),
"continuations should have same kIsSubgridBits");
}
GridReflowInput gridReflowInput(this, aReflowInput);
if (gridReflowInput.mIter.ItemsAreAlreadyInOrder()) {
AddStateBits(NS_STATE_GRID_NORMAL_FLOW_CHILDREN_IN_CSS_ORDER);
} else {
RemoveStateBits(NS_STATE_GRID_NORMAL_FLOW_CHILDREN_IN_CSS_ORDER);
}
if (gridReflowInput.mIter.AtEnd() ||
aReflowInput.mStyleDisplay->IsContainLayout()) {
// We have no grid items, or we're layout-contained. So, we have no
// baseline, and our parent should synthesize a baseline if needed.
AddStateBits(NS_STATE_GRID_SYNTHESIZE_BASELINE);
} else {
RemoveStateBits(NS_STATE_GRID_SYNTHESIZE_BASELINE);
}
const nscoord computedBSize = aReflowInput.ComputedBSize();
const nscoord computedISize = aReflowInput.ComputedISize();
const WritingMode& wm = gridReflowInput.mWM;
const LogicalSize computedSize(wm, computedISize, computedBSize);
nscoord consumedBSize = 0;
nscoord bSize = 0;
if (MOZ_LIKELY(!prevInFlow)) {
Grid grid;
if (MOZ_LIKELY(!IsSubgrid())) {
RepeatTrackSizingInput repeatSizing(aReflowInput.ComputedMinSize(),
computedSize,
aReflowInput.ComputedMaxSize());
grid.PlaceGridItems(gridReflowInput, repeatSizing);
} else {
auto* subgrid = GetProperty(Subgrid::Prop());
MOZ_ASSERT(subgrid, "an ancestor forgot to call PlaceGridItems?");
gridReflowInput.mGridItems = subgrid->mGridItems.Clone();
gridReflowInput.mAbsPosItems = subgrid->mAbsPosItems.Clone();
grid.mGridColEnd = subgrid->mGridColEnd;
grid.mGridRowEnd = subgrid->mGridRowEnd;
}
// XXX Technically incorrect: 'contain-intrinsic-block-size: none' is
// treated as 0, ignoring our row sizes, when really we should use them but
// *they* should be computed as if we had no children. To be fixed in bug
// 1488878.
const Maybe<nscoord> containBSize =
aReflowInput.mFrame->ContainIntrinsicBSize();
const nscoord trackSizingBSize = [&] {
// This clamping only applies to auto sizes.
if (containBSize && computedBSize == NS_UNCONSTRAINEDSIZE) {
return aReflowInput.ApplyMinMaxBSize(*containBSize);
}
return computedBSize;
}();
const LogicalSize containLogicalSize(wm, computedISize, trackSizingBSize);
gridReflowInput.CalculateTrackSizes(grid, containLogicalSize,
SizingConstraint::NoConstraint);
if (containBSize) {
bSize = *containBSize;
} else {
if (IsMasonry(LogicalAxis::Block)) {
bSize = computedBSize;
} else {
const auto& rowSizes = gridReflowInput.mRows.mSizes;
if (MOZ_LIKELY(!IsSubgrid(LogicalAxis::Block))) {
// Note: we can't use GridLineEdge here since we haven't calculated
// the rows' mPosition yet (happens in AlignJustifyContent below).
for (const auto& sz : rowSizes) {
bSize += sz.mBase;
}
bSize += gridReflowInput.mRows.SumOfGridGaps();
} else if (computedBSize == NS_UNCONSTRAINEDSIZE) {
bSize = gridReflowInput.mRows.GridLineEdge(
rowSizes.Length(), GridLineSide::BeforeGridGap);
}
}
}
} else {
consumedBSize = CalcAndCacheConsumedBSize();
gridReflowInput.InitializeForContinuation(this, consumedBSize);
// XXX Technically incorrect: 'contain-intrinsic-block-size: none' is
// treated as 0, ignoring our row sizes, when really we should use them but
// *they* should be computed as if we had no children. To be fixed in bug
// 1488878.
if (Maybe<nscoord> containBSize =
aReflowInput.mFrame->ContainIntrinsicBSize()) {
bSize = *containBSize;
} else {
const uint32_t numRows = gridReflowInput.mRows.mSizes.Length();
bSize = gridReflowInput.mRows.GridLineEdge(numRows,
GridLineSide::AfterGridGap);
}
}
if (computedBSize == NS_UNCONSTRAINEDSIZE) {
bSize = aReflowInput.ApplyMinMaxBSize(bSize);
} else if (aReflowInput.ShouldApplyAutomaticMinimumOnBlockAxis()) {
nscoord contentBSize = aReflowInput.ApplyMinMaxBSize(bSize);
bSize = std::max(contentBSize, computedBSize);
} else {
bSize = computedBSize;
}
if (bSize != NS_UNCONSTRAINEDSIZE) {
bSize = std::max(bSize - consumedBSize, 0);
}
auto& bp = gridReflowInput.mBorderPadding;
LogicalRect contentArea(wm, bp.IStart(wm), bp.BStart(wm), computedISize,
bSize);
if (!prevInFlow) {
const auto& rowSizes = gridReflowInput.mRows.mSizes;
if (!IsRowSubgrid()) {
// Apply 'align-content' to the grid.
if (computedBSize == NS_UNCONSTRAINEDSIZE &&
stylePos->mRowGap.IsLengthPercentage() &&
stylePos->mRowGap.AsLengthPercentage().HasPercent()) {
// Re-resolve the row-gap now that we know our intrinsic block-size.
gridReflowInput.mRows.mGridGap =
nsLayoutUtils::ResolveGapToLength(stylePos->mRowGap, bSize);
}
if (!gridReflowInput.mRows.mIsMasonry) {
auto alignment = stylePos->mAlignContent;
gridReflowInput.mRows.AlignJustifyContent(stylePos, alignment, wm,
bSize, false);
}
} else {
if (computedBSize == NS_UNCONSTRAINEDSIZE) {
bSize = gridReflowInput.mRows.GridLineEdge(rowSizes.Length(),
GridLineSide::BeforeGridGap);
contentArea.BSize(wm) = std::max(bSize, nscoord(0));
}
}
// Save the final row sizes for use by subgrids, if needed.
if (HasSubgridItems() || IsSubgrid()) {
StoreUsedTrackSizes(LogicalAxis::Block, rowSizes);
}
}
nsSize containerSize = contentArea.Size(wm).GetPhysicalSize(wm);
bool repositionChildren = false;
if (containerSize.width == NS_UNCONSTRAINEDSIZE && wm.IsVerticalRL()) {
// Note that writing-mode:vertical-rl is the only case where the block
// logical direction progresses in a negative physical direction, and
// therefore block-dir coordinate conversion depends on knowing the width
// of the coordinate space in order to translate between the logical and
// physical origins.
//
// A masonry axis size may be unconstrained, otherwise in a regular grid
// our intrinsic size is always known by now. We'll re-position
// the children below once our size is known.
repositionChildren = true;
containerSize.width = 0;
}
containerSize.width += bp.LeftRight(wm);
containerSize.height += bp.TopBottom(wm);
bSize = ReflowChildren(gridReflowInput, contentArea, containerSize,
aDesiredSize, aStatus);
bSize = std::max(bSize - consumedBSize, 0);
// Skip our block-end border if we're INCOMPLETE.
if (!aStatus.IsComplete() && !gridReflowInput.mSkipSides.BEnd() &&
StyleBorder()->mBoxDecorationBreak != StyleBoxDecorationBreak::Clone) {
bp.BEnd(wm) = nscoord(0);
}
LogicalSize desiredSize(wm, computedISize + bp.IStartEnd(wm),
bSize + bp.BStartEnd(wm));
aDesiredSize.SetSize(wm, desiredSize);
nsRect frameRect(0, 0, aDesiredSize.Width(), aDesiredSize.Height());
aDesiredSize.mOverflowAreas.UnionAllWith(frameRect);
if (repositionChildren) {
nsPoint physicalDelta(aDesiredSize.Width() - bp.LeftRight(wm), 0);
for (const auto& item : gridReflowInput.mGridItems) {
auto* child = item.mFrame;
child->MovePositionBy(physicalDelta);
ConsiderChildOverflow(aDesiredSize.mOverflowAreas, child);
}
}
if (Style()->GetPseudoType() == PseudoStyleType::scrolledContent) {
// Per spec, the grid area is included in a grid container's scrollable
// overflow region [1], as well as the padding on the end-edge sides that
// would satisfy the requirements of 'place-content: end' alignment [2].
//
// Note that we include the padding from all sides of the grid area, not
// just the end sides; this is fine because the grid area is relative to our
// content-box origin. The inflated bounds won't go beyond our padding-box
// edges on the start sides.
//
// The margin areas of grid item boxes are also included in the scrollable
// overflow region [2].
//
// [1] https://drafts.csswg.org/css-grid-1/#overflow
// [2] https://drafts.csswg.org/css-overflow-3/#scrollable
// Synthesize a grid area covering all columns and rows, and compute its
// rect relative to our border-box.
//
// Note: the grid columns and rows exist only if there is an explicit grid;
// or when an implicit grid is needed to place any grid items. See
// nsGridContainerFrame::Grid::PlaceGridItems().
const auto numCols =
static_cast<int32_t>(gridReflowInput.mCols.mSizes.Length());
const auto numRows =
static_cast<int32_t>(gridReflowInput.mRows.mSizes.Length());
if (numCols > 0 && numRows > 0) {
const GridArea gridArea(LineRange(0, numCols), LineRange(0, numRows));
const LogicalRect gridAreaRect =
gridReflowInput.ContainingBlockFor(gridArea) +
LogicalPoint(wm, bp.IStart(wm), bp.BStart(wm));
MOZ_ASSERT(bp == aReflowInput.ComputedLogicalPadding(wm),
"A scrolled inner frame shouldn't have any border!");
const LogicalMargin& padding = bp;
nsRect physicalGridAreaRectWithPadding =
gridAreaRect.GetPhysicalRect(wm, containerSize);
physicalGridAreaRectWithPadding.Inflate(padding.GetPhysicalMargin(wm));
aDesiredSize.mOverflowAreas.UnionAllWith(physicalGridAreaRectWithPadding);
}
nsRect gridItemMarginBoxBounds;
for (const auto& item : gridReflowInput.mGridItems) {
gridItemMarginBoxBounds =
gridItemMarginBoxBounds.Union(item.mFrame->GetMarginRect());
}
aDesiredSize.mOverflowAreas.UnionAllWith(gridItemMarginBoxBounds);
}
// TODO: fix align-tracks alignment in fragments
if ((IsMasonry(LogicalAxis::Block) && !prevInFlow) ||
IsMasonry(LogicalAxis::Inline)) {
gridReflowInput.AlignJustifyTracksInMasonryAxis(
contentArea.Size(wm), aDesiredSize.PhysicalSize());
}
// Convert INCOMPLETE -> OVERFLOW_INCOMPLETE and zero bsize if we're an OC.
if (HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER)) {
if (!aStatus.IsComplete()) {
aStatus.SetOverflowIncomplete();
aStatus.SetNextInFlowNeedsReflow();
}
bSize = 0;
desiredSize.BSize(wm) = bSize + bp.BStartEnd(wm);
aDesiredSize.SetSize(wm, desiredSize);
}
if (!gridReflowInput.mInFragmentainer) {
MOZ_ASSERT(gridReflowInput.mIter.IsValid());
auto sz = frameRect.Size();
CalculateBaselines(BaselineSet::eBoth, &gridReflowInput.mIter,
&gridReflowInput.mGridItems, gridReflowInput.mCols, 0,
gridReflowInput.mCols.mSizes.Length(), wm, sz,
bp.IStart(wm), bp.IEnd(wm), desiredSize.ISize(wm));
CalculateBaselines(BaselineSet::eBoth, &gridReflowInput.mIter,
&gridReflowInput.mGridItems, gridReflowInput.mRows, 0,
gridReflowInput.mRows.mSizes.Length(), wm, sz,
bp.BStart(wm), bp.BEnd(wm), desiredSize.BSize(wm));
} else {
// Only compute 'first baseline' if this fragment contains the first track.
// XXXmats maybe remove this condition? bug 1306499
BaselineSet baselines = BaselineSet::eNone;
if (gridReflowInput.mStartRow == 0 &&
gridReflowInput.mStartRow != gridReflowInput.mNextFragmentStartRow) {
baselines = BaselineSet::eFirst;
}
// Only compute 'last baseline' if this fragment contains the last track.
// XXXmats maybe remove this condition? bug 1306499
uint32_t len = gridReflowInput.mRows.mSizes.Length();
if (gridReflowInput.mStartRow != len &&
gridReflowInput.mNextFragmentStartRow == len) {
baselines = BaselineSet(baselines | BaselineSet::eLast);
}
Maybe<CSSOrderAwareFrameIterator> iter;
Maybe<nsTArray<GridItemInfo>> gridItems;
if (baselines != BaselineSet::eNone) {
// We need to create a new iterator and GridItemInfo array because we
// might have pushed some children at this point.
// Even if the gridReflowInput iterator is invalid we can reuse its
// state about order to optimize initialization of the new iterator.
// An ordered child list can't become unordered by pushing frames.
// An unordered list can become ordered in a number of cases, but we
// ignore that here and guess that the child list is still unordered.
// XXX this is O(n^2) in the number of items in this fragment: bug 1306705
using Filter = CSSOrderAwareFrameIterator::ChildFilter;
using Order = CSSOrderAwareFrameIterator::OrderState;
bool ordered = gridReflowInput.mIter.ItemsAreAlreadyInOrder();
auto orderState = ordered ? Order::Ordered : Order::Unordered;
iter.emplace(this, FrameChildListID::Principal, Filter::SkipPlaceholders,
orderState);
gridItems.emplace();
for (; !iter->AtEnd(); iter->Next()) {
auto child = **iter;
for (const auto& info : gridReflowInput.mGridItems) {
if (info.mFrame == child) {
gridItems->AppendElement(info);
}
}
}
}
auto sz = frameRect.Size();
CalculateBaselines(baselines, iter.ptrOr(nullptr), gridItems.ptrOr(nullptr),
gridReflowInput.mCols, 0,
gridReflowInput.mCols.mSizes.Length(), wm, sz,
bp.IStart(wm), bp.IEnd(wm), desiredSize.ISize(wm));
CalculateBaselines(baselines, iter.ptrOr(nullptr), gridItems.ptrOr(nullptr),
gridReflowInput.mRows, gridReflowInput.mStartRow,
gridReflowInput.mNextFragmentStartRow, wm, sz,
bp.BStart(wm), bp.BEnd(wm), desiredSize.BSize(wm));
}
if (HasAnyStateBits(NS_STATE_GRID_COMPUTED_INFO)) {
// This state bit will never be cleared, since reflow can be called
// multiple times in fragmented grids, and it's challenging to scope
// the bit to only that sequence of calls. This is relatively harmless
// since this bit is only set by accessing a ChromeOnly property, and
// therefore can't unduly slow down normal web browsing.
// Clear our GridFragmentInfo property, which might be holding a stale
// dom::Grid object built from previously-computed info. This will
// ensure that the next call to GetGridFragments will create a new one.
if (mozilla::dom::Grid* grid = TakeProperty(GridFragmentInfo())) {
grid->ForgetFrame();
}
// Now that we know column and row sizes and positions, set
// the ComputedGridTrackInfo and related properties
const auto* subgrid = GetProperty(Subgrid::Prop());
const auto* subgridColRange = subgrid && IsSubgrid(LogicalAxis::Inline)
? &subgrid->SubgridCols()
: nullptr;
LineNameMap colLineNameMap(
gridReflowInput.mGridStyle, GetImplicitNamedAreas(),
gridReflowInput.mColFunctions, nullptr, subgridColRange, true);
uint32_t colTrackCount = gridReflowInput.mCols.mSizes.Length();
nsTArray<nscoord> colTrackPositions(colTrackCount);
nsTArray<nscoord> colTrackSizes(colTrackCount);
nsTArray<uint32_t> colTrackStates(colTrackCount);
nsTArray<bool> colRemovedRepeatTracks(
gridReflowInput.mColFunctions.mRemovedRepeatTracks.Clone());
uint32_t col = 0;
for (const TrackSize& sz : gridReflowInput.mCols.mSizes) {
colTrackPositions.AppendElement(sz.mPosition);
colTrackSizes.AppendElement(sz.mBase);
bool isRepeat =
((col >= gridReflowInput.mColFunctions.mRepeatAutoStart) &&
(col < gridReflowInput.mColFunctions.mRepeatAutoEnd));
colTrackStates.AppendElement(
isRepeat ? (uint32_t)mozilla::dom::GridTrackState::Repeat
: (uint32_t)mozilla::dom::GridTrackState::Static);
col++;
}
// Get the number of explicit tracks first. The order of argument evaluation
// is implementation-defined. We should be OK here because colTrackSizes is
// taken by rvalue, but computing the size first prevents any changes in the
// argument types of the constructor from breaking this.
const uint32_t numColExplicitTracks =
IsSubgrid(LogicalAxis::Inline)
? colTrackSizes.Length()
: gridReflowInput.mColFunctions.NumExplicitTracks();
ComputedGridTrackInfo* colInfo = new ComputedGridTrackInfo(
gridReflowInput.mColFunctions.mExplicitGridOffset, numColExplicitTracks,
0, col, std::move(colTrackPositions), std::move(colTrackSizes),
std::move(colTrackStates), std::move(colRemovedRepeatTracks),
gridReflowInput.mColFunctions.mRepeatAutoStart,
colLineNameMap.GetResolvedLineNamesForComputedGridTrackInfo(),
IsSubgrid(LogicalAxis::Inline), IsMasonry(LogicalAxis::Inline));
SetProperty(GridColTrackInfo(), colInfo);
const auto* subgridRowRange = subgrid && IsSubgrid(LogicalAxis::Block)
? &subgrid->SubgridRows()
: nullptr;
LineNameMap rowLineNameMap(
gridReflowInput.mGridStyle, GetImplicitNamedAreas(),
gridReflowInput.mRowFunctions, nullptr, subgridRowRange, true);
uint32_t rowTrackCount = gridReflowInput.mRows.mSizes.Length();
nsTArray<nscoord> rowTrackPositions(rowTrackCount);
nsTArray<nscoord> rowTrackSizes(rowTrackCount);
nsTArray<uint32_t> rowTrackStates(rowTrackCount);
nsTArray<bool> rowRemovedRepeatTracks(
gridReflowInput.mRowFunctions.mRemovedRepeatTracks.Clone());
uint32_t row = 0;
for (const TrackSize& sz : gridReflowInput.mRows.mSizes) {
rowTrackPositions.AppendElement(sz.mPosition);
rowTrackSizes.AppendElement(sz.mBase);
bool isRepeat =
((row >= gridReflowInput.mRowFunctions.mRepeatAutoStart) &&
(row < gridReflowInput.mRowFunctions.mRepeatAutoEnd));
rowTrackStates.AppendElement(
isRepeat ? (uint32_t)mozilla::dom::GridTrackState::Repeat
: (uint32_t)mozilla::dom::GridTrackState::Static);
row++;
}
// Get the number of explicit tracks first. The order of argument evaluation
// is implementation-defined. We should be OK here because colTrackSizes is
// taken by rvalue, but computing the size first prevents any changes in the
// argument types of the constructor from breaking this.
const uint32_t numRowExplicitTracks =
IsSubgrid(LogicalAxis::Block)
? rowTrackSizes.Length()
: gridReflowInput.mRowFunctions.NumExplicitTracks();
// Row info has to accommodate fragmentation of the grid, which may happen
// in later calls to Reflow. For now, presume that no more fragmentation
// will occur.
ComputedGridTrackInfo* rowInfo = new ComputedGridTrackInfo(
gridReflowInput.mRowFunctions.mExplicitGridOffset, numRowExplicitTracks,
gridReflowInput.mStartRow, row, std::move(rowTrackPositions),
std::move(rowTrackSizes), std::move(rowTrackStates),
std::move(rowRemovedRepeatTracks),
gridReflowInput.mRowFunctions.mRepeatAutoStart,
rowLineNameMap.GetResolvedLineNamesForComputedGridTrackInfo(),
IsSubgrid(LogicalAxis::Block), IsMasonry(LogicalAxis::Block));
SetProperty(GridRowTrackInfo(), rowInfo);
if (prevInFlow) {
// This frame is fragmenting rows from a previous frame, so patch up
// the prior GridRowTrackInfo with a new end row.
// FIXME: This can be streamlined and/or removed when bug 1151204 lands.
ComputedGridTrackInfo* priorRowInfo =
prevInFlow->GetProperty(GridRowTrackInfo());
// Adjust track positions based on the first track in this fragment.
if (priorRowInfo->mPositions.Length() >
priorRowInfo->mStartFragmentTrack) {
nscoord delta =
priorRowInfo->mPositions[priorRowInfo->mStartFragmentTrack];
for (nscoord& pos : priorRowInfo->mPositions) {
pos -= delta;
}
}
ComputedGridTrackInfo* revisedPriorRowInfo = new ComputedGridTrackInfo(
priorRowInfo->mNumLeadingImplicitTracks,
priorRowInfo->mNumExplicitTracks, priorRowInfo->mStartFragmentTrack,
gridReflowInput.mStartRow, std::move(priorRowInfo->mPositions),
std::move(priorRowInfo->mSizes), std::move(priorRowInfo->mStates),
std::move(priorRowInfo->mRemovedRepeatTracks),
priorRowInfo->mRepeatFirstTrack,
std::move(priorRowInfo->mResolvedLineNames), priorRowInfo->mIsSubgrid,
priorRowInfo->mIsMasonry);
prevInFlow->SetProperty(GridRowTrackInfo(), revisedPriorRowInfo);
}
// Generate the line info properties. We need to provide the number of
// repeat tracks produced in the reflow. Only explicit names are assigned
// to lines here; the mozilla::dom::GridLines class will later extract
// implicit names from grid areas and assign them to the appropriate lines.
auto& colFunctions = gridReflowInput.mColFunctions;
// Generate column lines first.
uint32_t capacity = gridReflowInput.mCols.mSizes.Length();
nsTArray<nsTArray<RefPtr<nsAtom>>> columnLineNames(capacity);
for (col = 0; col <= gridReflowInput.mCols.mSizes.Length(); col++) {
// Offset col by the explicit grid offset, to get the original names.
nsTArray<RefPtr<nsAtom>> explicitNames =
colLineNameMap.GetExplicitLineNamesAtIndex(
col - colFunctions.mExplicitGridOffset);
columnLineNames.EmplaceBack(std::move(explicitNames));
}
// Get the explicit names that follow a repeat auto declaration.
nsTArray<RefPtr<nsAtom>> colNamesFollowingRepeat;
nsTArray<RefPtr<nsAtom>> colBeforeRepeatAuto;
nsTArray<RefPtr<nsAtom>> colAfterRepeatAuto;
// Note: the following is only used for a non-subgridded axis.
if (colLineNameMap.HasRepeatAuto()) {
MOZ_ASSERT(!colFunctions.mTemplate.IsSubgrid());
// The line name list after the repeatAutoIndex holds the line names
// for the first explicit line after the repeat auto declaration.
uint32_t repeatAutoEnd = colLineNameMap.RepeatAutoStart() + 1;
for (auto* list : colLineNameMap.ExpandedLineNames()[repeatAutoEnd]) {
for (auto& name : list->AsSpan()) {
colNamesFollowingRepeat.AppendElement(name.AsAtom());
}
}
auto names = colLineNameMap.TrackAutoRepeatLineNames();
for (auto& name : names[0].AsSpan()) {
colBeforeRepeatAuto.AppendElement(name.AsAtom());
}
for (auto& name : names[1].AsSpan()) {
colAfterRepeatAuto.AppendElement(name.AsAtom());
}
}
ComputedGridLineInfo* columnLineInfo = new ComputedGridLineInfo(
std::move(columnLineNames), std::move(colBeforeRepeatAuto),
std::move(colAfterRepeatAuto), std::move(colNamesFollowingRepeat));
SetProperty(GridColumnLineInfo(), columnLineInfo);
// Generate row lines next.
auto& rowFunctions = gridReflowInput.mRowFunctions;
capacity = gridReflowInput.mRows.mSizes.Length();
nsTArray<nsTArray<RefPtr<nsAtom>>> rowLineNames(capacity);
for (row = 0; row <= gridReflowInput.mRows.mSizes.Length(); row++) {
// Offset row by the explicit grid offset, to get the original names.
nsTArray<RefPtr<nsAtom>> explicitNames =
rowLineNameMap.GetExplicitLineNamesAtIndex(
row - rowFunctions.mExplicitGridOffset);
rowLineNames.EmplaceBack(std::move(explicitNames));
}
// Get the explicit names that follow a repeat auto declaration.
nsTArray<RefPtr<nsAtom>> rowNamesFollowingRepeat;
nsTArray<RefPtr<nsAtom>> rowBeforeRepeatAuto;
nsTArray<RefPtr<nsAtom>> rowAfterRepeatAuto;
// Note: the following is only used for a non-subgridded axis.
if (rowLineNameMap.HasRepeatAuto()) {
MOZ_ASSERT(!rowFunctions.mTemplate.IsSubgrid());
// The line name list after the repeatAutoIndex holds the line names
// for the first explicit line after the repeat auto declaration.
uint32_t repeatAutoEnd = rowLineNameMap.RepeatAutoStart() + 1;
for (auto* list : rowLineNameMap.ExpandedLineNames()[repeatAutoEnd]) {
for (auto& name : list->AsSpan()) {
rowNamesFollowingRepeat.AppendElement(name.AsAtom());
}
}
auto names = rowLineNameMap.TrackAutoRepeatLineNames();
for (auto& name : names[0].AsSpan()) {
rowBeforeRepeatAuto.AppendElement(name.AsAtom());
}
for (auto& name : names[1].AsSpan()) {
rowAfterRepeatAuto.AppendElement(name.AsAtom());
}
}
ComputedGridLineInfo* rowLineInfo = new ComputedGridLineInfo(
std::move(rowLineNames), std::move(rowBeforeRepeatAuto),
std::move(rowAfterRepeatAuto), std::move(rowNamesFollowingRepeat));
SetProperty(GridRowLineInfo(), rowLineInfo);
// Generate area info for explicit areas. Implicit areas are handled
// elsewhere.
if (!gridReflowInput.mGridStyle->mGridTemplateAreas.IsNone()) {
auto* areas = new StyleOwnedSlice<NamedArea>(
gridReflowInput.mGridStyle->mGridTemplateAreas.AsAreas()->areas);
SetProperty(ExplicitNamedAreasProperty(), areas);
} else {
RemoveProperty(ExplicitNamedAreasProperty());
}
}
if (!prevInFlow) {
SharedGridData* sharedGridData = GetProperty(SharedGridData::Prop());
if (!aStatus.IsFullyComplete()) {
if (!sharedGridData) {
sharedGridData = new SharedGridData;
SetProperty(SharedGridData::Prop(), sharedGridData);
}
sharedGridData->mCols.mSizes = std::move(gridReflowInput.mCols.mSizes);
sharedGridData->mCols.mContentBoxSize =
gridReflowInput.mCols.mContentBoxSize;
sharedGridData->mCols.mBaselineSubtreeAlign =
gridReflowInput.mCols.mBaselineSubtreeAlign;
sharedGridData->mCols.mIsMasonry = gridReflowInput.mCols.mIsMasonry;
sharedGridData->mRows.mSizes = std::move(gridReflowInput.mRows.mSizes);
// Save the original row grid sizes and gaps so we can restore them later
// in GridReflowInput::Initialize for the continuations.
auto& origRowData = sharedGridData->mOriginalRowData;
origRowData.ClearAndRetainStorage();
origRowData.SetCapacity(sharedGridData->mRows.mSizes.Length());
nscoord prevTrackEnd = 0;
for (auto& sz : sharedGridData->mRows.mSizes) {
SharedGridData::RowData data = {sz.mBase, sz.mPosition - prevTrackEnd};
origRowData.AppendElement(data);
prevTrackEnd = sz.mPosition + sz.mBase;
}
sharedGridData->mRows.mContentBoxSize =
gridReflowInput.mRows.mContentBoxSize;
sharedGridData->mRows.mBaselineSubtreeAlign =
gridReflowInput.mRows.mBaselineSubtreeAlign;
sharedGridData->mRows.mIsMasonry = gridReflowInput.mRows.mIsMasonry;
sharedGridData->mGridItems = std::move(gridReflowInput.mGridItems);
sharedGridData->mAbsPosItems = std::move(gridReflowInput.mAbsPosItems);
sharedGridData->mGenerateComputedGridInfo =
HasAnyStateBits(NS_STATE_GRID_COMPUTED_INFO);
} else if (sharedGridData && !GetNextInFlow()) {
RemoveProperty(SharedGridData::Prop());
}
}
FinishAndStoreOverflow(&aDesiredSize);
}
void nsGridContainerFrame::UpdateSubgridFrameState() {
nsFrameState oldBits = GetStateBits() & kIsSubgridBits;
nsFrameState newBits = ComputeSelfSubgridMasonryBits() & kIsSubgridBits;
if (newBits != oldBits) {
RemoveStateBits(kIsSubgridBits);
if (!newBits) {
RemoveProperty(Subgrid::Prop());
} else {
AddStateBits(newBits);
}
}
}
nsFrameState nsGridContainerFrame::ComputeSelfSubgridMasonryBits() const {
nsFrameState bits = nsFrameState(0);
const auto* pos = StylePosition();
// We can only have masonry layout in one axis.
if (pos->mGridTemplateRows.IsMasonry()) {
bits |= NS_STATE_GRID_IS_ROW_MASONRY;
} else if (pos->mGridTemplateColumns.IsMasonry()) {
bits |= NS_STATE_GRID_IS_COL_MASONRY;
}
// NOTE: The rest of this function is only relevant if we're a subgrid;
// hence, we return early as soon as we rule out that possibility.
// 'contain:layout/paint' makes us an "independent formatting context",
// which prevents us from being a subgrid in this case (but not always).
// We will also need to check our containing scroll frame for this property.
// https://drafts.csswg.org/css-display-3/#establish-an-independent-formatting-context
if (ShouldInhibitSubgridDueToIFC(this)) {
return bits;
}
// Skip over our scroll frame and such if we have it, to find our "parent
// grid", if we have one.
// After this loop, 'parent' will represent the parent of the outermost frame
// that shares our content node. (Normally this is just our parent frame, but
// if we're e.g. a scrolled frame, then this will be the parent of our
// wrapper-scrollable-frame.) If 'parent' turns out to be a grid container,
// then it's our "parent grid", and we could potentially be a subgrid of it.
auto* parent = GetParent();
while (parent && parent->GetContent() == GetContent()) {
// If we find our containing frame (e.g. our scroll frame) can't be a
// subgrid, then we can't be a subgrid, for the same reasons as above. This
// can happen when this frame is itself a grid item with "overflow:scroll"
// or similar.
if (ShouldInhibitSubgridDueToIFC(parent)) {
return bits;
}
parent = parent->GetParent();
}
const nsGridContainerFrame* parentGrid = do_QueryFrame(parent);
if (parentGrid) {
bool isOrthogonal =
GetWritingMode().IsOrthogonalTo(parent->GetWritingMode());
bool isColSubgrid = pos->mGridTemplateColumns.IsSubgrid();
// Subgridding a parent masonry axis makes us use masonry layout too,
// unless our other axis is a masonry axis.
if (isColSubgrid &&
parent->HasAnyStateBits(isOrthogonal ? NS_STATE_GRID_IS_ROW_MASONRY
: NS_STATE_GRID_IS_COL_MASONRY)) {
isColSubgrid = false;
if (!HasAnyStateBits(NS_STATE_GRID_IS_ROW_MASONRY)) {
bits |= NS_STATE_GRID_IS_COL_MASONRY;
}
}
if (isColSubgrid) {
bits |= NS_STATE_GRID_IS_COL_SUBGRID;
}
bool isRowSubgrid = pos->mGridTemplateRows.IsSubgrid();
if (isRowSubgrid &&
parent->HasAnyStateBits(isOrthogonal ? NS_STATE_GRID_IS_COL_MASONRY
: NS_STATE_GRID_IS_ROW_MASONRY)) {
isRowSubgrid = false;
if (!HasAnyStateBits(NS_STATE_GRID_IS_COL_MASONRY)) {
bits |= NS_STATE_GRID_IS_ROW_MASONRY;
}
}
if (isRowSubgrid) {
bits |= NS_STATE_GRID_IS_ROW_SUBGRID;
}
}
return bits;
}
void nsGridContainerFrame::Init(nsIContent* aContent, nsContainerFrame* aParent,
nsIFrame* aPrevInFlow) {
nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
if (HasAnyStateBits(NS_FRAME_FONT_INFLATION_CONTAINER)) {
AddStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT);
}
nsFrameState bits = nsFrameState(0);
if (MOZ_LIKELY(!aPrevInFlow)) {
bits = ComputeSelfSubgridMasonryBits();
} else {
bits = aPrevInFlow->GetStateBits() &
(NS_STATE_GRID_IS_ROW_MASONRY | NS_STATE_GRID_IS_COL_MASONRY |
kIsSubgridBits | NS_STATE_GRID_HAS_COL_SUBGRID_ITEM |
NS_STATE_GRID_HAS_ROW_SUBGRID_ITEM);
}
AddStateBits(bits);
}
void nsGridContainerFrame::DidSetComputedStyle(ComputedStyle* aOldStyle) {
nsContainerFrame::DidSetComputedStyle(aOldStyle);
if (!aOldStyle) {
return; // Init() already initialized the bits.
}
UpdateSubgridFrameState();
}
nscoord nsGridContainerFrame::IntrinsicISize(gfxContext* aRenderingContext,
IntrinsicISizeType aType) {
// Calculate the sum of column sizes under intrinsic sizing.
// http://dev.w3.org/csswg/css-grid/#intrinsic-sizes
NormalizeChildLists();
GridReflowInput state(this, *aRenderingContext);
InitImplicitNamedAreas(state.mGridStyle); // XXX optimize
// The min/sz/max sizes are the input to the "repeat-to-fill" algorithm:
// https://drafts.csswg.org/css-grid/#auto-repeat
// They're only used for auto-repeat so we skip computing them otherwise.
RepeatTrackSizingInput repeatSizing(state.mWM);
if (!IsColSubgrid() && state.mColFunctions.mHasRepeatAuto) {
repeatSizing.InitFromStyle(LogicalAxis::Inline, state.mWM,
state.mFrame->Style());
}
if ((!IsRowSubgrid() && state.mRowFunctions.mHasRepeatAuto &&
!(state.mGridStyle->mGridAutoFlow & StyleGridAutoFlow::ROW)) ||
IsMasonry(LogicalAxis::Inline)) {
// Only 'grid-auto-flow:column' can create new implicit columns, so that's
// the only case where our block-size can affect the number of columns.
// Masonry layout always depends on how many rows we have though.
repeatSizing.InitFromStyle(LogicalAxis::Block, state.mWM,
state.mFrame->Style());
}
Grid grid;
if (MOZ_LIKELY(!IsSubgrid())) {
grid.PlaceGridItems(state, repeatSizing); // XXX optimize
} else {
auto* subgrid = GetProperty(Subgrid::Prop());
state.mGridItems = subgrid->mGridItems.Clone();
state.mAbsPosItems = subgrid->mAbsPosItems.Clone();
grid.mGridColEnd = subgrid->mGridColEnd;
grid.mGridRowEnd = subgrid->mGridRowEnd;
}
auto constraint = aType == IntrinsicISizeType::MinISize
? SizingConstraint::MinContent
: SizingConstraint::MaxContent;
if (IsMasonry(LogicalAxis::Inline)) {
ReflowOutput desiredSize(state.mWM);
nsSize containerSize;
LogicalRect contentArea(state.mWM);
nsReflowStatus status;
state.mRows.mSizes.SetLength(grid.mGridRowEnd);
state.CalculateTrackSizesForAxis(LogicalAxis::Inline, grid,
NS_UNCONSTRAINEDSIZE, constraint);
return MasonryLayout(state, contentArea, constraint, desiredSize, status,
nullptr, containerSize);
}
if (grid.mGridColEnd == 0) {
return nscoord(0);
}
state.CalculateTrackSizesForAxis(LogicalAxis::Inline, grid,
NS_UNCONSTRAINEDSIZE, constraint);
if (MOZ_LIKELY(!IsSubgrid())) {
return state.mCols.SumOfGridTracksAndGaps();
}
const auto& last = state.mCols.mSizes.LastElement();
return last.mPosition + last.mBase;
}
nscoord nsGridContainerFrame::GetMinISize(gfxContext* aRC) {
auto* f = static_cast<nsGridContainerFrame*>(FirstContinuation());
if (f != this) {
return f->GetMinISize(aRC);
}
if (mCachedMinISize == NS_INTRINSIC_ISIZE_UNKNOWN) {
Maybe<nscoord> containISize = ContainIntrinsicISize();
mCachedMinISize = containISize
? *containISize
: IntrinsicISize(aRC, IntrinsicISizeType::MinISize);
}
return mCachedMinISize;
}
nscoord nsGridContainerFrame::GetPrefISize(gfxContext* aRC) {
auto* f = static_cast<nsGridContainerFrame*>(FirstContinuation());
if (f != this) {
return f->GetPrefISize(aRC);
}
if (mCachedPrefISize == NS_INTRINSIC_ISIZE_UNKNOWN) {
Maybe<nscoord> containISize = ContainIntrinsicISize();
mCachedPrefISize = containISize
? *containISize
: IntrinsicISize(aRC, IntrinsicISizeType::PrefISize);
}
return mCachedPrefISize;
}
void nsGridContainerFrame::MarkIntrinsicISizesDirty() {
mCachedMinISize = NS_INTRINSIC_ISIZE_UNKNOWN;
mCachedPrefISize = NS_INTRINSIC_ISIZE_UNKNOWN;
for (auto& perAxisBaseline : mBaseline) {
for (auto& baseline : perAxisBaseline) {
baseline = NS_INTRINSIC_ISIZE_UNKNOWN;
}
}
nsContainerFrame::MarkIntrinsicISizesDirty();
}
void nsGridContainerFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsDisplayListSet& aLists) {
DisplayBorderBackgroundOutline(aBuilder, aLists);
if (GetPrevInFlow()) {
DisplayOverflowContainers(aBuilder, aLists);
}
// Our children are all grid-level boxes, which behave the same as
// inline-blocks in painting, so their borders/backgrounds all go on
// the BlockBorderBackgrounds list.
typedef CSSOrderAwareFrameIterator::OrderState OrderState;
OrderState order =
HasAnyStateBits(NS_STATE_GRID_NORMAL_FLOW_CHILDREN_IN_CSS_ORDER)
? OrderState::Ordered
: OrderState::Unordered;
CSSOrderAwareFrameIterator iter(
this, FrameChildListID::Principal,
CSSOrderAwareFrameIterator::ChildFilter::IncludeAll, order);
const auto flags = DisplayFlagsForFlexOrGridItem();
for (; !iter.AtEnd(); iter.Next()) {
nsIFrame* child = *iter;
BuildDisplayListForChild(aBuilder, child, aLists, flags);
}
}
bool nsGridContainerFrame::DrainSelfOverflowList() {
return DrainAndMergeSelfOverflowList();
}
void nsGridContainerFrame::AppendFrames(ChildListID aListID,
nsFrameList&& aFrameList) {
NoteNewChildren(aListID, aFrameList);
nsContainerFrame::AppendFrames(aListID, std::move(aFrameList));
}
void nsGridContainerFrame::InsertFrames(
ChildListID aListID, nsIFrame* aPrevFrame,
const nsLineList::iterator* aPrevFrameLine, nsFrameList&& aFrameList) {
NoteNewChildren(aListID, aFrameList);
nsContainerFrame::InsertFrames(aListID, aPrevFrame, aPrevFrameLine,
std::move(aFrameList));
}
void nsGridContainerFrame::RemoveFrame(DestroyContext& aContext,
ChildListID aListID,
nsIFrame* aOldFrame) {
MOZ_ASSERT(aListID == FrameChildListID::Principal, "unexpected child list");
#ifdef DEBUG
SetDidPushItemsBitIfNeeded(aListID, aOldFrame);
#endif
nsContainerFrame::RemoveFrame(aContext, aListID, aOldFrame);
}
StyleAlignFlags nsGridContainerFrame::CSSAlignmentForAbsPosChild(
const ReflowInput& aChildRI, LogicalAxis aLogicalAxis) const {
MOZ_ASSERT(aChildRI.mFrame->IsAbsolutelyPositioned(),
"This method should only be called for abspos children");
StyleAlignFlags alignment =
(aLogicalAxis == LogicalAxis::Inline)
? aChildRI.mStylePosition->UsedJustifySelf(Style())._0
: aChildRI.mStylePosition->UsedAlignSelf(Style())._0;
// Extract and strip the flag bits
StyleAlignFlags alignmentFlags = alignment & StyleAlignFlags::FLAG_BITS;
alignment &= ~StyleAlignFlags::FLAG_BITS;
if (alignment == StyleAlignFlags::NORMAL) {
// "the 'normal' keyword behaves as 'start' on replaced
// absolutely-positioned boxes, and behaves as 'stretch' on all other
// absolutely-positioned boxes."
// https://drafts.csswg.org/css-align/#align-abspos
// https://drafts.csswg.org/css-align/#justify-abspos
alignment = aChildRI.mFrame->IsReplaced() ? StyleAlignFlags::START
: StyleAlignFlags::STRETCH;
} else if (alignment == StyleAlignFlags::FLEX_START) {
alignment = StyleAlignFlags::START;
} else if (alignment == StyleAlignFlags::FLEX_END) {
alignment = StyleAlignFlags::END;
} else if (alignment == StyleAlignFlags::LEFT ||
alignment == StyleAlignFlags::RIGHT) {
if (aLogicalAxis == LogicalAxis::Inline) {
const bool isLeft = (alignment == StyleAlignFlags::LEFT);
WritingMode wm = GetWritingMode();
alignment = (isLeft == wm.IsBidiLTR()) ? StyleAlignFlags::START
: StyleAlignFlags::END;
} else {
alignment = StyleAlignFlags::START;
}
} else if (alignment == StyleAlignFlags::BASELINE) {
alignment = StyleAlignFlags::START;
} else if (alignment == StyleAlignFlags::LAST_BASELINE) {
alignment = StyleAlignFlags::END;
}
return (alignment | alignmentFlags);
}
nscoord nsGridContainerFrame::SynthesizeBaseline(
const FindItemInGridOrderResult& aGridOrderItem, LogicalAxis aAxis,
BaselineSharingGroup aGroup, const nsSize& aCBPhysicalSize, nscoord aCBSize,
WritingMode aCBWM) {
if (MOZ_UNLIKELY(!aGridOrderItem.mItem)) {
// No item in this fragment - synthesize a baseline from our border-box.
return ::SynthesizeBaselineFromBorderBox(aGroup, aCBWM, aAxis, aCBSize);
}
nsIFrame* child = aGridOrderItem.mItem->mFrame;
nsGridContainerFrame* grid = do_QueryFrame(child);
auto childWM = child->GetWritingMode();
bool isOrthogonal = aCBWM.IsOrthogonalTo(childWM);
const LogicalAxis childAxis = isOrthogonal ? GetOrthogonalAxis(aAxis) : aAxis;
nscoord baseline;
nscoord start;
nscoord size;
if (aAxis == LogicalAxis::Block) {
start = child->GetLogicalNormalPosition(aCBWM, aCBPhysicalSize).B(aCBWM);
size = child->BSize(aCBWM);
if (grid && aGridOrderItem.mIsInEdgeTrack) {
baseline = isOrthogonal ? grid->GetIBaseline(aGroup)
: grid->GetBBaseline(aGroup);
} else if (!isOrthogonal && aGridOrderItem.mIsInEdgeTrack) {
// This assertion is mostly for documentation purposes; it must hold,
// given the checks in our 'if' statements. (We know aAxis is
// LogicalAxis::Block, and isOrthogonal is false, which means childAxis
// must be LogicalAxis::Block). If instead we got here with a childAxis of
// LogicalAxis::Inline, then our call to
// Baseline::SynthesizeBaselineFromBorderBox might incorrectly think
// it makes sense to use a central baseline, in an axis where that
// doesn't make sense.
MOZ_ASSERT(childAxis == LogicalAxis::Block, "unexpected childAxis");
baseline = child
->GetNaturalBaselineBOffset(childWM, aGroup,
BaselineExportContext::Other)
.valueOrFrom([aGroup, child, childWM]() {
return Baseline::SynthesizeBOffsetFromBorderBox(
child, childWM, aGroup);
});
} else {
baseline =
::SynthesizeBaselineFromBorderBox(aGroup, childWM, childAxis, size);
}
} else {
start = child->GetLogicalNormalPosition(aCBWM, aCBPhysicalSize).I(aCBWM);
size = child->ISize(aCBWM);
if (grid && aGridOrderItem.mIsInEdgeTrack) {
baseline = isOrthogonal ? grid->GetBBaseline(aGroup)
: grid->GetIBaseline(aGroup);
} else if (isOrthogonal && aGridOrderItem.mIsInEdgeTrack) {
baseline = child
->GetNaturalBaselineBOffset(childWM, aGroup,
BaselineExportContext::Other)
.valueOrFrom([aGroup, childWM, childAxis, size]() {
return ::SynthesizeBaselineFromBorderBox(
aGroup, childWM, childAxis, size);
});
} else {
baseline =
::SynthesizeBaselineFromBorderBox(aGroup, childWM, childAxis, size);
}
}
return aGroup == BaselineSharingGroup::First
? start + baseline
: aCBSize - start - size + baseline;
}
void nsGridContainerFrame::CalculateBaselines(
BaselineSet aBaselineSet, CSSOrderAwareFrameIterator* aIter,
const nsTArray<GridItemInfo>* aGridItems, const Tracks& aTracks,
uint32_t aFragmentStartTrack, uint32_t aFirstExcludedTrack, WritingMode aWM,
const nsSize& aCBPhysicalSize, nscoord aCBBorderPaddingStart,
nscoord aCBBorderPaddingEnd, nscoord aCBSize) {
const auto axis = aTracks.mAxis;
auto firstBaseline = aTracks.mBaseline[BaselineSharingGroup::First];
if (!(aBaselineSet & BaselineSet::eFirst)) {
mBaseline[axis][BaselineSharingGroup::First] =
::SynthesizeBaselineFromBorderBox(BaselineSharingGroup::First, aWM,
axis, aCBSize);
} else if (firstBaseline == NS_INTRINSIC_ISIZE_UNKNOWN) {
FindItemInGridOrderResult gridOrderFirstItem = FindFirstItemInGridOrder(
*aIter, *aGridItems,
axis == LogicalAxis::Block ? &GridArea::mRows : &GridArea::mCols,
axis == LogicalAxis::Block ? &GridArea::mCols : &GridArea::mRows,
aFragmentStartTrack);
mBaseline[axis][BaselineSharingGroup::First] = SynthesizeBaseline(
gridOrderFirstItem, axis, BaselineSharingGroup::First, aCBPhysicalSize,
aCBSize, aWM);
} else {
// We have a 'first baseline' group in the start track in this fragment.
// Convert it from track to grid container border-box coordinates.
MOZ_ASSERT(!aGridItems->IsEmpty());
nscoord gapBeforeStartTrack =
aFragmentStartTrack == 0
? aTracks.GridLineEdge(aFragmentStartTrack,
GridLineSide::AfterGridGap)
: nscoord(0); // no content gap at start of fragment
mBaseline[axis][BaselineSharingGroup::First] =
aCBBorderPaddingStart + gapBeforeStartTrack + firstBaseline;
}
auto lastBaseline = aTracks.mBaseline[BaselineSharingGroup::Last];
if (!(aBaselineSet & BaselineSet::eLast)) {
mBaseline[axis][BaselineSharingGroup::Last] =
::SynthesizeBaselineFromBorderBox(BaselineSharingGroup::Last, aWM, axis,
aCBSize);
} else if (lastBaseline == NS_INTRINSIC_ISIZE_UNKNOWN) {
// For finding items for the 'last baseline' we need to create a reverse
// iterator ('aIter' is the forward iterator from the GridReflowInput).
using Iter = ReverseCSSOrderAwareFrameIterator;
auto orderState = aIter->ItemsAreAlreadyInOrder()
? Iter::OrderState::Ordered
: Iter::OrderState::Unordered;
Iter iter(this, FrameChildListID::Principal,
Iter::ChildFilter::SkipPlaceholders, orderState);
iter.SetItemCount(aGridItems->Length());
FindItemInGridOrderResult gridOrderLastItem = FindLastItemInGridOrder(
iter, *aGridItems,
axis == LogicalAxis::Block ? &GridArea::mRows : &GridArea::mCols,
axis == LogicalAxis::Block ? &GridArea::mCols : &GridArea::mRows,
aFragmentStartTrack, aFirstExcludedTrack);
mBaseline[axis][BaselineSharingGroup::Last] =
SynthesizeBaseline(gridOrderLastItem, axis, BaselineSharingGroup::Last,
aCBPhysicalSize, aCBSize, aWM);
} else {
// We have a 'last baseline' group in the end track in this fragment.
// Convert it from track to grid container border-box coordinates.
MOZ_ASSERT(!aGridItems->IsEmpty());
auto borderBoxStartToEndOfEndTrack =
aCBBorderPaddingStart +
aTracks.GridLineEdge(aFirstExcludedTrack, GridLineSide::BeforeGridGap) -
aTracks.GridLineEdge(aFragmentStartTrack, GridLineSide::BeforeGridGap);
mBaseline[axis][BaselineSharingGroup::Last] =
(aCBSize - borderBoxStartToEndOfEndTrack) + lastBaseline;
}
}
#ifdef DEBUG_FRAME_DUMP
nsresult nsGridContainerFrame::GetFrameName(nsAString& aResult) const {
return MakeFrameName(u"GridContainer"_ns, aResult);
}
void nsGridContainerFrame::ExtraContainerFrameInfo(nsACString& aTo) const {
if (const void* const subgrid = GetProperty(Subgrid::Prop())) {
aTo += nsPrintfCString(" [subgrid=%p]", subgrid);
}
}
#endif
/* static */ nsGridContainerFrame::FindItemInGridOrderResult
nsGridContainerFrame::FindFirstItemInGridOrder(
CSSOrderAwareFrameIterator& aIter, const nsTArray<GridItemInfo>& aGridItems,
LineRange GridArea::*aMajor, LineRange GridArea::*aMinor,
uint32_t aFragmentStartTrack) {
FindItemInGridOrderResult result = {nullptr, false};
uint32_t minMajor = kTranslatedMaxLine + 1;
uint32_t minMinor = kTranslatedMaxLine + 1;
aIter.Reset();
for (; !aIter.AtEnd(); aIter.Next()) {
const GridItemInfo& item = aGridItems[aIter.ItemIndex()];
if ((item.mArea.*aMajor).mEnd <= aFragmentStartTrack) {
continue; // item doesn't span any track in this fragment
}
uint32_t major = (item.mArea.*aMajor).mStart;
uint32_t minor = (item.mArea.*aMinor).mStart;
if (major < minMajor || (major == minMajor && minor < minMinor)) {
minMajor = major;
minMinor = minor;
result.mItem = &item;
result.mIsInEdgeTrack = major == 0U;
}
}
return result;
}
/* static */ nsGridContainerFrame::FindItemInGridOrderResult
nsGridContainerFrame::FindLastItemInGridOrder(
ReverseCSSOrderAwareFrameIterator& aIter,
const nsTArray<GridItemInfo>& aGridItems, LineRange GridArea::*aMajor,
LineRange GridArea::*aMinor, uint32_t aFragmentStartTrack,
uint32_t aFirstExcludedTrack) {
FindItemInGridOrderResult result = {nullptr, false};
int32_t maxMajor = -1;
int32_t maxMinor = -1;
aIter.Reset();
int32_t lastMajorTrack = int32_t(aFirstExcludedTrack) - 1;
for (; !aIter.AtEnd(); aIter.Next()) {
const GridItemInfo& item = aGridItems[aIter.ItemIndex()];
// Subtract 1 from the end line to get the item's last track index.
int32_t major = (item.mArea.*aMajor).mEnd - 1;
// Currently, this method is only called with aFirstExcludedTrack ==
// the first track in the next fragment, so we take the opportunity
// to assert this item really belongs to this fragment.
MOZ_ASSERT((item.mArea.*aMajor).mStart < aFirstExcludedTrack,
"found an item that belongs to some later fragment");
if (major < int32_t(aFragmentStartTrack)) {
continue; // item doesn't span any track in this fragment
}
int32_t minor = (item.mArea.*aMinor).mEnd - 1;
MOZ_ASSERT(minor >= 0 && major >= 0, "grid item must have span >= 1");
if (major > maxMajor || (major == maxMajor && minor > maxMinor)) {
maxMajor = major;
maxMinor = minor;
result.mItem = &item;
result.mIsInEdgeTrack = major == lastMajorTrack;
}
}
return result;
}
nsGridContainerFrame::UsedTrackSizes* nsGridContainerFrame::GetUsedTrackSizes()
const {
return GetProperty(UsedTrackSizes::Prop());
}
void nsGridContainerFrame::StoreUsedTrackSizes(
LogicalAxis aAxis, const nsTArray<TrackSize>& aSizes) {
auto* uts = GetUsedTrackSizes();
if (!uts) {
uts = new UsedTrackSizes();
SetProperty(UsedTrackSizes::Prop(), uts);
}
uts->mSizes[aAxis] = aSizes.Clone();
uts->mCanResolveLineRangeSize[aAxis] = true;
// XXX is resetting these bits necessary?
for (auto& sz : uts->mSizes[aAxis]) {
sz.mState &= ~(TrackSize::eFrozen | TrackSize::eSkipGrowUnlimited |
TrackSize::eInfinitelyGrowable);
}
}
#ifdef DEBUG
void nsGridContainerFrame::SetInitialChildList(ChildListID aListID,
nsFrameList&& aChildList) {
ChildListIDs supportedLists = {FrameChildListID::Principal};
// We don't handle the FrameChildListID::Backdrop frames in any way, but it
// only contains a placeholder for ::backdrop which is OK to not reflow (for
// now anyway).
supportedLists += FrameChildListID::Backdrop;
MOZ_ASSERT(supportedLists.contains(aListID), "unexpected child list");
return nsContainerFrame::SetInitialChildList(aListID, std::move(aChildList));
}
void nsGridContainerFrame::TrackSize::DumpStateBits(StateBits aState) {
printf("min:");
if (aState & eAutoMinSizing) {
printf("auto-min ");
} else if (aState & eMinContentMinSizing) {
printf("min-content ");
} else if (aState & eMaxContentMinSizing) {
printf("max-content ");
}
printf(" max:");
if (aState & eAutoMaxSizing) {
printf("auto ");
} else if (aState & eMinContentMaxSizing) {
printf("min-content ");
} else if (aState & eMaxContentMaxSizing) {
printf("max-content ");
} else if (aState & eFlexMaxSizing) {
printf("flex ");
}
if (aState & eFrozen) {
printf("frozen ");
}
if (aState & eModified) {
printf("modified ");
}
if (aState & eBreakBefore) {
printf("break-before ");
}
}
void nsGridContainerFrame::TrackSize::Dump() const {
printf("mPosition=%d mBase=%d mLimit=%d ", mPosition, mBase, mLimit);
DumpStateBits(mState);
}
#endif // DEBUG
bool nsGridContainerFrame::GridItemShouldStretch(const nsIFrame* aChild,
LogicalAxis aAxis) const {
MOZ_ASSERT(aChild->IsGridItem());
if (aChild->IsGridContainerFrame()) {
// The subgrid is always stretched in its subgridded dimensions.
// https://drafts.csswg.org/css-grid/#subgrid-box-alignment
const auto* gridContainer =
static_cast<const nsGridContainerFrame*>(aChild);
if (gridContainer->IsSubgrid(aAxis)) {
return true;
}
}
const auto wm = aChild->GetWritingMode();
if (aChild->StyleMargin()->HasAuto(aAxis, wm)) {
// Per https://drafts.csswg.org/css-grid/#auto-margins, any 'auto' margin in
// an axis disables the alignment property in that axis.
return false;
}
const auto cbwm = GetWritingMode();
const bool isOrthogonal = wm.IsOrthogonalTo(cbwm);
if (IsMasonry(isOrthogonal ? GetOrthogonalAxis(aAxis) : aAxis)) {
// The child is in the container's masonry-axis.
// AlignJustifyTracksInMasonryAxis will stretch it, so we don't report that
// here.
return false;
}
const auto* pos = aChild->StylePosition();
const auto alignment = (aAxis == LogicalAxis::Inline) == !isOrthogonal
? pos->UsedJustifySelf(Style())._0
: pos->UsedAlignSelf(Style())._0;
return alignment == StyleAlignFlags::NORMAL ||
alignment == StyleAlignFlags::STRETCH;
}
bool nsGridContainerFrame::ShouldInhibitSubgridDueToIFC(
const nsIFrame* aFrame) {
// Just checking for things that make us establish an independent formatting
// context (IFC) and hence prevent us from being a subgrid:
// * Out-of-flow (e.g. abspos) frames also establish an IFC. Note, our
// NS_FRAME_OUT_OF_FLOW bit potentially isn't set yet, so we check our style.
// * contain:layout and contain:paint each make us establish an IFC.
const auto* display = aFrame->StyleDisplay();
return display->IsAbsolutelyPositionedStyle() || display->IsContainLayout() ||
display->IsContainPaint();
}
nsGridContainerFrame* nsGridContainerFrame::GetGridContainerFrame(
nsIFrame* aFrame) {
nsGridContainerFrame* gridFrame = nullptr;
if (aFrame) {
nsIFrame* inner = aFrame;
if (MOZ_UNLIKELY(aFrame->IsFieldSetFrame())) {
inner = static_cast<nsFieldSetFrame*>(aFrame)->GetInner();
}
// Since "Get" methods like GetInner and GetContentInsertionFrame can
// return null, we check the return values before dereferencing. Our
// calling pattern makes this unlikely, but we're being careful.
nsIFrame* insertionFrame =
inner ? inner->GetContentInsertionFrame() : nullptr;
nsIFrame* possibleGridFrame = insertionFrame ? insertionFrame : aFrame;
gridFrame = possibleGridFrame->IsGridContainerFrame()
? static_cast<nsGridContainerFrame*>(possibleGridFrame)
: nullptr;
}
return gridFrame;
}
nsGridContainerFrame* nsGridContainerFrame::GetGridFrameWithComputedInfo(
nsIFrame* aFrame) {
nsGridContainerFrame* gridFrame = GetGridContainerFrame(aFrame);
if (!gridFrame) {
return nullptr;
}
auto HasComputedInfo = [](const nsGridContainerFrame& aFrame) -> bool {
return aFrame.HasProperty(GridColTrackInfo()) &&
aFrame.HasProperty(GridRowTrackInfo()) &&
aFrame.HasProperty(GridColumnLineInfo()) &&
aFrame.HasProperty(GridRowLineInfo());
};
if (HasComputedInfo(*gridFrame)) {
return gridFrame;
}
// Trigger a reflow that generates additional grid property data.
// Hold onto aFrame while we do this, in case reflow destroys it.
AutoWeakFrame weakFrameRef(gridFrame);
RefPtr<mozilla::PresShell> presShell = gridFrame->PresShell();
gridFrame->AddStateBits(NS_STATE_GRID_COMPUTED_INFO);
presShell->FrameNeedsReflow(gridFrame, IntrinsicDirty::None,
NS_FRAME_IS_DIRTY);
presShell->FlushPendingNotifications(FlushType::Layout);
// If the weakFrameRef is no longer valid, then we must bail out.
if (!weakFrameRef.IsAlive()) {
return nullptr;
}
// This can happen if for some reason we ended up not reflowing, like in print
// preview under some circumstances.
if (MOZ_UNLIKELY(!HasComputedInfo(*gridFrame))) {
return nullptr;
}
return gridFrame;
}
// TODO: This is a rather dumb implementation of nsILineIterator, but it's
// better than our pre-existing behavior. Ideally, we should probably use the
// grid information to return a meaningful number of lines etc.
bool nsGridContainerFrame::IsLineIteratorFlowRTL() { return false; }
int32_t nsGridContainerFrame::GetNumLines() const {
return mFrames.GetLength();
}
Result<nsILineIterator::LineInfo, nsresult> nsGridContainerFrame::GetLine(
int32_t aLineNumber) {
if (aLineNumber < 0 || aLineNumber >= GetNumLines()) {
return Err(NS_ERROR_FAILURE);
}
LineInfo rv;
nsIFrame* f = mFrames.FrameAt(aLineNumber);
rv.mLineBounds = f->GetRect();
rv.mFirstFrameOnLine = f;
rv.mNumFramesOnLine = 1;
return rv;
}
int32_t nsGridContainerFrame::FindLineContaining(nsIFrame* aFrame,
int32_t aStartLine) {
const int32_t index = mFrames.IndexOf(aFrame);
if (index < 0) {
return -1;
}
if (index < aStartLine) {
return -1;
}
return index;
}
NS_IMETHODIMP
nsGridContainerFrame::CheckLineOrder(int32_t aLine, bool* aIsReordered,
nsIFrame** aFirstVisual,
nsIFrame** aLastVisual) {
*aIsReordered = false;
*aFirstVisual = nullptr;
*aLastVisual = nullptr;
return NS_OK;
}
NS_IMETHODIMP
nsGridContainerFrame::FindFrameAt(int32_t aLineNumber, nsPoint aPos,
nsIFrame** aFrameFound,
bool* aPosIsBeforeFirstFrame,
bool* aPosIsAfterLastFrame) {
const auto wm = GetWritingMode();
const LogicalPoint pos(wm, aPos, GetSize());
*aFrameFound = nullptr;
*aPosIsBeforeFirstFrame = true;
*aPosIsAfterLastFrame = false;
nsIFrame* f = mFrames.FrameAt(aLineNumber);
if (!f) {
return NS_OK;
}
auto rect = f->GetLogicalRect(wm, GetSize());
*aFrameFound = f;
*aPosIsBeforeFirstFrame = pos.I(wm) < rect.IStart(wm);
*aPosIsAfterLastFrame = pos.I(wm) > rect.IEnd(wm);
return NS_OK;
}
Reference in New Issue View Git Blame Copy Permalink