targetContentOffsetForProposedContentOffset: withScrollingVelocity bez podklasy UICollectionViewFlowLayout


99

Mam bardzo prostą kolekcję w mojej aplikacji (tylko jeden wiersz kwadratowych miniatur).

Chciałbym przechwycić przewijanie, aby przesunięcie zawsze pozostawiło pełny obraz po lewej stronie. W tej chwili przewija się w dowolne miejsce i pozostawia ucięte obrazy.

W każdym razie wiem, że muszę użyć tej funkcji

- (CGPoint)targetContentOffsetForProposedContentOffset:withScrollingVelocity

aby to zrobić, ale używam tylko standardu UICollectionViewFlowLayout. Nie podklasy tego.

Czy istnieje sposób na przechwycenie tego bez tworzenia podklas UICollectionViewFlowLayout?

Dzięki

Odpowiedzi:


113

OK, odpowiedź brzmi: nie, nie da się tego zrobić bez podklasy UICollectionViewFlowLayout.

Jednak tworzenie podklas jest niezwykle łatwe dla każdego, kto czyta to w przyszłości.

Najpierw skonfigurowałem wywołanie podklasy, MyCollectionViewFlowLayouta następnie w konstruktorze interfejsu zmieniłem układ widoku kolekcji na Niestandardowy i wybrałem podklasę układu przepływu.

Ponieważ robisz to w ten sposób, nie możesz określić rozmiarów elementów itp ... w IB, więc w MyCollectionViewFlowLayout.m mam to ...

- (void)awakeFromNib
{
    self.itemSize = CGSizeMake(75.0, 75.0);
    self.minimumInteritemSpacing = 10.0;
    self.minimumLineSpacing = 10.0;
    self.scrollDirection = UICollectionViewScrollDirectionHorizontal;
    self.sectionInset = UIEdgeInsetsMake(10.0, 10.0, 10.0, 10.0);
}

To ustawia dla mnie wszystkie rozmiary i kierunek przewijania.

Następnie ...

- (CGPoint)targetContentOffsetForProposedContentOffset:(CGPoint)proposedContentOffset withScrollingVelocity:(CGPoint)velocity
{
    CGFloat offsetAdjustment = MAXFLOAT;
    CGFloat horizontalOffset = proposedContentOffset.x + 5;

    CGRect targetRect = CGRectMake(proposedContentOffset.x, 0, self.collectionView.bounds.size.width, self.collectionView.bounds.size.height);

    NSArray *array = [super layoutAttributesForElementsInRect:targetRect];

    for (UICollectionViewLayoutAttributes *layoutAttributes in array) {
        CGFloat itemOffset = layoutAttributes.frame.origin.x;
        if (ABS(itemOffset - horizontalOffset) < ABS(offsetAdjustment)) {
            offsetAdjustment = itemOffset - horizontalOffset;
        }
    }

    return CGPointMake(proposedContentOffset.x + offsetAdjustment, proposedContentOffset.y);
}

Gwarantuje to, że przewijanie kończy się marginesem 5,0 na lewej krawędzi.

To wszystko, co musiałem zrobić. W ogóle nie musiałem ustawiać układu przepływu w kodzie.


1
Właściwie używany jest naprawdę potężny. Czy oglądałeś sesje Collection View z WWDC 2012? Naprawdę warto je obejrzeć. Niesamowite rzeczy.
Fogmeister

2
targetContentOffsetForProposedContentOffset:withVelocitynie jest do mnie wzywany, kiedy przewijam. Co się dzieje?
fatuhoku

4
@TomSawyer ustawił współczynnik deklaracji UICollectionView na UIScrollViewDecelerationRateFast.
Clay Ellis,

3
@fatuhoku upewnij się, że właściwość paginEnabled Twojej kolekcji collectionView jest ustawiona na wartość false
chrs

4
Święta Moly, musiałem przewinąć w dół jak milion mil, żeby zobaczyć tę odpowiedź. :)
AnBisw

67

Rozwiązanie Dana jest wadliwe. Nie radzi sobie dobrze z przesuwaniem użytkownika. Przypadki, w których użytkownik szybko klika, a scroll nie poruszał się tak bardzo, mają usterki animacji.

Proponowana przeze mnie alternatywna implementacja ma taką samą paginację jak poprzednio, ale obsługuje przeskakiwanie między stronami.

 #pragma mark - Pagination
 - (CGFloat)pageWidth {
     return self.itemSize.width + self.minimumLineSpacing;
 }

 - (CGPoint)targetContentOffsetForProposedContentOffset:(CGPoint)proposedContentOffset withScrollingVelocity:(CGPoint)velocity
 {           
        CGFloat rawPageValue = self.collectionView.contentOffset.x / self.pageWidth;
        CGFloat currentPage = (velocity.x > 0.0) ? floor(rawPageValue) : ceil(rawPageValue);
        CGFloat nextPage = (velocity.x > 0.0) ? ceil(rawPageValue) : floor(rawPageValue);

        BOOL pannedLessThanAPage = fabs(1 + currentPage - rawPageValue) > 0.5;
        BOOL flicked = fabs(velocity.x) > [self flickVelocity];
        if (pannedLessThanAPage && flicked) {
            proposedContentOffset.x = nextPage * self.pageWidth;
        } else {
            proposedContentOffset.x = round(rawPageValue) * self.pageWidth;
        }

        return proposedContentOffset;
 }

 - (CGFloat)flickVelocity {
     return 0.3;
 }

Dziękuję Ci! To zadziałało jak urok. Trochę trudno to zrozumieć, ale się tam dostać.
Rajiev Timal

Mam ten błąd: nie można przypisać do „x” w „wniosku o treść”? Używasz szybkiego? jak mogę przypisać do wartości x?
TomSawyer,

Parametry @TomSawyer są domyślnie włączone. Spróbuj zadeklarować funkcję jako tę w Swift (używając var przed param): override func targetContentOffsetForProposedContentOffset (var allowedContentOffset: CGPoint) -> CGPoint
DarthMike

1
Nie możesz szybko użyć CGPointMake. Osobiście użyłem tego: "var targetContentOffset: CGPoint if pannedLessThanAPage && flicked {targetContentOffset = CGPoint (x: nextPage * pageWidth (), y: recommendedContentOffset.y);} else {targetContentOffset = CGPoint (x: round (rawPageVidue) * ), y: recommendedContentOffset.y);} return recommendedContentOffset "
Plot

1
Powinna to być wybrana odpowiedź.
khunshan

26

Szybka wersja zaakceptowanej odpowiedzi.

override func targetContentOffset(forProposedContentOffset proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -> CGPoint {
    var offsetAdjustment = CGFloat.greatestFiniteMagnitude
    let horizontalOffset = proposedContentOffset.x
    let targetRect = CGRect(origin: CGPoint(x: proposedContentOffset.x, y: 0), size: self.collectionView!.bounds.size)

    for layoutAttributes in super.layoutAttributesForElements(in: targetRect)! {
        let itemOffset = layoutAttributes.frame.origin.x
        if (abs(itemOffset - horizontalOffset) < abs(offsetAdjustment)) {
            offsetAdjustment = itemOffset - horizontalOffset
        }
    }

    return CGPoint(x: proposedContentOffset.x + offsetAdjustment, y: proposedContentOffset.y)
}    

Obowiązuje dla Swift 5 .


Ta wersja działa świetnie i działa również dobrze dla osi Y, jeśli zamienisz kod.
Chris

Przeważnie sprawdza się tutaj świetnie. Ale jeśli przestanę przewijać i podniosę palec (ostrożnie), nie przewinie on żadnej strony i po prostu się na tym zatrzyma.
Christian A. Strømmen

@ ChristianA.Strømmen Dziwne, działa dobrze z moją aplikacją.
André Abreu

@ AndréAbreu, gdzie umieścić tę funkcję?
FlowUI. SimpleUITesting.com

2
@Jay Musisz utworzyć podklasę UICollectionViewLayout lub dowolną klasę, która już jest podklasą (np. UICollectionViewFlowLayout).
André Abreu,

24

Oto moja implementacja w Swift 5 do stronicowania pionowego opartego na komórkach:

override func targetContentOffset(forProposedContentOffset proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -> CGPoint {

    guard let collectionView = self.collectionView else {
        let latestOffset = super.targetContentOffset(forProposedContentOffset: proposedContentOffset, withScrollingVelocity: velocity)
        return latestOffset
    }

    // Page height used for estimating and calculating paging.
    let pageHeight = self.itemSize.height + self.minimumLineSpacing

    // Make an estimation of the current page position.
    let approximatePage = collectionView.contentOffset.y/pageHeight

    // Determine the current page based on velocity.
    let currentPage = velocity.y == 0 ? round(approximatePage) : (velocity.y < 0.0 ? floor(approximatePage) : ceil(approximatePage))

    // Create custom flickVelocity.
    let flickVelocity = velocity.y * 0.3

    // Check how many pages the user flicked, if <= 1 then flickedPages should return 0.
    let flickedPages = (abs(round(flickVelocity)) <= 1) ? 0 : round(flickVelocity)

    let newVerticalOffset = ((currentPage + flickedPages) * pageHeight) - collectionView.contentInset.top

    return CGPoint(x: proposedContentOffset.x, y: newVerticalOffset)
}

Kilka uwag:

  • Nie glitch
  • USTAW PAGING NA FAŁSZ ! (w przeciwnym razie to nie zadziała)
  • Pozwala łatwo ustawić własną prędkość ruchu .
  • Jeśli po wypróbowaniu tego coś nadal nie działa, sprawdź, czy itemSizefaktycznie pasuje on do rozmiaru przedmiotu, ponieważ często stanowi to problem, zwłaszcza podczas używania collectionView(_:layout:sizeForItemAt:), zamiast tego użyj niestandardowej zmiennej z itemSize.
  • Działa to najlepiej, gdy ustawisz self.collectionView.decelerationRate = UIScrollView.DecelerationRate.fast.

Oto wersja pozioma (nie przetestowałem jej dokładnie, więc proszę wybaczyć wszelkie błędy):

override func targetContentOffset(forProposedContentOffset proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -> CGPoint {

    guard let collectionView = self.collectionView else {
        let latestOffset = super.targetContentOffset(forProposedContentOffset: proposedContentOffset, withScrollingVelocity: velocity)
        return latestOffset
    }

    // Page width used for estimating and calculating paging.
    let pageWidth = self.itemSize.width + self.minimumInteritemSpacing

    // Make an estimation of the current page position.
    let approximatePage = collectionView.contentOffset.x/pageWidth

    // Determine the current page based on velocity.
    let currentPage = velocity.x == 0 ? round(approximatePage) : (velocity.x < 0.0 ? floor(approximatePage) : ceil(approximatePage))

    // Create custom flickVelocity.
    let flickVelocity = velocity.x * 0.3

    // Check how many pages the user flicked, if <= 1 then flickedPages should return 0.
    let flickedPages = (abs(round(flickVelocity)) <= 1) ? 0 : round(flickVelocity)

    // Calculate newHorizontalOffset.
    let newHorizontalOffset = ((currentPage + flickedPages) * pageWidth) - collectionView.contentInset.left

    return CGPoint(x: newHorizontalOffset, y: proposedContentOffset.y)
}

Ten kod jest oparty na kodzie, którego używam w moim osobistym projekcie, możesz go sprawdzić tutaj , pobierając go i uruchamiając przykładowy cel.


4
Jesteś zbawcą życia! Ważna uwaga, aby USTAWIĆ PAGING NA FAŁSZ !!! Straciłem jakieś 2 godziny życia naprawiając twoją funkcję, która już działa ...
denis631

@ denis631 Tak mi przykro! Powinienem był to dodać, zmienię post, aby to odzwierciedlić! Cieszę się, że zadziałało :)
JoniVR

jesssus, zastanawiałem się, dlaczego to nie działa, dopóki nie zobaczyłem tego komentarza o wyłączaniu stronicowania ... oczywiście mój był ustawiony na true
Kam Wo

@JoniVR Pokazuje mi ten błąd Metoda nie zastępuje żadnej metody z jej superklasy
Muju

22

Chociaż ta odpowiedź była dla mnie bardzo pomocna, zauważalne jest migotanie podczas szybkiego przesuwania na niewielkiej odległości. O wiele łatwiej jest odtworzyć go na urządzeniu.

Odkryłem, że to zawsze się dzieje collectionView.contentOffset.x - proposedContentOffset.xi velocity.xma różne śpiewa.

Moje rozwiązanie polegało na upewnieniu się, że proposedContentOffsetjest to więcej niż w contentOffset.xprzypadku prędkości dodatniej, a mniejsze, jeśli jest ujemne. Jest w C #, ale powinno być dość proste do przetłumaczenia na Objective C:

public override PointF TargetContentOffset (PointF proposedContentOffset, PointF scrollingVelocity)
{
    /* Determine closest edge */

    float offSetAdjustment = float.MaxValue;
    float horizontalCenter = (float) (proposedContentOffset.X + (this.CollectionView.Bounds.Size.Width / 2.0));

    RectangleF targetRect = new RectangleF (proposedContentOffset.X, 0.0f, this.CollectionView.Bounds.Size.Width, this.CollectionView.Bounds.Size.Height);
    var array = base.LayoutAttributesForElementsInRect (targetRect);

    foreach (var layoutAttributes in array) {
        float itemHorizontalCenter = layoutAttributes.Center.X;
        if (Math.Abs (itemHorizontalCenter - horizontalCenter) < Math.Abs (offSetAdjustment)) {
            offSetAdjustment = itemHorizontalCenter - horizontalCenter;
        }
    }

    float nextOffset = proposedContentOffset.X + offSetAdjustment;

    /*
     * ... unless we end up having positive speed
     * while moving left or negative speed while moving right.
     * This will cause flicker so we resort to finding next page
     * in the direction of velocity and use it.
     */

    do {
        proposedContentOffset.X = nextOffset;

        float deltaX = proposedContentOffset.X - CollectionView.ContentOffset.X;
        float velX = scrollingVelocity.X;

        // If their signs are same, or if either is zero, go ahead
        if (Math.Sign (deltaX) * Math.Sign (velX) != -1)
            break;

        // Otherwise, look for the closest page in the right direction
        nextOffset += Math.Sign (scrollingVelocity.X) * SnapStep;
    } while (IsValidOffset (nextOffset));

    return proposedContentOffset;
}

bool IsValidOffset (float offset)
{
    return (offset >= MinContentOffset && offset <= MaxContentOffset);
}

Ten kod jest używany MinContentOffset, MaxContentOffseta SnapStepjego zdefiniowanie powinno być proste. W moim przypadku okazali się

float MinContentOffset {
    get { return -CollectionView.ContentInset.Left; }
}

float MaxContentOffset {
    get { return MinContentOffset + CollectionView.ContentSize.Width - ItemSize.Width; }
}

float SnapStep {
    get { return ItemSize.Width + MinimumLineSpacing; }
}

7
To działa naprawdę dobrze. Przekonwertowałem go na Objective-C dla zainteresowanych: gist.github.com/rkeniger/7687301
Rob

21

Po długich testach znalazłem rozwiązanie polegające na przyciągnięciu do środka z niestandardową szerokością komórki (każda komórka ma różną szerokość), co eliminuje migotanie. Zapraszam do ulepszania skryptu.

- (CGPoint) targetContentOffsetForProposedContentOffset: (CGPoint) proposedContentOffset withScrollingVelocity: (CGPoint)velocity
{
    CGFloat offSetAdjustment = MAXFLOAT;
    CGFloat horizontalCenter = (CGFloat) (proposedContentOffset.x + (self.collectionView.bounds.size.width / 2.0));

    //setting fastPaging property to NO allows to stop at page on screen (I have pages lees, than self.collectionView.bounds.size.width)
    CGRect targetRect = CGRectMake(self.fastPaging ? proposedContentOffset.x : self.collectionView.contentOffset.x, 
                                   0.0,
                                   self.collectionView.bounds.size.width,
                                   self.collectionView.bounds.size.height);

    NSArray *attributes = [self layoutAttributesForElementsInRect:targetRect];
    NSPredicate *cellAttributesPredicate = [NSPredicate predicateWithBlock: ^BOOL(UICollectionViewLayoutAttributes * _Nonnull evaluatedObject,
                                                                             NSDictionary<NSString *,id> * _Nullable bindings) 
    {
        return (evaluatedObject.representedElementCategory == UICollectionElementCategoryCell); 
    }];        

    NSArray *cellAttributes = [attributes filteredArrayUsingPredicate: cellAttributesPredicate];

    UICollectionViewLayoutAttributes *currentAttributes;

    for (UICollectionViewLayoutAttributes *layoutAttributes in cellAttributes)
    {
        CGFloat itemHorizontalCenter = layoutAttributes.center.x;
        if (ABS(itemHorizontalCenter - horizontalCenter) < ABS(offSetAdjustment))
        {
            currentAttributes   = layoutAttributes;
            offSetAdjustment    = itemHorizontalCenter - horizontalCenter;
        }
    }

    CGFloat nextOffset          = proposedContentOffset.x + offSetAdjustment;

    proposedContentOffset.x     = nextOffset;
    CGFloat deltaX              = proposedContentOffset.x - self.collectionView.contentOffset.x;
    CGFloat velX                = velocity.x;

    // detection form  gist.github.com/rkeniger/7687301
    // based on http://stackoverflow.com/a/14291208/740949
    if (fabs(deltaX) <= FLT_EPSILON || fabs(velX) <= FLT_EPSILON || (velX > 0.0 && deltaX > 0.0) || (velX < 0.0 && deltaX < 0.0)) 
    {

    } 
    else if (velocity.x > 0.0) 
    {
       // revert the array to get the cells from the right side, fixes not correct center on different size in some usecases
        NSArray *revertedArray = [[array reverseObjectEnumerator] allObjects];

        BOOL found = YES;
        float proposedX = 0.0;

        for (UICollectionViewLayoutAttributes *layoutAttributes in revertedArray)
        {
            if(layoutAttributes.representedElementCategory == UICollectionElementCategoryCell)
            {
                CGFloat itemHorizontalCenter = layoutAttributes.center.x;
                if (itemHorizontalCenter > proposedContentOffset.x) {
                     found = YES;
                     proposedX = nextOffset + (currentAttributes.frame.size.width / 2) + (layoutAttributes.frame.size.width / 2);
                } else {
                     break;
                }
            }
        }

       // dont set on unfound element
        if (found) {
            proposedContentOffset.x = proposedX;
        }
    } 
    else if (velocity.x < 0.0) 
    {
        for (UICollectionViewLayoutAttributes *layoutAttributes in cellAttributes)
        {
            CGFloat itemHorizontalCenter = layoutAttributes.center.x;
            if (itemHorizontalCenter > proposedContentOffset.x) 
            {
                proposedContentOffset.x = nextOffset - ((currentAttributes.frame.size.width / 2) + (layoutAttributes.frame.size.width / 2));
                break;
            }
        }
    }

    proposedContentOffset.y = 0.0;

    return proposedContentOffset;
}

10
Najlepsze rozwiązanie ze wszystkich, dzięki! Również dla przyszłych czytelników, musisz wyłączyć stronicowanie, aby to zadziałało.
sridvijay

1
Gdyby ktoś chciał wyrównać go od lewej, zamiast komórki wyrównanej do środka, jak moglibyśmy to zmienić?
CyberMew

Nie jestem pewien, czy dobrze rozumiem, ale jeśli chcesz rozpocząć elementy w środku i wyrównać je do środka, musisz zmienić contentInset. Używam tego: gist.github.com/pionl/432fc8059dee3b540e38
Pion

Aby wyrównać pozycję X komórki do środka widoku, po prostu usuń + (layoutAttributes.frame.size.width / 2) w sekcji velocity.
Pion

1
@Jay Cześć, po prostu utwórz niestandardowego delegata Flow i dodaj do niego ten kod. Nie zapomnij ustawić niestandardowego układu w końcówce lub kodzie.
Pion

18

odwołaj się do tej odpowiedzi Dana Abramova tutaj wersja Swift

    override func targetContentOffsetForProposedContentOffset(proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -> CGPoint {
    var _proposedContentOffset = CGPoint(x: proposedContentOffset.x, y: proposedContentOffset.y)
    var offSetAdjustment: CGFloat = CGFloat.max
    let horizontalCenter: CGFloat = CGFloat(proposedContentOffset.x + (self.collectionView!.bounds.size.width / 2.0))

    let targetRect = CGRect(x: proposedContentOffset.x, y: 0.0, width: self.collectionView!.bounds.size.width, height: self.collectionView!.bounds.size.height)

    let array: [UICollectionViewLayoutAttributes] = self.layoutAttributesForElementsInRect(targetRect)! as [UICollectionViewLayoutAttributes]
    for layoutAttributes: UICollectionViewLayoutAttributes in array {
        if (layoutAttributes.representedElementCategory == UICollectionElementCategory.Cell) {
            let itemHorizontalCenter: CGFloat = layoutAttributes.center.x
            if (abs(itemHorizontalCenter - horizontalCenter) < abs(offSetAdjustment)) {
                offSetAdjustment = itemHorizontalCenter - horizontalCenter
            }
        }
    }

    var nextOffset: CGFloat = proposedContentOffset.x + offSetAdjustment

    repeat {
        _proposedContentOffset.x = nextOffset
        let deltaX = proposedContentOffset.x - self.collectionView!.contentOffset.x
        let velX = velocity.x

        if (deltaX == 0.0 || velX == 0 || (velX > 0.0 && deltaX > 0.0) || (velX < 0.0 && deltaX < 0.0)) {
            break
        }

        if (velocity.x > 0.0) {
            nextOffset = nextOffset + self.snapStep()
        } else if (velocity.x < 0.0) {
            nextOffset = nextOffset - self.snapStep()
        }
    } while self.isValidOffset(nextOffset)

    _proposedContentOffset.y = 0.0

    return _proposedContentOffset
}

func isValidOffset(offset: CGFloat) -> Bool {
    return (offset >= CGFloat(self.minContentOffset()) && offset <= CGFloat(self.maxContentOffset()))
}

func minContentOffset() -> CGFloat {
    return -CGFloat(self.collectionView!.contentInset.left)
}

func maxContentOffset() -> CGFloat {
    return CGFloat(self.minContentOffset() + self.collectionView!.contentSize.width - self.itemSize.width)
}

func snapStep() -> CGFloat {
    return self.itemSize.width + self.minimumLineSpacing;
}

lub podsumuj tutaj https://gist.github.com/katopz/8b04c783387f0c345cd9


4
Zaktualizowana wersja tego dla Swift 3: gist.github.com/mstubna/beed10327e00310d05f12bf4747266a4
mstubna

1
Cholera @mstubna, skopiowałem powyższe, zaktualizowałem do wersji SWIFT 3, zacząłem tworzyć zaktualizowaną treść i wróciłem tutaj, aby zebrać notatki / tytuł, w którym momencie zauważyłem, że wykonałeś już szybkie 3 streszczenie. Dzięki! Szkoda, że ​​to przegapiłem.
VaporwareWolf

16

Dla każdego, kto szuka rozwiązania, które ...

  • NIE DZIAŁA, gdy użytkownik wykonuje krótkie szybkie przewijanie (tj. Bierze pod uwagę dodatnią i ujemną prędkość przewijania)
  • bierze pod uwagę collectionView.contentInset(i safeArea na iPhonie X)
  • uwzględnia tylko te komórki widoczne w miejscu przewijania (dla wydajności)
  • używa dobrze nazwanych zmiennych i komentarzy
  • jest Swift 4

zobacz poniżej ...

public class CarouselCollectionViewLayout: UICollectionViewFlowLayout {

    override public func targetContentOffset(forProposedContentOffset proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -> CGPoint {

        guard let collectionView = collectionView else {
            return super.targetContentOffset(forProposedContentOffset: proposedContentOffset, withScrollingVelocity: velocity)
        }

        // Identify the layoutAttributes of cells in the vicinity of where the scroll view will come to rest
        let targetRect = CGRect(origin: proposedContentOffset, size: collectionView.bounds.size)
        let visibleCellsLayoutAttributes = layoutAttributesForElements(in: targetRect)

        // Translate those cell layoutAttributes into potential (candidate) scrollView offsets
        let candidateOffsets: [CGFloat]? = visibleCellsLayoutAttributes?.map({ cellLayoutAttributes in
            if #available(iOS 11.0, *) {
                return cellLayoutAttributes.frame.origin.x - collectionView.contentInset.left - collectionView.safeAreaInsets.left - sectionInset.left
            } else {
                return cellLayoutAttributes.frame.origin.x - collectionView.contentInset.left - sectionInset.left
            }
        })

        // Now we need to work out which one of the candidate offsets is the best one
        let bestCandidateOffset: CGFloat

        if velocity.x > 0 {
            // If the scroll velocity was POSITIVE, then only consider cells/offsets to the RIGHT of the proposedContentOffset.x
            // Of the cells/offsets to the right, the NEAREST is the `bestCandidate`
            // If there is no nearestCandidateOffsetToLeft then we default to the RIGHT-MOST (last) of ALL the candidate cells/offsets
            //      (this handles the scenario where the user has scrolled beyond the last cell)
            let candidateOffsetsToRight = candidateOffsets?.toRight(ofProposedOffset: proposedContentOffset.x)
            let nearestCandidateOffsetToRight = candidateOffsetsToRight?.nearest(toProposedOffset: proposedContentOffset.x)
            bestCandidateOffset = nearestCandidateOffsetToRight ?? candidateOffsets?.last ?? proposedContentOffset.x
        }
        else if velocity.x < 0 {
            // If the scroll velocity was NEGATIVE, then only consider cells/offsets to the LEFT of the proposedContentOffset.x
            // Of the cells/offsets to the left, the NEAREST is the `bestCandidate`
            // If there is no nearestCandidateOffsetToLeft then we default to the LEFT-MOST (first) of ALL the candidate cells/offsets
            //      (this handles the scenario where the user has scrolled beyond the first cell)
            let candidateOffsetsToLeft = candidateOffsets?.toLeft(ofProposedOffset: proposedContentOffset.x)
            let nearestCandidateOffsetToLeft = candidateOffsetsToLeft?.nearest(toProposedOffset: proposedContentOffset.x)
            bestCandidateOffset = nearestCandidateOffsetToLeft ?? candidateOffsets?.first ?? proposedContentOffset.x
        }
        else {
            // If the scroll velocity was ZERO we consider all `candidate` cells (regarless of whether they are to the left OR right of the proposedContentOffset.x)
            // The cell/offset that is the NEAREST is the `bestCandidate`
            let nearestCandidateOffset = candidateOffsets?.nearest(toProposedOffset: proposedContentOffset.x)
            bestCandidateOffset = nearestCandidateOffset ??  proposedContentOffset.x
        }

        return CGPoint(x: bestCandidateOffset, y: proposedContentOffset.y)
    }

}

fileprivate extension Sequence where Iterator.Element == CGFloat {

    func toLeft(ofProposedOffset proposedOffset: CGFloat) -> [CGFloat] {

        return filter() { candidateOffset in
            return candidateOffset < proposedOffset
        }
    }

    func toRight(ofProposedOffset proposedOffset: CGFloat) -> [CGFloat] {

        return filter() { candidateOffset in
            return candidateOffset > proposedOffset
        }
    }

    func nearest(toProposedOffset proposedOffset: CGFloat) -> CGFloat? {

        guard let firstCandidateOffset = first(where: { _ in true }) else {
            // If there are no elements in the Sequence, return nil
            return nil
        }

        return reduce(firstCandidateOffset) { (bestCandidateOffset: CGFloat, candidateOffset: CGFloat) -> CGFloat in

            let candidateOffsetDistanceFromProposed = fabs(candidateOffset - proposedOffset)
            let bestCandidateOffsetDistancFromProposed = fabs(bestCandidateOffset - proposedOffset)

            if candidateOffsetDistanceFromProposed < bestCandidateOffsetDistancFromProposed {
                return candidateOffset
            }

            return bestCandidateOffset
        }
    }
}

1
Dzięki! właśnie skopiowany i wklejony, działa idealnie .. o wiele lepiej zgodnie z oczekiwaniami.
Steven B.

1
Jedyne rozwiązanie, które faktycznie działa. Dobra robota! Dzięki!
LinusGeffarth

1
return cellLayoutAttributes.frame.origin.x - collectionView.contentInset.left - collectionView.safeAreaInsets.left patientOffsets - sectionInset.left jest problem w tej linii
Utku Dalmaz

1
@Dalmaz dzięki za powiadomienie mnie. Naprawiłem teraz problem.
Oliver Pearmain

1
Tak, właśnie skopiowałem i wkleiłem, oszczędzasz mój czas.
Wei

7

Oto moje rozwiązanie Swift w widoku kolekcji przewijanym w poziomie. Jest prosty, słodki i zapobiega migotaniu.

  override func targetContentOffsetForProposedContentOffset(proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -> CGPoint {
    guard let collectionView = collectionView else { return proposedContentOffset }

    let currentXOffset = collectionView.contentOffset.x
    let nextXOffset = proposedContentOffset.x
    let maxIndex = ceil(currentXOffset / pageWidth())
    let minIndex = floor(currentXOffset / pageWidth())

    var index: CGFloat = 0

    if nextXOffset > currentXOffset {
      index = maxIndex
    } else {
      index = minIndex
    }

    let xOffset = pageWidth() * index
    let point = CGPointMake(xOffset, 0)

    return point
  }

  func pageWidth() -> CGFloat {
    return itemSize.width + minimumInteritemSpacing
  }

co to jest itemSize??
Konstantinos Natsios

Jest to rozmiar komórek kolekcji. Te funkcje są używane podczas tworzenia podklas UICollectionViewFlowLayout.
Scott Kaiser


1
Podoba mi się to rozwiązanie, ale mam kilka uwag. pageWidth()powinien używać, minimumLineSpacingponieważ przewija się poziomo. W moim przypadku mam contentInsetwidok kolekcji, aby można było wyśrodkować pierwszą i ostatnią komórkę, więc używam let xOffset = pageWidth() * index - collectionView.contentInset.left.
blwinters

6

mały problem, który napotkałem podczas korzystania z targetContentOffsetForProposedContentOffset, to problem z ostatnią komórką, która nie dostosowywała się do nowego punktu, który zwróciłem.
Dowiedziałem się, że CGPoint, który zwróciłem, miał wartość Y większą niż dozwolona, ​​więc użyłem następującego kodu na końcu mojej implementacji targetContentOffsetForProposedContentOffset:

// if the calculated y is bigger then the maximum possible y we adjust accordingly
CGFloat contentHeight = self.collectionViewContentSize.height;
CGFloat collectionViewHeight = self.collectionView.bounds.size.height;
CGFloat maxY = contentHeight - collectionViewHeight;
if (newY > maxY)
{
    newY = maxY;
}

return CGPointMake(0, newY);

żeby było jaśniej, oto moja pełna implementacja układu, która po prostu imituje zachowanie stronicowania w pionie:

- (CGPoint)targetContentOffsetForProposedContentOffset:(CGPoint)proposedContentOffset withScrollingVelocity:(CGPoint)velocity
{
    return [self targetContentOffsetForProposedContentOffset:proposedContentOffset];
}

- (CGPoint)targetContentOffsetForProposedContentOffset:(CGPoint)proposedContentOffset
{
    CGFloat heightOfPage = self.itemSize.height;
    CGFloat heightOfSpacing = self.minimumLineSpacing;

    CGFloat numOfPage = lround(proposedContentOffset.y / (heightOfPage + heightOfSpacing));
    CGFloat newY = numOfPage * (heightOfPage + heightOfSpacing);

    // if the calculated y is bigger then the maximum possible y we adjust accordingly
    CGFloat contentHeight = self.collectionViewContentSize.height;
    CGFloat collectionViewHeight = self.collectionView.bounds.size.height;
    CGFloat maxY = contentHeight - collectionViewHeight;
    if (newY > maxY)
    {
        newY = maxY;
    }

    return CGPointMake(0, newY);
}

miejmy nadzieję, że zaoszczędzi to komuś czasu i bólu głowy


1
Ten sam problem, wygląda na to, że widok kolekcji ignoruje nieprawidłowe wartości zamiast zaokrąglać je do swoich granic.
Mike M

6

Wolę, aby użytkownik mógł przeglądać kilka stron. Oto moja wersja targetContentOffsetForProposedContentOffset(oparta na odpowiedzi DarthMike) dla układu pionowego .

- (CGPoint)targetContentOffsetForProposedContentOffset:(CGPoint)proposedContentOffset withScrollingVelocity:(CGPoint)velocity {
    CGFloat approximatePage = self.collectionView.contentOffset.y / self.pageHeight;
    CGFloat currentPage = (velocity.y < 0.0) ? floor(approximatePage) : ceil(approximatePage);

    NSInteger flickedPages = ceil(velocity.y / self.flickVelocity);

    if (flickedPages) {
        proposedContentOffset.y = (currentPage + flickedPages) * self.pageHeight;
    } else {
        proposedContentOffset.y = currentPage * self.pageHeight;
    }

    return proposedContentOffset;
}

- (CGFloat)pageHeight {
    return self.itemSize.height + self.minimumLineSpacing;
}

- (CGFloat)flickVelocity {
    return 1.2;
}

4

Odpowiedź Fogmeister działała dla mnie, chyba że przewinęłam do końca wiersza. Moje komórki nie mieszczą się dokładnie na ekranie, więc przewijałyby się do końca i szarpały z powrotem, tak że ostatnia komórka zawsze zachodziła na prawą krawędź ekranu.

Aby temu zapobiec, dodaj następujący wiersz kodu na początku metody targetcontentoffset

if(proposedContentOffset.x>self.collectionViewContentSize.width-320-self.sectionInset.right)
    return proposedContentOffset;

Przypuszczam, że 320 to szerokość widoku twojej kolekcji :)
Au Ris

Uwielbiam spoglądać wstecz na stary kod. Myślę, że to była ta magiczna liczba.
Ajaxharg

2

Kod @ André Abreu

Wersja Swift3

class CustomCollectionViewFlowLayout: UICollectionViewFlowLayout {
    override func targetContentOffset(forProposedContentOffset proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -> CGPoint {
        var offsetAdjustment = CGFloat.greatestFiniteMagnitude
        let horizontalOffset = proposedContentOffset.x
        let targetRect = CGRect(x: proposedContentOffset.x, y: 0, width: self.collectionView!.bounds.size.width, height: self.collectionView!.bounds.size.height)
        for layoutAttributes in super.layoutAttributesForElements(in: targetRect)! {
            let itemOffset = layoutAttributes.frame.origin.x
            if abs(itemOffset - horizontalOffset) < abs(offsetAdjustment){
                offsetAdjustment = itemOffset - horizontalOffset
            }
        }
        return CGPoint(x: proposedContentOffset.x + offsetAdjustment, y: proposedContentOffset.y)
    }
}

Dziękuję za to! Najlepsze oczekiwane zachowanie. Bardzo dziękuję!
G Clovs

2

Szybki 4

Najłatwiejsze rozwiązanie dla widoku kolekcji z komórkami o jednym rozmiarze (przewijanie w poziomie):

override func targetContentOffset(forProposedContentOffset proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -> CGPoint {
    guard let collectionView = collectionView else { return proposedContentOffset }

    // Calculate width of your page
    let pageWidth = calculatedPageWidth()

    // Calculate proposed page
    let proposedPage = round(proposedContentOffset.x / pageWidth)

    // Adjust necessary offset
    let xOffset = pageWidth * proposedPage - collectionView.contentInset.left

    return CGPoint(x: xOffset, y: 0)
}

func calculatedPageWidth() -> CGFloat {
    return itemSize.width + minimumInteritemSpacing
}

2

Krótsze rozwiązanie (zakładając, że buforujesz atrybuty układu):

override func targetContentOffset(forProposedContentOffset proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -> CGPoint {
    let proposedEndFrame = CGRect(x: proposedContentOffset.x, y: 0, width: collectionView!.bounds.width, height: collectionView!.bounds.height)
    let targetLayoutAttributes = cache.max { $0.frame.intersection(proposedEndFrame).width < $1.frame.intersection(proposedEndFrame).width }!
    return CGPoint(x: targetLayoutAttributes.frame.minX - horizontalPadding, y: 0)
}

Aby umieścić to w kontekście:

class Layout : UICollectionViewLayout {
    private var cache: [UICollectionViewLayoutAttributes] = []
    private static let horizontalPadding: CGFloat = 16
    private static let interItemSpacing: CGFloat = 8

    override func prepare() {
        let (itemWidth, itemHeight) = (collectionView!.bounds.width - 2 * Layout.horizontalPadding, collectionView!.bounds.height)
        cache.removeAll()
        let count = collectionView!.numberOfItems(inSection: 0)
        var x: CGFloat = Layout.horizontalPadding
        for item in (0..<count) {
            let indexPath = IndexPath(item: item, section: 0)
            let attributes = UICollectionViewLayoutAttributes(forCellWith: indexPath)
            attributes.frame = CGRect(x: x, y: 0, width: itemWidth, height: itemHeight)
            cache.append(attributes)
            x += itemWidth + Layout.interItemSpacing
        }
    }

    override var collectionViewContentSize: CGSize {
        let width: CGFloat
        if let maxX = cache.last?.frame.maxX {
            width = maxX + Layout.horizontalPadding
        } else {
            width = collectionView!.width
        }
        return CGSize(width: width, height: collectionView!.height)
    }

    override func layoutAttributesForItem(at indexPath: IndexPath) -> UICollectionViewLayoutAttributes? {
        return cache.first { $0.indexPath == indexPath }
    }

    override func layoutAttributesForElements(in rect: CGRect) -> [UICollectionViewLayoutAttributes]? {
        return cache.filter { $0.frame.intersects(rect) }
    }

    override func targetContentOffset(forProposedContentOffset proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -> CGPoint {
        let proposedEndFrame = CGRect(x: proposedContentOffset.x, y: 0, width: collectionView!.bounds.width, height: collectionView!.bounds.height)
        let targetLayoutAttributes = cache.max { $0.frame.intersection(proposedEndFrame).width < $1.frame.intersection(proposedEndFrame).width }!
        return CGPoint(x: targetLayoutAttributes.frame.minX - Layout.horizontalPadding, y: 0)
    }
}

1

Aby upewnić się, że działa w wersji Swift (teraz Swift 5), skorzystałem z odpowiedzi od @ André Abreu, dodaję więcej informacji:

Podczas tworzenia podklas UICollectionViewFlowLayout, "override func awakeFromNib () {}" nie działa (nie wiem dlaczego). Zamiast tego użyłem „override init () {super.init ()}”

Oto mój kod umieszczony w klasie SubclassFlowLayout: UICollectionViewFlowLayout {}:

let padding: CGFloat = 16
override init() {
    super.init()
    self.minimumLineSpacing = padding
    self.minimumInteritemSpacing = 2
    self.scrollDirection = .horizontal
    self.sectionInset = UIEdgeInsets(top: 0, left: padding, bottom: 0, right: 100) //right = "should set for footer" (Horizental)

}

required init?(coder: NSCoder) {
    fatalError("init(coder:) has not been implemented")
}

override func targetContentOffset(forProposedContentOffset proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -> CGPoint {
    var offsetAdjustment = CGFloat.greatestFiniteMagnitude
    let leftInset = padding
    let horizontalOffset = proposedContentOffset.x + leftInset // leftInset is for "where you want the item stop on the left"
    let targetRect = CGRect(origin: CGPoint(x: proposedContentOffset.x, y: 0), size: self.collectionView!.bounds.size)

    for layoutAttributes in super.layoutAttributesForElements(in: targetRect)! {
        let itemOffset = layoutAttributes.frame.origin.x
        if (abs(itemOffset - horizontalOffset) < abs(offsetAdjustment)) {
            offsetAdjustment = itemOffset - horizontalOffset
        }
    }

    let targetPoint = CGPoint(x: proposedContentOffset.x + offsetAdjustment, y: proposedContentOffset.y)
    return targetPoint

}

Po utworzeniu podklasy pamiętaj, aby umieścić to w ViewDidLoad ():

customCollectionView.collectionViewLayout = SubclassFlowLayout()
customCollectionView.isPagingEnabled = false
customCollectionView.decelerationRate = .fast //-> this for scrollView speed

0

Dla szukających rozwiązania w Swift:

class CustomCollectionViewFlowLayout: UICollectionViewFlowLayout {
    private let collectionViewHeight: CGFloat = 200.0
    private let screenWidth: CGFloat = UIScreen.mainScreen().bounds.width

    override func awakeFromNib() {
        super.awakeFromNib()

        self.itemSize = CGSize(width: [InsertItemWidthHere], height: [InsertItemHeightHere])
        self.minimumInteritemSpacing = [InsertItemSpacingHere]
        self.scrollDirection = .Horizontal
        let inset = (self.screenWidth - CGFloat(self.itemSize.width)) / 2
        self.collectionView?.contentInset = UIEdgeInsets(top: 0,
                                                         left: inset,
                                                         bottom: 0,
                                                         right: inset)
    }

    override func targetContentOffsetForProposedContentOffset(proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -> CGPoint {
        var offsetAdjustment = CGFloat.max
        let horizontalOffset = proposedContentOffset.x + ((self.screenWidth - self.itemSize.width) / 2)

        let targetRect = CGRect(x: proposedContentOffset.x, y: 0, width: self.screenWidth, height: self.collectionViewHeight)
        var array = super.layoutAttributesForElementsInRect(targetRect)

        for layoutAttributes in array! {
            let itemOffset = layoutAttributes.frame.origin.x
            if (abs(itemOffset - horizontalOffset) < abs(offsetAdjustment)) {
                offsetAdjustment = itemOffset - horizontalOffset
            }
        }

        return CGPoint(x: proposedContentOffset.x + offsetAdjustment, y: proposedContentOffset.y)
    }
}

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.