Pobieranie bieżącej strony

Całkiem polecam użycie tego kodu

int indexOfPage = scrollView.contentOffset.x / scrollView.frame.size.width;

Ale jeśli używasz tego kodu, twój widok nie musi znajdować się dokładnie na stronie, którą daje Ci indexOfPage. Dlatego też zalecam użycie tego kodu tylko w tej metodzie

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

Który jest wywoływany, gdy twój scrollView kończy przewijanie i aby numer twojej strony był naprawdę ostry

Polecam ustawić scrollView na paged włączony tym kodem

[scrollView setPagingEnabled:YES];

Więc w końcu powinno tak wyglądać sposób

-(void) methodWhereYouSetYourScrollView
{
   //set scrollView
   [scrollView setPagingEnabled:YES];
   scrollView.delegate = self;
}

-(void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView
{
   int indexOfPage = scrollView.contentOffset.x / scrollView.frame.size.width;
   //your stuff with index
}

W swifcie zrobiłbym to w rozszerzeniu:

extension UIScrollView {
    var currentPage:Int{
        return Int((self.contentOffset.x+(0.5*self.frame.size.width))/self.frame.width)+1
    }
}

To po prostu zadzwoń:

scrollView.currentPage

Jak wyżej, ale jako kategoria

@interface UIScrollView (CurrentPage)
-(int) currentPage;
@end
@implementation UIScrollView (CurrentPage)
-(int) currentPage{
    CGFloat pageWidth = self.frame.size.width;
    return floor((self.contentOffset.x - pageWidth / 2) / pageWidth) + 1;
}
@end

Inny sposób :

extension MyViewController: UIScrollViewDelegate {
    func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
        let width = scrollView.frame.width
        let page = Int(round(scrollView.contentOffset.x/width))
        print("CurrentPage:\(page)")
    }
}

Jest tu już kilka dobrych odpowiedzi. Jednak w przypadku scenariuszy, w których zawartość nie pasuje dokładnie do strony - i jeśli tak jak ja chcesz użyć wyniku dla UIPageControl, konieczne jest użycie funkcji ceil.

Weźmy przykład, w którym mam "cztery i trochę" stron treści.

Oprę to na moim obecnym przykładzie z prawdziwego życia. Szerokość rozmiaru zawartości wynosi 3140 punktów. W oparciu o rozmiar ramki mojej kolekcji, szerokość strony wynosi 728.

Tak Liczba stron równa się:

 3140 / 728 = 4.313 

Moje numberOfPages będzie pięć. Cztery z nich pokażą całość, a ostatnia - strona piąta - pokaże Pozostałe 0.313 treści.

Teraz, numberOfPages pięć oznacza, że indeksy stron będą 0, 1, 2, 3 i 4.

Kiedy przesuwam palcem w prawo, stroniąc w kierunku ostatecznego przesunięcia, metoda scrollViewDidEndDecelerating daje ostateczne przesunięcie X 2412.

Zastosowanie obliczenia zaokrąglenia:

2412 / 728 = 3.313 then rounded = 3

To nieprawda. użytkownik strony jest wyświetlanie według offsetu powinno być:

Offset / Page User Is Viewing
0        0
728      1
1456     2
2184     3
2412     4

Prawidłowe obliczenie za pomocą ceil:

private func pageForOffset(offset:CGFloat, pageWidth width:CGFloat) -> Int
{
    let page = Int(ceil(offset / width))
    NSLog("\(__FUNCTION__) offset \(offset) width \(width) page \(page) ")
    return page
}

Po prostu podziel bieżące przesunięcie przez rozmiar strony:

CGFloat pageNum = (int)(scrollView.contentOffset.x / scrollView.frame.size.width);

Rozwiązanie Aoakenfo jest niesamowite, jest to kolejne rozwiązanie łączące Twój kod z funkcją scrollViewDidScroll i PageController

- (void)scrollViewDidScroll:(UIScrollView *)sender {
    if (sender == self.scroll) {
        int pageNum = (int)(self.scrPage.contentOffset.x / self.scrPage.frame.size.width);
        self.pagecontroller.currentPage =pageNum;
    }
}

Dla Swifta użyłbym tego

    let width = scrollView.frame.width
    let page = round(scrollView.contentOffset.x/width)

Dość proste, w zasadzie zajmuje pozycję scrollview x, dzieli ją przez szerokość scrollview, a następnie zaokrągla.

W xCode 7.x swift 2.X można zrobić:

//MARK: - ScrollView Extensions
// Get the current page number
extension UIScrollView {
    var currentPage: Int {
        return Int(round(self.contentOffset.x / self.bounds.size.width))
    }

// If you have reversed offset (start from contentSize.width to 0)
    var reverseCurrentPage: Int {
        return Int(round((contentSize.width - self.contentOffset.x) / self.bounds.size.width))-1
    }
}

Wyciągnąłem to z kilku naszych aplikacji...

- (NSInteger)currentPage
{
    if (0 == self.frame.size.width) {
        NSLog(@"frame width == 0!");
        return 0;
    }
    if (! self.currentPageValid) {
        _currentPage = round(self.contentOffset.x / self.frame.size.width);
        self.currentPageValid = YES;
    }
    return _currentPage;
}

Pełne źródło tutaj

Czy używasz UIPageControl? Jeśli tak, to mA currentPage właściwość. Jeśli nie, myślę, że będziesz musiał obliczyć indeks strony z offsetu przewijania.

Jeśli ktoś szuka sposobu na zrobienie w C# dla Xamarin

    public int CurrentIndex
    {
        get => (int)Math.Round(this.scrollView.ContentOffset.X / this.scrollView.Frame.Width);
        set => this.scrollView.ScrollRectToVisible(new CGRect(new CGPoint(this.scrollView.Frame.Size.Width * value, 0), this.scrollView.Frame.Size), true);
    }

Ten getter i Setter powinny dostarczyć bieżącą stronę, a także umożliwić przewijanie do podanej strony

Swift 5.1 + rozszerzenie UIScrollView (pomijając słowo kluczowe return)

extension UIScrollView {

    var currentPage: Int {
        Int(round(self.contentOffset.x / self.frame.width))
    }
}