UICollectionAfficher l'index de cellule visible actuel

J'utilise pour la UICollectionViewpremière fois dans mon application iPad. J'ai défini de UICollectionViewtelle sorte que sa taille et sa taille de cellule soient identiques, ce qui signifie qu'une seule cellule est affichée à la fois.

Problème: maintenant, lorsque l'utilisateur fait défiler UICollectionView, j'ai besoin de savoir quelle cellule est visible, je dois mettre à jour d'autres éléments de l'interface utilisateur en cas de modification. Je n'ai trouvé aucune méthode déléguée pour cela. Comment puis-je atteindre cet objectif?

Code:

[self.mainImageCollection setTag:MAIN_IMAGE_COLLECTION_VIEW];
[self.mainImageCollection registerClass:[InspirationMainImageCollectionCell class] forCellWithReuseIdentifier:@"cellIdentifier"];
[self.mainImageFlowLayout setScrollDirection:UICollectionViewScrollDirectionHorizontal];
[self.mainImageFlowLayout setMinimumInteritemSpacing:0.0f];
[self.mainImageFlowLayout setMinimumLineSpacing:0.0f];
self.mainImageFlowLayout.minimumLineSpacing = 0;
[self.mainImageCollection setPagingEnabled:YES];
[self.mainImageCollection setShowsHorizontalScrollIndicator:NO];
[self.mainImageCollection setCollectionViewLayout:self.mainImageFlowLayout];

Ce que j'ai essayé:

Comme UICollectionViewconforme à UIScrollView, j'ai obtenu lorsque le défilement de l'utilisateur se termine par la UIScrollViewDelegateméthode

-(void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView

Mais à l'intérieur de la fonction ci-dessus, comment puis-je obtenir l'indice de cellule visible actuel de UICollectionView???

La méthode [collectionView visibleCells] vous donne tous les tableaux visiblesCells que vous voulez. Utilisez-le lorsque vous voulez obtenir

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView{
    for (UICollectionViewCell *cell in [self.mainImageCollection visibleCells]) {
        NSIndexPath *indexPath = [self.mainImageCollection indexPathForCell:cell];
        NSLog(@"%@",indexPath);
    }
}

Mettre à jour vers Swift 5:

func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
    for cell in yourCollectionView.visibleCells {
        let indexPath = yourCollectionView.indexPath(for: cell)
        print(indexPath)
    }
}

indexPathsForVisibleItemspeut fonctionner dans la plupart des situations, mais il renvoie parfois un tableau avec plus d'un chemin d'index et il peut être difficile de déterminer celui que vous voulez. Dans ces situations, vous pouvez faire quelque chose comme ceci:

CGRect visibleRect = (CGRect){.origin = self.collectionView.contentOffset, .size = self.collectionView.bounds.size};
CGPoint visiblePoint = CGPointMake(CGRectGetMidX(visibleRect), CGRectGetMidY(visibleRect));
NSIndexPath *visibleIndexPath = [self.collectionView indexPathForItemAtPoint:visiblePoint];

Cela fonctionne particulièrement bien lorsque chaque élément de votre vue de collection occupe tout l'écran.

Version Swift

let visibleRect = CGRect(origin: collectionView.contentOffset, size: collectionView.bounds.size)
let visiblePoint = CGPoint(x: visibleRect.midX, y: visibleRect.midY)
let visibleIndexPath = collectionView.indexPathForItem(at: visiblePoint)

Swift 5 :

func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
    var visibleRect = CGRect()

    visibleRect.origin = collectionView.contentOffset
    visibleRect.size = collectionView.bounds.size

    let visiblePoint = CGPoint(x: visibleRect.midX, y: visibleRect.midY)

    guard let indexPath = collectionView.indexPathForItem(at: visiblePoint) else { return } 

    print(indexPath)
}

Réponses pratiques combinées dans Swift 2.2:

 func scrollViewDidEndDecelerating(scrollView: UIScrollView) {

        var visibleRect = CGRect()

        visibleRect.origin = self.collectionView.contentOffset
        visibleRect.size = self.collectionView.bounds.size

        let visiblePoint = CGPointMake(CGRectGetMidX(visibleRect), CGRectGetMidY(visibleRect))

        let visibleIndexPath: NSIndexPath = self.collectionView.indexPathForItemAtPoint(visiblePoint)

        guard let indexPath = visibleIndexPath else { return } 
        print(indexPath)

    }

Par souci d'exhaustivité, c'est la méthode qui a fini par fonctionner pour moi. C'était une combinaison des méthodes de @Anthony et @ iAn.

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView {
      CGRect visibleRect = (CGRect){.origin = self.collectionView.contentOffset, .size = self.collectionView.bounds.size};
      CGPoint visiblePoint = CGPointMake(CGRectGetMidX(visibleRect), CGRectGetMidY(visibleRect));
      NSIndexPath *visibleIndexPath = [self.collectionView indexPathForItemAtPoint:visiblePoint];
      NSLog(@"%@",visibleIndexPath);
}

Il sera probablement préférable d'utiliser les méthodes UICollectionViewDelegate: (Swift 3)

// Called before the cell is displayed    
func collectionView(_ collectionView: UICollectionView, willDisplay cell: UICollectionViewCell, forItemAt indexPath: IndexPath) {
    print(indexPath.row)
}

// Called when the cell is displayed
func collectionView(_ collectionView: UICollectionView, didEndDisplaying cell: UICollectionViewCell, forItemAt indexPath: IndexPath) {
    print(indexPath.row)
}

Je veux juste ajouter pour les autres: pour une raison quelconque, je n'ai pas obtenu la cellule qui était visible pour l'utilisateur lorsque je faisais défiler la cellule précédente dans collectionView avec pagingEnabled.

J'insère donc le code dans dispatch_async pour lui donner un peu d '"air" et cela fonctionne pour moi.

-(void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView
{
    dispatch_async(dispatch_get_main_queue(), ^{
            UICollectionViewCell * visibleCell= [[self.collectionView visibleCells] objectAtIndex:0];


            [visibleCell doSomthing];
        });
}

Pour Swift 3.0

func scrollViewDidScroll(_ scrollView: UIScrollView) {
    let visibleRect = CGRect(origin: colView.contentOffset, size: colView.bounds.size)
    let visiblePoint = CGPoint(x: visibleRect.midX, y: visibleRect.midY)
    let indexPath = colView.indexPathForItem(at: visiblePoint)
}

Swift 3.0

Solution la plus simple qui vous donnera indexPath pour les cellules visibles.

yourCollectionView.indexPathsForVisibleItems 

renverra le tableau de indexpath.

Prenez simplement le premier objet du tableau comme celui-ci.

yourCollectionView.indexPathsForVisibleItems.first

Je suppose que cela devrait également fonctionner avec Objective-C.

UICollection Afficher l'index de cellule visible actuel: Swift 3

var visibleCurrentCellIndexPath: IndexPath? {
    for cell in self.collectionView.visibleCells {
        let indexPath = self.collectionView.indexPath(for: cell)
        return indexPath
     }

     return nil
}

la conversion de la réponse de @ Anthony en Swift 3.0 a parfaitement fonctionné pour moi:

func scrollViewDidScroll(_ scrollView: UIScrollView) {

    var visibleRect = CGRect()
    visibleRect.origin = yourCollectionView.contentOffset
    visibleRect.size = yourCollectionView.bounds.size
    let visiblePoint = CGPoint(x: CGFloat(visibleRect.midX), y: CGFloat(visibleRect.midY))
    let visibleIndexPath: IndexPath? = yourCollectionView.indexPathForItem(at: visiblePoint)
    print("Visible cell's index is : \(visibleIndexPath?.row)!")
}

Vous pouvez utiliser scrollViewDidEndDecelerating: pour cela

//@property (strong, nonatomic) IBOutlet UICollectionView *collectionView;

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

        for (UICollectionViewCell *cell in [self.collectionView visibleCells]) {
            NSIndexPath *indexPath = [self.collectionView indexPathForCell:cell];
            NSUInteger lastIndex = [indexPath indexAtPosition:[indexPath length] - 1];
            NSLog(@"visible cell value %d",lastIndex);
        }

    }

C'est une vieille question mais dans mon cas ...

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

    _m_offsetIdx = [m_cv indexPathForCell:m_cv.visibleCells.firstObject].row;
}

- (void) scrollViewDidEndDecelerating:(UIScrollView *)scrollView {
    _m_offsetIdx = [m_cv indexPathForCell:m_cv.visibleCells.lastObject].row;
}

Vérifiez également cet extrait

let isCellVisible = collectionView.visibleCells.map { collectionView.indexPath(for: $0) }.contains(inspectingIndexPath)

Dans ce fil, il y a tellement de solutions qui fonctionnent bien si la cellule prend le plein écran mais elles utilisent les limites de vue de collection et les points médians de Visible rect Cependant il existe une solution simple à ce problème

    DispatchQueue.main.async {
        let visibleCell = self.collImages.visibleCells.first
        print(self.collImages.indexPath(for: visibleCell))
    }

par cela, vous pouvez obtenir indexPath de la cellule visible. J'ai ajouté DispatchQueue car lorsque vous glissez plus rapidement et si pendant un bref instant la cellule suivante est affichée, sans dispactchQueue, vous obtiendrez indexPath de la cellule brièvement affichée et non de la cellule affichée à l'écran.

essayez ceci, cela fonctionne. (dans l'exemple ci-dessous, j'ai 3 cellules par exemple.)

    func scrollViewDidEndDecelerating(scrollView: UIScrollView) {
    let visibleRect = CGRect(origin: self.collectionView.contentOffset, size: self.collectionView.bounds.size)
    let visiblePoint = CGPointMake(CGRectGetMidX(visibleRect), CGRectGetMidY(visibleRect))
    let visibleIndexPath = self.collectionView.indexPathForItemAtPoint(visiblePoint)
    if let v = visibleIndexPath {
        switch v.item {
        case 0: setImageDescription()
            break
        case 1: setImageConditions()
            break
        case 2: setImageResults()
            break
        default: break
        }
    }

Swift 3 et Swift 4:

func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
   var visibleRect = CGRect()

   visibleRect.origin = collectionView.contentOffset
   visibleRect.size = collectionView.bounds.size

   let visiblePoint = CGPoint(x: visibleRect.midX, y: visibleRect.midY)

   guard let indexPath = collectionView.indexPathForItem(at: visiblePoint) else { return } 

   print(indexPath[1])
}

Si vous souhaitez afficher le nombre réel, vous pouvez ajouter +1