फ्रेम आकार की तुलना में छोटे वेतन वृद्धि में UIScrollView पेजिंग

Question 1

मेरे पास एक स्क्रॉल दृश्य है जो स्क्रीन की चौड़ाई है लेकिन केवल लगभग 70 पिक्सेल ऊँची है। इसमें कई 50 x 50 आइकन (उनके आसपास की जगह के साथ) हैं जो मैं चाहता हूं कि उपयोगकर्ता से चुनने में सक्षम हो। लेकिन मैं हमेशा यही चाहता हूं कि स्क्रॉल दृश्य एक शांत तरीके से व्यवहार करे, हमेशा सटीक केंद्र में एक आइकन के साथ बंद हो।

यदि आइकन स्क्रीन की चौड़ाई थे, तो यह एक समस्या नहीं होगी क्योंकि UIScrollView का पेजिंग इसका ध्यान रखेगा। लेकिन क्योंकि मेरे छोटे चिह्न सामग्री आकार से बहुत कम हैं, इसलिए यह काम नहीं करता है।

मैंने इस व्यवहार को ऐप कॉल AllRecipes से पहले देखा है। मुझे नहीं पता कि यह कैसे करना है।

मैं काम करने के लिए प्रति-आइकन आकार के आधार पर पेजिंग कैसे प्राप्त करूं?

Question 2

अपने स्क्रॉलव्यू को स्क्रीन के आकार (चौड़ाई-वार) से कम करने का प्रयास करें, लेकिन IB में "क्लिप सबव्यू" चेकबॉक्स को अनचेक करें। फिर, एक पारदर्शी उपयोक्ता को उपरिशायी करें, निष्क्रिय किया हुआ = इसके ऊपर (पूर्ण चौड़ाई पर) कोई दृश्य नहीं, जो हिटस्ट को ओवरराइड करता है: withEvent: अपने स्क्रॉल दृश्य को वापस करने के लिए। आपको वह देना चाहिए जो आप खोज रहे हैं। देखें इस उत्तर अधिक जानकारी के लिए।

Question 3

वहाँ भी एक और समाधान है जो शायद एक दूसरे दृश्य के साथ स्क्रॉल दृश्य को ओवरलेइंग करने और हिटटेस्ट को ओवरराइड करने की तुलना में थोड़ा बेहतर है।

आप UIScrollView को उप-वर्ग कर सकते हैं और इसके बिंदु को ओवरराइड कर सकते हैं। फिर स्क्रॉल दृश्य इसके फ़्रेम के बाहर टच के लिए प्रतिक्रिया कर सकता है। बेशक बाकी सब वही है।

@interface PagingScrollView : UIScrollView {

    UIEdgeInsets responseInsets;
}

@property (nonatomic, assign) UIEdgeInsets responseInsets;

@end


@implementation PagingScrollView

@synthesize responseInsets;

- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event {
    CGPoint parentLocation = [self convertPoint:point toView:[self superview]];
    CGRect responseRect = self.frame;
    responseRect.origin.x -= responseInsets.left;
    responseRect.origin.y -= responseInsets.top;
    responseRect.size.width += (responseInsets.left + responseInsets.right);
    responseRect.size.height += (responseInsets.top + responseInsets.bottom);

    return CGRectContainsPoint(responseRect, parentLocation);
}

@end

Question 4

मैं बहुत सारे समाधान देखता हूं, लेकिन वे बहुत जटिल हैं। छोटे पृष्ठ रखने का एक बहुत आसान तरीका है, लेकिन फिर भी सभी क्षेत्र को स्क्रॉल करने योग्य रखना है, स्क्रॉल को छोटा करना है और scrollView.panGestureRecognizerअपने माता-पिता के दृष्टिकोण पर ले जाना है। ये चरण हैं:

अपने स्क्रॉल दृश्य का आकार कम करें
सुनिश्चित करें कि आपका स्क्रॉल दृश्य पृष्ठांकित है और सबव्यू क्लिप नहीं करता है
कोड में, स्क्रॉलव पैन पैन जेस्चर को पैरेंट कंटेनर दृश्य में ले जाएं जो पूर्ण चौड़ाई वाला हो:

    override func viewDidLoad() {
        super.viewDidLoad()
        statsView.addGestureRecognizer(statsScrollView.panGestureRecognizer)
    }

Question 5

स्वीकृत उत्तर बहुत अच्छा है, लेकिन यह केवल UIScrollViewकक्षा के लिए काम करेगा , और इसके वंशजों में से कोई भी नहीं। उदाहरण के लिए यदि आपके पास बहुत सारे विचार हैं और में कनवर्ट करने के लिए UICollectionView, आप इस पद्धति का उपयोग नहीं कर पाएंगे, क्योंकि संग्रह दृश्य उन विचारों को हटा देगा जो यह सोचते हैं कि वे "दिखाई नहीं दे रहे हैं" (इसलिए भले ही वे क्लिप न हों, वे करेंगे गायब होना)।

उस उल्लेख के बारे में टिप्पणी scrollViewWillEndDragging:withVelocity:targetContentOffset:, मेरी राय में, सही उत्तर है।

आप क्या कर सकते हैं, इस प्रतिनिधि पद्धति के अंदर आप वर्तमान पृष्ठ / सूचकांक की गणना करते हैं। फिर आप तय करते हैं कि वेग और लक्ष्य ऑफसेट एक "अगले पृष्ठ" आंदोलन को योग्यता देते हैं या नहीं। आप pagingEnabledव्यवहार के बहुत करीब आ सकते हैं ।

नोट: मैं आमतौर पर इन दिनों एक रूबीमोशन देव हूं, इसलिए कोई कृपया इस ओबज-सी कोड को शुद्धता के लिए प्रमाणित करें। CamelCase और snake_case के मिश्रण के लिए क्षमा करें, मैं इस कोड को बहुत कॉपी और पेस्ट करता हूं।

- (void) scrollViewWillEndDragging:(UIScrollView *)scrollView
         withVelocity:(CGPoint)velocity
         targetContentOffset:(inout CGPoint *)targetOffset
{
    CGFloat x = targetOffset->x;
    int index = [self convertXToIndex: x];
    CGFloat w = 300f;  // this is your custom page width
    CGFloat current_x = w * [self convertXToIndex: scrollView.contentOffset.x];

    // even if the velocity is low, if the offset is more than 50% past the halfway
    // point, proceed to the next item.
    if ( velocity.x < -0.5 || (current_x - x) > w / 2 ) {
      index -= 1
    } 
    else if ( velocity.x > 0.5 || (x - current_x) > w / 2 ) {
      index += 1;
    }

    if ( index >= 0 || index < self.items.length ) {
      CGFloat new_x = [self convertIndexToX: index];
      targetOffset->x = new_x;
    }
}

Question 6

- (void) scrollViewWillEndDragging:(UIScrollView *)scrollView
         withVelocity:(CGPoint)velocity
         targetContentOffset:(inout CGPoint *)targetOffset
{
    static CGFloat previousIndex;
    CGFloat x = targetOffset->x + kPageOffset;
    int index = (x + kPageWidth/2)/kPageWidth;
    if(index<previousIndex - 1){
        index = previousIndex - 1;
    }else if(index > previousIndex + 1){
        index = previousIndex + 1;
    }

    CGFloat newTarget = index * kPageWidth;
    targetOffset->x = newTarget - kPageOffset;
    previousIndex = index;
}

kPageWidth वह चौड़ाई है जो आप चाहते हैं कि आपका पृष्ठ हो। kPageOffset है यदि आप नहीं चाहते हैं कि कोशिकाओं को संरेखित किया जाए (अर्थात यदि आप उन्हें केंद्र संरेखित करना चाहते हैं, तो इसे अपने सेल की आधी चौड़ाई पर सेट करें)। अन्यथा, यह शून्य होना चाहिए।

यह भी एक समय में केवल एक पृष्ठ स्क्रॉल करने की अनुमति देगा।

Question 7

-scrollView:didEndDragging:willDecelerate:विधि पर एक नज़र डालें UIScrollViewDelegate। कुछ इस तरह:

- (void)scrollViewDidEndDragging:(UIScrollView *)scrollView willDecelerate:(BOOL)decelerate
{
    int x = scrollView.contentOffset.x;
    int xOff = x % 50;
    if(xOff < 25)
        x -= xOff;
    else
        x += 50 - xOff;

    int halfW = scrollView.contentSize.width / 2; // the width of the whole content view, not just the scroll view
    if(x > halfW)
        x = halfW;

    [scrollView setContentOffset:CGPointMake(x,scrollView.contentOffset.y)];
}

यह सही नहीं है - पिछली बार मैंने इस कोड की कोशिश की थी जब मुझे रबर-बैंडेड स्क्रॉल से लौटते समय कुछ बदसूरत व्यवहार (कूदना, जैसा कि मुझे याद है) मिला। आप केवल स्क्रॉल दृश्य की bouncesसंपत्ति सेट करके इससे बचने में सक्षम हो सकते हैं NO।

Question 8

चूँकि मुझे टिप्पणी करने की अनुमति नहीं दी जा रही है, फिर भी मैं अपनी टिप्पणियाँ नूह के उत्तर में यहाँ जोड़ दूंगा।

मैंने सफलतापूर्वक उस विधि से इसे प्राप्त किया है जिसे नूह विदरस्पून ने वर्णित किया है। मैंने जंपिंग व्यवहार के आस-पास काम किया, बस उस setContentOffset:विधि को नहीं कहा जब स्क्रॉलव्यू इसके किनारों को पार कर रहा था।

         - (void)scrollViewDidEndDragging:(UIScrollView *)scrollView willDecelerate:(BOOL)decelerate
         {      
             // Don't snap when at the edges because that will override the bounce mechanic
             if (self.contentOffset.x < 0 || self.contentOffset.x + self.bounds.size.width > self.contentSize.width)
                 return;

             ...
         }

मैंने यह भी पाया कि मुझे सभी मामलों को पकड़ने के लिए -scrollViewWillBeginDecelerating:विधि को लागू करने की आवश्यकता थी UIScrollViewDelegate।

Question 9

मैंने ऊपर दिए गए समाधान की कोशिश की, जिसमें बिंदु के साथ एक पारदर्शी दृश्य ओवरले किया गया था: withEvent: overridden। इसने मेरे लिए बहुत अच्छा काम किया, लेकिन कुछ मामलों के लिए टूट गया - मेरी टिप्पणी देखें। मैंने वर्तमान पृष्ठ अनुक्रमणिका और स्क्रॉलव्यूबिल्डइंडग्रैगिंग: withVelocity: targetContentOffset और scrollViewDidEndDragging: willDecelerate उपयुक्त पृष्ठ पर जाने के लिए ट्रैक करने के लिए स्क्रॉलव्यूडीकॉल के संयोजन के साथ स्वयं पेजिंग को लागू करना समाप्त कर दिया। ध्यान दें, विल-एंड विधि केवल iOS5 + उपलब्ध है, लेकिन यदि वेलोसिटी में किसी विशेष ऑफसेट को लक्षित करने के लिए यह बहुत प्यारा है! = 0. विशेष रूप से, आप कॉलर को बता सकते हैं कि आप स्क्रॉल दृश्य को एनीमेशन के साथ लैंड करना चाहते हैं यदि वहाँ वेग है? विशेष दिशा।

Question 10

स्क्रॉलव्यू बनाते समय, सुनिश्चित करें कि आपने इसे सेट किया है:

scrollView.showsHorizontalScrollIndicator = false;
scrollView.showsVerticalScrollIndicator = false;
scrollView.pagingEnabled = true;

फिर अपने सूचकांक में स्कोरर की ऊंचाई * उनके सूचकांक के बराबर ऑफसेट पर जोड़ें। यह एक ऊर्ध्वाधर घुमक्कड़ के लिए है:

UIView * sub = [UIView new];
sub.frame = CGRectMake(0, index * h, w, subViewHeight);
[scrollView addSubview:sub];

यदि आप इसे चलाते हैं, तो दृश्य समाप्त हो गए हैं, और पेजिंग सक्षम होने के साथ वे एक बार में स्क्रॉल करते हैं।

तो फिर अपने दृश्य में डाल दो इससडक्रोल विधि:

    //set vars
    int index = scrollView.contentOffset.y / h; //current index
    float y = scrollView.contentOffset.y; //actual offset
    float p = (y / h)-index; //percentage of page scroll complete (0.0-1.0)
    int subViewHeight = h-240; //height of the view
    int spacing = 30; //preferred spacing between views (if any)

    NSArray * array = scrollView.subviews;

    //cycle through array
    for (UIView * sub in array){

        //subview index in array
        int subIndex = (int)[array indexOfObject:sub];

        //moves the subs up to the top (on top of each other)
        float transform = (-h * subIndex);

        //moves them back down with spacing
        transform += (subViewHeight + spacing) * subIndex;

        //adjusts the offset during scroll
        transform += (h - subViewHeight - spacing) * p;

        //adjusts the offset for the index
        transform += index * (h - subViewHeight - spacing);

        //apply transform
        sub.transform = CGAffineTransformMakeTranslation(0, transform);
    }

सबव्यू के फ्रेम अभी भी बाहर हैं, हम केवल उन्हें एक परिवर्तन के माध्यम से एक साथ स्थानांतरित कर रहे हैं जैसे कि उपयोगकर्ता स्क्रॉल करते हैं।

इसके अलावा, आपके पास ऊपर चर चर तक पहुंच है, जिसे आप अन्य चीजों के लिए उपयोग कर सकते हैं, जैसे कि अल्फा या सबव्यू के भीतर रूपांतरित करता है। जब p == 1, वह पृष्ठ पूरी तरह से दिखाया जा रहा है, या यह 1 की ओर जाता है।

Question 11

स्क्रॉल व्यू की सामग्री का उपयोग करने का प्रयास करें:

scrollView.pagingEnabled = YES;

[scrollView setContentSize:CGSizeMake(height, pageWidth * 3)];
double leftContentOffset = pageWidth - kSomeOffset;
scrollView.contentInset = UIEdgeInsetsMake(0, leftContentOffset, 0, 0);

वांछित पेजिंग को प्राप्त करने के लिए आपके मूल्यों के साथ कुछ खेल हो सकता है।

मैंने इसे पोस्ट किए गए विकल्पों की तुलना में अधिक सफाई से काम करने के लिए पाया है। scrollViewWillEndDragging:डेलिगेट विधि का उपयोग करने में समस्या धीमी फ्लिक्स के लिए त्वरण स्वाभाविक नहीं है।

Question 12

यह समस्या का एकमात्र वास्तविक समाधान है।

import UIKit

class TestScrollViewController: UIViewController, UIScrollViewDelegate {

    var scrollView: UIScrollView!

    var cellSize:CGFloat!
    var inset:CGFloat!
    var preX:CGFloat=0
    let pages = 8

    override func viewDidLoad() {
        super.viewDidLoad()

        cellSize = (self.view.bounds.width-180)
        inset=(self.view.bounds.width-cellSize)/2
        scrollView=UIScrollView(frame: self.view.bounds)
        self.view.addSubview(scrollView)

        for i in 0..<pages {
            let v = UIView(frame: self.view.bounds)
            v.backgroundColor=UIColor(red: CGFloat(CGFloat(i)/CGFloat(pages)), green: CGFloat(1 - CGFloat(i)/CGFloat(pages)), blue: CGFloat(CGFloat(i)/CGFloat(pages)), alpha: 1)
            v.frame.origin.x=CGFloat(i)*cellSize
            v.frame.size.width=cellSize
            scrollView.addSubview(v)
        }

        scrollView.contentSize.width=cellSize*CGFloat(pages)
        scrollView.isPagingEnabled=false
        scrollView.delegate=self
        scrollView.contentInset.left=inset
        scrollView.contentOffset.x = -inset
        scrollView.contentInset.right=inset

    }

    func scrollViewWillBeginDragging(_ scrollView: UIScrollView) {
        preX = scrollView.contentOffset.x
    }

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

        let originalIndex = Int((preX+cellSize/2)/cellSize)

        let targetX = targetContentOffset.pointee.x
        var targetIndex = Int((targetX+cellSize/2)/cellSize)

        if targetIndex > originalIndex + 1 {
            targetIndex=originalIndex+1
        }
        if targetIndex < originalIndex - 1 {
            targetIndex=originalIndex - 1
        }

        if velocity.x == 0 {
            let currentIndex = Int((scrollView.contentOffset.x+self.view.bounds.width/2)/cellSize)
            let tx=CGFloat(currentIndex)*cellSize-(self.view.bounds.width-cellSize)/2
            scrollView.setContentOffset(CGPoint(x:tx,y:0), animated: true)
            return
        }

        let tx=CGFloat(targetIndex)*cellSize-(self.view.bounds.width-cellSize)/2
        targetContentOffset.pointee.x=scrollView.contentOffset.x

        UIView.animate(withDuration: 0.5, delay: 0, usingSpringWithDamping: 1, initialSpringVelocity: velocity.x, options: [UIViewAnimationOptions.curveEaseOut, UIViewAnimationOptions.allowUserInteraction], animations: {
            scrollView.contentOffset=CGPoint(x:tx,y:0)
        }) { (b:Bool) in

        }

    }


}

Question 13

यहाँ मेरा जवाब है। मेरे उदाहरण में, collectionViewजिसमें एक अनुभाग हेडर है स्क्रॉल स्क्रॉल है जिसे हम इसे कस्टम isPagingEnabledप्रभाव बनाना चाहते हैं , और सेल की ऊंचाई एक निरंतर मूल्य है।

var isScrollingDown = false // in my example, scrollDirection is vertical
var lastScrollOffset = CGPoint.zero

func scrollViewDidScroll(_ sv: UIScrollView) {
    isScrollingDown = sv.contentOffset.y > lastScrollOffset.y
    lastScrollOffset = sv.contentOffset
}

// 实现 isPagingEnabled 效果
func scrollViewWillEndDragging(_ sv: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer<CGPoint>) {

    let realHeaderHeight = headerHeight + collectionViewLayout.sectionInset.top
    guard realHeaderHeight < targetContentOffset.pointee.y else {
        // make sure that user can scroll to make header visible.
        return // 否则无法手动滚到顶部
    }

    let realFooterHeight: CGFloat = 0
    let realCellHeight = cellHeight + collectionViewLayout.minimumLineSpacing
    guard targetContentOffset.pointee.y < sv.contentSize.height - realFooterHeight else {
        // make sure that user can scroll to make footer visible
        return // 若有footer，不在此处 return 会导致无法手动滚动到底部
    }

    let indexOfCell = (targetContentOffset.pointee.y - realHeaderHeight) / realCellHeight
    // velocity.y can be 0 when lifting your hand slowly
    let roundedIndex = isScrollingDown ? ceil(indexOfCell) : floor(indexOfCell) // 如果松手时滚动速度为 0，则 velocity.y == 0，且 sv.contentOffset == targetContentOffset.pointee
    let y = realHeaderHeight + realCellHeight * roundedIndex - collectionViewLayout.minimumLineSpacing
    targetContentOffset.pointee.y = y
}

Question 14

UICollectionViewसमाधान का परिष्कृत स्विफ्ट संस्करण :

प्रति स्वाइप एक पृष्ठ तक सीमित है
पृष्ठ पर तेज़ स्नैप सुनिश्चित करता है, भले ही आपकी स्क्रॉल धीमी थी

override func viewDidLoad() {
    super.viewDidLoad()
    collectionView.decelerationRate = .fast
}

private var dragStartPage: CGPoint = .zero

func scrollViewWillBeginDragging(_ scrollView: UIScrollView) {
    dragStartOffset = scrollView.contentOffset
}

func scrollViewWillEndDragging(_ scrollView: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer<CGPoint>) {
    // Snap target offset to current or adjacent page
    let currentIndex = pageIndexForContentOffset(dragStartOffset)
    var targetIndex = pageIndexForContentOffset(targetContentOffset.pointee)
    if targetIndex != currentIndex {
        targetIndex = currentIndex + (targetIndex - currentIndex).signum()
    } else if abs(velocity.x) > 0.25 {
        targetIndex = currentIndex + (velocity.x > 0 ? 1 : 0)
    }
    // Constrain to valid indices
    if targetIndex < 0 { targetIndex = 0 }
    if targetIndex >= items.count { targetIndex = max(items.count-1, 0) }
    // Set new target offset
    targetContentOffset.pointee.x = contentOffsetForCardIndex(targetIndex)
}

Question 15

पुराना धागा, लेकिन इस पर मेरे लेने के उल्लेख के लायक:

import Foundation
import UIKit

class PaginatedCardScrollView: UIScrollView {

    convenience init() {
        self.init(frame: CGRect.zero)
    }

    override init(frame: CGRect) {
        super.init(frame: frame)
        _setup()
    }

    required init?(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
        _setup()
    }

    private func _setup() {
        isPagingEnabled = true
        isScrollEnabled = true
        clipsToBounds = false
        showsHorizontalScrollIndicator = false
    }

    override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
        // Asume the scrollview extends uses the entire width of the screen
        return point.y >= frame.origin.y && point.y <= frame.origin.y + frame.size.height
    }
}

इस तरह से आप a) स्क्रोलव्यू की पूरी चौड़ाई को पैन / स्वाइप और बी में उपयोग कर सकते हैं) स्क्रोलव्यू के मूल सीमा से बाहर के तत्वों के साथ बातचीत करने में सक्षम हो सकते हैं।

Question 16

UICollectionView मुद्दे के लिए (जो मेरे लिए आगामी / पूर्व कार्ड के "टिकर" के साथ क्षैतिज स्क्रॉल कार्ड के संग्रह का एक UITableViewCell था), मुझे बस Apple के मूल पेजिंग का उपयोग करने पर छोड़ देना था। डेमियन के गीथूब समाधान ने मेरे लिए अजीब काम किया। आप हेडर की चौड़ाई बढ़ाकर टिकर के आकार को ट्विस्ट कर सकते हैं और गतिशील रूप से इसे तब शून्य कर सकते हैं जब आप पहले इंडेक्स पर होते हैं ताकि आप एक बड़े रिक्त मार्जिन के साथ समाप्त न हों