Specifying one Dimension of Cells in UICollectionView using Auto Layout

It sounds like what you are asking for is a way to use UICollectionView to produce a layout like UITableView. If that's really what you want, the right way to do this is with a custom UICollectionViewLayout subclass (maybe something like SBTableLayout).

On the other hand, if you're really asking if there is a clean way to do this with the default UICollectionViewFlowLayout, then I believe there is no way. Even with iOS8's self-sizing cells, it is not straightforward. The fundamental problem, as you say, is that the flow layout's machinery provides no way to fix one dimension and let another respond. (In addition, even if you could, there would be additional complexity around needing two layout passes to size the multi-line labels. This might not fit with how self-sizing cells want to compute all sizing via one call to systemLayoutSizeFittingSize.)

However, if you still want to create a tableview-like layout with a flow layout, with cells that determine their own size, and respond naturally to the collection view's width, of course it is possible. There is still the messy way. I have done it with a "sizing cell", i.e., a non-displayed UICollectionViewCell that the controller keeps only for calculating cell sizes.

There are two parts to this approach. The first part is for the collection view delegate to calculate the correct cell size, by taking in the collection view's width and using the sizing cell to calculate the cell's height.

In your UICollectionViewDelegateFlowLayout, you implement a method like this:

func collectionView(collectionView: UICollectionView,  layout collectionViewLayout: UICollectionViewLayout,  sizeForItemAtIndexPath indexPath: NSIndexPath) -> CGSize{  // NOTE: here is where we say we want cells to use the width of the collection view   let requiredWidth = collectionView.bounds.size.width   // NOTE: here is where we ask our sizing cell to compute what height it needs  let targetSize = CGSize(width: requiredWidth, height: 0)  /// NOTE: populate the sizing cell's contents so it can compute accurately  self.sizingCell.label.text = items[indexPath.row]  let adequateSize = self.sizingCell.preferredLayoutSizeFittingSize(targetSize)  return adequateSize}

This will cause the collection view to set the width of the cell based on the enclosing collection view, but then ask the sizing cell to calculate the height.

The second part is to get the sizing cell to use its own AL constraints to calculate the height. This can be harder than it should be, because of the way multi-line UILabel's effectively require a two-stage layout process. The work is done in the method preferredLayoutSizeFittingSize, which is like so:

 /* Computes the size the cell will need to be to fit within targetSize. targetSize should be used to pass in a width. the returned size will have the same width, and the height which is calculated by Auto Layout so that the contents of the cell (i.e., text in the label) can fit within that width. */ func preferredLayoutSizeFittingSize(targetSize:CGSize) -> CGSize {   // save original frame and preferredMaxLayoutWidth   let originalFrame = self.frame   let originalPreferredMaxLayoutWidth = self.label.preferredMaxLayoutWidth   // assert: targetSize.width has the required width of the cell   // step1: set the cell.frame to use that width   var frame = self.frame   frame.size = targetSize   self.frame = frame   // step2: layout the cell   self.setNeedsLayout()   self.layoutIfNeeded()   self.label.preferredMaxLayoutWidth = self.label.bounds.size.width   // assert: the label's bounds and preferredMaxLayoutWidth are set to the width required by the cell's width   // step3: compute how tall the cell needs to be   // this causes the cell to compute the height it needs, which it does by asking the    // label what height it needs to wrap within its current bounds (which we just set).   let computedSize = self.systemLayoutSizeFittingSize(UILayoutFittingCompressedSize)   // assert: computedSize has the needed height for the cell   // Apple: "Only consider the height for cells, because the contentView isn't anchored correctly sometimes."   let newSize = CGSize(width:targetSize.width,height:computedSize.height)   // restore old frame and preferredMaxLayoutWidth   self.frame = originalFrame   self.label.preferredMaxLayoutWidth = originalPreferredMaxLayoutWidth   return newSize }

(This code is adapted from the Apple sample code from the sample code of the WWDC2014 session on "Advanced Collection View".)

A couple points to notice. It's using layoutIfNeeded() to force layout of the entire cell, in order to compute and set the width of the label. But that's not enough. I believe you also need to set preferredMaxLayoutWidth so that the label will use that width with Auto Layout. And only then can you use systemLayoutSizeFittingSize in order to get the cell to compute its height while taking the label into account.

Do I like this approach? No!! It feels way too complex, and it does layout twice. But as long as performance doesn't become an issue, I'd rather perform layout twice at runtime than have to define it twice in code, which seems to be the only other alternative.

My hope is that eventually self-sizing cells will work differently and this will all get a lot simpler.

Example project showing it at work.

But why not just use self-sizing cells?

In theory, iOS8's new facilities for "self-sizing cells" should make this unnecessary. If you've defined a cell with Auto Layout (AL), then the collection view should be smart enough to let it size itself and lay itself out correctly. In practice, I haven't seen any examples that have gotten this to work with multi-line labels. I think this is partly because the self-sizing cell mechanism is still buggy.

But I'd bet it's mostly because of the usual trickiness of Auto Layout and labels, which is that UILabels require a basically two-step layout process. It's not clear to me how you can perform both steps with self-sizing cells.

And like I said, this is really a job for a different layout. It is part of flow layout's essence that it positions things that have a size, rather than fixes a width and lets them choose their height.

And what about preferredLayoutAttributesFittingAttributes: ?

The preferredLayoutAttributesFittingAttributes: method is a red herring, I think. That is only there to be used with the new self-sizing cell mechanism. So this isn't the answer as long as that mechanism is unreliable.

And what's up with systemlayoutSizeFittingSize:?

You're right the docs are confusing.

The docs on systemLayoutSizeFittingSize: and systemLayoutSizeFittingSize:withHorizontalFittingPriority:verticalFittingPriority: both suggest that you should only pass UILayoutFittingCompressedSize and UILayoutFittingExpandedSize as the targetSize. However, the method signature itself, the header comments, and the behavior of the functions indicate that they are responding to the exact value of the targetSize parameter.

In fact, if you set the UICollectionViewFlowLayoutDelegate.estimatedItemSize, in order to enable the new self-sizing cell mechanism, that value seems to get passed in as the targetSize. And UILabel.systemLayoutSizeFittingSize seems to return the exact same values as UILabel.sizeThatFits. This is suspicious, given that the argument to systemLayoutSizeFittingSize is supposed to be a rough target and the argument to sizeThatFits: is supposed to be a maximum circumscribing size.

More Resources

While it is sad to think that such a routine requirement should require "research resources", I think it does. Good examples and discussions are:

• http://www.objc.io/issue-3/advanced-auto-layout-toolbox.html
• http://devetc.org/code/2014/07/07/auto-layout-and-views-that-wrap.html
• code for WWDC2014 session 232, "Advanced User Interfaces with Collection Views"

There's a cleaner way to do this than some of the other answers here, and it works well. It should be performant (collection views load fast, no unnecessary auto layout passes etc), and doesn't have any 'magic numbers' like a fixed collection view width. Changing the collection view size, e.g. on rotation, and then invalidating the layout should work great too.

1. Create the following flow layout subclass

class HorizontallyFlushCollectionViewFlowLayout: UICollectionViewFlowLayout {    // Don't forget to use this class in your storyboard (or code, .xib etc)    override func layoutAttributesForItemAtIndexPath(indexPath: NSIndexPath) -> UICollectionViewLayoutAttributes? {        let attributes = super.layoutAttributesForItemAtIndexPath(indexPath)?.copy() as? UICollectionViewLayoutAttributes        guard let collectionView = collectionView else { return attributes }        attributes?.bounds.size.width = collectionView.bounds.width - sectionInset.left - sectionInset.right        return attributes    }    override func layoutAttributesForElementsInRect(rect: CGRect) -> [UICollectionViewLayoutAttributes]? {        let allAttributes = super.layoutAttributesForElementsInRect(rect)        return allAttributes?.flatMap { attributes in            switch attributes.representedElementCategory {            case .Cell: return layoutAttributesForItemAtIndexPath(attributes.indexPath)            default: return attributes            }        }    }}

2. Register your collection view for automatic sizing

// The provided size should be a plausible estimate of the actual// size. You can set your item size in your storyboard// to a good estimate and use the code below. Otherwise,// you can provide it manually too, e.g. CGSize(width: 100, height: 100)flowLayout.estimatedItemSize = flowLayout.itemSize

3. Use the predefined width + custom height in your cell subclass

override func preferredLayoutAttributesFittingAttributes(layoutAttributes: UICollectionViewLayoutAttributes) -> UICollectionViewLayoutAttributes {    layoutAttributes.bounds.size.height = systemLayoutSizeFittingSize(UILayoutFittingCompressedSize).height    return layoutAttributes}

A simple way to do it in iOS 9 in a few lines of codes - the horizontal way exemple (fixing its height to its Collection View height) :

Init your Collection View Flow Layout with an estimatedItemSize to enable self-sizing cell :

self.scrollDirection = UICollectionViewScrollDirectionHorizontal;self.estimatedItemSize = CGSizeMake(1, 1);

Implement the Collection View Layout Delegate (in your View Controller most of the time), collectionView:layout:sizeForItemAtIndexPath: . The goal here is to set the fixed height (or width) to the Collection View dimension. The 10 value can be anything, but you should set it to a value that doesn't break constraints :

- (CGSize)collectionView:(UICollectionView *)collectionView                  layout:(UICollectionViewLayout *)collectionViewLayout  sizeForItemAtIndexPath:(NSIndexPath *)indexPath{    return CGSizeMake(10, CGRectGetHeight(collectionView.bounds));}

Override your custom cell preferredLayoutAttributesFittingAttributes: method, this part actually calculate your dynamic cell width based on your Auto Layout constraints and the height you have just set :

- (UICollectionViewLayoutAttributes *)preferredLayoutAttributesFittingAttributes:(UICollectionViewLayoutAttributes *)layoutAttributes{    UICollectionViewLayoutAttributes *attributes = [layoutAttributes copy];    float desiredWidth = [self.contentView systemLayoutSizeFittingSize:UILayoutFittingCompressedSize].width;    CGRect frame = attributes.frame;    frame.size.width = desiredWidth;    attributes.frame = frame;    return attributes;}