corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug 1009776 - part 1, [css-grid] Implement line-based placement. r=dholbert

Browse Source
This commit is contained in:
Mats Palmgren
2015-03-18 09:02:32 +00:00
parent 0d41e4fcbb
commit 89cbfd7d1e
2 changed files with 471 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

326
layout/generic/nsGridContainerFrame.cpp
View File

@@ -15,6 +15,107 @@
using namespace mozilla;
/**
* Search for the aNth occurrence of aName in aNameList (forward), starting at
* the zero-based aFromIndex, and return the 1-based index (line number).
* Also take into account there is an unconditional match at aImplicitLine
* unless it's zero.
* Return the last match if aNth occurrences can't be found, or zero if no
* occurrence can be found.
*/
static uint32_t
FindLine(const nsString& aName, uint32_t aNth,
uint32_t aFromIndex, uint32_t aImplicitLine,
const nsTArray<nsTArray<nsString>>& aNameList)
{
MOZ_ASSERT(aNth != 0);
const uint32_t len = aNameList.Length();
uint32_t lastFound = 0;
uint32_t line;
uint32_t i = aFromIndex;
for (; i < len; i = line) {
line = i + 1;
if (line == aImplicitLine || aNameList[i].Contains(aName)) {
lastFound = line;
if (--aNth == 0) {
return lastFound;
}
}
}
if (aImplicitLine > i) {
// aImplicitLine is after the lines we searched above so it's last.
// (grid-template-areas has more tracks than grid-template-[rows|columns])
lastFound = aImplicitLine;
}
return lastFound;
}
/**
* @see FindLine, this function does the same but searches in reverse.
*/
static uint32_t
RFindLine(const nsString& aName, uint32_t aNth,
uint32_t aFromIndex, uint32_t aImplicitLine,
const nsTArray<nsTArray<nsString>>& aNameList)
{
MOZ_ASSERT(aNth != 0);
const uint32_t len = aNameList.Length();
uint32_t lastFound = 0;
// The implicit line may be beyond the length of aNameList so we match this
// line first if it's within the 0..aFromIndex range.
if (aImplicitLine > len && aImplicitLine < aFromIndex) {
lastFound = aImplicitLine;
if (--aNth == 0) {
return lastFound;
}
}
uint32_t i = aFromIndex == 0 ? len : std::min(aFromIndex, len);
for (; i; --i) {
if (i == aImplicitLine || aNameList[i - 1].Contains(aName)) {
lastFound = i;
if (--aNth == 0) {
break;
}
}
}
return lastFound;
}
static uint32_t
FindNamedLine(const nsString& aName, int32_t aNth,
uint32_t aFromIndex, uint32_t aImplicitLine,
const nsTArray<nsTArray<nsString>>& aNameList)
{
MOZ_ASSERT(aNth != 0);
if (aNth > 0) {
return ::FindLine(aName, aNth, aFromIndex, aImplicitLine, aNameList);
}
return ::RFindLine(aName, -aNth, aFromIndex, aImplicitLine, aNameList);
}
/**
* A convenience method to lookup a name in 'grid-template-areas'.
* @param aStyle the StylePosition() for the grid container
* @return null if not found
*/
static const css::GridNamedArea*
FindNamedArea(const nsSubstring& aName, const nsStylePosition* aStyle)
{
if (!aStyle->mGridTemplateAreas) {
return nullptr;
}
const nsTArray<css::GridNamedArea>& areas =
aStyle->mGridTemplateAreas->mNamedAreas;
size_t len = areas.Length();
for (size_t i = 0; i < len; ++i) {
const css::GridNamedArea& area = areas[i];
if (area.mName == aName) {
return &area;
}
}
return nullptr;
}
// 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
@@ -116,6 +217,230 @@ nsGridContainerFrame::InitImplicitNamedAreas(const nsStylePosition* aStyle)
}
}
uint32_t
nsGridContainerFrame::ResolveLine(
const nsStyleGridLine& aLine,
int32_t aNth,
uint32_t aFromIndex,
const nsTArray<nsTArray<nsString>>& aLineNameList,
uint32_t GridNamedArea::* aAreaStart,
uint32_t GridNamedArea::* aAreaEnd,
uint32_t aExplicitGridEnd,
LineRangeSide aSide,
const nsStylePosition* aStyle)
{
MOZ_ASSERT(!aLine.IsAuto());
uint32_t line = 0;
if (aLine.mLineName.IsEmpty()) {
MOZ_ASSERT(aNth != 0, "css-grid 9.2: <integer> must not be zero.");
line = std::max(int32_t(aFromIndex) + aNth, 1);
} else {
if (aNth == 0) {
// <integer> was omitted; treat it as 1.
aNth = 1;
}
bool isNameOnly = !aLine.mHasSpan && aLine.mInteger == 0;
if (isNameOnly) {
const GridNamedArea* area = ::FindNamedArea(aLine.mLineName, aStyle);
if (area || HasImplicitNamedArea(aLine.mLineName)) {
// The given name 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
uint32_t implicitLine = 0;
nsAutoString lineName(aLine.mLineName);
if (aSide == eLineRangeSideStart) {
lineName.AppendLiteral("-start");
implicitLine = area ? area->*aAreaStart : 0;
} else {
lineName.AppendLiteral("-end");
implicitLine = area ? area->*aAreaEnd : 0;
}
// XXX must Implicit Named Areas have all four lines?
// http://dev.w3.org/csswg/css-grid/#implicit-named-areas
line = ::FindNamedLine(lineName, aNth, aFromIndex, implicitLine,
aLineNameList);
}
}
if (line == 0) {
// If mLineName ends in -start/-end, try the prefix as a named area.
uint32_t implicitLine = 0;
uint32_t index;
auto GridNamedArea::* areaEdge = aAreaStart;
bool found = ::IsNameWithStartSuffix(aLine.mLineName, &index);
if (!found) {
found = ::IsNameWithEndSuffix(aLine.mLineName, &index);
areaEdge = aAreaEnd;
}
if (found) {
const GridNamedArea* area =
::FindNamedArea(nsDependentSubstring(aLine.mLineName, 0, index),
aStyle);
if (area) {
implicitLine = area->*areaEdge;
}
}
line = ::FindNamedLine(aLine.mLineName, aNth, aFromIndex, implicitLine,
aLineNameList);
}
if (line == 0) {
// No line matching <custom-ident> exists.
if (aLine.mHasSpan) {
// http://dev.w3.org/csswg/css-grid/#grid-placement-span-int
// Treat 'span <custom-ident> N' as 'span N'.
line = std::max(int32_t(aFromIndex) + aNth, 1);
} else {
// http://dev.w3.org/csswg/css-grid/#grid-placement-int
// Treat '<custom-ident> N' as first/last line depending on N's sign.
// XXX this is wrong due to a spec change, see bug 1009776 comment 17.
// XXX we want to possibly expand the implicit grid here.
line = aNth >= 0 ? 1 : aExplicitGridEnd;
}
}
}
// The only case which can result in "auto" (line == 0) is a plain
// <custom-ident> (without <integer> or 'span') which wasn't found.
MOZ_ASSERT(line != 0 || (!aLine.mHasSpan && aLine.mInteger == 0),
"Given a <integer> or 'span' the result should never be auto");
return line;
}
nsGridContainerFrame::LinePair
nsGridContainerFrame::ResolveLineRangeHelper(
const nsStyleGridLine& aStart,
const nsStyleGridLine& aEnd,
const nsTArray<nsTArray<nsString>>& aLineNameList,
uint32_t GridNamedArea::* aAreaStart,
uint32_t GridNamedArea::* aAreaEnd,
uint32_t aExplicitGridEnd,
const nsStylePosition* aStyle)
{
if (aStart.mHasSpan) {
if (aEnd.mHasSpan || aEnd.IsAuto()) {
// http://dev.w3.org/csswg/css-grid/#grid-placement-errors
if (aStart.mLineName.IsEmpty()) {
// span <integer> / span *
// span <integer> / auto
return LinePair(0, aStart.mInteger);
}
// span <custom-ident> / span *
// span <custom-ident> / auto
return LinePair(0, 1); // XXX subgrid explicit size instead of 1?
}
auto end = ResolveLine(aEnd, aEnd.mInteger, 0, aLineNameList, aAreaStart,
aAreaEnd, aExplicitGridEnd, eLineRangeSideEnd,
aStyle);
if (end == 0) {
// span * / <custom-ident> that can't be found
return LinePair(0, aStart.mInteger);
}
int32_t span = aStart.mInteger == 0 ? 1 : aStart.mInteger;
auto start = ResolveLine(aStart, -span, end, aLineNameList, aAreaStart,
aAreaEnd, aExplicitGridEnd, eLineRangeSideStart,
aStyle);
MOZ_ASSERT(start > 0, "A start span can never resolve to 'auto'");
return LinePair(start, end);
}
uint32_t start = 0;
if (!aStart.IsAuto()) {
start = ResolveLine(aStart, aStart.mInteger, 0, aLineNameList, aAreaStart,
aAreaEnd, aExplicitGridEnd, eLineRangeSideStart,
aStyle);
}
if (aEnd.IsAuto()) {
// * (except span) / auto
return LinePair(start, 1); // XXX subgrid explicit size instead of 1?
}
if (start == 0 && aEnd.mHasSpan) {
if (aEnd.mLineName.IsEmpty()) {
// auto (or not found <custom-ident>) / span <integer>
MOZ_ASSERT(aEnd.mInteger != 0);
return LinePair(0, aEnd.mInteger);
}
// http://dev.w3.org/csswg/css-grid/#grid-placement-errors
// auto (or not found <custom-ident>) / span <custom-ident>
return LinePair(0, 1); // XXX subgrid explicit size instead of 1?
}
uint32_t from = aEnd.mHasSpan ? start : 0;
auto end = ResolveLine(aEnd, aEnd.mInteger, from, aLineNameList, aAreaStart,
aAreaEnd, aExplicitGridEnd, eLineRangeSideEnd, aStyle);
if (end == 0) {
// * (except span) / not found <custom-ident>
end = 1; // XXX subgrid explicit size instead of 1?
} else if (start == 0) {
// auto (or not found <custom-ident>) / definite line
start = std::max(1U, end - 1);
}
return LinePair(start, end);
}
nsGridContainerFrame::LineRange
nsGridContainerFrame::ResolveLineRange(
const nsStyleGridLine& aStart,
const nsStyleGridLine& aEnd,
const nsTArray<nsTArray<nsString>>& aLineNameList,
uint32_t GridNamedArea::* aAreaStart,
uint32_t GridNamedArea::* aAreaEnd,
uint32_t aExplicitGridEnd,
const nsStylePosition* aStyle)
{
LinePair r = ResolveLineRangeHelper(aStart, aEnd, aLineNameList, aAreaStart,
aAreaEnd, aExplicitGridEnd, aStyle);
MOZ_ASSERT(r.second != 0);
// http://dev.w3.org/csswg/css-grid/#grid-placement-errors
if (r.second <= r.first) {
r.second = r.first + 1;
}
return LineRange(r.first, r.second);
}
nsGridContainerFrame::GridArea
nsGridContainerFrame::PlaceDefinite(nsIFrame* aChild,
const nsStylePosition* aStyle)
{
const nsStylePosition* itemStyle = aChild->StylePosition();
return GridArea(
ResolveLineRange(itemStyle->mGridColumnStart, itemStyle->mGridColumnEnd,
aStyle->mGridTemplateColumns.mLineNameLists,
&GridNamedArea::mColumnStart, &GridNamedArea::mColumnEnd,
mExplicitGridColEnd, aStyle),
ResolveLineRange(itemStyle->mGridRowStart, itemStyle->mGridRowEnd,
aStyle->mGridTemplateRows.mLineNameLists,
&GridNamedArea::mRowStart, &GridNamedArea::mRowEnd,
mExplicitGridRowEnd, aStyle));
}
void
nsGridContainerFrame::InitializeGridBounds(const nsStylePosition* aStyle)
{
// http://dev.w3.org/csswg/css-grid/#grid-definition
uint32_t colEnd = aStyle->mGridTemplateColumns.mLineNameLists.Length();
uint32_t rowEnd = aStyle->mGridTemplateRows.mLineNameLists.Length();
auto areas = aStyle->mGridTemplateAreas.get();
mExplicitGridColEnd = std::max(colEnd, areas ? areas->mNColumns + 1 : 1);
mExplicitGridRowEnd = std::max(rowEnd, areas ? areas->NRows() + 1 : 1);
mGridColEnd = mExplicitGridColEnd;
mGridRowEnd = mExplicitGridRowEnd;
}
void
nsGridContainerFrame::PlaceGridItems(const nsStylePosition* aStyle)
{
InitializeGridBounds(aStyle);
// http://dev.w3.org/csswg/css-grid/#auto-placement-algo
// Step 1, place definite positions.
for (nsFrameList::Enumerator e(PrincipalChildList()); !e.AtEnd(); e.Next()) {
nsIFrame* child = e.get();
PlaceDefinite(child, aStyle);
}
}
void
nsGridContainerFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
@@ -148,6 +473,7 @@ nsGridContainerFrame::Reflow(nsPresContext* aPresContext,
const nsStylePosition* stylePos = aReflowState.mStylePosition;
InitImplicitNamedAreas(stylePos);
PlaceGridItems(stylePos);
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);