wake-up-neo.com

Wie bestimmen Sie den Abstand zwischen Zellen in UICollectionView flowLayout?

Ich habe eine UICollectionView mit einem Flusslayout und jede Zelle ist ein Quadrat. Wie bestimme ich den Abstand zwischen den einzelnen Zellen in jeder Zeile? Ich finde anscheinend keine passenden Einstellungen dafür. Ich sehe, dass in der Nib-Datei für eine Sammlungsansicht ein Mindestabstandsattribut vorhanden ist, aber ich habe diesen Wert auf 0 gesetzt, und die Zellen haften nicht einmal.

enter image description here

Irgendeine andere Idee?

46
adit

Update: Schnelle Version dieser Antwort: https://github.com/fanpyi/UICollectionViewLeftAlignedLayout-Swift


@ mats Führung übernehmen Ich habe seinen Code geändert, um sicherzustellen, dass Elemente IMMER links ausgerichtet sind. Ich habe festgestellt, dass ein Element, das auf einer Zeile alleine landet, durch das Flusslayout zentriert wird. Ich habe die folgenden Änderungen vorgenommen, um dieses Problem zu beheben.

Diese Situation tritt nur dann auf, wenn Sie Zellen mit unterschiedlicher Breite haben, was zu einem Layout wie dem folgenden führen kann. Die letzte Zeile bleibt aufgrund des Verhaltens von UICollectionViewFlowLayout immer links ausgerichtet. Das Problem liegt in Elementen, die sich in jeder Zeile außer der letzten befinden.

Mit @ mats Code habe ich gesehen.

enter image description here

In diesem Beispiel sehen wir, dass Zellen zentriert werden, wenn sie alleine auf der Linie landen. Der folgende Code stellt sicher, dass Ihre Sammlungsansicht so aussehen würde.

enter image description here

#import "CWDLeftAlignedCollectionViewFlowLayout.h"

const NSInteger kMaxCellSpacing = 9;

@implementation CWDLeftAlignedCollectionViewFlowLayout

- (NSArray *)layoutAttributesForElementsInRect:(CGRect)rect {
    NSArray* attributesToReturn = [super layoutAttributesForElementsInRect:rect];
    for (UICollectionViewLayoutAttributes* attributes in attributesToReturn) {
        if (nil == attributes.representedElementKind) {
            NSIndexPath* indexPath = attributes.indexPath;
            attributes.frame = [self layoutAttributesForItemAtIndexPath:indexPath].frame;
        }
    }
    return attributesToReturn;
}

- (UICollectionViewLayoutAttributes *)layoutAttributesForItemAtIndexPath:(NSIndexPath *)indexPath {
    UICollectionViewLayoutAttributes* currentItemAttributes =
    [super layoutAttributesForItemAtIndexPath:indexPath];

    UIEdgeInsets sectionInset = [(UICollectionViewFlowLayout *)self.collectionView.collectionViewLayout sectionInset];

    if (indexPath.item == 0) { // first item of section
        CGRect frame = currentItemAttributes.frame;
        frame.Origin.x = sectionInset.left; // first item of the section should always be left aligned
        currentItemAttributes.frame = frame;

        return currentItemAttributes;
    }

    NSIndexPath* previousIndexPath = [NSIndexPath indexPathForItem:indexPath.item-1 inSection:indexPath.section];
    CGRect previousFrame = [self layoutAttributesForItemAtIndexPath:previousIndexPath].frame;
    CGFloat previousFrameRightPoint = previousFrame.Origin.x + previousFrame.size.width + kMaxCellSpacing;

    CGRect currentFrame = currentItemAttributes.frame;
    CGRect strecthedCurrentFrame = CGRectMake(0,
                                              currentFrame.Origin.y,
                                              self.collectionView.frame.size.width,
                                              currentFrame.size.height);

    if (!CGRectIntersectsRect(previousFrame, strecthedCurrentFrame)) { // if current item is the first item on the line
        // the approach here is to take the current frame, left align it to the Edge of the view
        // then stretch it the width of the collection view, if it intersects with the previous frame then that means it
        // is on the same line, otherwise it is on it's own new line
        CGRect frame = currentItemAttributes.frame;
        frame.Origin.x = sectionInset.left; // first item on the line should always be left aligned
        currentItemAttributes.frame = frame;
        return currentItemAttributes;
    }

    CGRect frame = currentItemAttributes.frame;
    frame.Origin.x = previousFrameRightPoint;
    currentItemAttributes.frame = frame;
    return currentItemAttributes;
}

@end
68
Chris Wagner

Um einen maximalen Abstand zwischen den Elementen zu erhalten, müssen Sie die Unterklasse UICollectionViewFlowLayout und layoutAttributesForElementsInRect: und layoutAttributesForItemAtIndexPath: überschreiben.

Ein häufiges Problem ist zum Beispiel folgendes: Die Zeilen einer Sammlungsansicht sind rechts und links ausgerichtet, mit Ausnahme der letzten Zeile, die linksbündig ist. Nehmen wir an, wir wollen alle die Linien sind linksbündig, so dass der Abstand zwischen ihnen beispielsweise 10 Punkte beträgt. Hier ist ein einfacher Weg (in Ihrer UICollectionViewFlowLayout-Unterklasse):

- (NSArray *)layoutAttributesForElementsInRect:(CGRect)rect {
    NSArray* arr = [super layoutAttributesForElementsInRect:rect];
    for (UICollectionViewLayoutAttributes* atts in arr) {
        if (nil == atts.representedElementKind) {
            NSIndexPath* ip = atts.indexPath;
            atts.frame = [self layoutAttributesForItemAtIndexPath:ip].frame;
        }
    }
    return arr;
}

- (UICollectionViewLayoutAttributes *)layoutAttributesForItemAtIndexPath:(NSIndexPath *)indexPath {
    UICollectionViewLayoutAttributes* atts =
    [super layoutAttributesForItemAtIndexPath:indexPath];

    if (indexPath.item == 0) // degenerate case 1, first item of section
        return atts;

    NSIndexPath* ipPrev =
    [NSIndexPath indexPathForItem:indexPath.item-1 inSection:indexPath.section];

    CGRect fPrev = [self layoutAttributesForItemAtIndexPath:ipPrev].frame;
    CGFloat rightPrev = fPrev.Origin.x + fPrev.size.width + 10;
    if (atts.frame.Origin.x <= rightPrev) // degenerate case 2, first item of line
        return atts;

    CGRect f = atts.frame;
    f.Origin.x = rightPrev;
    atts.frame = f;
    return atts;
}

Der Grund ist, dass dies so einfach ist, dass wir das schwere Anheben der Anlage nicht wirklich durchführen. Wir nutzen die Layoutarbeit, die UICollectionViewFlowLayout bereits für uns geleistet hat. Es ist bereits entschieden, wie viele Artikel in jeder Zeile enthalten sind. Wir lesen nur diese Zeilen und schieben die Elemente zusammen, wenn Sie sehen, was ich meine.

32
matt

Es gibt ein paar Dinge zu beachten:

  1. Ändern Sie den Mindestabstand in IB, lassen Sie den Cursor jedoch in diesem Feld. Beachten Sie, dass Xcode das Dokument nicht sofort als geändert markiert. Wenn Sie jedoch in ein anderes Feld klicken, stellt Xcode fest, dass das Dokument geändert wurde, und markiert es im Datei-Navigator. Stellen Sie daher sicher, dass Sie nach einer Änderung in ein anderes Feld wechseln oder klicken.

  2. Speichern Sie Ihre Storyboard-/Xib-Datei, nachdem Sie eine Änderung vorgenommen haben, und stellen Sie sicher, dass Sie die App neu erstellen. Es ist nicht schwer, diesen Schritt zu verpassen. Dann kratzen Sie sich den Kopf und wundern sich, warum Ihre Änderungen keine Auswirkung hatten.

  3. UICollectionViewFlowLayout hat eine minimumInteritemSpacing-Eigenschaft, die Sie in IB festlegen. Der Delegat der Sammlung kann jedoch auch eine Methode zur Bestimmung des Abstandes zwischen den Elementen haben. Diese Methode übertrumpft die Eigenschaft des Layouts. Wenn Sie sie also in Ihrem Delegaten implementieren, wird die Eigenschaft Ihres Layouts nicht verwendet.

  4. Denken Sie daran, dass der Abstand dort ein Minimum Abstand ist. Das Layout verwendet diese Nummer (unabhängig davon, ob sie von der Eigenschaft oder von der Delegat-Methode stammt) als kleinsten zulässigen Speicherplatz. Möglicherweise wird jedoch ein größerer Speicherplatz verwendet, wenn in der Zeile noch Platz vorhanden ist. Wenn Sie beispielsweise den Mindestabstand auf 0 setzen, werden möglicherweise noch einige Pixel zwischen den Elementen angezeigt. Wenn Sie mehr Kontrolle über den Abstand der Elemente wünschen, sollten Sie wahrscheinlich ein anderes Layout verwenden (möglicherweise eines Ihrer eigenen Elemente).

16
Caleb

Ein bisschen Mathematik macht den Trick leichter. Der von Chris Wagner geschriebene Code ist schrecklich, weil er die Layoutattribute der vorherigen Elemente aufruft. Je mehr Sie scrollen, desto langsamer ist es ...

Verwenden Sie einfach modulo wie folgt (ich verwende meinen minimumInteritemSpacing-Wert auch als Maximalwert):

- (UICollectionViewLayoutAttributes *)layoutAttributesForItemAtIndexPath:(NSIndexPath *)indexPath
{
    UICollectionViewLayoutAttributes* currentItemAttributes = [super layoutAttributesForItemAtIndexPath:indexPath];
    NSInteger numberOfItemsPerLine = floor([self collectionViewContentSize].width / [self itemSize].width);

    if (indexPath.item % numberOfItemsPerLine != 0)
    {
        NSInteger cellIndexInLine = (indexPath.item % numberOfItemsPerLine);

        CGRect itemFrame = [currentItemAttributes frame];
        itemFrame.Origin.x = ([self itemSize].width * cellIndexInLine) + ([self minimumInteritemSpacing] * cellIndexInLine);
        currentItemAttributes.frame = itemFrame;
    }

    return currentItemAttributes;
}
4
ldesroziers

Eine einfache Möglichkeit zur Ausrichtung nach links ist das Ändern von layoutAttributesForElementsInRect: in Ihrer Unterklasse von UICollectionViewFlowLayout:

- (NSArray *)layoutAttributesForElementsInRect:(CGRect)rect
{
    NSArray *allLayoutAttributes = [super layoutAttributesForElementsInRect:rect];
    CGRect prevFrame = CGRectMake(-FLT_MAX, -FLT_MAX, 0, 0);
    for (UICollectionViewLayoutAttributes *layoutAttributes in allLayoutAttributes)
    {
        //fix blur
        CGRect theFrame = CGRectIntegral(layoutAttributes.frame);

        //left justify
        if(prevFrame.Origin.x > -FLT_MAX &&
           prevFrame.Origin.y >= theFrame.Origin.y &&
           prevFrame.Origin.y <= theFrame.Origin.y) //workaround for float == warning
        {
            theFrame.Origin.x = prevFrame.Origin.x +
                                prevFrame.size.width + 
                                EXACT_SPACE_BETWEEN_ITEMS;
        }
        prevFrame = theFrame;

        layoutAttributes.frame = theFrame;
    }
    return allLayoutAttributes;
}
3
xytor

Die Swift-Version der Chris-Lösung.

class PazLeftAlignedCollectionViewFlowLayout : UICollectionViewFlowLayout {
    var maxCellSpacing = 14.0
    override func layoutAttributesForElementsInRect(rect: CGRect) -> [AnyObject]? {
        if var attributesToReturn = super.layoutAttributesForElementsInRect(rect) as? Array<UICollectionViewLayoutAttributes> {
            for attributes in attributesToReturn {
                if attributes.representedElementKind == nil {
                    let indexPath = attributes.indexPath
                    attributes.frame = self.layoutAttributesForItemAtIndexPath(indexPath).frame;
                }
            }
            return attributesToReturn;
        }
        return super.layoutAttributesForElementsInRect(rect)
    }

    override func layoutAttributesForItemAtIndexPath(indexPath: NSIndexPath) -> UICollectionViewLayoutAttributes! {
        let currentItemAttributes = super.layoutAttributesForItemAtIndexPath(indexPath)

        if let collectionViewFlowLayout = self.collectionView?.collectionViewLayout as? UICollectionViewFlowLayout {
            let sectionInset = collectionViewFlowLayout.sectionInset
            if (indexPath.item == 0) { // first item of section
                var frame = currentItemAttributes.frame;
                frame.Origin.x = sectionInset.left; // first item of the section should always be left aligned
                currentItemAttributes.frame = frame;

                return currentItemAttributes;
            }

            let previousIndexPath = NSIndexPath(forItem:indexPath.item-1, inSection:indexPath.section)
            let previousFrame = self.layoutAttributesForItemAtIndexPath(previousIndexPath).frame;
            let previousFrameRightPoint = Double(previousFrame.Origin.x) + Double(previousFrame.size.width) + self.maxCellSpacing

            let currentFrame = currentItemAttributes.frame
            var width : CGFloat = 0.0
            if let collectionViewWidth = self.collectionView?.frame.size.width {
                width = collectionViewWidth
            }
            let strecthedCurrentFrame = CGRectMake(0,
                currentFrame.Origin.y,
                width,
                currentFrame.size.height);

            if (!CGRectIntersectsRect(previousFrame, strecthedCurrentFrame)) { // if current item is the first item on the line
                // the approach here is to take the current frame, left align it to the Edge of the view
                // then stretch it the width of the collection view, if it intersects with the previous frame then that means it
                // is on the same line, otherwise it is on it's own new line
                var frame = currentItemAttributes.frame;
                frame.Origin.x = sectionInset.left; // first item on the line should always be left aligned
                currentItemAttributes.frame = frame;
                return currentItemAttributes;
            }

            var frame = currentItemAttributes.frame;
            frame.Origin.x = CGFloat(previousFrameRightPoint)
            currentItemAttributes.frame = frame;
        }
        return currentItemAttributes;
    }
}

Um es zu benutzen, mache folgendes:

    override func viewDidLoad() {
    super.viewDidLoad()
    self.collectionView.collectionViewLayout = self.layout
}
var layout : PazLeftAlignedCollectionViewFlowLayout {
    var layout = PazLeftAlignedCollectionViewFlowLayout()
    layout.itemSize = CGSizeMake(220.0, 230.0)
    layout.minimumLineSpacing = 12.0
    return layout
}
2
zirinisp

Das "Problem" bei UICollectionViewFlowLayout besteht darin, dass die Zellen mit einer Ausrichtung versehen werden: Die erste Zelle in einer Reihe ist linksbündig, die letzte Zelle in einer Reihe ist rechtsbündig und alle anderen Zellen dazwischen sind Gleichmäßig verteilt mit einem gleichen Abstand, der größer ist als der minimumInteritemSpacing.

Es gibt bereits viele gute Antworten auf diesen Beitrag, die dieses Problem lösen, indem Sie UICollectionViewFlowLayout in Unterklassen unterteilen. Als Ergebnis erhalten Sie ein Layout, das die Zellen nach links ausrichtet . Eine andere gültige Lösung zum Verteilen der Zellen mit einem konstanten Abstand ist das Ausrichten der Zellen nach rechts .

AlignedCollectionViewFlowLayout

Ich habe auch eine UICollectionViewFlowLayout -Unterklasse erstellt, die einer ähnlichen Idee folgt, wie sie von matt und Chris Wagner vorgeschlagen wurde das kann entweder die Zellen ausrichten

⬅︎  übrig :

Left-aligned layout

oder ➡︎  richtig :

Right-aligned layout

Sie können es einfach von hier herunterladen, die Layoutdatei zu Ihrem Projekt hinzufügen und AlignedCollectionViewFlowLayout als Layoutklasse für Ihre Sammlungsansicht festlegen:
https://github.com/mischa-hildebrand/AlignedCollectionViewFlowLayout

So funktioniert es (bei linksbündigen Zellen):

 +---------+----------------------------------------------------------------+---------+
 |         |                                                                |         |
 |         |     +------------+                                             |         |
 |         |     |            |                                             |         |
 | section |- - -|- - - - - - |- - - - +---------------------+ - - - - - - -| section |
 |  inset  |     |intersection|        |                     |   line rect  |  inset  |
 |         |- - -|- - - - - - |- - - - +---------------------+ - - - - - - -|         |
 | (left)  |     |            |             current item                    | (right) |
 |         |     +------------+                                             |         |
 |         |     previous item                                              |         |
 +---------+----------------------------------------------------------------+---------+

Das Konzept hier ist, zu überprüfen, ob die aktuelle Zelle mit dem Index i und die vorherige Zelle mit dem Index i - 1 dieselbe Zeile belegen.

  • Ist dies nicht der Fall, ist die Zelle mit dem Index i die am weitesten links stehende Zelle in der Zeile.
    → Verschieben Sie die Zelle an den linken Rand der Sammlungsansicht (ohne ihre vertikale Position zu ändern).
  • In diesem Fall ist die Zelle mit dem Index i nicht die Zelle ganz links in der Zeile.
    → Hole den Frame der vorherigen Zelle (mit dem Index i − 1) und verschiebe die aktuelle Zelle daneben.

Für rechtsbündige Zellen ...

... Sie machen dasselbe umgekehrt, d. h. Sie überprüfen stattdessen die next -Zelle mit dem Index i + 1.

2
Mischa

Sie können dies auf zwei Arten tun.

Nehmen Sie zunächst einige Änderungen in layoutAttributesForItem vor.

ruft das Layout der aktuellen Attribute über das vorherige layoutAttributesForItem(at: IndexPath(item: indexPath.item - 1, section: indexPath.section))?.frame ab.

layoutAttributesForItem (at :): Diese Methode stellt der Sammlungsansicht bei Bedarf Layoutinformationen zur Verfügung. Sie müssen es überschreiben und die Layoutattribute für das Element am angeforderten Indexpfad zurückgeben.

Zweitens können Sie einige Attribute über UICollectionViewLayoutAttributes(forCellWith: indexPath) neu definieren und beliebig anordnen.

Und die Mathematik ist etwas umfangreicher, weil sie das Layout stark anhebt.

layoutAttributesForElements (in :): Bei dieser Methode müssen Sie die Layoutattribute für alle Elemente im angegebenen Rechteck zurückgeben. Sie geben die Attribute als Array von UICollectionViewLayoutAttributes an die Auflistungsansicht zurück.


Sie können Mein Repo überprüfen

  • sie können Elemente linksbündig platzieren

  • sie können Elemente rechtsbündig platzieren

  • sie können Elemente rechtsbündig ausrichten und Elemente umkehren

2
dengApro

Clean Swift-Lösung aus einer Evolutionsgeschichte:

  1. es gab matte Antwort
  2. es gab Chris Wagner einseitige Gegenstände zu beheben
  3. es gab mokagio sectionInset und minimumInteritemSpaceverbesserung
  4. es gab fanpyi Swift version
  5. hier ist eine vereinfachte und saubere Version von mir:
open class UICollectionViewLeftAlignedLayout: UICollectionViewFlowLayout {
    open override func layoutAttributesForElements(in rect: CGRect) -> [UICollectionViewLayoutAttributes]? {
        return super.layoutAttributesForElements(in: rect)?.map { $0.representedElementKind == nil ? layoutAttributesForItem(at: $0.indexPath)! : $0 }
    }

    open override func layoutAttributesForItem(at indexPath: IndexPath) -> UICollectionViewLayoutAttributes? {
        guard let currentItemAttributes = super.layoutAttributesForItem(at: indexPath)?.copy() as? UICollectionViewLayoutAttributes,
            collectionView != nil else {
            // should never happen
            return nil
        }

        // if the current frame, once stretched to the full row intersects the previous frame then they are on the same row
        if indexPath.item != 0,
            let previousFrame = layoutAttributesForItem(at: IndexPath(item: indexPath.item - 1, section: indexPath.section))?.frame,
            currentItemAttributes.frame.intersects(CGRect(x: -.infinity, y: previousFrame.Origin.y, width: .infinity, height: previousFrame.size.height)) {
            // the next item on a line
            currentItemAttributes.frame.Origin.x = previousFrame.Origin.x + previousFrame.size.width + evaluatedMinimumInteritemSpacingForSection(at: indexPath.section)
        } else {
            // the first item on a line
            currentItemAttributes.frame.Origin.x = evaluatedSectionInsetForSection(at: indexPath.section).left
        }
        return currentItemAttributes
    }

    func evaluatedMinimumInteritemSpacingForSection(at section: NSInteger) -> CGFloat {
        return (collectionView?.delegate as? UICollectionViewDelegateFlowLayout)?.collectionView?(collectionView!, layout: self, minimumInteritemSpacingForSectionAt: section) ?? minimumInteritemSpacing
    }

    func evaluatedSectionInsetForSection(at index: NSInteger) -> UIEdgeInsets {
        return (collectionView?.delegate as? UICollectionViewDelegateFlowLayout)?.collectionView?(collectionView!, layout: self, insetForSectionAt: index) ?? sectionInset
    }
}

Verwendung: Der Abstand zwischen den Elementen wird durch collectionView (_:layout:minimumInteritemSpacingForSectionAt:) des Delegierten bestimmt.

Ich legte es auf github, https://github.com/Coeur/UICollectionViewLeftAlignedLayout , wobei ich tatsächlich eine Funktion zur Unterstützung der beiden Bildlaufrichtungen (horizontal und vertikal) hinzugefügt habe.

1
Cœur

Eine saubere Swift-Version für interessierte Menschen, basierend auf der Antwort von Chris Wagner:

class AlignLeftFlowLayout: UICollectionViewFlowLayout {

    var maximumCellSpacing = CGFloat(9.0)

    override func layoutAttributesForElementsInRect(rect: CGRect) -> [AnyObject]? {
        let attributesToReturn = super.layoutAttributesForElementsInRect(rect) as? [UICollectionViewLayoutAttributes]

        for attributes in attributesToReturn ?? [] {
            if attributes.representedElementKind == nil {
                attributes.frame = self.layoutAttributesForItemAtIndexPath(attributes.indexPath).frame
            }
        }

        return attributesToReturn
    }

    override func layoutAttributesForItemAtIndexPath(indexPath: NSIndexPath) -> UICollectionViewLayoutAttributes! {
        let curAttributes = super.layoutAttributesForItemAtIndexPath(indexPath)
        let sectionInset = (self.collectionView?.collectionViewLayout as UICollectionViewFlowLayout).sectionInset

        if indexPath.item == 0 {
            let f = curAttributes.frame
            curAttributes.frame = CGRectMake(sectionInset.left, f.Origin.y, f.size.width, f.size.height)
            return curAttributes
        }

        let prevIndexPath = NSIndexPath(forItem: indexPath.item-1, inSection: indexPath.section)
        let prevFrame = self.layoutAttributesForItemAtIndexPath(prevIndexPath).frame
        let prevFrameRightPoint = prevFrame.Origin.x + prevFrame.size.width + maximumCellSpacing

        let curFrame = curAttributes.frame
        let stretchedCurFrame = CGRectMake(0, curFrame.Origin.y, self.collectionView!.frame.size.width, curFrame.size.height)

        if CGRectIntersectsRect(prevFrame, stretchedCurFrame) {
            curAttributes.frame = CGRectMake(prevFrameRightPoint, curFrame.Origin.y, curFrame.size.width, curFrame.size.height)
        } else {
            curAttributes.frame = CGRectMake(sectionInset.left, curFrame.Origin.y, curFrame.size.width, curFrame.size.height)
        }

        return curAttributes
    }
}
1
Kevin R

Hier ist es für NSCollectionViewFlowLayout

class LeftAlignedCollectionViewFlowLayout: NSCollectionViewFlowLayout {

    var maximumCellSpacing = CGFloat(2.0)

    override func layoutAttributesForElementsInRect(rect: NSRect) -> [NSCollectionViewLayoutAttributes] {

        let attributesToReturn = super.layoutAttributesForElementsInRect(rect)

        for attributes in attributesToReturn ?? [] {
            if attributes.representedElementKind == nil {
                attributes.frame = self.layoutAttributesForItemAtIndexPath(attributes.indexPath!)!.frame
            }
        }
        return attributesToReturn
    }

    override func layoutAttributesForItemAtIndexPath(indexPath: NSIndexPath) -> NSCollectionViewLayoutAttributes? {

        let curAttributes = super.layoutAttributesForItemAtIndexPath(indexPath)
        let sectionInset = (self.collectionView?.collectionViewLayout as! NSCollectionViewFlowLayout).sectionInset

        if indexPath.item == 0 {
            let f = curAttributes!.frame
            curAttributes!.frame = CGRectMake(sectionInset.left, f.Origin.y, f.size.width, f.size.height)
            return curAttributes
        }

        let prevIndexPath = NSIndexPath(forItem: indexPath.item-1, inSection: indexPath.section)
        let prevFrame = self.layoutAttributesForItemAtIndexPath(prevIndexPath)!.frame
        let prevFrameRightPoint = prevFrame.Origin.x + prevFrame.size.width + maximumCellSpacing

        let curFrame = curAttributes!.frame
        let stretchedCurFrame = CGRectMake(0, curFrame.Origin.y, self.collectionView!.frame.size.width, curFrame.size.height)

        if CGRectIntersectsRect(prevFrame, stretchedCurFrame) {
            curAttributes!.frame = CGRectMake(prevFrameRightPoint, curFrame.Origin.y, curFrame.size.width, curFrame.size.height)
        } else {
            curAttributes!.frame = CGRectMake(sectionInset.left, curFrame.Origin.y, curFrame.size.width, curFrame.size.height)
        }

        return curAttributes
    }
}
0
Chris