UICollectionView rastet beim horizontalen Bildlauf in die Zelle ein

Für was es Wert ist, hier ist eine einfache Berechnung, die ich benutze (swift):

func snapToNearestCell(_ collectionView: UICollectionView) {
    for i in 0..<collectionView.numberOfItems(inSection: 0) {

        let itemWithSpaceWidth = collectionViewFlowLayout.itemSize.width + collectionViewFlowLayout.minimumLineSpacing
        let itemWidth = collectionViewFlowLayout.itemSize.width

        if collectionView.contentOffset.x <= CGFloat(i) * itemWithSpaceWidth + itemWidth / 2 {                
            let indexPath = IndexPath(item: i, section: 0)
            collectionView.scrollToItem(at: indexPath, at: .centeredHorizontally, animated: true)
            break
        }
    }
}

Nennen, wo Sie es brauchen. Ich nenne es in

func scrollViewDidEndDragging(scrollView: UIScrollView, willDecelerate decelerate: Bool) {
    snapToNearestCell(scrollView)
}

Und

func scrollViewDidEndDecelerating(scrollView: UIScrollView) {
    snapToNearestCell(scrollView)
}

Wo collectionViewFlowLayout könnte kommen von:

override func viewDidLayoutSubviews() {
    super.viewDidLayoutSubviews()

    //Set up collection view
    collectionViewFlowLayout = collectionView.collectionViewLayout as! UICollectionViewFlowLayout
}

InformationsquelleAutor der Antwort Nam

Bekam eine Antwort aus, SO post hier und docs hier

Erste, Was Sie tun können, ist legen Sie Ihre Sammlung Ansicht scrollview - delegate Ihre Klasse, indem Sie Ihre Klasse ein scrollview delegieren

MyViewController : SuperViewController<... ,UIScrollViewDelegate>

Dann stellen Sie Ihre view-controller als delegate

UIScrollView *scrollView = (UIScrollView *)super.self.collectionView;
scrollView.delegate = self;

Oder tun es in den interface builder, indem Sie Strg + Umschalt-Klick auf Ihre Sammlung ansehen und dann Strg + ziehen oder mit der rechten Maustaste ziehen, um Ihre view-controller und wählen Sie delegate. (Sie sollten wissen, wie Sie dies tun). Das funktioniert nicht. UICollectionView ist eine Unterklasse von UIScrollView ist, so werden Sie nun in der Lage sein, um es zu sehen im interface builder durch Strg + shift-Klick

Nächste Implementierung der delegate-Methode - (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView

MyViewController.m

... 

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView
{

}

Docs-Zustand:

Parameter

scrollView | Die scroll-view-Objekt, das Abbremsen der scrolling
von der Inhalts-Ansicht.

Diskussion Die scroll-view ruft diese Methode auf, wenn das scrollen
Bewegung kommt zum Stillstand. Das Abbremsen Eigenschaft von UIScrollView
kontrolliert Abbremsen.

Verfügbarkeit Verfügbar in iOS 2.0 und höher.

Dann innerhalb der Methode prüfen, die Zelle war am nächsten an der Mitte der scrollview, wenn es aufgehört zu scrollen

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView
{
  //NSLog(@"%f", truncf(scrollView.contentOffset.x + (self.pictureCollectionView.bounds.size.width /2)));

float visibleCenterPositionOfScrollView = scrollView.contentOffset.x + (self.pictureCollectionView.bounds.size.width / 2);

//NSLog(@"%f", truncf(visibleCenterPositionOfScrollView /imageArray.count));


NSInteger closestCellIndex;

for (id item in imageArray) {
    //equation to use to figure out closest cell
    //abs(visibleCenter - cellCenterX) <= (cellWidth + cellSpacing/2)

    //Get cell width (and cell too)
    UICollectionViewCell *cell = (UICollectionViewCell *)[self collectionView:self.pictureCollectionView cellForItemAtIndexPath:[NSIndexPath indexPathWithIndex:[imageArray indexOfObject:item]]];
    float cellWidth = cell.bounds.size.width;

    float cellCenter = cell.frame.origin.x + cellWidth / 2;

    float cellSpacing = [self collectionView:self.pictureCollectionView layout:self.pictureCollectionView.collectionViewLayout minimumInteritemSpacingForSectionAtIndex:[imageArray indexOfObject:item]];

    //Now calculate closest cell

    if (fabsf(visibleCenterPositionOfScrollView - cellCenter) <= (cellWidth + (cellSpacing / 2))) {
        closestCellIndex = [imageArray indexOfObject:item];
        break;
    }
}

if (closestCellIndex != nil) {

[self.pictureCollectionView scrollToItemAtIndexPath:[NSIndexPath indexPathWithIndex:closestCellIndex] atScrollPosition:UICollectionViewScrollPositionCenteredVertically animated:YES];

//This code is untested. Might not work.

}

InformationsquelleAutor der Antwort Minebomber

Basiert auf Antworten von Mete und Kommentar von Chris Chute,

Hier ist ein Swift 4-Erweiterung, die wird genau das tun, was OP will. Es ist getestet auf einzelne Zeile und doppelte Zeile für verschachtelte Sammlung von Ansichten und es funktioniert Prima.

extension UICollectionView {
    func scrollToNearestVisibleCollectionViewCell() {
        self.decelerationRate = UIScrollViewDecelerationRateFast
        let visibleCenterPositionOfScrollView = Float(self.contentOffset.x + (self.bounds.size.width / 2))
        var closestCellIndex = -1
        var closestDistance: Float = .greatestFiniteMagnitude
        for i in 0..<self.visibleCells.count {
            let cell = self.visibleCells[i]
            let cellWidth = cell.bounds.size.width
            let cellCenter = Float(cell.frame.origin.x + cellWidth / 2)

            //Now calculate closest cell
            let distance: Float = fabsf(visibleCenterPositionOfScrollView - cellCenter)
            if distance < closestDistance {
                closestDistance = distance
                closestCellIndex = self.indexPath(for: cell)!.row
            }
        }
        if closestCellIndex != -1 {
            self.scrollToItem(at: IndexPath(row: closestCellIndex, section: 0), at: .centeredHorizontally, animated: true)
        }
    }
}

Müssen Sie implementieren UIScrollViewDelegate - Protokoll für Ihre Sammlung anzuzeigen, und fügen Sie dann diese zwei Methoden:

func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
    self.collectionView.scrollToNearestVisibleCollectionViewCell()
}

func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool) {
    if !decelerate {
        self.collectionView.scrollToNearestVisibleCollectionViewCell()
    }
}

InformationsquelleAutor der Antwort Vahid Amiri

Snap auf die nächste Zelle, die Achtung scroll-Geschwindigkeit.

Funktioniert ohne Störungen.

import UIKit

class SnapCenterLayout: UICollectionViewFlowLayout {
  override func targetContentOffset(forProposedContentOffset proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -> CGPoint {
    guard let collectionView = collectionView else { return super.targetContentOffset(forProposedContentOffset: proposedContentOffset, withScrollingVelocity: velocity) }
    let parent = super.targetContentOffset(forProposedContentOffset: proposedContentOffset, withScrollingVelocity: velocity)

    let itemSpace = itemSize.width + minimumInteritemSpacing
    var currentItemIdx = round(collectionView.contentOffset.x / itemSpace)

    //Skip to the next cell, if there is residual scrolling velocity left.
    //This helps to prevent glitches
    let vX = velocity.x
    if vX > 0 {
      currentItemIdx += 1
    } else if vX < 0 {
      currentItemIdx -= 1
    }

    let nearestPageOffset = currentItemIdx * itemSpace
    return CGPoint(x: nearestPageOffset,
                   y: parent.y)
  }
}

InformationsquelleAutor der Antwort Richard Topchiy

Ich gerade gefunden, was ich denke, ist die beste mögliche Lösung für dieses problem:

Fügen Sie zunächst ein Ziel für die collectionView bereits bestehenden gestureRecognizer:

[self.collectionView.panGestureRecognizer addTarget:self action:@selector(onPan:)];

Haben, den Wahlschalter auf eine Methode verweisen, die eine UIPanGestureRecognizer als parameter:

- (void)onPan:(UIPanGestureRecognizer *)recognizer {};

Dann in diese Methode, die Kraft der collectionView, um zu Blättern, um die entsprechende Zelle, wenn die pan-Geste beendet wurde.
Ich Tat dies, indem Sie die sichtbaren Objekte aus der Sammlung anzuzeigen und zu bestimmen, welche Artikel möchte ich scrollen, um abhängig von der Richtung der Pfanne.

if (recognizer.state == UIGestureRecognizerStateEnded) {

        //Get the visible items
        NSArray<NSIndexPath *> *indexes = [self.collectionView indexPathsForVisibleItems];
        int index = 0;

        if ([(UIPanGestureRecognizer *)recognizer velocityInView:self.view].x > 0) {
            //Return the smallest index if the user is swiping right
            for (int i = index;i < indexes.count;i++) {
                if (indexes[i].row < indexes[index].row) {
                    index = i;
                }
            }
        } else {
            //Return the biggest index if the user is swiping left
            for (int i = index;i < indexes.count;i++) {
                if (indexes[i].row > indexes[index].row) {
                    index = i;
                }
            }
        }
        //Scroll to the selected item
        [self.collectionView scrollToItemAtIndexPath:indexes[index] atScrollPosition:UICollectionViewScrollPositionLeft animated:YES];
    }

Beachten Sie, dass in meinem Fall nur zwei Einträge sichtbar zu einer Zeit. Ich bin mir sicher, dass diese Methode angepasst werden kann, für weitere Artikel jedoch.

InformationsquelleAutor der Antwort Julius

Wenn Sie wollen einfach native Verhalten, ohne Anpassung:

collectionView.pagingEnabled = YES;

Dieser funktioniert nur richtig, wenn die Größe der Sammlung-Ansicht layout-Elemente sind alle nur eine Größe und die UICollectionViewCell's clipToBounds Eigenschaft YES.

InformationsquelleAutor der Antwort NSDestr0yer