blocks|key|214188|text|好吧，答案是否定的，没有子类化UICollectionViewFlowLayout是无法做到这一点的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|214189|然而，对于将来阅读这篇文章的任何人来说，将其子类化是非常容易的。|214190|首先，我设置了一个名为MyCollectionViewFlowLayout的子类，然后在接口构建器中，我将集合视图布局更改为自定义，并选择了我的流布局子类。|offset|length|style|CODE|214191|因为你是这样做的，你不能指定项目的大小，等等。在IB中，所以在MyCollectionViewFlowLayout.m中，我有这个...|214192|-+(void)awakeFromNib
{
++++self.itemSize+=+CGSizeMake(75.0,+75.0);
++++self.minimumInteritemSpacing+=+10.0;
++++self.minimumLineSpacing+=+10.0;
++++self.scrollDirection+=+UICollectionViewScrollDirectionHorizontal;
++++self.sectionInset+=+UIEdgeInsetsMake(10.0,+10.0,+10.0,+10.0);
}|code-block|syntax|javascript|214193|这为我设置了所有的大小和滚动方向。|214194|然后..。|214195|-+(CGPoint)targetContentOffsetForProposedContentOffset:(CGPoint)proposedContentOffset+withScrollingVelocity:(CGPoint)velocity
{
++++CGFloat+offsetAdjustment+=+MAXFLOAT;
++++CGFloat+horizontalOffset+=+proposedContentOffset.x+%2B+5;

++++CGRect+targetRect+=+CGRectMake(proposedContentOffset.x,+0,+self.collectionView.bounds.size.width,+self.collectionView.bounds.size.height);

++++NSArray+*array+=+[super+layoutAttributesForElementsInRect:targetRect];

++++for+(UICollectionViewLayoutAttributes+*layoutAttributes+in+array)+{
++++++++CGFloat+itemOffset+=+layoutAttributes.frame.origin.x;
++++++++if+(ABS(itemOffset+-+horizontalOffset)+<+ABS(offsetAdjustment))+{
++++++++++++offsetAdjustment+=+itemOffset+-+horizontalOffset;
++++++++}
++++}

++++return+CGPointMake(proposedContentOffset.x+%2B+offsetAdjustment,+proposedContentOffset.y);
}|214196|这可确保滚动在左侧边缘的边距为5.0时结束。|214197|这就是我需要做的一切。我根本不需要在代码中设置流布局。|214198|entityMap^0|0|0|B|Q|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|14|8|@$F|15|G|16|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|17|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|18|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|N|7|1B|8|@]|9|@]|A|$O|P]]|$1|W|3|X|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1D|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

OK, answer is no, there is no way to do this without subclassing UICollectionViewFlowLayout.

However, subclassing it is incredibly easy for anyone who is reading this in the future.

First I set up the subclass call <code>MyCollectionViewFlowLayout</code> and then in interface builder I changed the collection view layout to Custom and selected my flow layout subclass.

Because you're doing it this way you can't specify items sizes, etc... in IB so in MyCollectionViewFlowLayout.m I have this...

<pre><code>- (void)awakeFromNib
{
 self.itemSize = CGSizeMake(75.0, 75.0);
 self.minimumInteritemSpacing = 10.0;
 self.minimumLineSpacing = 10.0;
 self.scrollDirection = UICollectionViewScrollDirectionHorizontal;
 self.sectionInset = UIEdgeInsetsMake(10.0, 10.0, 10.0, 10.0);
}
</code></pre>

This sets up all the sizes for me and the scroll direction.

Then ...

<pre><code>- (CGPoint)targetContentOffsetForProposedContentOffset:(CGPoint)proposedContentOffset withScrollingVelocity:(CGPoint)velocity
{
 CGFloat offsetAdjustment = MAXFLOAT;
 CGFloat horizontalOffset = proposedContentOffset.x + 5;

 CGRect targetRect = CGRectMake(proposedContentOffset.x, 0, self.collectionView.bounds.size.width, self.collectionView.bounds.size.height);

 NSArray *array = [super layoutAttributesForElementsInRect:targetRect];

 for (UICollectionViewLayoutAttributes *layoutAttributes in array) {
 CGFloat itemOffset = layoutAttributes.frame.origin.x;
 if (ABS(itemOffset - horizontalOffset) &lt; ABS(offsetAdjustment)) {
 offsetAdjustment = itemOffset - horizontalOffset;
 }
 }

 return CGPointMake(proposedContentOffset.x + offsetAdjustment, proposedContentOffset.y);
}
</code></pre>

This ensures that the scrolling ends with a margin of 5.0 on the left hand edge.

That's all I needed to do. I didn't need to set the flow layout in code at all.

blocks|key|432550|text|Fogmeisters的答案对我很有效，除非我滚动到一行的末尾。我的单元格不能整齐地放在屏幕上，所以它会滚动到末尾，然后猛地跳回来，这样最后一个单元格总是与屏幕的右边缘重叠。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|432551|为了防止出现这种情况，在targetcontentoffset方法的开头添加以下代码行|432552|if(proposedContentOffset.x>self.collectionViewContentSize.width-320-self.sectionInset.right)
++++return+proposedContentOffset;|code-block|syntax|javascript|432553|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Fogmeisters answer worked for me unless I scrolled to the end of the row. My cells don't fit neatly on the screen so it would scroll to the end and jump back with a jerk so that the last cell always overlapped the right edge of the screen.

To prevent this add the following line of code at the start of the targetcontentoffset method

<pre><code>if(proposedContentOffset.x&gt;self.collectionViewContentSize.width-320-self.sectionInset.right)
 return proposedContentOffset;
</code></pre>

blocks|key|432592|text|虽然this+answer对我有很大的帮助，但当你在很小的距离上快速滑动时，会有明显的闪烁。在设备上重现它要容易得多。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|432593|我发现当collectionView.contentOffset.x+-+proposedContentOffset.x和velocity.x有不同的声音时，总是会发生这种情况。|style|CODE|432594|我的解决方案是确保如果速度为正，proposedContentOffset大于contentOffset.x，如果速度为负，则小于。它是用C#编写的，但转换成Objective+C应该相当简单：|432595|public+override+PointF+TargetContentOffset+(PointF+proposedContentOffset,+PointF+scrollingVelocity)
{
++++/*+Determine+closest+edge+*/

++++float+offSetAdjustment+=+float.MaxValue;
++++float+horizontalCenter+=+(float)+(proposedContentOffset.X+%2B+(this.CollectionView.Bounds.Size.Width+/+2.0));

++++RectangleF+targetRect+=+new+RectangleF+(proposedContentOffset.X,+0.0f,+this.CollectionView.Bounds.Size.Width,+this.CollectionView.Bounds.Size.Height);
++++var+array+=+base.LayoutAttributesForElementsInRect+(targetRect);

++++foreach+(var+layoutAttributes+in+array)+{
++++++++float+itemHorizontalCenter+=+layoutAttributes.Center.X;
++++++++if+(Math.Abs+(itemHorizontalCenter+-+horizontalCenter)+<+Math.Abs+(offSetAdjustment))+{
++++++++++++offSetAdjustment+=+itemHorizontalCenter+-+horizontalCenter;
++++++++}
++++}

++++float+nextOffset+=+proposedContentOffset.X+%2B+offSetAdjustment;

++++/*
+++++*+...+unless+we+end+up+having+positive+speed
+++++*+while+moving+left+or+negative+speed+while+moving+right.
+++++*+This+will+cause+flicker+so+we+resort+to+finding+next+page
+++++*+in+the+direction+of+velocity+and+use+it.
+++++*/

++++do+{
++++++++proposedContentOffset.X+=+nextOffset;

++++++++float+deltaX+=+proposedContentOffset.X+-+CollectionView.ContentOffset.X;
++++++++float+velX+=+scrollingVelocity.X;

++++++++//+If+their+signs+are+same,+or+if+either+is+zero,+go+ahead
++++++++if+(Math.Sign+(deltaX)+*+Math.Sign+(velX)+!=+-1)
++++++++++++break;

++++++++//+Otherwise,+look+for+the+closest+page+in+the+right+direction
++++++++nextOffset+%2B=+Math.Sign+(scrollingVelocity.X)+*+SnapStep;
++++}+while+(IsValidOffset+(nextOffset));

++++return+proposedContentOffset;
}

bool+IsValidOffset+(float+offset)
{
++++return+(offset+>=+MinContentOffset+&&+offset+<=+MaxContentOffset);
}|code-block|syntax|javascript|432596|这段代码使用了MinContentOffset、MaxContentOffset和SnapStep，这对你来说应该是微不足道的。在我的案例中，它们被证明是|432597|float+MinContentOffset+{
++++get+{+return+-CollectionView.ContentInset.Left;+}
}

float+MaxContentOffset+{
++++get+{+return+MinContentOffset+%2B+CollectionView.ContentSize.Width+-+ItemSize.Width;+}
}

float+SnapStep+{
++++get+{+return+ItemSize.Width+%2B+MinimumLineSpacing;+}
}|432598|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/13493707/458193^0|2|B|0|0|4|1K|1P|A|0|G|L|13|F|0|0|7|G|O|G|15|8|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|6|7|14|8|@$A|15|B|16|F|G]|$A|17|B|18|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|19|8|@$A|1A|B|1B|F|G]|$A|1C|B|1D|F|G]]|9|@]|C|$]]|$1|J|3|K|5|L|7|1E|8|@]|9|@]|C|$M|N]]|$1|O|3|P|5|6|7|1F|8|@$A|1G|B|1H|F|G]|$A|1I|B|1J|F|G]|$A|1K|B|1L|F|G]]|9|@]|C|$]]|$1|Q|3|R|5|L|7|1M|8|@]|9|@]|C|$M|N]]|$1|S|3|-4|5|6|7|1N|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]]]

While <a href="https://stackoverflow.com/a/13493707/458193">this answer</a> has been a great help to me, there is a noticeable flicker when you swipe fast on a small distance. It's much easier to reproduce it on the device.

I found that this always happens when <code>collectionView.contentOffset.x - proposedContentOffset.x</code> and <code>velocity.x</code> have different sings.

My solution was to ensure that <code>proposedContentOffset</code> is more than <code>contentOffset.x</code> if velocity is positive, and less if it is negative. It's in C# but should be fairly simple to translate to Objective C:

<pre><code>public override PointF TargetContentOffset (PointF proposedContentOffset, PointF scrollingVelocity)
{
 /* Determine closest edge */

 float offSetAdjustment = float.MaxValue;
 float horizontalCenter = (float) (proposedContentOffset.X + (this.CollectionView.Bounds.Size.Width / 2.0));

 RectangleF targetRect = new RectangleF (proposedContentOffset.X, 0.0f, this.CollectionView.Bounds.Size.Width, this.CollectionView.Bounds.Size.Height);
 var array = base.LayoutAttributesForElementsInRect (targetRect);

 foreach (var layoutAttributes in array) {
 float itemHorizontalCenter = layoutAttributes.Center.X;
 if (Math.Abs (itemHorizontalCenter - horizontalCenter) &lt; Math.Abs (offSetAdjustment)) {
 offSetAdjustment = itemHorizontalCenter - horizontalCenter;
 }
 }

 float nextOffset = proposedContentOffset.X + offSetAdjustment;

 /*
 * ... unless we end up having positive speed
 * while moving left or negative speed while moving right.
 * This will cause flicker so we resort to finding next page
 * in the direction of velocity and use it.
 */

 do {
 proposedContentOffset.X = nextOffset;

 float deltaX = proposedContentOffset.X - CollectionView.ContentOffset.X;
 float velX = scrollingVelocity.X;

 // If their signs are same, or if either is zero, go ahead
 if (Math.Sign (deltaX) * Math.Sign (velX) != -1)
 break;

 // Otherwise, look for the closest page in the right direction
 nextOffset += Math.Sign (scrollingVelocity.X) * SnapStep;
 } while (IsValidOffset (nextOffset));

 return proposedContentOffset;
}

bool IsValidOffset (float offset)
{
 return (offset &gt;= MinContentOffset &amp;&amp; offset &lt;= MaxContentOffset);
}
</code></pre>

This code is using <code>MinContentOffset</code>, <code>MaxContentOffset</code> and <code>SnapStep</code> which should be trivial for you to define. In my case they turned out to be

<pre><code>float MinContentOffset {
 get { return -CollectionView.ContentInset.Left; }
}

float MaxContentOffset {
 get { return MinContentOffset + CollectionView.ContentSize.Width - ItemSize.Width; }
}

float SnapStep {
 get { return ItemSize.Width + MinimumLineSpacing; }
}
</code></pre>

blocks|key|432661|text|我在使用targetContentOffsetForProposedContentOffset时遇到的一个小问题是，最后一个单元格没有根据我返回的新点进行调整。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|432662|我发现我返回的CGPoint的Y值大于允许的值，因此我在targetContentOffsetForProposedContentOffset实现的末尾使用了以下代码：|432663|//+if+the+calculated+y+is+bigger+then+the+maximum+possible+y+we+adjust+accordingly
CGFloat+contentHeight+=+self.collectionViewContentSize.height;
CGFloat+collectionViewHeight+=+self.collectionView.bounds.size.height;
CGFloat+maxY+=+contentHeight+-+collectionViewHeight;
if+(newY+>+maxY)
{
++++newY+=+maxY;
}

return+CGPointMake(0,+newY);|code-block|syntax|javascript|432664|为了清楚起见，这是我的完整布局实现，它只是模仿垂直分页行为：|432665|-+(CGPoint)targetContentOffsetForProposedContentOffset:(CGPoint)proposedContentOffset+withScrollingVelocity:(CGPoint)velocity
{
++++return+[self+targetContentOffsetForProposedContentOffset:proposedContentOffset];
}

-+(CGPoint)targetContentOffsetForProposedContentOffset:(CGPoint)proposedContentOffset
{
++++CGFloat+heightOfPage+=+self.itemSize.height;
++++CGFloat+heightOfSpacing+=+self.minimumLineSpacing;

++++CGFloat+numOfPage+=+lround(proposedContentOffset.y+/+(heightOfPage+%2B+heightOfSpacing));
++++CGFloat+newY+=+numOfPage+*+(heightOfPage+%2B+heightOfSpacing);

++++//+if+the+calculated+y+is+bigger+then+the+maximum+possible+y+we+adjust+accordingly
++++CGFloat+contentHeight+=+self.collectionViewContentSize.height;
++++CGFloat+collectionViewHeight+=+self.collectionView.bounds.size.height;
++++CGFloat+maxY+=+contentHeight+-+collectionViewHeight;
++++if+(newY+>+maxY)
++++{
++++++++newY+=+maxY;
++++}

++++return+CGPointMake(0,+newY);
}|432666|希望这将为某人节省一些时间和头痛。|432667|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

a small issue I encountered while using targetContentOffsetForProposedContentOffset is a problem with the last cell not adjusting according to the new point I returned. 
I found out that the CGPoint I returned had a Y value bigger then allowed so i used the following code at the end of my targetContentOffsetForProposedContentOffset implementation:

<pre><code>// if the calculated y is bigger then the maximum possible y we adjust accordingly
CGFloat contentHeight = self.collectionViewContentSize.height;
CGFloat collectionViewHeight = self.collectionView.bounds.size.height;
CGFloat maxY = contentHeight - collectionViewHeight;
if (newY &gt; maxY)
{
 newY = maxY;
}

return CGPointMake(0, newY);
</code></pre>

just to make it clearer this is my full layout implementation which just imitates vertical paging behavior:

<pre><code>- (CGPoint)targetContentOffsetForProposedContentOffset:(CGPoint)proposedContentOffset withScrollingVelocity:(CGPoint)velocity
{
 return [self targetContentOffsetForProposedContentOffset:proposedContentOffset];
}

- (CGPoint)targetContentOffsetForProposedContentOffset:(CGPoint)proposedContentOffset
{
 CGFloat heightOfPage = self.itemSize.height;
 CGFloat heightOfSpacing = self.minimumLineSpacing;

 CGFloat numOfPage = lround(proposedContentOffset.y / (heightOfPage + heightOfSpacing));
 CGFloat newY = numOfPage * (heightOfPage + heightOfSpacing);

 // if the calculated y is bigger then the maximum possible y we adjust accordingly
 CGFloat contentHeight = self.collectionViewContentSize.height;
 CGFloat collectionViewHeight = self.collectionView.bounds.size.height;
 CGFloat maxY = contentHeight - collectionViewHeight;
 if (newY &gt; maxY)
 {
 newY = maxY;
 }

 return CGPointMake(0, newY);
}
</code></pre>

hopefully this will save someone some time and a headache

blocks|key|432693|text|丹的解决方案有缺陷。它不能很好地处理用户的轻弹。当用户快速轻拍和滚动没有移动太多的情况下，动画故障。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|432694|我提出的替代实现具有与前面提出的相同的分页，但处理用户在页面之间的闪烁。|432695|+#pragma+mark+-+Pagination
+-+(CGFloat)pageWidth+{
+++++return+self.itemSize.width+%2B+self.minimumLineSpacing;
+}

+-+(CGPoint)targetContentOffsetForProposedContentOffset:(CGPoint)proposedContentOffset+withScrollingVelocity:(CGPoint)velocity
+{+++++++++++
++++++++CGFloat+rawPageValue+=+self.collectionView.contentOffset.x+/+self.pageWidth;
++++++++CGFloat+currentPage+=+(velocity.x+>+0.0)+?+floor(rawPageValue)+:+ceil(rawPageValue);
++++++++CGFloat+nextPage+=+(velocity.x+>+0.0)+?+ceil(rawPageValue)+:+floor(rawPageValue);

++++++++BOOL+pannedLessThanAPage+=+fabs(1+%2B+currentPage+-+rawPageValue)+>+0.5;
++++++++BOOL+flicked+=+fabs(velocity.x)+>+[self+flickVelocity];
++++++++if+(pannedLessThanAPage+&&+flicked)+{
++++++++++++proposedContentOffset.x+=+nextPage+*+self.pageWidth;
++++++++}+else+{
++++++++++++proposedContentOffset.x+=+round(rawPageValue)+*+self.pageWidth;
++++++++}

++++++++return+proposedContentOffset;
+}

+-+(CGFloat)flickVelocity+{
+++++return+0.3;
+}|code-block|syntax|javascript|432696|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Dan's solution is flawed. It does not handle user flicking well. The cases when user flicks fast and scroll did not move so much, have animation glitches.

My proposed alternative implementation has the same pagination as proposed before, but handles user flicking between pages.

<pre><code> #pragma mark - Pagination
 - (CGFloat)pageWidth {
 return self.itemSize.width + self.minimumLineSpacing;
 }

 - (CGPoint)targetContentOffsetForProposedContentOffset:(CGPoint)proposedContentOffset withScrollingVelocity:(CGPoint)velocity
 { 
 CGFloat rawPageValue = self.collectionView.contentOffset.x / self.pageWidth;
 CGFloat currentPage = (velocity.x &gt; 0.0) ? floor(rawPageValue) : ceil(rawPageValue);
 CGFloat nextPage = (velocity.x &gt; 0.0) ? ceil(rawPageValue) : floor(rawPageValue);

 BOOL pannedLessThanAPage = fabs(1 + currentPage - rawPageValue) &gt; 0.5;
 BOOL flicked = fabs(velocity.x) &gt; [self flickVelocity];
 if (pannedLessThanAPage &amp;&amp; flicked) {
 proposedContentOffset.x = nextPage * self.pageWidth;
 } else {
 proposedContentOffset.x = round(rawPageValue) * self.pageWidth;
 }

 return proposedContentOffset;
 }

 - (CGFloat)flickVelocity {
 return 0.3;
 }
</code></pre>

blocks|key|432734|text|经过长时间的测试，我找到了使用自定义单元格宽度居中对齐的解决方案(每个单元格都有不同。宽度)，它修复了闪烁。请随意改进脚本。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|432735|-+(CGPoint)+targetContentOffsetForProposedContentOffset:+(CGPoint)+proposedContentOffset+withScrollingVelocity:+(CGPoint)velocity
{
++++CGFloat+offSetAdjustment+=+MAXFLOAT;
++++CGFloat+horizontalCenter+=+(CGFloat)+(proposedContentOffset.x+%2B+(self.collectionView.bounds.size.width+/+2.0));

++++//setting+fastPaging+property+to+NO+allows+to+stop+at+page+on+screen+(I+have+pages+lees,+than+self.collectionView.bounds.size.width)
++++CGRect+targetRect+=+CGRectMake(self.fastPaging+?+proposedContentOffset.x+:+self.collectionView.contentOffset.x,+
+++++++++++++++++++++++++++++++++++0.0,
+++++++++++++++++++++++++++++++++++self.collectionView.bounds.size.width,
+++++++++++++++++++++++++++++++++++self.collectionView.bounds.size.height);

++++NSArray+*attributes+=+[self+layoutAttributesForElementsInRect:targetRect];
++++NSPredicate+*cellAttributesPredicate+=+[NSPredicate+predicateWithBlock:+%5EBOOL(UICollectionViewLayoutAttributes+*+_Nonnull+evaluatedObject,
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++NSDictionary<NSString+*,id>+*+_Nullable+bindings)+
++++{
++++++++return+(evaluatedObject.representedElementCategory+==+UICollectionElementCategoryCell);+
++++}];++++++++

++++NSArray+*cellAttributes+=+[attributes+filteredArrayUsingPredicate:+cellAttributesPredicate];

++++UICollectionViewLayoutAttributes+*currentAttributes;

++++for+(UICollectionViewLayoutAttributes+*layoutAttributes+in+cellAttributes)
++++{
++++++++CGFloat+itemHorizontalCenter+=+layoutAttributes.center.x;
++++++++if+(ABS(itemHorizontalCenter+-+horizontalCenter)+<+ABS(offSetAdjustment))
++++++++{
++++++++++++currentAttributes+++=+layoutAttributes;
++++++++++++offSetAdjustment++++=+itemHorizontalCenter+-+horizontalCenter;
++++++++}
++++}

++++CGFloat+nextOffset++++++++++=+proposedContentOffset.x+%2B+offSetAdjustment;

++++proposedContentOffset.x+++++=+nextOffset;
++++CGFloat+deltaX++++++++++++++=+proposedContentOffset.x+-+self.collectionView.contentOffset.x;
++++CGFloat+velX++++++++++++++++=+velocity.x;

++++//+detection+form++gist.github.com/rkeniger/7687301
++++//+based+on+http://stackoverflow.com/a/14291208/740949
++++if+(fabs(deltaX)+<=+FLT_EPSILON+%7C%7C+fabs(velX)+<=+FLT_EPSILON+%7C%7C+(velX+>+0.0+&&+deltaX+>+0.0)+%7C%7C+(velX+<+0.0+&&+deltaX+<+0.0))+
++++{

++++}+
++++else+if+(velocity.x+>+0.0)+
++++{
+++++++//+revert+the+array+to+get+the+cells+from+the+right+side,+fixes+not+correct+center+on+different+size+in+some+usecases
++++++++NSArray+*revertedArray+=+[[array+reverseObjectEnumerator]+allObjects];

++++++++BOOL+found+=+YES;
++++++++float+proposedX+=+0.0;

++++++++for+(UICollectionViewLayoutAttributes+*layoutAttributes+in+revertedArray)
++++++++{
++++++++++++if(layoutAttributes.representedElementCategory+==+UICollectionElementCategoryCell)
++++++++++++{
++++++++++++++++CGFloat+itemHorizontalCenter+=+layoutAttributes.center.x;
++++++++++++++++if+(itemHorizontalCenter+>+proposedContentOffset.x)+{
+++++++++++++++++++++found+=+YES;
+++++++++++++++++++++proposedX+=+nextOffset+%2B+(currentAttributes.frame.size.width+/+2)+%2B+(layoutAttributes.frame.size.width+/+2);
++++++++++++++++}+else+{
+++++++++++++++++++++break;
++++++++++++++++}
++++++++++++}
++++++++}

+++++++//+dont+set+on+unfound+element
++++++++if+(found)+{
++++++++++++proposedContentOffset.x+=+proposedX;
++++++++}
++++}+
++++else+if+(velocity.x+<+0.0)+
++++{
++++++++for+(UICollectionViewLayoutAttributes+*layoutAttributes+in+cellAttributes)
++++++++{
++++++++++++CGFloat+itemHorizontalCenter+=+layoutAttributes.center.x;
++++++++++++if+(itemHorizontalCenter+>+proposedContentOffset.x)+
++++++++++++{
++++++++++++++++proposedContentOffset.x+=+nextOffset+-+((currentAttributes.frame.size.width+/+2)+%2B+(layoutAttributes.frame.size.width+/+2));
++++++++++++++++break;
++++++++++++}
++++++++}
++++}

++++proposedContentOffset.y+=+0.0;

++++return+proposedContentOffset;
}|code-block|syntax|javascript|432736|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

After long testing I found solution to snap to center with custom cell width (each cell has diff. width) which fixes the flickering. Feel free to improve the script.

<pre><code>- (CGPoint) targetContentOffsetForProposedContentOffset: (CGPoint) proposedContentOffset withScrollingVelocity: (CGPoint)velocity
{
 CGFloat offSetAdjustment = MAXFLOAT;
 CGFloat horizontalCenter = (CGFloat) (proposedContentOffset.x + (self.collectionView.bounds.size.width / 2.0));

 //setting fastPaging property to NO allows to stop at page on screen (I have pages lees, than self.collectionView.bounds.size.width)
 CGRect targetRect = CGRectMake(self.fastPaging ? proposedContentOffset.x : self.collectionView.contentOffset.x, 
 0.0,
 self.collectionView.bounds.size.width,
 self.collectionView.bounds.size.height);

 NSArray *attributes = [self layoutAttributesForElementsInRect:targetRect];
 NSPredicate *cellAttributesPredicate = [NSPredicate predicateWithBlock: ^BOOL(UICollectionViewLayoutAttributes * _Nonnull evaluatedObject,
 NSDictionary&lt;NSString *,id&gt; * _Nullable bindings) 
 {
 return (evaluatedObject.representedElementCategory == UICollectionElementCategoryCell); 
 }]; 

 NSArray *cellAttributes = [attributes filteredArrayUsingPredicate: cellAttributesPredicate];

 UICollectionViewLayoutAttributes *currentAttributes;

 for (UICollectionViewLayoutAttributes *layoutAttributes in cellAttributes)
 {
 CGFloat itemHorizontalCenter = layoutAttributes.center.x;
 if (ABS(itemHorizontalCenter - horizontalCenter) &lt; ABS(offSetAdjustment))
 {
 currentAttributes = layoutAttributes;
 offSetAdjustment = itemHorizontalCenter - horizontalCenter;
 }
 }

 CGFloat nextOffset = proposedContentOffset.x + offSetAdjustment;

 proposedContentOffset.x = nextOffset;
 CGFloat deltaX = proposedContentOffset.x - self.collectionView.contentOffset.x;
 CGFloat velX = velocity.x;

 // detection form gist.github.com/rkeniger/7687301
 // based on http://stackoverflow.com/a/14291208/740949
 if (fabs(deltaX) &lt;= FLT_EPSILON || fabs(velX) &lt;= FLT_EPSILON || (velX &gt; 0.0 &amp;&amp; deltaX &gt; 0.0) || (velX &lt; 0.0 &amp;&amp; deltaX &lt; 0.0)) 
 {

 } 
 else if (velocity.x &gt; 0.0) 
 {
 // revert the array to get the cells from the right side, fixes not correct center on different size in some usecases
 NSArray *revertedArray = [[array reverseObjectEnumerator] allObjects];

 BOOL found = YES;
 float proposedX = 0.0;

 for (UICollectionViewLayoutAttributes *layoutAttributes in revertedArray)
 {
 if(layoutAttributes.representedElementCategory == UICollectionElementCategoryCell)
 {
 CGFloat itemHorizontalCenter = layoutAttributes.center.x;
 if (itemHorizontalCenter &gt; proposedContentOffset.x) {
 found = YES;
 proposedX = nextOffset + (currentAttributes.frame.size.width / 2) + (layoutAttributes.frame.size.width / 2);
 } else {
 break;
 }
 }
 }

 // dont set on unfound element
 if (found) {
 proposedContentOffset.x = proposedX;
 }
 } 
 else if (velocity.x &lt; 0.0) 
 {
 for (UICollectionViewLayoutAttributes *layoutAttributes in cellAttributes)
 {
 CGFloat itemHorizontalCenter = layoutAttributes.center.x;
 if (itemHorizontalCenter &gt; proposedContentOffset.x) 
 {
 proposedContentOffset.x = nextOffset - ((currentAttributes.frame.size.width / 2) + (layoutAttributes.frame.size.width / 2));
 break;
 }
 }
 }

 proposedContentOffset.y = 0.0;

 return proposedContentOffset;
}
</code></pre>

blocks|key|432754|text|请参阅this+answer+by+Dan+Abramov+here的Swift版本|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|432755|++++override+func+targetContentOffsetForProposedContentOffset(proposedContentOffset:+CGPoint,+withScrollingVelocity+velocity:+CGPoint)+->+CGPoint+{
++++var+_proposedContentOffset+=+CGPoint(x:+proposedContentOffset.x,+y:+proposedContentOffset.y)
++++var+offSetAdjustment:+CGFloat+=+CGFloat.max
++++let+horizontalCenter:+CGFloat+=+CGFloat(proposedContentOffset.x+%2B+(self.collectionView!.bounds.size.width+/+2.0))

++++let+targetRect+=+CGRect(x:+proposedContentOffset.x,+y:+0.0,+width:+self.collectionView!.bounds.size.width,+height:+self.collectionView!.bounds.size.height)

++++let+array:+[UICollectionViewLayoutAttributes]+=+self.layoutAttributesForElementsInRect(targetRect)!+as+[UICollectionViewLayoutAttributes]
++++for+layoutAttributes:+UICollectionViewLayoutAttributes+in+array+{
++++++++if+(layoutAttributes.representedElementCategory+==+UICollectionElementCategory.Cell)+{
++++++++++++let+itemHorizontalCenter:+CGFloat+=+layoutAttributes.center.x
++++++++++++if+(abs(itemHorizontalCenter+-+horizontalCenter)+<+abs(offSetAdjustment))+{
++++++++++++++++offSetAdjustment+=+itemHorizontalCenter+-+horizontalCenter
++++++++++++}
++++++++}
++++}

++++var+nextOffset:+CGFloat+=+proposedContentOffset.x+%2B+offSetAdjustment

++++repeat+{
++++++++_proposedContentOffset.x+=+nextOffset
++++++++let+deltaX+=+proposedContentOffset.x+-+self.collectionView!.contentOffset.x
++++++++let+velX+=+velocity.x

++++++++if+(deltaX+==+0.0+%7C%7C+velX+==+0+%7C%7C+(velX+>+0.0+&&+deltaX+>+0.0)+%7C%7C+(velX+<+0.0+&&+deltaX+<+0.0))+{
++++++++++++break
++++++++}

++++++++if+(velocity.x+>+0.0)+{
++++++++++++nextOffset+=+nextOffset+%2B+self.snapStep()
++++++++}+else+if+(velocity.x+<+0.0)+{
++++++++++++nextOffset+=+nextOffset+-+self.snapStep()
++++++++}
++++}+while+self.isValidOffset(nextOffset)

++++_proposedContentOffset.y+=+0.0

++++return+_proposedContentOffset
}

func+isValidOffset(offset:+CGFloat)+->+Bool+{
++++return+(offset+>=+CGFloat(self.minContentOffset())+&&+offset+<=+CGFloat(self.maxContentOffset()))
}

func+minContentOffset()+->+CGFloat+{
++++return+-CGFloat(self.collectionView!.contentInset.left)
}

func+maxContentOffset()+->+CGFloat+{
++++return+CGFloat(self.minContentOffset()+%2B+self.collectionView!.contentSize.width+-+self.itemSize.width)
}

func+snapStep()+->+CGFloat+{
++++return+self.itemSize.width+%2B+self.minimumLineSpacing;
}|code-block|syntax|javascript|432756|或者要点在这里https://gist.github.com/katopz/8b04c783387f0c345cd9|432757|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/14291208/2624884|1|https://gist.github.com/katopz/8b04c783387f0c345cd9^0|3|Q|0|0|0|7|1F|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]]]

refer to <a href="https://stackoverflow.com/a/14291208/2624884">this answer by Dan Abramov</a> here's Swift version

<pre><code> override func targetContentOffsetForProposedContentOffset(proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -&gt; CGPoint {
 var _proposedContentOffset = CGPoint(x: proposedContentOffset.x, y: proposedContentOffset.y)
 var offSetAdjustment: CGFloat = CGFloat.max
 let horizontalCenter: CGFloat = CGFloat(proposedContentOffset.x + (self.collectionView!.bounds.size.width / 2.0))

 let targetRect = CGRect(x: proposedContentOffset.x, y: 0.0, width: self.collectionView!.bounds.size.width, height: self.collectionView!.bounds.size.height)

 let array: [UICollectionViewLayoutAttributes] = self.layoutAttributesForElementsInRect(targetRect)! as [UICollectionViewLayoutAttributes]
 for layoutAttributes: UICollectionViewLayoutAttributes in array {
 if (layoutAttributes.representedElementCategory == UICollectionElementCategory.Cell) {
 let itemHorizontalCenter: CGFloat = layoutAttributes.center.x
 if (abs(itemHorizontalCenter - horizontalCenter) &lt; abs(offSetAdjustment)) {
 offSetAdjustment = itemHorizontalCenter - horizontalCenter
 }
 }
 }

 var nextOffset: CGFloat = proposedContentOffset.x + offSetAdjustment

 repeat {
 _proposedContentOffset.x = nextOffset
 let deltaX = proposedContentOffset.x - self.collectionView!.contentOffset.x
 let velX = velocity.x

 if (deltaX == 0.0 || velX == 0 || (velX &gt; 0.0 &amp;&amp; deltaX &gt; 0.0) || (velX &lt; 0.0 &amp;&amp; deltaX &lt; 0.0)) {
 break
 }

 if (velocity.x &gt; 0.0) {
 nextOffset = nextOffset + self.snapStep()
 } else if (velocity.x &lt; 0.0) {
 nextOffset = nextOffset - self.snapStep()
 }
 } while self.isValidOffset(nextOffset)

 _proposedContentOffset.y = 0.0

 return _proposedContentOffset
}

func isValidOffset(offset: CGFloat) -&gt; Bool {
 return (offset &gt;= CGFloat(self.minContentOffset()) &amp;&amp; offset &lt;= CGFloat(self.maxContentOffset()))
}

func minContentOffset() -&gt; CGFloat {
 return -CGFloat(self.collectionView!.contentInset.left)
}

func maxContentOffset() -&gt; CGFloat {
 return CGFloat(self.minContentOffset() + self.collectionView!.contentSize.width - self.itemSize.width)
}

func snapStep() -&gt; CGFloat {
 return self.itemSize.width + self.minimumLineSpacing;
}
</code></pre>

or gist here <a href="https://gist.github.com/katopz/8b04c783387f0c345cd9" rel="noreferrer">https://gist.github.com/katopz/8b04c783387f0c345cd9</a>

blocks|key|214577|text|这是我在水平滚动集合视图上的Swift解决方案。这是简单，甜蜜，并避免任何闪烁。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|214578|++override+func+targetContentOffsetForProposedContentOffset(proposedContentOffset:+CGPoint,+withScrollingVelocity+velocity:+CGPoint)+->+CGPoint+{
++++guard+let+collectionView+=+collectionView+else+{+return+proposedContentOffset+}

++++let+currentXOffset+=+collectionView.contentOffset.x
++++let+nextXOffset+=+proposedContentOffset.x
++++let+maxIndex+=+ceil(currentXOffset+/+pageWidth())
++++let+minIndex+=+floor(currentXOffset+/+pageWidth())

++++var+index:+CGFloat+=+0

++++if+nextXOffset+>+currentXOffset+{
++++++index+=+maxIndex
++++}+else+{
++++++index+=+minIndex
++++}

++++let+xOffset+=+pageWidth()+*+index
++++let+point+=+CGPointMake(xOffset,+0)

++++return+point
++}

++func+pageWidth()+->+CGFloat+{
++++return+itemSize.width+%2B+minimumInteritemSpacing
++}|code-block|syntax|javascript|214579|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is my Swift solution on a horizontally scrolling collection view. It's simple, sweet and avoids any flickering.

<pre><code> override func targetContentOffsetForProposedContentOffset(proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -&gt; CGPoint {
 guard let collectionView = collectionView else { return proposedContentOffset }

 let currentXOffset = collectionView.contentOffset.x
 let nextXOffset = proposedContentOffset.x
 let maxIndex = ceil(currentXOffset / pageWidth())
 let minIndex = floor(currentXOffset / pageWidth())

 var index: CGFloat = 0

 if nextXOffset &gt; currentXOffset {
 index = maxIndex
 } else {
 index = minIndex
 }

 let xOffset = pageWidth() * index
 let point = CGPointMake(xOffset, 0)

 return point
 }

 func pageWidth() -&gt; CGFloat {
 return itemSize.width + minimumInteritemSpacing
 }
</code></pre>

blocks|key|214591|text|对于那些在Swift中寻找解决方案的人：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|214592|class+CustomCollectionViewFlowLayout:+UICollectionViewFlowLayout+{
++++private+let+collectionViewHeight:+CGFloat+=+200.0
++++private+let+screenWidth:+CGFloat+=+UIScreen.mainScreen().bounds.width

++++override+func+awakeFromNib()+{
++++++++super.awakeFromNib()

++++++++self.itemSize+=+CGSize(width:+[InsertItemWidthHere],+height:+[InsertItemHeightHere])
++++++++self.minimumInteritemSpacing+=+[InsertItemSpacingHere]
++++++++self.scrollDirection+=+.Horizontal
++++++++let+inset+=+(self.screenWidth+-+CGFloat(self.itemSize.width))+/+2
++++++++self.collectionView?.contentInset+=+UIEdgeInsets(top:+0,
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++left:+inset,
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++bottom:+0,
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++right:+inset)
++++}

++++override+func+targetContentOffsetForProposedContentOffset(proposedContentOffset:+CGPoint,+withScrollingVelocity+velocity:+CGPoint)+->+CGPoint+{
++++++++var+offsetAdjustment+=+CGFloat.max
++++++++let+horizontalOffset+=+proposedContentOffset.x+%2B+((self.screenWidth+-+self.itemSize.width)+/+2)

++++++++let+targetRect+=+CGRect(x:+proposedContentOffset.x,+y:+0,+width:+self.screenWidth,+height:+self.collectionViewHeight)
++++++++var+array+=+super.layoutAttributesForElementsInRect(targetRect)

++++++++for+layoutAttributes+in+array!+{
++++++++++++let+itemOffset+=+layoutAttributes.frame.origin.x
++++++++++++if+(abs(itemOffset+-+horizontalOffset)+<+abs(offsetAdjustment))+{
++++++++++++++++offsetAdjustment+=+itemOffset+-+horizontalOffset
++++++++++++}
++++++++}

++++++++return+CGPoint(x:+proposedContentOffset.x+%2B+offsetAdjustment,+y:+proposedContentOffset.y)
++++}
}|code-block|syntax|javascript|214593|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For those looking for a solution in Swift:

<pre><code>class CustomCollectionViewFlowLayout: UICollectionViewFlowLayout {
 private let collectionViewHeight: CGFloat = 200.0
 private let screenWidth: CGFloat = UIScreen.mainScreen().bounds.width

 override func awakeFromNib() {
 super.awakeFromNib()

 self.itemSize = CGSize(width: [InsertItemWidthHere], height: [InsertItemHeightHere])
 self.minimumInteritemSpacing = [InsertItemSpacingHere]
 self.scrollDirection = .Horizontal
 let inset = (self.screenWidth - CGFloat(self.itemSize.width)) / 2
 self.collectionView?.contentInset = UIEdgeInsets(top: 0,
 left: inset,
 bottom: 0,
 right: inset)
 }

 override func targetContentOffsetForProposedContentOffset(proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -&gt; CGPoint {
 var offsetAdjustment = CGFloat.max
 let horizontalOffset = proposedContentOffset.x + ((self.screenWidth - self.itemSize.width) / 2)

 let targetRect = CGRect(x: proposedContentOffset.x, y: 0, width: self.screenWidth, height: self.collectionViewHeight)
 var array = super.layoutAttributesForElementsInRect(targetRect)

 for layoutAttributes in array! {
 let itemOffset = layoutAttributes.frame.origin.x
 if (abs(itemOffset - horizontalOffset) &lt; abs(offsetAdjustment)) {
 offsetAdjustment = itemOffset - horizontalOffset
 }
 }

 return CGPoint(x: proposedContentOffset.x + offsetAdjustment, y: proposedContentOffset.y)
 }
}
</code></pre>

blocks|key|432855|text|Swift+4|type|unstyled|depth|inlineStyleRanges|entityRanges|data|432856|对于具有一种大小的单元格(水平滚动)的集合视图，最简单的解决方案是：|432857|override+func+targetContentOffset(forProposedContentOffset+proposedContentOffset:+CGPoint,+withScrollingVelocity+velocity:+CGPoint)+->+CGPoint+{
++++guard+let+collectionView+=+collectionView+else+{+return+proposedContentOffset+}

++++//+Calculate+width+of+your+page
++++let+pageWidth+=+calculatedPageWidth()

++++//+Calculate+proposed+page
++++let+proposedPage+=+round(proposedContentOffset.x+/+pageWidth)

++++//+Adjust+necessary+offset
++++let+xOffset+=+pageWidth+*+proposedPage+-+collectionView.contentInset.left

++++return+CGPoint(x:+xOffset,+y:+0)
}

func+calculatedPageWidth()+->+CGFloat+{
++++return+itemSize.width+%2B+minimumInteritemSpacing
}|code-block|syntax|javascript|432858|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Swift 4

The easiest solution for collection view with cells of one size (horizontal scroll):

<pre><code>override func targetContentOffset(forProposedContentOffset proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -&gt; CGPoint {
 guard let collectionView = collectionView else { return proposedContentOffset }

 // Calculate width of your page
 let pageWidth = calculatedPageWidth()

 // Calculate proposed page
 let proposedPage = round(proposedContentOffset.x / pageWidth)

 // Adjust necessary offset
 let xOffset = pageWidth * proposedPage - collectionView.contentInset.left

 return CGPoint(x: xOffset, y: 0)
}

func calculatedPageWidth() -&gt; CGFloat {
 return itemSize.width + minimumInteritemSpacing
}
</code></pre>

blocks|key|432890|text|一种较短的解决方案(假设您正在缓存布局属性)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|432891|override+func+targetContentOffset(forProposedContentOffset+proposedContentOffset:+CGPoint,+withScrollingVelocity+velocity:+CGPoint)+->+CGPoint+{
++++let+proposedEndFrame+=+CGRect(x:+proposedContentOffset.x,+y:+0,+width:+collectionView!.bounds.width,+height:+collectionView!.bounds.height)
++++let+targetLayoutAttributes+=+cache.max+{+$0.frame.intersection(proposedEndFrame).width+<+$1.frame.intersection(proposedEndFrame).width+}!
++++return+CGPoint(x:+targetLayoutAttributes.frame.minX+-+horizontalPadding,+y:+0)
}|code-block|syntax|javascript|432892|将其放在上下文中：|432893|class+Layout+:+UICollectionViewLayout+{
++++private+var+cache:+[UICollectionViewLayoutAttributes]+=+[]
++++private+static+let+horizontalPadding:+CGFloat+=+16
++++private+static+let+interItemSpacing:+CGFloat+=+8

++++override+func+prepare()+{
++++++++let+(itemWidth,+itemHeight)+=+(collectionView!.bounds.width+-+2+*+Layout.horizontalPadding,+collectionView!.bounds.height)
++++++++cache.removeAll()
++++++++let+count+=+collectionView!.numberOfItems(inSection:+0)
++++++++var+x:+CGFloat+=+Layout.horizontalPadding
++++++++for+item+in+(0..<count)+{
++++++++++++let+indexPath+=+IndexPath(item:+item,+section:+0)
++++++++++++let+attributes+=+UICollectionViewLayoutAttributes(forCellWith:+indexPath)
++++++++++++attributes.frame+=+CGRect(x:+x,+y:+0,+width:+itemWidth,+height:+itemHeight)
++++++++++++cache.append(attributes)
++++++++++++x+%2B=+itemWidth+%2B+Layout.interItemSpacing
++++++++}
++++}

++++override+var+collectionViewContentSize:+CGSize+{
++++++++let+width:+CGFloat
++++++++if+let+maxX+=+cache.last?.frame.maxX+{
++++++++++++width+=+maxX+%2B+Layout.horizontalPadding
++++++++}+else+{
++++++++++++width+=+collectionView!.width
++++++++}
++++++++return+CGSize(width:+width,+height:+collectionView!.height)
++++}

++++override+func+layoutAttributesForItem(at+indexPath:+IndexPath)+->+UICollectionViewLayoutAttributes?+{
++++++++return+cache.first+{+$0.indexPath+==+indexPath+}
++++}

++++override+func+layoutAttributesForElements(in+rect:+CGRect)+->+[UICollectionViewLayoutAttributes]?+{
++++++++return+cache.filter+{+$0.frame.intersects(rect)+}
++++}

++++override+func+targetContentOffset(forProposedContentOffset+proposedContentOffset:+CGPoint,+withScrollingVelocity+velocity:+CGPoint)+->+CGPoint+{
++++++++let+proposedEndFrame+=+CGRect(x:+proposedContentOffset.x,+y:+0,+width:+collectionView!.bounds.width,+height:+collectionView!.bounds.height)
++++++++let+targetLayoutAttributes+=+cache.max+{+$0.frame.intersection(proposedEndFrame).width+<+$1.frame.intersection(proposedEndFrame).width+}!
++++++++return+CGPoint(x:+targetLayoutAttributes.frame.minX+-+Layout.horizontalPadding,+y:+0)
++++}
}|432894|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

A shorter solution (assuming you're caching your layout attributes):

<pre><code>override func targetContentOffset(forProposedContentOffset proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -&gt; CGPoint {
 let proposedEndFrame = CGRect(x: proposedContentOffset.x, y: 0, width: collectionView!.bounds.width, height: collectionView!.bounds.height)
 let targetLayoutAttributes = cache.max { $0.frame.intersection(proposedEndFrame).width &lt; $1.frame.intersection(proposedEndFrame).width }!
 return CGPoint(x: targetLayoutAttributes.frame.minX - horizontalPadding, y: 0)
}
</code></pre>

To put this in context:

<pre><code>class Layout : UICollectionViewLayout {
 private var cache: [UICollectionViewLayoutAttributes] = []
 private static let horizontalPadding: CGFloat = 16
 private static let interItemSpacing: CGFloat = 8

 override func prepare() {
 let (itemWidth, itemHeight) = (collectionView!.bounds.width - 2 * Layout.horizontalPadding, collectionView!.bounds.height)
 cache.removeAll()
 let count = collectionView!.numberOfItems(inSection: 0)
 var x: CGFloat = Layout.horizontalPadding
 for item in (0..&lt;count) {
 let indexPath = IndexPath(item: item, section: 0)
 let attributes = UICollectionViewLayoutAttributes(forCellWith: indexPath)
 attributes.frame = CGRect(x: x, y: 0, width: itemWidth, height: itemHeight)
 cache.append(attributes)
 x += itemWidth + Layout.interItemSpacing
 }
 }

 override var collectionViewContentSize: CGSize {
 let width: CGFloat
 if let maxX = cache.last?.frame.maxX {
 width = maxX + Layout.horizontalPadding
 } else {
 width = collectionView!.width
 }
 return CGSize(width: width, height: collectionView!.height)
 }

 override func layoutAttributesForItem(at indexPath: IndexPath) -&gt; UICollectionViewLayoutAttributes? {
 return cache.first { $0.indexPath == indexPath }
 }

 override func layoutAttributesForElements(in rect: CGRect) -&gt; [UICollectionViewLayoutAttributes]? {
 return cache.filter { $0.frame.intersects(rect) }
 }

 override func targetContentOffset(forProposedContentOffset proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -&gt; CGPoint {
 let proposedEndFrame = CGRect(x: proposedContentOffset.x, y: 0, width: collectionView!.bounds.width, height: collectionView!.bounds.height)
 let targetLayoutAttributes = cache.max { $0.frame.intersection(proposedEndFrame).width &lt; $1.frame.intersection(proposedEndFrame).width }!
 return CGPoint(x: targetLayoutAttributes.frame.minX - Layout.horizontalPadding, y: 0)
 }
}
</code></pre>

blocks|key|214668|text|为了确保它在Swift版本(现在是swift+5)中工作，我使用了@andréabreu的answer，我添加了一些更多的信息：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|214669|当子类化函数时，"override+func+awakeFromNib(){}“不起作用(不知道为什么)。相反，我使用了"override+init(){super.init()}“|214670|这是我放在类SubclassFlowLayout中的代码:+UICollectionViewFlowLayout+{}：|214671|let+padding:+CGFloat+=+16
override+init()+{
++++super.init()
++++self.minimumLineSpacing+=+padding
++++self.minimumInteritemSpacing+=+2
++++self.scrollDirection+=+.horizontal
++++self.sectionInset+=+UIEdgeInsets(top:+0,+left:+padding,+bottom:+0,+right:+100)+//right+=+"should+set+for+footer"+(Horizental)

}

required+init?(coder:+NSCoder)+{
++++fatalError("init(coder:)+has+not+been+implemented")
}

override+func+targetContentOffset(forProposedContentOffset+proposedContentOffset:+CGPoint,+withScrollingVelocity+velocity:+CGPoint)+->+CGPoint+{
++++var+offsetAdjustment+=+CGFloat.greatestFiniteMagnitude
++++let+leftInset+=+padding
++++let+horizontalOffset+=+proposedContentOffset.x+%2B+leftInset+//+leftInset+is+for+"where+you+want+the+item+stop+on+the+left"
++++let+targetRect+=+CGRect(origin:+CGPoint(x:+proposedContentOffset.x,+y:+0),+size:+self.collectionView!.bounds.size)

++++for+layoutAttributes+in+super.layoutAttributesForElements(in:+targetRect)!+{
++++++++let+itemOffset+=+layoutAttributes.frame.origin.x
++++++++if+(abs(itemOffset+-+horizontalOffset)+<+abs(offsetAdjustment))+{
++++++++++++offsetAdjustment+=+itemOffset+-+horizontalOffset
++++++++}
++++}

++++let+targetPoint+=+CGPoint(x:+proposedContentOffset.x+%2B+offsetAdjustment,+y:+proposedContentOffset.y)
++++return+targetPoint

}|code-block|syntax|javascript|214672|在子类化之后，确保将其放在ViewDidLoad()中：|214673|customCollectionView.collectionViewLayout+=+SubclassFlowLayout()
customCollectionView.isPagingEnabled+=+false
customCollectionView.decelerationRate+=+.fast+//->+this+for+scrollView+speed|214674|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/35798242/11229563^0|19|6|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|14|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|C|$]]|$1|O|3|P|5|J|7|16|8|@]|9|@]|C|$K|L]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

To make sure it works in Swift version (swift 5 now), I used the <a href="https://stackoverflow.com/a/35798242/11229563">answer</a> from @André Abreu, I add some more informations:

When subclassing UICollectionViewFlowLayout, the "override func awakeFromNib(){}" doesn't works (don't know why). Instead, I used "override init(){super.init()}"

This is my code put in class SubclassFlowLayout: UICollectionViewFlowLayout {} :

<pre><code>let padding: CGFloat = 16
override init() {
 super.init()
 self.minimumLineSpacing = padding
 self.minimumInteritemSpacing = 2
 self.scrollDirection = .horizontal
 self.sectionInset = UIEdgeInsets(top: 0, left: padding, bottom: 0, right: 100) //right = "should set for footer" (Horizental)

}

required init?(coder: NSCoder) {
 fatalError("init(coder:) has not been implemented")
}

override func targetContentOffset(forProposedContentOffset proposedContentOffset: CGPoint, withScrollingVelocity velocity: CGPoint) -&gt; CGPoint {
 var offsetAdjustment = CGFloat.greatestFiniteMagnitude
 let leftInset = padding
 let horizontalOffset = proposedContentOffset.x + leftInset // leftInset is for "where you want the item stop on the left"
 let targetRect = CGRect(origin: CGPoint(x: proposedContentOffset.x, y: 0), size: self.collectionView!.bounds.size)

 for layoutAttributes in super.layoutAttributesForElements(in: targetRect)! {
 let itemOffset = layoutAttributes.frame.origin.x
 if (abs(itemOffset - horizontalOffset) &lt; abs(offsetAdjustment)) {
 offsetAdjustment = itemOffset - horizontalOffset
 }
 }

 let targetPoint = CGPoint(x: proposedContentOffset.x + offsetAdjustment, y: proposedContentOffset.y)
 return targetPoint

}
</code></pre>

After subclassing, make sure to put this in ViewDidLoad():

<pre><code>customCollectionView.collectionViewLayout = SubclassFlowLayout()
customCollectionView.isPagingEnabled = false
customCollectionView.decelerationRate = .fast //-&gt; this for scrollView speed
</code></pre>

blocks|key|214695|text|这是一个按单元格分页的演示(当快速滚动时，不跳过一个或多个单元格)：https://github.com/ApesTalk/ATPagingByCell|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|214696|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/ApesTalk/ATPagingByCell^0|Y|16|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Here is a demo for paging by cell （when scroll fast, not skip one or more cell）: <a href="https://github.com/ApesTalk/ATPagingByCell" rel="nofollow noreferrer">https://github.com/ApesTalk/ATPagingByCell</a>

I've got a very simple collectionView in my app (just a single row of square thumbnail images).

I'd like to intercept the scrolling so that the offset always leaves a full image at the left side. At the moment it scrolls to wherever and will leave cut off images.

Anyway, I know I need to use the function

<pre><code>- (CGPoint)targetContentOffsetForProposedContentOffset:withScrollingVelocity
</code></pre>

to do this but I'm just using a standard <code>UICollectionViewFlowLayout</code>. I'm not subclassing it.

Is there any way of intercepting this without subclassing <code>UICollectionViewFlowLayout</code>?

Thanks

targetContentOffsetForProposedContentOffset:withScrollingVelocity without subclassing UICollectionViewFlowLayout

Swift

我的应用程序中有一个非常简单的collectionView (只有一排正方形的缩略图)。我想截取滚动，以便偏移量始终在左侧留下完整的图像。此时，它会滚动到任何位置，并会留下截取的图像。无论如何，我知道我需要使用函数- (CGPoint)targetContentOffsetForProposedContentOffse...

问无子类化UICollectionViewFlowLayout的targetContentOffsetForProposedContentOffset:withScrollingVelocity
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问无子类化UICollectionViewFlowLayout的targetContentOffsetForProposedContentOffset:withScrollingVelocityEN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问无子类化UICollectionViewFlowLayout的targetContentOffsetForProposedContentOffset:withScrollingVelocity
EN