UIScrollView d'échange personnalisé taille

1. Changer votre scrollView la taille pour la taille de la page que vous souhaitez
2. Définir votre scroll.clipsToBounds = NO

3. Créer une sous-classe UIView (e.g HackClipView) et remplacer le hitTest:withEvent: méthode

   -(UIView *) hitTest:(CGPoint) point withEvent:(UIEvent *)event
   {     
       UIView* child = [super hitTest:point withEvent:event]; 
       if (child == self && self.subviews.count > 0)  
       {
           return self.subviews[0];
       }
       return child;
   }

4. Définir la HackClipView.clipsToBounds = YES

5. Mettre votre scrollView dans ce HackClipView (avec le nombre total de défilement de la taille que vous voulez)

Voir cette réponse pour plus de détails

Mise à jour:
Comme indiqué dans lucius de réponse, vous pouvez maintenant mettre en œuvre la UIScollViewDelegate protocole et le - (void)scrollViewWillEndDragging:(UIScrollView *)scrollView withVelocity:(CGPoint)velocity targetContentOffset:(inout CGPoint *)targetContentOffset méthode. Comme le targetContentOffset est un pointeur. L'utilisation de cette méthode ne garantit pas le même résultat avec le défilement de l'affichage des pages que l'utilisateur peut faire défiler plusieurs pages à la fois. Mais le réglage de la descelerationRate à fast sera presque vous donner le même résultat

Swift 4.1 solution qui simplifie la réutilisation:

///Protocol that simplifies custom page size configuration for UIScrollView.
///Sadly, can not be done better due to protocol extensions limitations - https://stackoverflow.com/questions/39487168/non-objc-method-does-not-satisfy-optional-requirement-of-objc-protocol
///- note: Set `.decelerationRate` to `UIScrollViewDecelerationRateFast` for a fancy scrolling animation.
protocol ScrollViewCustomHorizontalPageSize: UIScrollViewDelegate {
///Custom page size
var pageSize: CGFloat { get }
///Helper method to get current page fraction
func getCurrentPage(scrollView: UIScrollView) -> CGFloat
///Helper method to get targetContentOffset. Usage:
///
///    func scrollViewWillEndDragging(_ scrollView: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer<CGPoint>) {
///        targetContentOffset.pointee.x = getTargetContentOffset(scrollView: scrollView, velocity: velocity)
///    }
func getTargetContentOffset(scrollView: UIScrollView, velocity: CGPoint) -> CGFloat
///Must be implemented. See `getTargetContentOffset` for more info.
func scrollViewWillEndDragging(_ scrollView: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer<CGPoint>)
}
extension ScrollViewCustomHorizontalPageSize {
func getCurrentPage(scrollView: UIScrollView) -> CGFloat {
return (scrollView.contentOffset.x + scrollView.contentInset.left) / pageSize
}
func getTargetContentOffset(scrollView: UIScrollView, velocity: CGPoint) -> CGFloat {
let targetX: CGFloat = scrollView.contentOffset.x + velocity.x * 60.0
var targetIndex = (targetX + scrollView.contentInset.left) / pageSize
let maxOffsetX = scrollView.contentSize.width - scrollView.bounds.width + scrollView.contentInset.right
let maxIndex = (maxOffsetX + scrollView.contentInset.left) / pageSize
if velocity.x > 0 {
targetIndex = ceil(targetIndex)
} else if velocity.x < 0 {
targetIndex = floor(targetIndex)
} else {
let (maxFloorIndex, lastInterval) = modf(maxIndex)
if targetIndex > maxFloorIndex {
if targetIndex >= lastInterval / 2 + maxFloorIndex {
targetIndex = maxIndex
} else {
targetIndex = maxFloorIndex
}
} else {
targetIndex = round(targetIndex)
}
}
if targetIndex < 0 {
targetIndex = 0
}
var offsetX = targetIndex * pageSize - scrollView.contentInset.left
offsetX = min(offsetX, maxOffsetX)
return offsetX
}
}

Juste se conformer à ScrollViewCustomPageSize protocole dans votre UIScrollView/UITableView/UICollectionView délégué et vous sont effectués, par exemple:

extension MyCollectionViewController: ScrollViewCustomPageSize {
var pageSize: CGFloat {
return 200
}
func scrollViewWillEndDragging(_ scrollView: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer<CGPoint>) {
targetContentOffset.pointee.x = getTargetContentOffset(scrollView: scrollView, velocity: velocity)
}
}

Pour une fantaisie de défilement, je vous le recommande pour définir collectionView.decelerationRate = UIScrollViewDecelerationRateFast

J'ai eu le même problème j'ai donc fait une coutume UIScrollView.
Il est disponible sur Github maintenant, parce que quand j'ai cherché je n'ai pas trouver toutes les solutions de ce type. Profitez-en!
https://github.com/MartinMetselaar/MMCPSScrollView

MMCPSScrollView* scrollView = [[MMCPSScrollView alloc] initWithFrame:self.view.bounds];
[scrollView setType:MMCPSScrollVertical];
[scrollView setPageHeight:250];
[scrollView setPageSize:2];
[self.view addSubview:scrollView];

Si vous avez des questions au sujet de ce composant, il suffit de demander.

Cela semblait fonctionner beaucoup mieux pour moi:

UIScrollView D'Échange Personnalisé

Ici, ils sont en ajoutant de la scrollview (garder la pagination de la gentillesse) comme une sous-vue à un ExtendedTouchView ou sous-classe de UIVIew et d'écraser le coup de la méthode de test

- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event {
if ([self pointInside:point withEvent:event]) {
if ([[self subviews] count] > 0) {
//force return of first child, if exists
return [[self subviews] objectAtIndex:0];
} else {
return self;
}
}
return nil;
}

Cela fait exactement whatI voulais, avec un minimum de code et des maux de tête.

Swift 4.1, iOS11+:

func scrollViewWillEndDragging(_ scrollView: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer<CGPoint>) {
targetContentOffset.pointee = CGPoint(
x: round(targetContentOffset.pointee.x / pageWidth) * pageWidth,
y: targetContentOffset.pointee.y
)
}