Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

[css-grid-2] Masonry layout #4650

Open
MatsPalmgren opened this issue Jan 6, 2020 · 22 comments
Open

[css-grid-2] Masonry layout #4650

MatsPalmgren opened this issue Jan 6, 2020 · 22 comments

Comments

@MatsPalmgren
Copy link

@MatsPalmgren MatsPalmgren commented Jan 6, 2020

Overview

This is a proposal to extend CSS Grid to support masonry layout in one of the axes while doing normal grid layout in the other. I'll use grid-template-rows/columns: masonryto specify the masonry-axis in the examples (and I'll call the other axis the grid-axis). Here's a simple example:

<style>
.grid {
  display: inline-grid;
  grid: masonry / 50px 100px auto;
  grid-auto-columns: 200px;
  grid-gap: 10px;
  border: 1px solid;
}
item { background: silver; }
</style>

<div class="grid">
  <item style="border:10px solid">1</item>
  <item>2</item>
  <item>3</item>
  <item style="height:50px">4</item>
  <item>5</item>
  <item>6</item>
</div>

Result:
image

The grid-axis behaves pretty much the same as in a normal grid container. Line names and track sizes can be specified and items can be placed and span multiple tracks using grid-column/row. CSS Box Alignment works normally etc. In the masonry-axis, items are placed into the grid-axis track(s) with the most space (typically) after the margin-box of the last item in those tracks.

Line name resolution and grid item placement

Grid items are formed and blockified the same as in a normal grid container. Line name resolution works the same as if masonry were replaced with none, i.e. names resolve in both axes. Grid item placement is done normally as well, although most of this result is discarded. Any items that were placed in the first hypothetical "track" in the masonry-axis keep their placement. Other items that have a definite position in the grid-axis keep that. Other placement results are ignored. These items will instead be placed according to the Masonry layout algorithm. (This implies that items can only be placed into the same grid area in this first hypothetical "track"). The flow axis specified by grid-auto-flow is ignored - items are always placed by filling the grid-axis. direction:rtl works as usual (reverses the grid) if the grid-axis is the inline-axis.

Containing block

The containing block for a grid item is formed by the grid area in the grid-axis and the grid container's content-box in the masonry-axis. Self-alignment works normally in the grid-axis, but is ignored in the masonry-axis. Margins do not collapse in either axis.

Track sizing

The Track Sizing Algorithm works as usual in the grid-axis, except only the subset of items with a definite placement in the grid-axis contribute to the intrinsic sizing. This makes the first (implicit grid) "track" in the masonry-axis special since those items always contribute to the intrinsic sizing. auto-placed items which don't end up in the first track don't contribute (since which track they end up in depends on layout results). The min/max-content size of a grid container in the masonry-axis is the largest distance between the item margin-edges in each of the tracks in the grid-axis, when sized under a min/max-content constraint.

Grid container alignment and gutters

Alignment etc works normally in the grid-axis. Gutters are supported in both axes. In the masonry-axis the relevant gap is applied between each item. Content alignment (align/justify-content) in the masonry-axis is applied "to the content as a whole". More specifically, the alignment subject is the "masonry box", which has the extent from the content box edge of the grid container to the margin-box end edge of the item that is the furthest away, as indicated by the dashed border here:
image
(Item "1" has a 5px bottom margin here.)
Note that there is only ever one alignment subject for these properties in the masonry axis, so the unique alignments boil down to start, center, end and stretch. (normal behaves as stretch as usual for grid containers). The above image shows the alignment subject with align-content:start. By default the masonry box is the same as the content box due to being stretched. This doesn't affect the items' alignment within the masonry box in any way though (which is what I meant by "to the content as a whole"). So I've added two properties to allow authors to align the items within the masonry box: align/justify-tracks which have the same values as the corresponding -content property. Here's a screenshot showing a few alignment possibilities:
image
(Here's the testcase for that.)
There's one difference for these new properties though: normal behaves as start. So if all these properties have their initial values, the rendering is the expected "packed" masonry layout as shown in the top left corner above.

align/justify-tracks:stretch

align/justify-tracks:stretch can be used to fill the tracks in the masonry axis by stretching items individually. Items can opt out from stretching process by setting align/justify-self to something other than normal/stretch in the relevant axis. Items that have either a definite size or an auto margin in the masonry axis are excluded from this stretching. An item only grows up to its max-size. auto margins can be used to align the item inside its new larger space instead of changing its size. I made a testcase and a video to illustrate. Only the purple items have height:auto, so they are the ones that may grow by default. A few items worth noting: item 4 has max-height:40px so it only grows up to that size and then the other items in its track picks up the remaining size. Item 16 opts out from resizing by setting align-self:end. Item 18 has margin-top/bottom:auto so it's centered in its allotted space instead of growing. Item 20 has margin-top:auto so it's aligned to the end. (Here's the corresponding testcase with a masonry inline-axis instead, with video.) It should be noted that this is an alignment step only - all items keep their pre-alignment track placement.

Baselines

Item baseline alignment inside the tracks in the grid-axis works as usual, as defined in Grid and Box Alignment specs, and the grid container's baseline is determined the same as for a regular grid in that axis.

TBD: Would it be possible to support item baseline alignment in the masonry axis for some items? Perhaps items adjacent to the masonry box start/end edge could be baseline-aligned? What's the grid container's first/last baseline in this axis? ISSUE: investigate baselines

Masonry layout algorithm

Items are placed in order-modifed document order but items with a definite placement are placed before items with an indefinite position (as for a normal grid). For each of the tracks in the grid-axis, keep a running position initialized to zero. For each item that has an indefinite placement:

  1. starting at line 1...
  2. find the largest running position of the tracks that the item spans at this position, call it min_pos
  3. increment the line and repeat step 2 until the item would no longer fit inside the grid
  4. pick the line number that resulted in the smallest min_posas the definite placement

Calculate the size of the containing block and flow the item. Then calculate its resulting margin-box size in the masonry-axis. Set the running position of the tracks the item spans to min_pos + margin-box + grid-gap.

There are a few variations of this algorithm that might be useful to authors. First, the "definite items first" might be useful to skip in some cases, so that a plain order-modifed document order is used instead. Also, opting out from the packing behavior described above and instead placing each item in order (a couple of existing masonry JS packages provides this option). So, perhaps something like this: masonry-auto-flow: [ definite-first | ordered ] || [ pack | next ]. Example:

<style>
.grid {
  display: inline-grid;
  grid: 50px 100px auto / masonry;
  border: 1px solid;
  masonry-auto-flow: next;
}

.grid > * {
  margin: 5px;
  background: silver;
}
.grid > :nth-child(2n) {
  background: pink;
  width: 70px;
}
</style>

<div class="grid">
  <item>1</item>
  <item style="height: 50px">2</item>
  <item>3</item>
  <item style="order: -1">4</item>
  <item>5</item>
  <item>6</item>
  <item>7</item>
</div>

Result:
image

(Without masonry-auto-flow: next, 1,3,5,6 are placed in the middle row.)

Fragmentation

Fragmentation in the masonry-axis is supported. Each grid-axis track is fragmented independently. If an item is fragmented, or has a forced break before/after it, then the running position for the tracks that it spans in the grid-axis are set to the size of the fragmentainer so that no further items will be placed in those tracks. Placement continues until all items are placed or pushed.

Subgrid

Masonry layout is supported also in subgrids (e.g. grid: subgrid / masonry). However, only a parent grid-axis can be subgridded. A subgrid axis with a parent masonry-axis will behave as masonry, unless the subgrid's other axis is also masonry in which case it behaves as none. (A grid container can only have one masonry-axis). auto-placed subgrids don't inherit any line names from their parent grid, but are aligned to the parent's tracks as usual. Here's a subgrid example:

<style>
.grid {
  display: inline-grid;
  grid: auto auto 100px / masonry;
  align-content: center;
  height: 300px;
  border: 1px solid;
}

.grid > * {
  margin: 5px;
  background: silver;
}
.grid > :nth-child(2n) {
  background: pink;
}

.grid subgrid {
  display: grid;
  grid: subgrid / subgrid;
  grid-row: 2 / span 2;
  grid-gap: 30px;
}
.grid subgrid > * { background: cyan; }
</style>

<div class="grid">
  <item>1</item>
  <item>2</item>
  <item>3</item>
  <subgrid>
    <item style="height:100px">subgrid.1</item>
    <item>sub.2</item>
    <item>s.3</item>
  </subgrid>
  <item>4</item>
  <item>5</item>
  <item style="width: 80px">6</item>
  <item>7</item>
</div>

Result:
image

Note how the subgrid's first item ("subgrid.1") contributes to the intrinsic size of the 2nd row in the parent grid. This is possible since the subgrid specified a definite placement so we know which tracks it will occupy. Note also that it's subgridding the masonry-axis of the parent which falls back to masonry layout in the inline-axis for the subgrid.

Absolute Positioning

Grid-aligned absolute positioned children are supported. The containing block is the grid-area in the grid-axis and the grid container padding edges in the masonry-axis, except for line 1 in the masonry-axis which corresponds to the start of the "grid" (the content-box start edge usually). It might be useful to define a static position in the masonry-axis though, given that we only have a one line in that axis to align to. Maybe it could defined as the max (or min?) current running position of the grid-axis tracks at that point?

repeat(auto-fit)

I don't see a way to support repeat(auto-fit) since auto-placed items depend on the layout size of its siblings. Removing empty tracks after layout wouldn't be possible in most cases since it might affect any intrinsic track sizes. Even if all track sizes are definite the containing block size could change for grid-aligned abs.pos. descendants. So repeat(auto-fit) behaves as repeat(auto-fill) when the other axis is a masonry-axis.

Performance notes

In general, masonry layout should have significantly better performance than the equivalent (2-axis) grid layout, particularly when the masonry-axis is the block-axis since the intrinsic sizing of grid rows is typically quite expensive. Any intrinsic track sizing in the grid-axis should be cheaper too, because, typically, only a subset of items contribute to the intrinsic sizing in a masonry layout, contrary to a 2-axis grid where all items spanning the intrinsic track contributes. That said, justify/align-tracks:stretch specifically adds a cost proportionate to the number of items that are resized. (Note that stretch isn't the default value for these properties though.) Stretched items do a second layout (size reflow) with the new size (when it actually changed) so this can be costly if there are a huge amount of stretched items that each contains a lot of content. Especially nested stretched masonry layouts should be avoided unless they are small/trivial. This can be ameliorated by the author by opting out from the stretching on most items though, e.g. specifying justify/align-items:start and then opting in for just a few items with justify/align-self:stretch to let those items fill the masonry axis. Other justify/align-tracks values such as center, endand <content-distribution> (other than stretch) shouldn't be a problem though since they just reposition the items which is fast. (This performance analysis is from a Gecko perspective, but I suspect there's some truth to it for other engines as well.)

Graceful degradation

A Masonry design should degrade quite nicely in an UA that supports Grid layout but not Masonry layout if the grid/grid-template shorthands are avoided and the longhands are used instead. e.g.

  grid-template-rows: masonry; /* ignored by UAs that don't support it */
  grid-template-columns: 150px 100px 50px;

Here's a testcase to demonstrate. It gives you a three-column grid layout, but with "more gaps" than if the UA supported masonry. (A video of the masonry layout for comparison.)

@tabatkins

This comment has been minimized.

Copy link
Member

@tabatkins tabatkins commented Jan 7, 2020

I'm liking this quite a bit!

Just to be clear, the masonry axis has no explicit tracks, right? Everything's effectively placed into implicit tracks?

I'm not sure I understand from this description how auto-placed items interact with definite-placement items. In your first example, what would happen if item 4 said "grid-column: 2;"? What about item 2 or 6? Do they just get placed after all the masonry-placed items, which are presumably all in the first implicit column?

For repeat(auto-fit), is there really a case that would differ here? An empty track would be at minimum run, right, so the only way it could possibly be empty is if there just aren't enough elements in the grid to reach that track; there's no dependence on the layout size of the elements. Am I missing an interaction here?

@MatsPalmgren

This comment has been minimized.

Copy link
Author

@MatsPalmgren MatsPalmgren commented Jan 8, 2020

Just to be clear, the masonry axis has no explicit tracks, right? Everything's effectively placed into implicit tracks?

Right, the line name resolution + "hypothetical grid-placement" steps are done as if masonry were none. Note that this grid is an illusion though, there are no tracks in the masonry axis. The purpose of the grid-placement step is to resolve (some) auto-positioned items into definite tracks in the grid-axis for the intrinsic track sizing step. Only items placed into the hypothetical first implicit track keep their resolved auto-position, other auto-placed items don't. The subset of items with a definite position in the grid-axis goes into the track sizing step and contributes to the intrinsic sizing. So for example:

<style>
.grid {
  display: inline-grid;
  grid: masonry / auto;
}
x { background: silver; }
y { background: lime; width:100px; grid-row: 1; }
</style>
<div class="grid">
  <x>x</x>
  <y>y</y>
</div>

This makes the column size 100px. Removing grid-row: 1 makes is the size of "x" and the y element overflows.

Currently, I'm also handling the items that are were placed at first implicit line specially in the masonry layout step. They are sorted before other items and they all start at position zero. This has two effects, a) you can make these items in this first hypothetical track intentionally overlap. E.g., using grid-area: 1/1 above and adding more <y> items would make them all overlap. This may not seem very useful at first glance, but it's actually quite useful in creating a stacked tab-panel type of layout where you want the size to be the maximum of the children. (<x> would then follow after the largest <y>). And b) it moves the <y> element to the start, which seems like the least surprising layout.

I'm not sure I understand from this description how auto-placed items interact with definite-placement items.

Items with an auto-placement in the grid-axis gain a definite placement only if they end up in the first hypothetical track in the masonry axis. Otherwise, they are still considered auto-placed and will not contribute to track sizing. There's a sorting step before masonry layout starts. The masonry-auto-flow: [ definite-first | ordered ] controls if items with a non-auto grid-axis placement should be placed first or not (the actual line number isn't considered just if it's auto or non-auto, the set is already sorted in order-modifed document order to begin with and this is a stable sort).

In your first example, what would happen if item 4 said "grid-column: 2;"? What about item 2 or 6?

No change. No change. With grid-column: 2 on item 6:

image

In the above: items 1,2,3 are attached the first implicit line in the masonry axis, so they are placed first. Then item 6, because it has a definite placement in the grid-axis. Then 4 and 5 since the are auto-placed in the grid-axis. Items 1,2,3 and 6 have a definite grid-axis placement when masonry layout starts so we simply position them in the requested column at the minimum position possible for its span extent.
That's the behavior with masonry-auto-flow: definite-first which is the default. With masonry-auto-flow: ordered you get:
image

Do they just get placed after all the masonry-placed items, which are presumably all in the first implicit column?

Yes, all items with definite placement first, then auto-placed. The auto-placed items don't really have a column yet. It's resolved by the masonry layout step while honoring the masonry-auto-flow: [ pack | next ] preference for the positioning.

So, perhaps it's confusing to use the term track at all in the masonry axis since there really aren't any tracks there. It's a continuous layout. I think it's still useful to have a "first implicit line" there though. It's convenient for intrinsic sizing purposes with auto-placed items, and it allows overlapping items at this line.

It's also useful to have a line at the start/end of the items in the masonry axis for abs.pos. items to align to, although I'll punt on the exact details of that for a bit. (Currently, I'm resolving grid-row:auto/1 from the padding edge to the start of the first implicit line, and N > 1 to the last implicit line.)
Example:

<style>
.grid {
  display: inline-grid;
  grid: masonry / 100px;
  padding: 40px;
  position: relative;
  border: 1px solid;
}
a {
  position:absolute;
  inset: 10px;
  border: 3px dashed red;
}
y { background: lightgrey; }
</style>
<div class="grid">
  <y>y</y><y>y</y><y>y</y>
  <a></a>
  <a style="grid-row-end: 1; border-color: blue"></a>
  <a style="grid-row-start: 2; border-color: black"></a>
</div>

Result:
image

For repeat(auto-fit), is there really a case that would differ here? An empty track would be at minimum run, right

Correct.

so the only way it could possibly be empty is if there just aren't enough elements in the grid to reach that track; there's no dependence on the layout size of the elements.

Consider:

<style>
.grid {
  display: inline-grid;
  grid: masonry / repeat(auto-fit, 100px);
  width: 300px;
  border: 1px solid;
}
x { background: silver; }
</style>
<div class="grid">
  <x>1</x>
  <x>2</x>
  <x style="grid-column:span 2">3</x>
</div>

Item 1 and 2 have equal height so masonry layout places item 3 in column 1 (it doesn't fit in column 3 since it has span 2 and the grid only has 3 columns). With <x style="height: 4em">1</x> though, the desired result is that item 3 is placed in column 2. We don't know until after we have flowed and placed all items preceding item 3 whether it's the former or latter case.

@MatsPalmgren

This comment has been minimized.

Copy link
Author

@MatsPalmgren MatsPalmgren commented Jan 9, 2020

I've made a demo of a couple of fragmentation tests.
A grid with masonry layout in the inline-axis, fragments like this.
A grid with masonry layout in the block-axis, fragments like this.
I made the items that are fragmented keep its fragments in the same grid-axis track (so they should line up in paged media), whereas items that are pushed (break before due to break-inside:avoid) are masonry-placed in the next container fragment. Does this make sense? Or should we perhaps freeze the first pushed item (for each track) to the track it came from and just place the rest?

@MatsPalmgren

This comment has been minimized.

Copy link
Author

@MatsPalmgren MatsPalmgren commented Jan 9, 2020

Robert Utasi suggested that alignment in the masonry-axis per grid-axis track could be useful too.
I said above that "Alignment in the masonry-axis is applied to the content as a whole (same as for a block container in the block-axis).", but perhaps doing it per track is actually a better default. I can see both being useful though.

@MatsPalmgren

This comment has been minimized.

Copy link
Author

@MatsPalmgren MatsPalmgren commented Jan 9, 2020

A problem with doing the alignment per axis is that if there are items that span 2 or more grid-axis tracks then it's very likely that we'll make items overlap each other. It should work fine when all items are non-spanning though, which I guess is quite common in practice. Still, I think the align-per-axis feature should probably be opt-in to avoid that footgun. So we need an extension to css-align like justify/align-content: ... || per-track or something. A few examples to illustrate (grid container's content area is grey, the masonry axis is the block axis):
image

image

image

Alternatively, a new property to control the track- and content-area alignment independently instead of the more limited per-tracks keyword:
image

@heycam heycam added the Agenda+ F2F label Jan 9, 2020
@MatsPalmgren

This comment has been minimized.

Copy link
Author

@MatsPalmgren MatsPalmgren commented Jan 10, 2020

I think having separate properties for alignment within the tracks in the masonry axis is the way to go. It gives authors very good control over the final layout. I've updated the original description above with the details.

@MatsPalmgren

This comment has been minimized.

Copy link
Author

@MatsPalmgren MatsPalmgren commented Jan 14, 2020

I've updated the proposal above with align/justify-tracks:stretch that can be used to fill tracks in the masonry axis by stretching items.

@MatsPalmgren

This comment has been minimized.

Copy link
Author

@MatsPalmgren MatsPalmgren commented Jan 14, 2020

I've updated the proposal above with some notes on performance and graceful degradation.

@argyleink

This comment has been minimized.

Copy link
Contributor

@argyleink argyleink commented Jan 21, 2020

I love that this is getting attacked from a proposal perspective! Thanks so much for spinning this up and putting so much great thought into it 👍

I have a question around whether or not masonry fits better into a flexbox mentality than grid. To me, grid creates rows and columns, and it does so by drawing lines and fitting cells into those lines (this isnt an exact definition but I believe they are tenants). Where flex allows for more intrinsic layouts that have no lines, but does have an axis. Masonry is a combo of both in most cases, where columns are desired (so vertical lines) but no horizontal lines, as all items can have their own intrinsic height.

Screen Shot 2020-01-21 at 10 04 25 AM

In this above Pinterest masonry layout (arguably the most famous and shining example of why/when this is effective Ui/UX) there are no visible row lines, and I believe if you added them it would move the layout more towards "packery" than masonry. Grid can already make great "dense" packery type layouts, where row/column lines are super useful. While flexbox and css columns can do types of packery (example 2) and masonry (example 1), they can't properly layout as you've shown, 1, 2, 3 children are the first in the columns.

TLDR; masonry shares more with flexbox than grid in my opinion I'm curious if this assertion can help shape this proposal? also, maybe a new display type would be better, since I feel like masonry has hybrid properties of grid and flex. save us from overloading grid or flex by putting the uniqueness into a new display type?

Those are my thoughts, hope they're helpful!

Example #1:
flex masonry by setting container height
Screen Shot 2020-01-21 at 10 15 57 AM

Example #2:
flex packery by setting container height
Screen Shot 2020-01-21 at 10 16 07 AM

Example #3:
css columns masonry
Screen Shot 2020-01-21 at 10 17 08 AM

Notice how not 1 demo has a shared row line anywhere. I believe this to be the defining feature of masonry and I believe it conflicts with putting masonry into css grid. thoughts!? thanks for letting me vent the thought stream.

@meyerweb

This comment has been minimized.

Copy link

@meyerweb meyerweb commented Jan 22, 2020

I’m with @argyleink: I find it weird that the resulting layout is not a grid but is still invoked using display: grid. All the layouts remind me a lot more of Flexbox than Grid.

@MatsPalmgren

This comment has been minimized.

Copy link
Author

@MatsPalmgren MatsPalmgren commented Jan 22, 2020

@argyleink argyleink

Notice how not 1 demo has a shared row line anywhere. I believe this to be the defining feature of masonry and I believe it conflicts with putting masonry into css grid.

The proposal here is to define a "one-dimensional grid", so that you have tracks in just one axis and a continuous flow (stacking blocks one after another) in the other. So indeed, there are no "shared row lines" anywhere in the masonry axis (except at the start edge perhaps). It seems to me this is precisely what masonry layout is about, one axis has grid-like properties (tracks), while the other axis has a continuous flow (in each track separately).

I considered using flexbox instead, but I came to the conclusion that Grid is the ideal fit since all the complicated stuff is in the grid-axis and we get that for free with Grid. The layout in the masonry axis is trivial in comparison. As I see it, re-using well-known concepts from Grid is a benefit to everyone: spec authors can re-use large parts of the Grid (and Box Alignment) specs (blockification of items, item placement/spans, grid lines, track sizing, content/self-alignment etc (in the grid-axis)); implementors can cheaply implement this by re-using large parts of their CSS Grid implementation; and authors can re-use their existing knowledge about grid layout and their CSS properties.

@meyerweb using display: grid and specifying masonry for each axis separately (akin to subgrid) is just a convenient way to re-use existing properties/values. I don't feel strongly about what specific syntax we use though, except that the grid-axis should use existing Grid properties/values.

@MatsPalmgren

This comment has been minimized.

Copy link
Author

@MatsPalmgren MatsPalmgren commented Jan 22, 2020

@argyleink btw, the Pinterest masonry layout you showed above is pretty trivial to specify using this proposal:

.masonry-container {
  display: grid;
  grid: masonry / repeat(auto-fill, 150px);
  gap: 10px;
}

Or some such. Another thing that is somewhat common on the web is to span an item over one or more columns. Again, you get this for free with this proposal: just add grid-column:span 2 or whatever on the specific item.

@AmeliaBR

This comment has been minimized.

Copy link
Contributor

@AmeliaBR AmeliaBR commented Jan 22, 2020

While I like many aspects of the proposal, I tend to prefer a display: masonry layout mode that re-uses many of the grid/alignment properties instead of display: grid with masonry as a column/row template.

The reason: there are lots of weird edge cases and interactions in grid layout. Sizing rules have been exhaustively defined, but will still need to be refined every time new features are added (e.g., subgrid). Adding an extra mode where sometimes the grid doesn't actually exist in one direction would likely change the best approach for some of these situations. Versus, with a separate display mode we can consider the rules & constraints that make the most sense, independent of the grid behavior.

Example: with masonry, which items get placed in which columns depends on the heights of previous items (for vertical masonry). And the height of text-container items often depends on the width. But the width of a grid column can depend on the contents of that column & now we have a new circular layout concern (maximizing a column width to fit around an item can make it so that item is no longer in that column) that didn't exist in regular grid layout.

@rachelandrew

This comment has been minimized.

Copy link
Contributor

@rachelandrew rachelandrew commented Jan 22, 2020

@AmeliaBR just commented with the same concern I was developing while reading this thread today. It seems like we create a lot of additional complexity by making grid do a non-grid thing.

Add to that the teaching issue, it's been tricky enough to explain one-dimensional vs. two-dimensional to authors, and encourage understanding of which layout method to use for which use case. I think that tying Masonry, which is more like flex than grid, to grid layout would be ultimately very confusing.

An argument against making this a new thing is that we don't want to have to create a new layout type for everything the world comes up with. This is a reasonable concern, however given that a lot of the stuff this relates to is not in the grid spec but instead in Box Alignment and Sizing, and these things would need to account for any differences in Masonry over grid anyway, would that be such a problem?

@SebastianZ

This comment has been minimized.

Copy link
Contributor

@SebastianZ SebastianZ commented Jan 22, 2020

I like @MatsPalmgren's approach to reuse the already established grid layout for that. Though I agree with @argyleink, @meyerweb, @AmeliaBR, and @rachelandrew, that masonry is rather something between flex and grid, which, while sharing logic with both of them, deserves its own display type and properties.

The approach of masonry is different than the one of grid, as its idea is to minimize the gaps between different pieces.

By making its layout be based on grid, we restrict both of them in their future extensibility. That doesn't mean that masonry shouldn't borrow concepts and algorithms of grid layout or flexbox, though. It is just not exactly one or the other.

Sebastian

@jensimmons

This comment has been minimized.

Copy link

@jensimmons jensimmons commented Jan 23, 2020

@argyleink I believe that if the desire result is what you drew in your first diagram, you can already do that today using Multicolumn.

masonry 002

The key with Masonry is the content order. The Masonry JS library can do both of these content orders:

The default order puts the next item in the order as close to the top as possible.
masonry 004

An alternative order (horizontalOrder: true) usually puts the next item in the next column, without regard to how close to the top the next slot is:
masonry 005

I believe Masonry-style layout belongs in Grid, because the algorithm is thinking about both the rows and columns, and autoplacing content with regards to both. Flexbox can be thought of as a long content snake, that wraps around and around... same with multicolumn. Masonry requires "jumping" from one column to another — there's no content snake. No long unbroken wrapping chain.

Making this part of Grid also gives Authors all the other powers of Grid — track sizing, names, etc.

@css-meeting-bot

This comment has been minimized.

Copy link
Member

@css-meeting-bot css-meeting-bot commented Jan 23, 2020

The CSS Working Group just discussed Masonry Layout, and agreed to the following:

  • RESOLVED: Adopt Masonry layout proposal, editors fantasai and Tab, Mats if he's convinceable, Jen Simmons if she's able
The full IRC log of that discussion <fantasai> Topic: Masonry Layout
<TabAtkins> github: https://github.com//issues/4650
<fantasai> jensimmons: Mats Palmgren, layout engineer at Mozilla, over Christmas break, this is what he did for Christmas present
<fantasai> jensimmons: He's thought in detail about what it would take to add something to Grid to accomplish Masonry layout
<fantasai> jensimmons: It's lots of detailed from implementer perspective
<fantasai> jensimmons: So what is Masonry layout?
<fantasai> jensimmons: It's a popular idea of how to lay out content on the Web, e.g. on Pintrest
<fantasai> jensimmons: People wanted to do it with Grid, but you can't really, still have to use JS
<fantasai> jensimmons: works fast on Pintrest because they put a lot of money and effort into it
<fantasai> jensimmons: others use this library
<fantasai> jensimmons: Here's what the layout looks like [shows outline]
<fantasai> jensimmons: Why not do it with flexbox? well that would give the wrong content order
<fantasai> jensimmons: Don't want the early things to be below the fold with late things up at top in the later columns
<fantasai> jensimmons: also makes a problem with lazy loading, would rejigger layout
<fantasai> jensimmons: Order ppl need is going across
<fantasai> jensimmons: This version of Masonry, the most common one, is that as it goes to fill in the rest of the pieces of content
<fantasai> jensimmons: puts next item into the column that is the shortest, so always closest to the top
<fantasai> jensimmons: Other option is to go from 1st column to last column always
<fantasai> jensimmons: but skip columns that are too full to keep things roughly in order
<fantasai> jensimmons: Mats believes he's figured out how to do it in Grid
<fantasai> jensimmons: That's the issue
<fantasai> jensimmons: I think it would be popular and ppl would be super happy to have
<fantasai> TabAtkins: Yes, this has been requested for like 15 years
<fantasai> TabAtkins: Overall, love the proposal, think it's great, lots of detail in it
<bkardell_> q+
<fantasai> TabAtkins: Only concern, making it part of Grid instead of its own display type
<rachelandrew> q+
<fantasai> TabAtkins: Think we should make it display: masonry, copy over concepts from Grid
<heycam> fantasai: any examples of things you're concerned about?
<emilio> q+
<heycam> fantasai: this is somewhat similar in that subgrid is also kind of like a mode
<heycam> ... which creates a different way of laying out items in the grid
<heycam> ... masonry is a different model for doing the rows
<fantasai> TabAtkins: Sugrid is fundamenally a grid still
<fantasai> TabAtkins: but Masonry is different
<fantasai> TabAtkins: Example, Mats suggests an align-tracks property that only applies to masonry
<heycam> fantasai: what's it do?
<fantasai> TabAtkins: it aligns the Masonry stuff within their track
<fantasai> TabAtkins: So there are a few different layout concepts
<fantasai> TabAtkins: that don't apply to Masonry in Grid
<fantasai> TabAtkins: and that don't apply to Grid in Masonry
<jensimmons> q+
<fantasai> TabAtkins: So I think we should re-use as many concepts as possible
<tantek> Is this orientation specific? I.e. presumably masonry refers to the overlapping brick like layout. Flickr does this for displaying photo results, e.g. https://flickr.com/photos/tags/csswg
<fantasai> TabAtkins: but separate out as a distinct display type
<fantasai> TabAtkins: that has a clear signal for what applies here vs in Grid
<fantasai> florian: For align-tracks property, if we did have different modes, could we use an existing alignment property to do this?
<heycam> fantasai: if I understand correctly, you have a box, then some masonry tracks
<heycam> ... each individual track aligning its content to the bottom
<heycam> ... rather than taking the entire masonry chunk and sliding it to the bottom
<heycam> ... isn't this exactly what justify-content does in flexbox? why not just reuse align-content?
<heycam> TabAtkins: only given an hour thought to this
<heycam> fantasai: I think it's premature to split it out, it's its own layout model, but which should think about that
<heycam> ... for now leaving it as part of grid makes sense until we have a clearer idea of what doesn't fit
<tantek> q?
<fantasai> Rossen__: Fan of this proposal
<fantasai> Rossen__: What are we trying to get out of this discussion?
<fantasai> heycam: Wanted to get temperature of the room, see if there's interest
<fantasai> heycam: and also get thoughts on integration
<fantasai> bkardell_: Of course I want this
<fantasai> bkardell_: Want to say same thing as Grid and Flexbox, we should stop and solve the a11y problem with content reordering
<fantasai> bkardell_: I have concerns about that, that's all
<fantasai> rachelandrew: I would really like to see Masonry solved
<fantasai> rachelandrew: I also agree we should look at content reordering proble
<iank_> q+
<fantasai> rachelandrew: Don't think it should be part of Grid
<astearns> ack bkardell_
<fantasai> rachelandrew: Trying to teach it, it's not a grid
<TabAtkins> I think this doesn't introduce any new content-reordering problems; it's definitely no worse than "a pile of floats", still according with the standard "left to right, top to bottom" ordering.
<astearns> ack rachelandrew
<TabAtkins> (Unless you use 'order', of course.)
<fantasai> rachelandrew: would make a lot more sense to have a separate layout model
<tantek> Is there no attempt to do baseline alignment across masonry items in different columns?
<tantek> That might be one reason to consider it grid-like
<Rossen__> ack emilio
<fantasai> emilio: I don't know if should be separate model
<fantasai> emilio: but multicol changes layout model quite a lot, this still mostly fits within grid layout paradigm
<fantasai> emilio: can share a lot of code
<fantasai> emilio: so not quite like multicol
<Rossen__> ack jensimmons
<fantasai> jensimmons: I think these are great issues to bring up
<fantasai> jensimmons: taking of introducer hat
<fantasai> jensimmons: this is jen
<fantasai> jensimmons: I was also concerned about a11y order
<astearns> tantek: I doubt it would be feasible to to baseline alignment when there are not grid lines in the block direction
<fantasai> jensimmons: but aftter explaining, I think it's less of a problem than Grid
<fantasai> jensimmons: It does seem like ppl are tabbing through DOM order, focus rings
<fantasai> jensimmons: Easier because content doesn't go below the fold
<fantasai> jensimmons: I do feel like this belongs as grid
<fantasai> jensimmons: there are 2 axes, and this only works in one axis
<fantasai> jensimmons: do this in row directly, have all power of grid in column direction
<fantasai> jensimmons: Things when it comes to subgrid and nesting a grid inside a grid, might want things to interact
<tantek> would https://flickr.com/photos/tags/csswg be an example of doing it in the "row direction"?
<fantasai> jensimmons: things interact
<Rossen__> q?
<fantasai> jensimmons: Just choose how you want to treat other axis
<fantasai> jensimmons: ...
<fantasai> iank_: I'll try and channel Adam Argyle
<fantasai> iank_: He previously worked in industry and built lots and lots of Masonry layouts
<TabAtkins> Ah, I remember why *-content can't work for distributing the items in a masonry track!
<fantasai> iank_: he had similar reaction that might fit better as a separate layout model
<Rossen__> ack iank_
<Rossen__> ack dbaron
<Zakim> dbaron, you wanted to ask about which grid properties apply sensibly given the placement algorithm
<fantasai> dbaron: Jen was talking about, and think this might relate to Tab's comment on IRC, applying grid properties in vertical axis in masonry
<fantasai> dbaron: One thing I was wondering is how many interact with placement concept of Masonry
<fantasai> dbaron: e.g. if you have align-content in the vertical axis
<fantasai> dbaron: space-around, you want even gaps
<fantasai> dbaron: you don't know how many items until you place them
<hober> q+ myles
<fantasai> dbaron: and you can't place them until you know the number of gaps in each column above the item
<fantasai> TabAtkins: Mats answered it by saying you place items before applying align-content
<astearns> tantek: I don't think the flickr thing is masonry-row. The content order would go top to bottom in that case, and it looks to me like the first three pictures in the first row are in content order
<heycam> TabAtkins: align-content is a different thing, it moves the whole grid
<heycam> ... repeat autofill doesn't work
<fantasai> TabAtkins: But back to fantasai's point about align-content, in Grid it aligns the entire grid
<fantasai> florian: If you have a grid with sized tracks in the Block axis, and the size of the tracks is smaller than the container, then you can align
<fantasai> florian: but masonry tracks don't have such a size
<tantek> astearns, I have heard what Flickr does called "masonry" layout as well so that likely deserves some clarification
<tantek> in particular, the feature of resizing images to fit like that
<fantasai> TabAtkins: Track does have a size, it's the sum of all masonry items in it
<astearns> q+ to surface my side convo with tantek
<fantasai> myles: Want to jump on bandwagon and say it's really exciting
<fantasai> myles: wrt new display type, I think Mats makes a compelling argument wrt graceful degradation
<fantasai> fremy: you can just say `display: grid; display: masonry` which works
<Rossen__> ack myles
<fantasai> TabAtkins: Especially if we re-use grid-template-columns or whatever, it's easy fallback
<fantasai> astearns: Side conversation with Tantek on IRC
<fantasai> astearns: Has example of Flickr, wants to ask if that's also Masonry layout
<tantek> specifically with the resizing of items in the masonry layout
<tantek> yes dbaron
<fantasai> Rossen__: This is a multiline flex
<astearns> ack astearns
<Zakim> astearns, you wanted to surface my side convo with tantek
<fantasai> jensimmons: Flickr decides how many photos to put in a row
<fantasai> jensimmons: then makes the outer edges to match the container
<tantek> it's not just flex. it's about resizing the images automatically to fit them in the row
<fantasai> jensimmons: then changes the height of the row to match
<fantasai> jensimmons: it's weird and complicated and totally done in JS
<fantasai> dbaron: each image is sized based on other photos in the row
<tantek> anyway the point is due to the brick-like layout, this is *also* called masonry
<fantasai> jensimmons: If you [...] then you get basically that layout, but the images are cropped by object-fit
<fantasai> jensimmons: they use JS to avoid cropping the images
<fantasai> jensimmons: and Masonry is a whole different layout
<tantek> having the row heights adjust automatically is key
<tantek> I'm saying that web developers (some at least) know this as masonry as well
<tantek> so if you call something masonry, some may/will expect this to be supported
<fantasai> Rossen__: In summary, I'm hearing a lot of support for this proposal
<fantasai> Rossen__: reminds me of early days of Grid, when we proposed something
<fantasai> Rossen__: and 2nd model was proposed to add to it, at first seemed unlikely to fit
<fantasai> Rossen__: but ended up with a harmonious merge
<fantasai> Rossen__: Let's get something in a more spec-like proposal
<fantasai> Rossen__: then decide if it should fit into Grid, or should be its own thing
<jensimmons> The demo I was just talking about: https://labs.jensimmons.com/2016/examples/image-gallery-flexbox-1.html It only works in FIrefox because of the flexbox sizing bug of images in Chrome, Edge & Safari.
<fantasai> Rossen__: Are there parts that should be extensions to Grid?
<fantasai> Rossen__: I think it will take some time to figure out
<fantasai> Rossen__: but overall goal of proposal and exposure of topic is achieved in sense that there's a lot of support and demand for this, so let's continue working on this in a separate module for now to bake out the details and decide the next path forward
<fantasai> Rossen__: might be Grid, might be something else
<fantasai> Rossen__: sound good?
<fantasai> fantasai: +1
<tantek> +1
<bkardell_> ... and to double down on solving the general reordering issue?
<fantasai> Rossen__: So I propose we take a resolution to adopt Masonry layout and move from there.
<fantasai> fantasai: Who's editing
<fantasai> TabAtkins: I'll co-edit, but not primary edit
<fantasai> Rossen__: Mats?
<fantasai> dbaron: We might have to do some convincing
<fantasai> fantasai: I can edit.
<fantasai> RESOLVED: Adopt Masonry layout proposal, editors fantasai and Tab, and Mats if he's convinceable
<fantasai> bkardell_: Masonry isn't in content order
<dbaron> and Jen?
<fantasai> florian: yes and no, it's not a 1D thing, they're in 2D space
<fantasai> florian: but within that space they're in content order
<astearns> they are always top to bottom, not necessarily left to right
<fantasai> s/convinceable/convinceable, and Jen if she's allows/
<fantasai> ?
<bkardell_> for the record, not pushing back on 'this' - worried about the general space
@ramiy

This comment has been minimized.

Copy link

@ramiy ramiy commented Jan 23, 2020

Masonry layout can be implemented not only using the grid system (display: grid), but also using multiple-column layout (columns: 4) we just need to add support for the order/direction type (mentioned by @jensimmons).

Columns

The mechanism is there:

  • columns
  • column-count
  • column-fill
  • column-rule
  • column-span
  • column-width

We just need to add a new property:

  • column-order or column-direction

Column Direction

Inline

Inline behavior column-direction: inline (the default value), will position the next item in the same column:

masonry 002

Block

Block behavior column-direction: block, will position the next item in the next column:

masonry 005

Masonry

Masonry behavior column-direction: masonry, will position the next item as close to the top as possible, in any available column.

masonry 004

Orientation

I was also thinking to use the writing mode property to display vertically masonry and horizontally masonry.

@mrego

This comment has been minimized.

Copy link
Member

@mrego mrego commented Jan 23, 2020

It'd be nice to think how many of the grid layout stuff is needed or not for masonry layout. Basically thinking from an author perspective.

  • Do we need to set sizes for the columns? Do we need those sizes depend on the content (that might be very tricky as you never know when an item is going to end up?
    For example, if I got the initial proposal properly, if we have grid-template-columns: max-content 500px; and then we have 3 auto placed pictures, first picture will go to the first row and first column and will define the size of that column. But maybe picture 3 is bigger so it's going to overflow (still when we're setting max-content on the column) which would be hard to understand I guess.
  • Do we need to be able to position an item into a particular column? Or to span columns?
    If we allow people to set something like grid-column: 2; in a particular picture. Maybe there'll be confusion that something like grid-column: 2; grid-row: 3; (whatever that could mean on author's) maybe they want to refer to the 3rd position on the 2nd column, but it won't do anything regarding the row information.

Probably there could be more questions about grid layout features that might be useful or not for masonry layout.

@MatsPalmgren

This comment has been minimized.

Copy link
Author

@MatsPalmgren MatsPalmgren commented Jan 25, 2020

From the CSSWG discussion:

<tantek> Is there no attempt to do baseline alignment across masonry items in different columns?

It might be possible to implement baseline alignment for the set of items that we can determine will be at the starting edge without doing any layout. In theory, there might be a case for baseline alignment of items at the end edge (for align-tracks:end), but this is harder since we don't know which those items are without doing layout. Baseline alignment for other items (that aren't adjacent to the start/end edge) seems pointless since there's no obvious criteria for which items would belong to the same baseline-sharing group like there is in a regular Grid (same track).
Is this limited baseline alignment a feature that authors would find useful?

I haven't really thought much about baselines in general so far though... I'll add a Baselines section to the proposal above and look into it... Thanks for bringing it up!

@MatsPalmgren

This comment has been minimized.

Copy link
Author

@MatsPalmgren MatsPalmgren commented Jan 25, 2020

@AmeliaBR

And the height of text-container items often depends on the width. But the width of a grid column can depend on the contents of that column & now we have a new circular layout concern (maximizing a column width to fit around an item can make it so that item is no longer in that column) that didn't exist in regular grid layout.

I'm afraid I don't see the problem your talking about. Grid has a separate track sizing step that runs before any children are flowed. The circularity in (regular) Grid comes from having tracks in both axis which means an item's size in one axis may influence intrinsic track sizes in the other axis. That problem does not exist when you remove the tracks in one axis, as we do here in the masonry-axis. Feel free to provide a testcase though, in case I'm misunderstanding the problem...

(In case you missed it: I'm only including the subset of items with a known placement in the grid-axis for the intrinsic track sizing step. This step runs before any children are flowed (same as in regular grid) and thus before auto-placed items are placed in the masonry case (which indeed depends on layout results), but those items don't contribute to intrinsic track sizing.)

@MatsPalmgren

This comment has been minimized.

Copy link
Author

@MatsPalmgren MatsPalmgren commented Jan 25, 2020

@mrego

Do we need to set sizes for the columns? Do we need those sizes depend on the content (that might be very tricky as you never know when an item is going to end up?

See above. Yes, there are examples that would overflow because some (larger) item weren't in the subset of items that contributed to intrinsic track sizing. I doubt this will be a problem in practice though, from looking at actual examples of masonry designs on the web. It's also worth noting that authors can influence which items are considered for the intrinsic sizing step by using order to place items at the start, or use definite placement (grid-column:1 on the third item in your example), or use the placement property in the other axis to force it into the "first row", e.g. grid-row:1. Granted, it's not perfect, but it's impossible to let auto-placed items (other than those in the "first row") influence track sizes since it leads to unsolvable circularity issues. Personally, I'd rather include intrinsic track sizing that will work fine for the majority of practical designs than exclude it and require only definite track sizes just because it doesn't work perfectly in all cases.

The crux of your testcase is: how do you know which column item 3 will be placed in? This depends on the height of item 1 and 2. If item 1 has a larger height than item 2, then item 3 goes in the 2nd column and shouldn't contribute to the intrinsic size of the first column.

Do we need to be able to position an item into a particular column? Or to span columns?

Spanning tracks is most definitely a required feature if we want to support the designs already in use on the web. Maybe placing items into specific columns isn't needed but we get it for free so I see no reason to intentionally remove it. It's a powerful feature and I'm pretty sure authors will find a use for. It also gives authors better control over intrinsic sizing contributions (as noted above) so that's also an argument for keeping it. I also think it makes the design easier to understand if we can say that the grid-axis works exactly the same as in regular Grid. (Granted though, the effects of the item placement properties in the masonry axis is a bit fuzzy. Hopefully this will be easier to understand once we have polished spec text for it.)

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Projects
None yet
You can’t perform that action at this time.