Trouver le sens de défilement dans une UIScrollView?

...Je voudrais savoir quelle direction (gauche, droite) l'utilisateur fait défiler.

Dans ce cas, sur iOS 5 et au-dessus, utilisez le UIScrollViewDelegate afin de déterminer l'orientation de l'utilisateur du poêle geste:

- (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView
{ 
    if ([scrollView.panGestureRecognizer translationInView:scrollView.superview].x > 0) {
        //handle dragging to the right
    } else {
        //handle dragging to the left
    }
}

Pas nécessaire d'ajouter une variable supplémentaire pour garder une trace de ce. Utilisez simplement le UIScrollView's panGestureRecognizer propriété comme cela. Malheureusement, cela ne fonctionne que si la vitesse n'est pas 0:

CGFloat yVelocity = [scrollView.panGestureRecognizer velocityInView:scrollView].y;
if (yVelocity < 0) {
    NSLog(@"Up");
} else if (yVelocity > 0) {
    NSLog(@"Down");
} else {
    NSLog(@"Can't determine direction as velocity is 0");
}

Vous pouvez utiliser une combinaison de composants x et y pour détecter haut, bas, gauche et droite.

Swift 4:

Pour le défilement horizontal, vous pouvez tout simplement faire :

if scrollView.panGestureRecognizer.translation(in: scrollView.superview).x > 0 {
   print("left")
} else {
   print("right")
}

Pour le défilement vertical changement .x avec .y

C'est ce qu'il a travaillé pour moi (Objective-C):

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

        NSString *direction = ([scrollView.panGestureRecognizer translationInView:scrollView.superview].y >0)?@"up":@"down";
        NSLog(@"%@",direction);
    }

Alternativement, il est possible d'observer le chemin clé "contentOffset". Ceci est utile lorsqu'il n'est pas possible pour vous de régler/modifier le délégué de défilement de la vue.

[yourScrollView addObserver:self forKeyPath:@"contentOffset" options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld context:nil];

Après l'ajout de l'observateur, vous pouvez maintenant:

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context{
    CGFloat newOffset = [[change objectForKey:@"new"] CGPointValue].y;
    CGFloat oldOffset = [[change objectForKey:@"old"] CGPointValue].y;
    CGFloat diff = newOffset - oldOffset;
    if (diff < 0 ) { //scrolling down
        //do something
    }
}

Ne pas oublier de supprimer l'observateur en cas de besoin. par exemple, vous pouvez ajouter de l'observateur dans viewWillAppear et de le retirer en viewWillDisappear

Voici ma solution pour le comportement comme dans @followben réponse, mais sans perte de démarrage lent (quand dy 0)

@property (assign, nonatomic) BOOL isFinding;
@property (assign, nonatomic) CGFloat previousOffset;

- (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView {
    self.isFinding = YES;
}
- (void)scrollViewDidScroll:(UIScrollView *)scrollView {
    if (self.isFinding) {
        if (self.previousOffset == 0) {
            self.previousOffset = self.tableView.contentOffset.y;

        } else {
            CGFloat diff = self.tableView.contentOffset.y - self.previousOffset;
            if (diff != 0) {
                self.previousOffset = 0;
                self.isFinding = NO;

                if (diff > 0) {
                    //moved up
                } else {
                    //moved down
                }
            }
        }
    }
}

Je préfère faire un filtrage basé sur @memmons la réponse de

En Objective-C:

//in the private class extension
@property (nonatomic, assign) CGFloat lastContentOffset;

//in the class implementation
- (void)scrollViewDidScroll:(UIScrollView *)scrollView {

    if (fabs(self.lastContentOffset - scrollView.contentOffset.x) > 20 ) {
        self.lastContentOffset = scrollView.contentOffset.x;
    }

    if (self.lastContentOffset > scrollView.contentOffset.x) {
        // Scroll Direction Left
        // do what you need to with scrollDirection here.
    } else {
        // omitted 
        // if (self.lastContentOffset < scrollView.contentOffset.x)

        // do what you need to with scrollDirection here.
        // Scroll Direction Right
    } 
}

Lorsqu'il est testé dans - (void)scrollViewDidScroll:(UIScrollView *)scrollView:

NSLog(@"lastContentOffset: --- %f,   scrollView.contentOffset.x : --- %f", self.lastContentOffset, scrollView.contentOffset.x);

self.lastContentOffset change très vite, l'écart de valeur est proche de 0,5 f.

Il n'est pas nécessaire.

Et, occasionnellement, lors de la manipulation exacte de condition, votre orientation peut-être de se perdre. (mise en œuvre des déclarations sauté parfois)

tels que :

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

    CGFloat viewWidth = scrollView.frame.size.width;

    self.lastContentOffset = scrollView.contentOffset.x;
    //Bad example , needs value filtering

    NSInteger page = scrollView.contentOffset.x / viewWidth;

    if (page == self.images.count + 1 && self.lastContentOffset < scrollView.contentOffset.x ){
          // Scroll Direction Right
          // do what you need to with scrollDirection here.
    }
   ....

Dans Swift 4:

var lastContentOffset: CGFloat = 0

func scrollViewDidScroll(_ scrollView: UIScrollView) {

     if (abs(lastContentOffset - scrollView.contentOffset.x) > 20 ) {
         lastContentOffset = scrollView.contentOffset.x;
     }

     if (lastContentOffset > scrollView.contentOffset.x) {
          // Scroll Direction Left
          // do what you need to with scrollDirection here.
     } else {
         // omitted
         // if (self.lastContentOffset < scrollView.contentOffset.x)

         // do what you need to with scrollDirection here.
         // Scroll Direction Right
    }
}

Codes explique lui-même, je suppose.
CGFloat difference1 et difference2 déclaré dans la même classe interface privée.
Bon si contentSize reste la même.

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

        CGFloat contentOffSet = scrollView.contentOffset.y;
        CGFloat contentHeight = scrollView.contentSize.height;

        difference1 = contentHeight - contentOffSet;

        if (difference1 > difference2) {
            NSLog(@"Up");
        }else{
            NSLog(@"Down");
        }

        difference2 = contentHeight - contentOffSet;

       }

- (void)scrollViewWillEndDragging:(UIScrollView *)scrollView withVelocity:(CGPoint)velocity targetContentOffset:(inout CGPoint *)targetContentOffset {
NSLog(@"px %f py %f",velocity.x,velocity.y);}

Utiliser cette méthode du délégué de la scrollview.

Si la coordonnée de la vitesse est +ve défilement de l'affichage fait défiler vers le bas et s'il l'est, la ve le scrollview défile vers le haut.
De la même manière à gauche et à droite de défilement peuvent être détectés à l'aide de x coordonner.

Si vous travaillez avec UIScrollView et UIPageControl, cette méthode sera également modifier le contrôle pagecontrol de l'affichage de la page.

  func scrollViewWillEndDragging(scrollView: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer<CGPoint>) {

    let targetOffset = targetContentOffset.memory.x
    let widthPerPage = scrollView.contentSize.width / CGFloat(pageControl.numberOfPages)

    let currentPage = targetOffset / widthPerPage
    pageControl.currentPage = Int(currentPage)
}

Merci @Esq 's code Swift.

Dans tous les supérieure répond à deux grandes façons de résoudre ce problème est l'utilisation de panGestureRecognizer ou contentOffset. Les deux méthodes ont leurs inconvénients et les avantages.

Méthode 1: panGestureRecognizer

Lorsque vous utilisez panGestureRecognizer comme quoi @followben suggéré, si vous ne voulez pas de programmation pour faites défiler la vue, il fonctionne correctement.

- (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView
{ 
    if ([scrollView.panGestureRecognizer translationInView:scrollView.superview].x > 0) {
        //handle dragging to the right
    } else {
        //handle dragging to the left
    }
}

Contre

Mais si vous vous déplacez de défilement de l'affichage avec code suivant, code supérieur ne peut pas le reconnaître:

setContentOffset(CGPoint(x: 100, y: 0), animation: false)

Méthode 2: contentOffset

var lastContentOffset: CGPoint = CGPoint.zero

func scrollViewDidScroll(_ scrollView: UIScrollView) {
    if (self.lastContentOffset.x > scrollView.contentOffset.x) {
        //scroll to right
    } else if self.lastContentOffset.x < scrollView.contentOffset.x {
        //scroll to left
    }
    self.lastContentOffset = self.scrollView.contentOffset
}

Contre

Si vous voulez changer contentOffset par programme, au cours de défilement (comme quand vous voulez créer une infinité de défilement), cette méthode permet de problème, car vous risquez de vous changer contentOffset au cours de l'évolution des contenus des vues sur les places et dans ce temps, le code supérieur de sauter dans que vous faites défiler vers la droite ou la gauche.