UICollectionView complex grid again

I can't manage to get this type of layout:

I can only achieve this when I set size of cells in 'sizeForItemAt' method:

I tried solutions from Apple like UICollectionViewCompositionalLayout and subclassing of UICollectionViewLayout. But the first one don't give the flexibility needed for the device rotation because you have to set exact count of subitems in group. Another issue with UICollectionViewCompositionalLayout is scroll time calculations - it doesn't give the full layout after the screen is displayed. Subclassing of UICollectionViewLayout (https://developer.apple.com/documentation/uikit/views_and_controls/collection_views/layouts/customizing_collection_view_layouts)
has terrible performance.

But even with all the shortcomings of the above approaches, I did not get exactly the layout that I need. I can imagine that we can use an additional type of cell that contains a grid of four cells, but it's also not flexible.

I will appreciate any help.

This layout can be done with a custom UICollectionViewLayout and is probably much more straight-forward than it might seem.

First, think about the layout as a grid for each section... 4-columns x n rows:

Because we're using squares, the first item will take up 2-columns and 2-rows.

To avoid width/height confusion and replication, we'll call the 2x2 item the "Primary" item, and the 1x1 items "Secondary" items.

So, when we calculate the layout rectangles, we can say:

numCols = 4
secondarySize = collectionView.width / numCols

y = 0
row = 0
col = 0

for i in 0..<numItems {

    if i == 0 {

        itemRect = .init(x: 0.0, y: y, width: secondarySize * 2.0, height: secondarySize * 2.0)

        // skip a column
        col = 2

    } else {

		// if we're at the last column
		if col == numCols {
			// increment the row
			row += 1
			// if we're on row 1, next column is 2
			//	else it's 0
			col = row < 2 ? 2 : 0
		}
				
		itemRect = .init(x: col * secondarySize, y: y + row * secondarySize, width: secondarySize, height: secondarySize)
				
		// increment the column
		col += 1
				
	}

}

That works fine, giving us this on an iPhone 14 Pro Max:

It's not quite that simple though, because when we rotate the phone, we don't want this:

and if we're on an iPad, we definitely don't want this:

So, we need to decide how wide we can go for that layout.

Current phones range from 275 to 430 points wide (in Portrait orientation), so we might say:

• if the collectionView width is less than 450, use this default layout
• else
• let's use a specific size for the Primary item, and "fill in" the remaining space

If we decide we want the Primary item to be 200x200, that changes the initial part of our layout code to:

primaryItemSize = 200.0

if contentWidth < 450.0 {
	secondarySize = contentWidth / 4.0
	numCols = 4
} else {
	secondarySize = primaryItemSize / 2.0
	numCols = Int(contentWidth / secondarySize)
}

Now if our layout looks like this (again, iPhone 14 Pro Max):

rotating the phone gives us this:

and the iPad looks like this:

We may still want some conditional calculations... that same code on an iPhone SE looks like this:

So, a Primary size of 200x200 might be too big for that device.

Additionally, as you can see, setting an explicit Primary item size won't fill the width exactly. An iPhone SE in Landscape orientation has a view width of 667. If the secondary size (the column width) is 100, 6 columns gets us 600-points, leaving 667-points of empty space on the end.

If that's acceptable, great, less work Otherwise, we can do a "best fit" calculation which would either "grow" the size a bit to fill it out, or "shrink" the size a bit and expand to 7 columns.

And... if you want section spacing and/or headers, that would need to be factored in as well.

Here, though, is some sample code to get to this point:

class SampleViewController: UIViewController {
var collectionView: UICollectionView!
var myData: [[UIImage]] = []
// a view with a "spinner" to show that we are
//	generating the images to use as the data
//	(if the data needs to be created in this controller)
lazy var spinnerView: UIView = {
let v = UIView()
let label = UILabel()
label.text = "Generating Images Data..."
let spinner = UIActivityIndicatorView(style: .large)
spinner.startAnimating()
[label, spinner].forEach { sv in
sv.translatesAutoresizingMaskIntoConstraints = false
v.addSubview(sv)
}
NSLayoutConstraint.activate([
label.topAnchor.constraint(equalTo: v.topAnchor, constant: 20.0),
label.leadingAnchor.constraint(equalTo: v.leadingAnchor, constant: 20.0),
label.trailingAnchor.constraint(equalTo: v.trailingAnchor, constant: -20.0),
spinner.topAnchor.constraint(equalTo: label.bottomAnchor, constant: 20.0),
spinner.centerXAnchor.constraint(equalTo: v.centerXAnchor),
spinner.bottomAnchor.constraint(equalTo: v.bottomAnchor, constant: -20.0),
])
v.layer.cornerRadius = 8
v.layer.borderWidth = 1
v.layer.borderColor = UIColor.black.cgColor
v.backgroundColor = .white
return v
}()
// for development purposes
var showCellFrame: Bool = false
override func viewDidLoad() {
super.viewDidLoad()
view.backgroundColor = UIColor(white: 0.95, alpha: 1.0)
let gl = SampleGridLayout()
gl.primaryItemSize = 200.0
collectionView = UICollectionView(frame: .zero, collectionViewLayout: gl)
// the imageView in our SimpleImageCell is inset by 4-points, which results in
//	8-points between adjacent cells
// so, if we inset the content 4-points on each side, it will look "balanced"
//	with a total of 8-points on each side
collectionView.contentInset = .init(top: 0.0, left: 4.0, bottom: 0.0, right: 4.0)
collectionView.translatesAutoresizingMaskIntoConstraints = false
view.addSubview(collectionView)
let g = view.safeAreaLayoutGuide
NSLayoutConstraint.activate([
collectionView.topAnchor.constraint(equalTo: g.topAnchor, constant: 0.0),
collectionView.leadingAnchor.constraint(equalTo: g.leadingAnchor, constant: 0.0),
collectionView.trailingAnchor.constraint(equalTo: g.trailingAnchor, constant: 0.0),
collectionView.bottomAnchor.constraint(equalTo: g.bottomAnchor, constant: 0.0),
])
collectionView.register(SimpleImageCell.self, forCellWithReuseIdentifier: SimpleImageCell.identifier)
collectionView.dataSource = self
collectionView.delegate = self
// for use during development
let dt = UITapGestureRecognizer(target: self, action: #selector(toggleFraming(_:)))
dt.numberOfTapsRequired = 2
view.addGestureRecognizer(dt)
if myData.isEmpty {
spinnerView.translatesAutoresizingMaskIntoConstraints = false
view.addSubview(spinnerView)
NSLayoutConstraint.activate([
spinnerView.topAnchor.constraint(equalTo: g.topAnchor, constant: 40.0),
spinnerView.centerXAnchor.constraint(equalTo: g.centerXAnchor),
])
}
}
override func viewDidAppear(_ animated: Bool) {
super.viewDidAppear(animated)
// data may already be created by a data manager class
//	so only create images if needed
if myData.isEmpty {
DispatchQueue.global(qos: .userInitiated).async {
let sectionCounts: [Int] = [
8, 2, 3, 4, 5, 10, 13, 16, 24
]
self.myData = SampleData().generateData(sectionCounts)
DispatchQueue.main.async {
self.spinnerView.removeFromSuperview()
self.collectionView.reloadData()
}
}
}
}
// for use during development
@objc func toggleFraming(_ sender: Any?) {
self.showCellFrame.toggle()
self.collectionView.reloadData()
}
override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
super.viewWillTransition(to: size, with: coordinator)
coordinator.animate(
alongsideTransition: { [unowned self] _ in
self.collectionView.collectionViewLayout.invalidateLayout()
self.collectionView.reloadData()
},
completion: { [unowned self] _ in
// if we want to do something after the size transition
}
)
}
}
// "standard" collection view DataSource funcs
extension SampleViewController: UICollectionViewDataSource {
func numberOfSections(in collectionView: UICollectionView) -> Int {
return myData.count
}
func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
return myData[section].count
}
func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
let c = collectionView.dequeueReusableCell(withReuseIdentifier: SimpleImageCell.identifier, for: indexPath) as! SimpleImageCell
c.theImageView.image = myData[indexPath.section][indexPath.item]
// any other cell data configuration
// this is here only during development
c.showCellFrame = self.showCellFrame
return c
}
}
// "standard" collection view Delegate funcs
extension SampleViewController: UICollectionViewDelegate {
func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
print("Selected item at:", indexPath)
}
}
// MARK: image data generation
class SampleData: NSObject {
func generateData(_ sectionCounts: [Int]) -> [[UIImage]] {
// let's generate some sample data...
// we'll create numbered 200x200 UIImages,
//	cycling through some background colors
//	to make it easy to see the sections
let sectionColors: [UIColor] = [
.systemRed, .systemGreen, .systemBlue,
.cyan, .green, .yellow,
]
var returnArray: [[UIImage]] = []
for i in 0..<sectionCounts.count {
var sectionImages: [UIImage] = []
let c = sectionColors[i % sectionColors.count]
for n in 0..<sectionCounts[i] {
if let img = createLabel(text: "\(n)", bkgColor: c) {
sectionImages.append(img)
}
}
returnArray.append(sectionImages)
}
return returnArray
}
func createLabel(text: String, bkgColor: UIColor) -> UIImage? {
let label = CATextLayer()
let uiFont = UIFont.boldSystemFont(ofSize: 140)
label.font = CGFont(uiFont.fontName as CFString)
label.fontSize = 140
label.alignmentMode = .center
label.foregroundColor = UIColor.white.cgColor
label.string = text
label.shadowColor = UIColor.black.cgColor
label.shadowOffset = .init(width: 0.0, height: 3.0)
label.shadowRadius = 6
label.shadowOpacity = 0.9
let sz = label.preferredFrameSize()
label.frame = .init(x: 0.0, y: 0.0, width: 200.0, height: sz.height)
let r: CGRect = .init(x: 0.0, y: 0.0, width: 200.0, height: 200.0)
let renderer = UIGraphicsImageRenderer(size: r.size)
return renderer.image { context in
bkgColor.setFill()
context.fill(r)
context.cgContext.translateBy(x: 0.0, y: (200.0 - sz.height) / 2.0)
label.render(in: context.cgContext)
}
}
}
// basic collection view cell with a
//	rounded-corners image view, 4-points "padding" on all sides
class SimpleImageCell: UICollectionViewCell {
static let identifier: String = "simpleImageCell"
let theImageView: UIImageView = {
let v = UIImageView()
v.translatesAutoresizingMaskIntoConstraints = false
return v
}()
override init(frame: CGRect) {
super.init(frame: frame)
commonInit()
}
required init?(coder: NSCoder) {
super.init(coder: coder)
commonInit()
}
func commonInit() -> Void {
contentView.addSubview(theImageView)
let g = contentView
NSLayoutConstraint.activate([
theImageView.topAnchor.constraint(equalTo: g.topAnchor, constant: 4.0),
theImageView.leadingAnchor.constraint(equalTo: g.leadingAnchor, constant: 4.0),
theImageView.trailingAnchor.constraint(equalTo: g.trailingAnchor, constant: -4.0),
theImageView.bottomAnchor.constraint(equalTo: g.bottomAnchor, constant: -4.0),
])
theImageView.layer.cornerRadius = 12
theImageView.clipsToBounds = true
}
override var isSelected: Bool {
didSet {
theImageView.layer.borderWidth = isSelected ? 2.0 : 0.0
}
}
// for development, so we can see the framing
var showCellFrame: Bool = false {
didSet {
//contentView.backgroundColor = showCellFrame ? .systemYellow : .clear
contentView.layer.borderColor = showCellFrame ? UIColor.blue.cgColor : UIColor.clear.cgColor
contentView.layer.borderWidth = showCellFrame ? 1 : 0
}
}
}
class SampleGridLayout: UICollectionViewLayout {
public var primaryItemSize: CGFloat = 200.0
private var itemCache: [UICollectionViewLayoutAttributes] = []
private var nextY: CGFloat = 0.0
private var contentHeight: CGFloat = 0
private var contentWidth: CGFloat {
guard let collectionView = collectionView else {
return 0
}
let insets = collectionView.contentInset
return collectionView.bounds.width - (insets.left + insets.right)
}
override var collectionViewContentSize: CGSize {
return CGSize(width: contentWidth, height: contentHeight)
}
override func prepare() {
guard let collectionView = collectionView else { return }
var numCols: Int = 0
var secondarySize: CGFloat = 0
if contentWidth < 450.0 {
secondarySize = contentWidth / 4.0
numCols = 4
} else {
secondarySize = primaryItemSize / 2.0
numCols = Int(contentWidth / secondarySize)
}
var primaryFrame: CGRect = .zero
var secondaryFrame: CGRect = .zero
itemCache = []
nextY = 0.0
for section in 0..<collectionView.numberOfSections {
let y: CGFloat = nextY
var curCol: Int = 0
var curRow: Int = 0
for item in 0..<collectionView.numberOfItems(inSection: section) {
let indexPath = IndexPath(item: item, section: section)
if item == 0 {
primaryFrame = .init(x: 0.0, y: y, width: secondarySize * 2.0, height: secondarySize * 2.0)
let attributes = UICollectionViewLayoutAttributes(forCellWith: indexPath)
attributes.frame = primaryFrame
itemCache.append(attributes)
// item 0 takes up 2 columns
curCol = 2
} else {
// if we're at the last column
if curCol == numCols {
// increment the row
curRow += 1
// if we're on row 1, next column is 2
//	else it's 0
curCol = curRow < 2 ? 2 : 0
}
secondaryFrame = .init(x: CGFloat(curCol) * secondarySize, y: y + CGFloat(curRow) * secondarySize, width: secondarySize, height: secondarySize)
let attributes = UICollectionViewLayoutAttributes(forCellWith: indexPath)
attributes.frame = secondaryFrame
itemCache.append(attributes)
// increment the column
curCol += 1
}
}
nextY = max(primaryFrame.maxY, secondaryFrame.maxY)
}
contentHeight = nextY
}
override func layoutAttributesForElements(in rect: CGRect) -> [UICollectionViewLayoutAttributes]? {
super.layoutAttributesForElements(in: rect)
var visibleLayoutAttributes: [UICollectionViewLayoutAttributes] = []
for attributes in itemCache {
if attributes.frame.intersects(rect) {
visibleLayoutAttributes.append(attributes)
}
}
return visibleLayoutAttributes
}
override func layoutAttributesForItem(at indexPath: IndexPath) -> UICollectionViewLayoutAttributes? {
super.layoutAttributesForItem(at: indexPath)
return itemCache.count > indexPath.row ? itemCache[indexPath.row] : nil
}
}