Permalink
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
2311 lines (1943 sloc) 110 KB
//
// PSTCollectionView.m
// PSPDFKit
//
// Copyright (c) 2012-2013 Peter Steinberger. All rights reserved.
//
#import "PSTCollectionView.h"
#import "PSTCollectionViewData.h"
#import "PSTCollectionViewLayout+Internals.h"
#import "PSTCollectionViewItemKey.h"
#import <objc/runtime.h>
#if TARGET_IPHONE_SIMULATOR
#import <dlfcn.h>
#endif
#import <tgmath.h>
@interface PSTCollectionViewLayout (Internal)
@property (nonatomic, unsafe_unretained) PSTCollectionView *collectionView;
@end
@interface PSTCollectionViewData (Internal)
- (void)prepareToLoadData;
@end
@interface PSTCollectionViewCell (Internal)
- (void)performSelectionSegue;
@end
@interface PSTCollectionViewUpdateItem ()
- (NSIndexPath *)indexPath;
- (BOOL)isSectionOperation;
@end
@interface PSTCollectionViewLayoutAttributes () {
char junk[128];
}
@property (nonatomic, copy) NSString *elementKind;
@end
CGFloat PSTSimulatorAnimationDragCoefficient(void);
@class PSTCollectionViewExt;
@interface PSTCollectionView () <UIScrollViewDelegate> {
// ivar layout needs to EQUAL to UICollectionView.
PSTCollectionViewLayout *_layout;
__unsafe_unretained id<PSTCollectionViewDataSource> _dataSource;
UIView *_backgroundView;
NSMutableSet *_indexPathsForSelectedItems;
NSMutableDictionary *_cellReuseQueues;
NSMutableDictionary *_supplementaryViewReuseQueues;
NSMutableDictionary *_decorationViewReuseQueues;
NSMutableSet *_indexPathsForHighlightedItems;
int _reloadingSuspendedCount;
PSTCollectionReusableView *_firstResponderView;
UIView *_newContentView;
int _firstResponderViewType;
NSString *_firstResponderViewKind;
NSIndexPath *_firstResponderIndexPath;
NSMutableDictionary *_allVisibleViewsDict;
NSIndexPath *_pendingSelectionIndexPath;
NSMutableSet *_pendingDeselectionIndexPaths;
PSTCollectionViewData *_collectionViewData;
id _update;
CGRect _visibleBoundRects;
CGRect _preRotationBounds;
CGPoint _rotationBoundsOffset;
int _rotationAnimationCount;
int _updateCount;
NSMutableArray *_insertItems;
NSMutableArray *_deleteItems;
NSMutableArray *_reloadItems;
NSMutableArray *_moveItems;
NSArray *_originalInsertItems;
NSArray *_originalDeleteItems;
UITouch *_currentTouch;
void (^_updateCompletionHandler)(BOOL finished);
NSMutableDictionary *_cellClassDict;
NSMutableDictionary *_cellNibDict;
NSMutableDictionary *_supplementaryViewClassDict;
NSMutableDictionary *_supplementaryViewNibDict;
NSMutableDictionary *_cellNibExternalObjectsTables;
NSMutableDictionary *_supplementaryViewNibExternalObjectsTables;
struct {
unsigned int delegateShouldHighlightItemAtIndexPath : 1;
unsigned int delegateDidHighlightItemAtIndexPath : 1;
unsigned int delegateDidUnhighlightItemAtIndexPath : 1;
unsigned int delegateShouldSelectItemAtIndexPath : 1;
unsigned int delegateShouldDeselectItemAtIndexPath : 1;
unsigned int delegateDidSelectItemAtIndexPath : 1;
unsigned int delegateDidDeselectItemAtIndexPath : 1;
unsigned int delegateSupportsMenus : 1;
unsigned int delegateDidEndDisplayingCell : 1;
unsigned int delegateDidEndDisplayingSupplementaryView : 1;
unsigned int dataSourceNumberOfSections : 1;
unsigned int dataSourceViewForSupplementaryElement : 1;
unsigned int reloadSkippedDuringSuspension : 1;
unsigned int scheduledUpdateVisibleCells : 1;
unsigned int scheduledUpdateVisibleCellLayoutAttributes : 1;
unsigned int allowsSelection : 1;
unsigned int allowsMultipleSelection : 1;
unsigned int updating : 1;
unsigned int fadeCellsForBoundsChange : 1;
unsigned int updatingLayout : 1;
unsigned int needsReload : 1;
unsigned int reloading : 1;
unsigned int skipLayoutDuringSnapshotting : 1;
unsigned int layoutInvalidatedSinceLastCellUpdate : 1;
unsigned int doneFirstLayout : 1;
}_collectionViewFlags;
CGPoint _lastLayoutOffset;
char filler[232]; // [HACK] Our class needs to be larger than Apple's class for the superclass change to work.
}
@property (nonatomic, strong) PSTCollectionViewData *collectionViewData;
@property (nonatomic, strong, readonly) PSTCollectionViewExt *extVars;
@property (nonatomic, readonly) id currentUpdate;
@property (nonatomic, readonly) NSDictionary *visibleViewsDict;
@property (nonatomic, assign) CGRect visibleBoundRects;
@end
// Used by PSTCollectionView for external variables.
// (We need to keep the total class size equal to the UICollectionView variant)
@interface PSTCollectionViewExt : NSObject
@property (nonatomic, unsafe_unretained) id<PSTCollectionViewDelegate> collectionViewDelegate;
@property (nonatomic, strong) PSTCollectionViewLayout *nibLayout;
@property (nonatomic, strong) NSDictionary *nibCellsExternalObjects;
@property (nonatomic, strong) NSDictionary *supplementaryViewsExternalObjects;
@property (nonatomic, strong) NSIndexPath *touchingIndexPath;
@property (nonatomic, strong) NSIndexPath *currentIndexPath;
@end
@implementation PSTCollectionViewExt
@end
const char kPSTColletionViewExt;
@implementation PSTCollectionView
@synthesize collectionViewLayout = _layout;
@synthesize currentUpdate = _update;
@synthesize visibleViewsDict = _allVisibleViewsDict;
///////////////////////////////////////////////////////////////////////////////////////////
#pragma mark - NSObject
static void PSTCollectionViewCommonSetup(PSTCollectionView *_self) {
_self.allowsSelection = YES;
_self->_indexPathsForSelectedItems = [NSMutableSet new];
_self->_indexPathsForHighlightedItems = [NSMutableSet new];
_self->_cellReuseQueues = [NSMutableDictionary new];
_self->_supplementaryViewReuseQueues = [NSMutableDictionary new];
_self->_decorationViewReuseQueues = [NSMutableDictionary new];
_self->_allVisibleViewsDict = [NSMutableDictionary new];
_self->_cellClassDict = [NSMutableDictionary new];
_self->_cellNibDict = [NSMutableDictionary new];
_self->_supplementaryViewClassDict = [NSMutableDictionary new];
_self->_supplementaryViewNibDict = [NSMutableDictionary new];
// add class that saves additional ivars
objc_setAssociatedObject(_self, &kPSTColletionViewExt, [PSTCollectionViewExt new], OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
- (id)initWithFrame:(CGRect)frame {
return [self initWithFrame:frame collectionViewLayout:nil];
}
- (id)initWithFrame:(CGRect)frame collectionViewLayout:(PSTCollectionViewLayout *)layout {
if ((self = [super initWithFrame:frame])) {
// Set self as the UIScrollView's delegate
[super setDelegate:self];
PSTCollectionViewCommonSetup(self);
self.collectionViewLayout = layout;
_collectionViewData = [[PSTCollectionViewData alloc] initWithCollectionView:self layout:layout];
}
return self;
}
- (id)initWithCoder:(NSCoder *)inCoder {
if ((self = [super initWithCoder:inCoder])) {
// Set self as the UIScrollView's delegate
[super setDelegate:self];
PSTCollectionViewCommonSetup(self);
self.extVars.nibLayout = [inCoder decodeObjectForKey:@"UICollectionLayout"];
NSDictionary *cellExternalObjects = [inCoder decodeObjectForKey:@"UICollectionViewCellPrototypeNibExternalObjects"];
NSDictionary *cellNibs = [inCoder decodeObjectForKey:@"UICollectionViewCellNibDict"];
for (NSString *identifier in cellNibs.allKeys) {
_cellNibDict[identifier] = cellNibs[identifier];
}
self.extVars.nibCellsExternalObjects = cellExternalObjects;
NSDictionary *supplementaryViewExternalObjects = [inCoder decodeObjectForKey:@"UICollectionViewSupplementaryViewPrototypeNibExternalObjects"];
NSDictionary *supplementaryViewNibs = [inCoder decodeObjectForKey:@"UICollectionViewSupplementaryViewNibDict"];
for (NSString *identifier in supplementaryViewNibs.allKeys) {
_supplementaryViewNibDict[identifier] = supplementaryViewNibs[identifier];
}
self.extVars.supplementaryViewsExternalObjects = supplementaryViewExternalObjects;
}
return self;
}
- (void)awakeFromNib {
[super awakeFromNib];
PSTCollectionViewLayout *nibLayout = self.extVars.nibLayout;
if (nibLayout) {
self.collectionViewLayout = nibLayout;
self.extVars.nibLayout = nil;
}
}
- (NSString *)description {
return [NSString stringWithFormat:@"%@ collection view layout: %@", [super description], self.collectionViewLayout];
}
///////////////////////////////////////////////////////////////////////////////////////////
#pragma mark - UIView
- (void)layoutSubviews {
[super layoutSubviews];
// Adding alpha animation to make the relayouting smooth
if (_collectionViewFlags.fadeCellsForBoundsChange) {
CATransition *transition = [CATransition animation];
transition.duration = 0.25f * PSTSimulatorAnimationDragCoefficient();
transition.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionEaseInEaseOut];
transition.type = kCATransitionFade;
[self.layer addAnimation:transition forKey:@"rotationAnimation"];
}
[_collectionViewData validateLayoutInRect:self.bounds];
// update cells
if (_collectionViewFlags.fadeCellsForBoundsChange) {
[CATransaction begin];
[CATransaction setDisableActions:YES];
}
if (!_collectionViewFlags.updatingLayout)
[self updateVisibleCellsNow:YES];
if (_collectionViewFlags.fadeCellsForBoundsChange) {
[CATransaction commit];
}
// do we need to update contentSize?
CGSize contentSize = [_collectionViewData collectionViewContentRect].size;
if (!CGSizeEqualToSize(self.contentSize, contentSize)) {
self.contentSize = contentSize;
// if contentSize is different, we need to re-evaluate layout, bounds (contentOffset) might changed
[_collectionViewData validateLayoutInRect:self.bounds];
[self updateVisibleCellsNow:YES];
}
if (_backgroundView) {
_backgroundView.frame = (CGRect){.origin=self.contentOffset, .size=self.bounds.size};
}
_collectionViewFlags.fadeCellsForBoundsChange = NO;
_collectionViewFlags.doneFirstLayout = YES;
}
- (void)setFrame:(CGRect)frame {
if (!CGRectEqualToRect(frame, self.frame)) {
CGRect bounds = (CGRect){.origin=self.contentOffset, .size=frame.size};
BOOL shouldInvalidate = [self.collectionViewLayout shouldInvalidateLayoutForBoundsChange:bounds];
[super setFrame:frame];
if (shouldInvalidate) {
[self invalidateLayout];
_collectionViewFlags.fadeCellsForBoundsChange = YES;
}
}
}
- (void)setBounds:(CGRect)bounds {
if (!CGRectEqualToRect(bounds, self.bounds)) {
BOOL shouldInvalidate = [self.collectionViewLayout shouldInvalidateLayoutForBoundsChange:bounds];
[super setBounds:bounds];
if (shouldInvalidate) {
[self invalidateLayout];
_collectionViewFlags.fadeCellsForBoundsChange = YES;
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////
#pragma mark - UIScrollViewDelegate
- (void)scrollViewDidScroll:(UIScrollView *)scrollView {
id<PSTCollectionViewDelegate> delegate = self.extVars.collectionViewDelegate;
if ((id)delegate != self && [delegate respondsToSelector:@selector(scrollViewDidScroll:)]) {
[delegate scrollViewDidScroll:scrollView];
}
}
- (void)scrollViewDidZoom:(UIScrollView *)scrollView {
id<PSTCollectionViewDelegate> delegate = self.extVars.collectionViewDelegate;
if ((id)delegate != self && [delegate respondsToSelector:@selector(scrollViewDidZoom:)]) {
[delegate scrollViewDidZoom:scrollView];
}
}
- (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView {
id<PSTCollectionViewDelegate> delegate = self.extVars.collectionViewDelegate;
if ((id)delegate != self && [delegate respondsToSelector:@selector(scrollViewWillBeginDragging:)]) {
[delegate scrollViewWillBeginDragging:scrollView];
}
}
- (void)scrollViewWillEndDragging:(UIScrollView *)scrollView withVelocity:(CGPoint)velocity targetContentOffset:(inout CGPoint *)targetContentOffset {
// Let collectionViewLayout decide where to stop.
*targetContentOffset = [[self collectionViewLayout] targetContentOffsetForProposedContentOffset:*targetContentOffset withScrollingVelocity:velocity];
id<PSTCollectionViewDelegate> delegate = self.extVars.collectionViewDelegate;
if ((id)delegate != self && [delegate respondsToSelector:@selector(scrollViewWillEndDragging:withVelocity:targetContentOffset:)]) {
//if collectionViewDelegate implements this method, it may modify targetContentOffset as well
[delegate scrollViewWillEndDragging:scrollView withVelocity:velocity targetContentOffset:targetContentOffset];
}
}
- (void)scrollViewDidEndDragging:(UIScrollView *)scrollView willDecelerate:(BOOL)decelerate {
id<PSTCollectionViewDelegate> delegate = self.extVars.collectionViewDelegate;
if ((id)delegate != self && [delegate respondsToSelector:@selector(scrollViewDidEndDragging:willDecelerate:)]) {
[delegate scrollViewDidEndDragging:scrollView willDecelerate:decelerate];
}
// if we are in the middle of a cell touch event, perform the "touchEnded" simulation
if (self.extVars.touchingIndexPath) {
[self cellTouchCancelled];
}
}
- (void)scrollViewWillBeginDecelerating:(UIScrollView *)scrollView {
id<PSTCollectionViewDelegate> delegate = self.extVars.collectionViewDelegate;
if ((id)delegate != self && [delegate respondsToSelector:@selector(scrollViewWillBeginDecelerating:)]) {
[delegate scrollViewWillBeginDecelerating:scrollView];
}
}
- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView {
id<PSTCollectionViewDelegate> delegate = self.extVars.collectionViewDelegate;
if ((id)delegate != self && [delegate respondsToSelector:@selector(scrollViewDidEndDecelerating:)]) {
[delegate scrollViewDidEndDecelerating:scrollView];
}
}
- (void)scrollViewDidEndScrollingAnimation:(UIScrollView *)scrollView {
id<PSTCollectionViewDelegate> delegate = self.extVars.collectionViewDelegate;
if ((id)delegate != self && [delegate respondsToSelector:@selector(scrollViewDidEndScrollingAnimation:)]) {
[delegate scrollViewDidEndScrollingAnimation:scrollView];
}
}
- (UIView *)viewForZoomingInScrollView:(UIScrollView *)scrollView {
id<PSTCollectionViewDelegate> delegate = self.extVars.collectionViewDelegate;
if ((id)delegate != self && [delegate respondsToSelector:@selector(viewForZoomingInScrollView:)]) {
return [delegate viewForZoomingInScrollView:scrollView];
}
return nil;
}
- (void)scrollViewWillBeginZooming:(UIScrollView *)scrollView withView:(UIView *)view {
id<PSTCollectionViewDelegate> delegate = self.extVars.collectionViewDelegate;
if ((id)delegate != self && [delegate respondsToSelector:@selector(scrollViewWillBeginZooming:withView:)]) {
[delegate scrollViewWillBeginZooming:scrollView withView:view];
}
}
- (void)scrollViewDidEndZooming:(UIScrollView *)scrollView withView:(UIView *)view atScale:(CGFloat)scale {
id<PSTCollectionViewDelegate> delegate = self.extVars.collectionViewDelegate;
if ((id)delegate != self && [delegate respondsToSelector:@selector(scrollViewDidEndZooming:withView:atScale:)]) {
[delegate scrollViewDidEndZooming:scrollView withView:view atScale:scale];
}
}
- (BOOL)scrollViewShouldScrollToTop:(UIScrollView *)scrollView {
id<PSTCollectionViewDelegate> delegate = self.extVars.collectionViewDelegate;
if ((id)delegate != self && [delegate respondsToSelector:@selector(scrollViewShouldScrollToTop:)]) {
return [delegate scrollViewShouldScrollToTop:scrollView];
}
return YES;
}
- (void)scrollViewDidScrollToTop:(UIScrollView *)scrollView {
id<PSTCollectionViewDelegate> delegate = self.extVars.collectionViewDelegate;
if ((id)delegate != self && [delegate respondsToSelector:@selector(scrollViewDidScrollToTop:)]) {
[delegate scrollViewDidScrollToTop:scrollView];
}
}
///////////////////////////////////////////////////////////////////////////////////////////
#pragma mark - Public
- (void)registerClass:(Class)cellClass forCellWithReuseIdentifier:(NSString *)identifier {
NSParameterAssert(cellClass);
NSParameterAssert(identifier);
_cellClassDict[identifier] = cellClass;
}
- (void)registerClass:(Class)viewClass forSupplementaryViewOfKind:(NSString *)elementKind withReuseIdentifier:(NSString *)identifier {
NSParameterAssert(viewClass);
NSParameterAssert(elementKind);
NSParameterAssert(identifier);
NSString *kindAndIdentifier = [NSString stringWithFormat:@"%@/%@", elementKind, identifier];
_supplementaryViewClassDict[kindAndIdentifier] = viewClass;
}
- (void)registerNib:(UINib *)nib forCellWithReuseIdentifier:(NSString *)identifier {
NSArray *topLevelObjects = [nib instantiateWithOwner:nil options:nil];
#pragma unused(topLevelObjects)
NSAssert(topLevelObjects.count == 1 && [topLevelObjects[0] isKindOfClass:PSTCollectionViewCell.class], @"must contain exactly 1 top level object which is a PSTCollectionViewCell");
_cellNibDict[identifier] = nib;
}
- (void)registerNib:(UINib *)nib forSupplementaryViewOfKind:(NSString *)kind withReuseIdentifier:(NSString *)identifier {
NSArray *topLevelObjects = [nib instantiateWithOwner:nil options:nil];
#pragma unused(topLevelObjects)
NSAssert(topLevelObjects.count == 1 && [topLevelObjects[0] isKindOfClass:PSTCollectionReusableView.class], @"must contain exactly 1 top level object which is a PSTCollectionReusableView");
NSString *kindAndIdentifier = [NSString stringWithFormat:@"%@/%@", kind, identifier];
_supplementaryViewNibDict[kindAndIdentifier] = nib;
}
- (id)dequeueReusableCellWithReuseIdentifier:(NSString *)identifier forIndexPath:(NSIndexPath *)indexPath {
// de-queue cell (if available)
NSMutableArray *reusableCells = _cellReuseQueues[identifier];
PSTCollectionViewCell *cell = [reusableCells lastObject];
PSTCollectionViewLayoutAttributes *attributes = [self.collectionViewLayout layoutAttributesForItemAtIndexPath:indexPath];
if (cell) {
[reusableCells removeObjectAtIndex:reusableCells.count - 1];
}else {
if (_cellNibDict[identifier]) {
// Cell was registered via registerNib:forCellWithReuseIdentifier:
UINib *cellNib = _cellNibDict[identifier];
NSDictionary *externalObjects = self.extVars.nibCellsExternalObjects[identifier];
if (externalObjects) {
cell = [cellNib instantiateWithOwner:self options:@{UINibExternalObjects : externalObjects}][0];
}else {
cell = [cellNib instantiateWithOwner:self options:nil][0];
}
}else {
Class cellClass = _cellClassDict[identifier];
// compatibility layer
Class collectionViewCellClass = NSClassFromString(@"UICollectionViewCell");
if (collectionViewCellClass && [cellClass isEqual:collectionViewCellClass]) {
cellClass = PSTCollectionViewCell.class;
}
if (cellClass == nil) {
@throw [NSException exceptionWithName:NSInvalidArgumentException reason:[NSString stringWithFormat:@"Class not registered for identifier %@", identifier] userInfo:nil];
}
if (attributes) {
cell = [[cellClass alloc] initWithFrame:attributes.frame];
}else {
cell = [cellClass new];
}
}
cell.collectionView = self;
cell.reuseIdentifier = identifier;
}
[cell applyLayoutAttributes:attributes];
return cell;
}
- (id)dequeueReusableSupplementaryViewOfKind:(NSString *)elementKind withReuseIdentifier:(NSString *)identifier forIndexPath:(NSIndexPath *)indexPath {
NSString *kindAndIdentifier = [NSString stringWithFormat:@"%@/%@", elementKind, identifier];
NSMutableArray *reusableViews = _supplementaryViewReuseQueues[kindAndIdentifier];
PSTCollectionReusableView *view = [reusableViews lastObject];
if (view) {
[reusableViews removeObjectAtIndex:reusableViews.count - 1];
}else {
if (_supplementaryViewNibDict[kindAndIdentifier]) {
// supplementary view was registered via registerNib:forCellWithReuseIdentifier:
UINib *supplementaryViewNib = _supplementaryViewNibDict[kindAndIdentifier];
NSDictionary *externalObjects = self.extVars.supplementaryViewsExternalObjects[kindAndIdentifier];
if (externalObjects) {
view = [supplementaryViewNib instantiateWithOwner:self options:@{UINibExternalObjects : externalObjects}][0];
}else {
view = [supplementaryViewNib instantiateWithOwner:self options:nil][0];
}
}else {
Class viewClass = _supplementaryViewClassDict[kindAndIdentifier];
Class reusableViewClass = NSClassFromString(@"UICollectionReusableView");
if (reusableViewClass && [viewClass isEqual:reusableViewClass]) {
viewClass = PSTCollectionReusableView.class;
}
if (viewClass == nil) {
@throw [NSException exceptionWithName:NSInvalidArgumentException reason:[NSString stringWithFormat:@"Class not registered for kind/identifier %@", kindAndIdentifier] userInfo:nil];
}
if (self.collectionViewLayout) {
PSTCollectionViewLayoutAttributes *attributes = [self.collectionViewLayout layoutAttributesForSupplementaryViewOfKind:elementKind atIndexPath:indexPath];
if (attributes) {
view = [[viewClass alloc] initWithFrame:attributes.frame];
}
}else {
view = [viewClass new];
}
}
view.collectionView = self;
view.reuseIdentifier = identifier;
}
return view;
}
- (id)dequeueReusableOrCreateDecorationViewOfKind:(NSString *)elementKind forIndexPath:(NSIndexPath *)indexPath {
NSMutableArray *reusableViews = _decorationViewReuseQueues[elementKind];
PSTCollectionReusableView *view = [reusableViews lastObject];
PSTCollectionViewLayout *collectionViewLayout = self.collectionViewLayout;
PSTCollectionViewLayoutAttributes *attributes = [collectionViewLayout layoutAttributesForDecorationViewOfKind:elementKind atIndexPath:indexPath];
if (view) {
[reusableViews removeObjectAtIndex:reusableViews.count - 1];
}else {
NSDictionary *decorationViewNibDict = collectionViewLayout.decorationViewNibDict;
NSDictionary *decorationViewExternalObjects = collectionViewLayout.decorationViewExternalObjectsTables;
if (decorationViewNibDict[elementKind]) {
// supplementary view was registered via registerNib:forCellWithReuseIdentifier:
UINib *supplementaryViewNib = decorationViewNibDict[elementKind];
NSDictionary *externalObjects = decorationViewExternalObjects[elementKind];
if (externalObjects) {
view = [supplementaryViewNib instantiateWithOwner:self options:@{UINibExternalObjects : externalObjects}][0];
}else {
view = [supplementaryViewNib instantiateWithOwner:self options:nil][0];
}
}else {
NSDictionary *decorationViewClassDict = collectionViewLayout.decorationViewClassDict;
Class viewClass = decorationViewClassDict[elementKind];
Class reusableViewClass = NSClassFromString(@"UICollectionReusableView");
if (reusableViewClass && [viewClass isEqual:reusableViewClass]) {
viewClass = PSTCollectionReusableView.class;
}
if (viewClass == nil) {
@throw [NSException exceptionWithName:NSInvalidArgumentException reason:[NSString stringWithFormat:@"Class not registered for identifier %@", elementKind] userInfo:nil];
}
if (attributes) {
view = [[viewClass alloc] initWithFrame:attributes.frame];
}else {
view = [viewClass new];
}
}
view.collectionView = self;
view.reuseIdentifier = elementKind;
}
[view applyLayoutAttributes:attributes];
return view;
}
- (NSArray *)allCells {
return [[_allVisibleViewsDict allValues] filteredArrayUsingPredicate:[NSPredicate predicateWithBlock:^BOOL(id evaluatedObject, NSDictionary *bindings) {
return [evaluatedObject isKindOfClass:PSTCollectionViewCell.class];
}]];
}
- (NSArray *)visibleCells {
return [[_allVisibleViewsDict allValues] filteredArrayUsingPredicate:[NSPredicate predicateWithBlock:^BOOL(id evaluatedObject, NSDictionary *bindings) {
return [evaluatedObject isKindOfClass:PSTCollectionViewCell.class] && CGRectIntersectsRect(self.bounds, [evaluatedObject frame]);
}]];
}
- (void)reloadData {
if (_reloadingSuspendedCount != 0) return;
[self invalidateLayout];
[_allVisibleViewsDict enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {
if ([obj isKindOfClass:UIView.class]) {
[obj removeFromSuperview];
}
}];
[_allVisibleViewsDict removeAllObjects];
for (NSIndexPath *indexPath in _indexPathsForSelectedItems) {
PSTCollectionViewCell *selectedCell = [self cellForItemAtIndexPath:indexPath];
selectedCell.selected = NO;
selectedCell.highlighted = NO;
}
[_indexPathsForSelectedItems removeAllObjects];
[_indexPathsForHighlightedItems removeAllObjects];
[self setNeedsLayout];
}
///////////////////////////////////////////////////////////////////////////////////////////
#pragma mark - Query Grid
- (NSInteger)numberOfSections {
return [_collectionViewData numberOfSections];
}
- (NSInteger)numberOfItemsInSection:(NSInteger)section {
return [_collectionViewData numberOfItemsInSection:section];
}
- (PSTCollectionViewLayoutAttributes *)layoutAttributesForItemAtIndexPath:(NSIndexPath *)indexPath {
return [[self collectionViewLayout] layoutAttributesForItemAtIndexPath:indexPath];
}
- (PSTCollectionViewLayoutAttributes *)layoutAttributesForSupplementaryElementOfKind:(NSString *)kind atIndexPath:(NSIndexPath *)indexPath {
return [[self collectionViewLayout] layoutAttributesForSupplementaryViewOfKind:kind atIndexPath:indexPath];
}
- (NSIndexPath *)indexPathForItemAtPoint:(CGPoint)point {
PSTCollectionViewLayoutAttributes *attributes = [[self.collectionViewLayout layoutAttributesForElementsInRect:CGRectMake(point.x, point.y, 1, 1)] lastObject];
return attributes.indexPath;
}
- (NSIndexPath *)indexPathForCell:(PSTCollectionViewCell *)cell {
__block NSIndexPath *indexPath = nil;
[_allVisibleViewsDict enumerateKeysAndObjectsWithOptions:kNilOptions usingBlock:^(id key, id obj, BOOL *stop) {
PSTCollectionViewItemKey *itemKey = (PSTCollectionViewItemKey *)key;
if (itemKey.type == PSTCollectionViewItemTypeCell) {
PSTCollectionViewCell *currentCell = (PSTCollectionViewCell *)obj;
if (currentCell == cell) {
indexPath = itemKey.indexPath;
*stop = YES;
}
}
}];
return indexPath;
}
- (PSTCollectionViewCell *)cellForItemAtIndexPath:(NSIndexPath *)indexPath {
// NSInteger index = [_collectionViewData globalIndexForItemAtIndexPath:indexPath];
// TODO Apple uses some kind of globalIndex for this.
__block PSTCollectionViewCell *cell = nil;
[_allVisibleViewsDict enumerateKeysAndObjectsWithOptions:0 usingBlock:^(id key, id obj, BOOL *stop) {
PSTCollectionViewItemKey *itemKey = (PSTCollectionViewItemKey *)key;
if (itemKey.type == PSTCollectionViewItemTypeCell) {
if ([itemKey.indexPath isEqual:indexPath]) {
cell = obj;
*stop = YES;
}
}
}];
return cell;
}
- (NSArray *)indexPathsForVisibleItems {
NSArray *visibleCells = self.visibleCells;
NSMutableArray *indexPaths = [NSMutableArray arrayWithCapacity:visibleCells.count];
[visibleCells enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
PSTCollectionViewCell *cell = (PSTCollectionViewCell *)obj;
[indexPaths addObject:cell.layoutAttributes.indexPath];
}];
return indexPaths;
}
// returns nil or an array of selected index paths
- (NSArray *)indexPathsForSelectedItems {
return [_indexPathsForSelectedItems allObjects];
}
// Interacting with the collection view.
- (void)scrollToItemAtIndexPath:(NSIndexPath *)indexPath atScrollPosition:(PSTCollectionViewScrollPosition)scrollPosition animated:(BOOL)animated {
// Ensure grid is laid out; else we can't scroll.
[self layoutSubviews];
PSTCollectionViewLayoutAttributes *layoutAttributes = [self.collectionViewLayout layoutAttributesForItemAtIndexPath:indexPath];
if (layoutAttributes) {
CGRect targetRect = [self makeRect:layoutAttributes.frame toScrollPosition:scrollPosition];
[self scrollRectToVisible:targetRect animated:animated];
}
}
- (CGRect)makeRect:(CGRect)targetRect toScrollPosition:(PSTCollectionViewScrollPosition)scrollPosition {
// split parameters
NSUInteger verticalPosition = scrollPosition&0x07; // 0000 0111
NSUInteger horizontalPosition = scrollPosition&0x38; // 0011 1000
if (verticalPosition != PSTCollectionViewScrollPositionNone
&& verticalPosition != PSTCollectionViewScrollPositionTop
&& verticalPosition != PSTCollectionViewScrollPositionCenteredVertically
&& verticalPosition != PSTCollectionViewScrollPositionBottom) {
@throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"PSTCollectionViewScrollPosition: attempt to use a scroll position with multiple vertical positioning styles" userInfo:nil];
}
if (horizontalPosition != PSTCollectionViewScrollPositionNone
&& horizontalPosition != PSTCollectionViewScrollPositionLeft
&& horizontalPosition != PSTCollectionViewScrollPositionCenteredHorizontally
&& horizontalPosition != PSTCollectionViewScrollPositionRight) {
@throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"PSTCollectionViewScrollPosition: attempt to use a scroll position with multiple horizontal positioning styles" userInfo:nil];
}
CGRect frame = self.layer.bounds;
CGFloat calculateX;
CGFloat calculateY;
switch (verticalPosition) {
case PSTCollectionViewScrollPositionCenteredVertically:
calculateY = fmax(targetRect.origin.y - ((frame.size.height / 2) - (targetRect.size.height / 2)), -self.contentInset.top);
targetRect = CGRectMake(targetRect.origin.x, calculateY, targetRect.size.width, frame.size.height);
break;
case PSTCollectionViewScrollPositionTop:
targetRect = CGRectMake(targetRect.origin.x, targetRect.origin.y, targetRect.size.width, frame.size.height);
break;
case PSTCollectionViewScrollPositionBottom:
calculateY = fmax(targetRect.origin.y - (frame.size.height - targetRect.size.height), -self.contentInset.top);
targetRect = CGRectMake(targetRect.origin.x, calculateY, targetRect.size.width, frame.size.height);
break;
}
switch (horizontalPosition) {
case PSTCollectionViewScrollPositionCenteredHorizontally:
calculateX = targetRect.origin.x - ((frame.size.width / 2) - (targetRect.size.width / 2));
targetRect = CGRectMake(calculateX, targetRect.origin.y, frame.size.width, targetRect.size.height);
break;
case PSTCollectionViewScrollPositionLeft:
targetRect = CGRectMake(targetRect.origin.x, targetRect.origin.y, frame.size.width, targetRect.size.height);
break;
case PSTCollectionViewScrollPositionRight:
calculateX = targetRect.origin.x - (frame.size.width - targetRect.size.width);
targetRect = CGRectMake(calculateX, targetRect.origin.y, frame.size.width, targetRect.size.height);
break;
}
return targetRect;
}
///////////////////////////////////////////////////////////////////////////////////////////
#pragma mark - Touch Handling
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
[super touchesBegan:touches withEvent:event];
// reset touching state vars
self.extVars.touchingIndexPath = nil;
self.extVars.currentIndexPath = nil;
CGPoint touchPoint = [[touches anyObject] locationInView:self];
NSIndexPath *indexPath = [self indexPathForItemAtPoint:touchPoint];
if (indexPath && self.allowsSelection) {
if (![self highlightItemAtIndexPath:indexPath animated:YES scrollPosition:PSTCollectionViewScrollPositionNone notifyDelegate:YES])
return;
self.extVars.touchingIndexPath = indexPath;
self.extVars.currentIndexPath = indexPath;
if (!self.allowsMultipleSelection) {
// temporally unhighlight background on touchesBegan (keeps selected by _indexPathsForSelectedItems)
// single-select only mode only though
NSIndexPath *tempDeselectIndexPath = _indexPathsForSelectedItems.anyObject;
if (tempDeselectIndexPath && ![tempDeselectIndexPath isEqual:self.extVars.touchingIndexPath]) {
// iOS6 UICollectionView deselects cell without notification
PSTCollectionViewCell *selectedCell = [self cellForItemAtIndexPath:tempDeselectIndexPath];
selectedCell.selected = NO;
}
}
}
}
- (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event {
[super touchesMoved:touches withEvent:event];
// allows moving between highlight and unhighlight state only if setHighlighted is not overwritten
if (self.extVars.touchingIndexPath) {
CGPoint touchPoint = [[touches anyObject] locationInView:self];
NSIndexPath *indexPath = [self indexPathForItemAtPoint:touchPoint];
// moving out of bounds
if ([self.extVars.currentIndexPath isEqual:self.extVars.touchingIndexPath] &&
![indexPath isEqual:self.extVars.touchingIndexPath] &&
[self unhighlightItemAtIndexPath:self.extVars.touchingIndexPath animated:YES notifyDelegate:YES shouldCheckHighlight:YES]) {
self.extVars.currentIndexPath = indexPath;
// moving back into the original touching cell
}else if (![self.extVars.currentIndexPath isEqual:self.extVars.touchingIndexPath] &&
[indexPath isEqual:self.extVars.touchingIndexPath]) {
[self highlightItemAtIndexPath:self.extVars.touchingIndexPath animated:YES scrollPosition:PSTCollectionViewScrollPositionNone notifyDelegate:YES];
self.extVars.currentIndexPath = self.extVars.touchingIndexPath;
}
}
}
- (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event {
[super touchesEnded:touches withEvent:event];
if (self.extVars.touchingIndexPath) {
// first unhighlight the touch operation
[self unhighlightItemAtIndexPath:self.extVars.touchingIndexPath animated:YES notifyDelegate:YES];
CGPoint touchPoint = [[touches anyObject] locationInView:self];
NSIndexPath *indexPath = [self indexPathForItemAtPoint:touchPoint];
if ([indexPath isEqual:self.extVars.touchingIndexPath]) {
[self userSelectedItemAtIndexPath:indexPath];
}
else if (!self.allowsMultipleSelection) {
NSIndexPath *tempDeselectIndexPath = _indexPathsForSelectedItems.anyObject;
if (tempDeselectIndexPath && ![tempDeselectIndexPath isEqual:self.extVars.touchingIndexPath]) {
[self cellTouchCancelled];
}
}
// for pedantic reasons only - always set to nil on touchesBegan
self.extVars.touchingIndexPath = nil;
self.extVars.currentIndexPath = nil;
}
}
- (void)touchesCancelled:(NSSet *)touches withEvent:(UIEvent *)event {
[super touchesCancelled:touches withEvent:event];
// do not mark touchingIndexPath as nil because whoever cancelled this touch will need to signal a touch up event later
if (self.extVars.touchingIndexPath) {
// first unhighlight the touch operation
[self unhighlightItemAtIndexPath:self.extVars.touchingIndexPath animated:YES notifyDelegate:YES];
}
}
- (void)cellTouchCancelled {
// turn on ALL the *should be selected* cells (iOS6 UICollectionView does no state keeping or other fancy optimizations)
// there should be no notifications as this is a silent "turn everything back on"
for (NSIndexPath *tempDeselectedIndexPath in [_indexPathsForSelectedItems copy]) {
PSTCollectionViewCell *selectedCell = [self cellForItemAtIndexPath:tempDeselectedIndexPath];
selectedCell.selected = YES;
}
}
- (void)userSelectedItemAtIndexPath:(NSIndexPath *)indexPath {
if (self.allowsMultipleSelection && [_indexPathsForSelectedItems containsObject:indexPath]) {
[self deselectItemAtIndexPath:indexPath animated:YES notifyDelegate:YES];
}
else if (self.allowsSelection) {
[self selectItemAtIndexPath:indexPath animated:YES scrollPosition:PSTCollectionViewScrollPositionNone notifyDelegate:YES];
}
}
// select item, notify delegate (internal)
- (void)selectItemAtIndexPath:(NSIndexPath *)indexPath animated:(BOOL)animated scrollPosition:(PSTCollectionViewScrollPosition)scrollPosition notifyDelegate:(BOOL)notifyDelegate {
if (self.allowsMultipleSelection && [_indexPathsForSelectedItems containsObject:indexPath]) {
BOOL shouldDeselect = YES;
if (notifyDelegate && _collectionViewFlags.delegateShouldDeselectItemAtIndexPath) {
shouldDeselect = [self.delegate collectionView:self shouldDeselectItemAtIndexPath:indexPath];
}
if (shouldDeselect) {
[self deselectItemAtIndexPath:indexPath animated:animated notifyDelegate:notifyDelegate];
}
}
else {
// either single selection, or wasn't already selected in multiple selection mode
BOOL shouldSelect = YES;
if (notifyDelegate && _collectionViewFlags.delegateShouldSelectItemAtIndexPath) {
shouldSelect = [self.delegate collectionView:self shouldSelectItemAtIndexPath:indexPath];
}
if (!self.allowsMultipleSelection) {
// now unselect the previously selected cell for single selection
NSIndexPath *tempDeselectIndexPath = _indexPathsForSelectedItems.anyObject;
if (tempDeselectIndexPath && ![tempDeselectIndexPath isEqual:indexPath]) {
[self deselectItemAtIndexPath:tempDeselectIndexPath animated:YES notifyDelegate:YES];
}
}
if (shouldSelect) {
PSTCollectionViewCell *selectedCell = [self cellForItemAtIndexPath:indexPath];
selectedCell.selected = YES;
[_indexPathsForSelectedItems addObject:indexPath];
[selectedCell performSelectionSegue];
if (scrollPosition != PSTCollectionViewScrollPositionNone) {
[self scrollToItemAtIndexPath:indexPath atScrollPosition:scrollPosition animated:animated];
}
if (notifyDelegate && _collectionViewFlags.delegateDidSelectItemAtIndexPath) {
[self.delegate collectionView:self didSelectItemAtIndexPath:indexPath];
}
}
}
}
- (void)selectItemAtIndexPath:(NSIndexPath *)indexPath animated:(BOOL)animated scrollPosition:(PSTCollectionViewScrollPosition)scrollPosition {
[self selectItemAtIndexPath:indexPath animated:animated scrollPosition:scrollPosition notifyDelegate:NO];
}
- (void)deselectItemAtIndexPath:(NSIndexPath *)indexPath animated:(BOOL)animated {
[self deselectItemAtIndexPath:indexPath animated:animated notifyDelegate:NO];
}
- (void)deselectItemAtIndexPath:(NSIndexPath *)indexPath animated:(BOOL)animated notifyDelegate:(BOOL)notifyDelegate {
BOOL shouldDeselect = YES;
// deselect only relevant during multi mode
if (self.allowsMultipleSelection && notifyDelegate && _collectionViewFlags.delegateShouldDeselectItemAtIndexPath) {
shouldDeselect = [self.delegate collectionView:self shouldDeselectItemAtIndexPath:indexPath];
}
if (shouldDeselect && [_indexPathsForSelectedItems containsObject:indexPath]) {
PSTCollectionViewCell *selectedCell = [self cellForItemAtIndexPath:indexPath];
if (selectedCell) {
if (selectedCell.selected) {
selectedCell.selected = NO;
}
}
[_indexPathsForSelectedItems removeObject:indexPath];
if (notifyDelegate && _collectionViewFlags.delegateDidDeselectItemAtIndexPath) {
[self.delegate collectionView:self didDeselectItemAtIndexPath:indexPath];
}
}
}
- (BOOL)highlightItemAtIndexPath:(NSIndexPath *)indexPath animated:(BOOL)animated scrollPosition:(PSTCollectionViewScrollPosition)scrollPosition notifyDelegate:(BOOL)notifyDelegate {
BOOL shouldHighlight = YES;
if (notifyDelegate && _collectionViewFlags.delegateShouldHighlightItemAtIndexPath) {
shouldHighlight = [self.delegate collectionView:self shouldHighlightItemAtIndexPath:indexPath];
}
if (shouldHighlight) {
PSTCollectionViewCell *highlightedCell = [self cellForItemAtIndexPath:indexPath];
highlightedCell.highlighted = YES;
[_indexPathsForHighlightedItems addObject:indexPath];
if (scrollPosition != PSTCollectionViewScrollPositionNone) {
[self scrollToItemAtIndexPath:indexPath atScrollPosition:scrollPosition animated:animated];
}
if (notifyDelegate && _collectionViewFlags.delegateDidHighlightItemAtIndexPath) {
[self.delegate collectionView:self didHighlightItemAtIndexPath:indexPath];
}
}
return shouldHighlight;
}
- (BOOL)unhighlightItemAtIndexPath:(NSIndexPath *)indexPath animated:(BOOL)animated notifyDelegate:(BOOL)notifyDelegate {
return [self unhighlightItemAtIndexPath:indexPath animated:animated notifyDelegate:notifyDelegate shouldCheckHighlight:NO];
}
- (BOOL)unhighlightItemAtIndexPath:(NSIndexPath *)indexPath animated:(BOOL)animated notifyDelegate:(BOOL)notifyDelegate shouldCheckHighlight:(BOOL)check {
if ([_indexPathsForHighlightedItems containsObject:indexPath]) {
PSTCollectionViewCell *highlightedCell = [self cellForItemAtIndexPath:indexPath];
// iOS6 does not notify any delegate if the cell was never highlighted (setHighlighted overwritten) during touchMoved
if (check && !highlightedCell.highlighted) {
return NO;
}
// if multiple selection or not unhighlighting a selected item we don't perform any op
if (highlightedCell.highlighted && [_indexPathsForSelectedItems containsObject:indexPath]) {
highlightedCell.highlighted = YES;
}else {
highlightedCell.highlighted = NO;
}
[_indexPathsForHighlightedItems removeObject:indexPath];
if (notifyDelegate && _collectionViewFlags.delegateDidUnhighlightItemAtIndexPath) {
[self.delegate collectionView:self didUnhighlightItemAtIndexPath:indexPath];
}
return YES;
}
return NO;
}
///////////////////////////////////////////////////////////////////////////////////////////
#pragma mark - Update Grid
- (void)insertSections:(NSIndexSet *)sections {
[self updateSections:sections updateAction:PSTCollectionUpdateActionInsert];
}
- (void)deleteSections:(NSIndexSet *)sections {
// First delete all items
NSMutableArray *paths = [NSMutableArray new];
[sections enumerateIndexesUsingBlock:^(NSUInteger idx, BOOL *stop) {
for (int i = 0; i < [self numberOfItemsInSection:(NSInteger)idx]; ++i) {
[paths addObject:[NSIndexPath indexPathForItem:i inSection:(NSInteger)idx]];
}
}];
[self deleteItemsAtIndexPaths:paths];
// Then delete the section.
[self updateSections:sections updateAction:PSTCollectionUpdateActionDelete];
}
- (void)reloadSections:(NSIndexSet *)sections {
[self updateSections:sections updateAction:PSTCollectionUpdateActionReload];
}
- (void)moveSection:(NSInteger)section toSection:(NSInteger)newSection {
NSMutableArray *moveUpdateItems = [self arrayForUpdateAction:PSTCollectionUpdateActionMove];
[moveUpdateItems addObject:
[[PSTCollectionViewUpdateItem alloc] initWithInitialIndexPath:[NSIndexPath indexPathForItem:NSNotFound inSection:section]
finalIndexPath:[NSIndexPath indexPathForItem:NSNotFound inSection:newSection]
updateAction:PSTCollectionUpdateActionMove]];
if (!_collectionViewFlags.updating) {
[self setupCellAnimations];
[self endItemAnimations];
}
}
- (void)insertItemsAtIndexPaths:(NSArray *)indexPaths {
[self updateRowsAtIndexPaths:indexPaths updateAction:PSTCollectionUpdateActionInsert];
}
- (void)deleteItemsAtIndexPaths:(NSArray *)indexPaths {
[self updateRowsAtIndexPaths:indexPaths updateAction:PSTCollectionUpdateActionDelete];
}
- (void)reloadItemsAtIndexPaths:(NSArray *)indexPaths {
[self updateRowsAtIndexPaths:indexPaths updateAction:PSTCollectionUpdateActionReload];
}
- (void)moveItemAtIndexPath:(NSIndexPath *)indexPath toIndexPath:(NSIndexPath *)newIndexPath {
NSMutableArray *moveUpdateItems = [self arrayForUpdateAction:PSTCollectionUpdateActionMove];
[moveUpdateItems addObject:
[[PSTCollectionViewUpdateItem alloc] initWithInitialIndexPath:indexPath
finalIndexPath:newIndexPath
updateAction:PSTCollectionUpdateActionMove]];
if (!_collectionViewFlags.updating) {
[self setupCellAnimations];
[self endItemAnimations];
}
}
- (void)performBatchUpdates:(void (^)(void))updates completion:(void (^)(BOOL finished))completion {
[self setupCellAnimations];
if (updates) updates();
if (completion) _updateCompletionHandler = completion;
[self endItemAnimations];
}
///////////////////////////////////////////////////////////////////////////////////////////
#pragma mark - Properties
- (void)setBackgroundView:(UIView *)backgroundView {
if (backgroundView != _backgroundView) {
[_backgroundView removeFromSuperview];
_backgroundView = backgroundView;
backgroundView.frame = (CGRect){.origin=self.contentOffset, .size=self.bounds.size};
backgroundView.autoresizingMask = UIViewAutoresizingFlexibleHeight|UIViewAutoresizingFlexibleWidth;
[self addSubview:backgroundView];
[self sendSubviewToBack:backgroundView];
}
}
- (void)setCollectionViewLayout:(PSTCollectionViewLayout *)layout animated:(BOOL)animated {
if (layout == _layout) return;
// not sure it was it original code, but here this prevents crash
// in case we switch layout before previous one was initially loaded
if (CGRectIsEmpty(self.bounds) || !_collectionViewFlags.doneFirstLayout) {
_layout.collectionView = nil;
_collectionViewData = [[PSTCollectionViewData alloc] initWithCollectionView:self layout:layout];
layout.collectionView = self;
_layout = layout;
// originally the use method
// _setNeedsVisibleCellsUpdate:withLayoutAttributes:
// here with CellsUpdate set to YES and LayoutAttributes parameter set to NO
// inside this method probably some flags are set and finally
// setNeedsDisplay is called
_collectionViewFlags.scheduledUpdateVisibleCells = YES;
_collectionViewFlags.scheduledUpdateVisibleCellLayoutAttributes = NO;
[self setNeedsDisplay];
}
else {
layout.collectionView = self;
_layout.collectionView = nil;
_layout = layout;
_collectionViewData = [[PSTCollectionViewData alloc] initWithCollectionView:self layout:layout];
[_collectionViewData prepareToLoadData];
NSArray *previouslySelectedIndexPaths = [self indexPathsForSelectedItems];
NSMutableSet *selectedCellKeys = [NSMutableSet setWithCapacity:previouslySelectedIndexPaths.count];
for (NSIndexPath *indexPath in previouslySelectedIndexPaths) {
[selectedCellKeys addObject:[PSTCollectionViewItemKey collectionItemKeyForCellWithIndexPath:indexPath]];
}
NSArray *previouslyVisibleItemsKeys = [_allVisibleViewsDict allKeys];
NSSet *previouslyVisibleItemsKeysSet = [NSSet setWithArray:previouslyVisibleItemsKeys];
NSMutableSet *previouslyVisibleItemsKeysSetMutable = [NSMutableSet setWithArray:previouslyVisibleItemsKeys];
if ([selectedCellKeys intersectsSet:selectedCellKeys]) {
[previouslyVisibleItemsKeysSetMutable intersectSet:previouslyVisibleItemsKeysSetMutable];
}
[self bringSubviewToFront:_allVisibleViewsDict[[previouslyVisibleItemsKeysSetMutable anyObject]]];
CGPoint targetOffset = self.contentOffset;
CGPoint centerPoint = CGPointMake(self.bounds.origin.x + self.bounds.size.width / 2.f,
self.bounds.origin.y + self.bounds.size.height / 2.f);
NSIndexPath *centerItemIndexPath = [self indexPathForItemAtPoint:centerPoint];
if (!centerItemIndexPath) {
NSArray *visibleItems = [self indexPathsForVisibleItems];
if (visibleItems.count > 0) {
centerItemIndexPath = visibleItems[visibleItems.count / 2];
}
}
if (centerItemIndexPath) {
PSTCollectionViewLayoutAttributes *layoutAttributes = [layout layoutAttributesForItemAtIndexPath:centerItemIndexPath];
if (layoutAttributes) {
PSTCollectionViewScrollPosition scrollPosition = PSTCollectionViewScrollPositionCenteredVertically|PSTCollectionViewScrollPositionCenteredHorizontally;
CGRect targetRect = [self makeRect:layoutAttributes.frame toScrollPosition:scrollPosition];
targetOffset = CGPointMake(fmax(0.f, targetRect.origin.x), fmax(0.f, targetRect.origin.y));
}
}
CGRect newlyBounds = CGRectMake(targetOffset.x, targetOffset.y, self.bounds.size.width, self.bounds.size.height);
NSArray *newlyVisibleLayoutAttrs = [_collectionViewData layoutAttributesForElementsInRect:newlyBounds];
NSMutableDictionary *layoutInterchangeData = [NSMutableDictionary dictionaryWithCapacity:
newlyVisibleLayoutAttrs.count + previouslyVisibleItemsKeysSet.count];
NSMutableSet *newlyVisibleItemsKeys = [NSMutableSet set];
for (PSTCollectionViewLayoutAttributes *attr in newlyVisibleLayoutAttrs) {
PSTCollectionViewItemKey *newKey = [PSTCollectionViewItemKey collectionItemKeyForLayoutAttributes:attr];
[newlyVisibleItemsKeys addObject:newKey];
PSTCollectionViewLayoutAttributes *prevAttr = nil;
PSTCollectionViewLayoutAttributes *newAttr = nil;
if (newKey.type == PSTCollectionViewItemTypeDecorationView) {
prevAttr = [self.collectionViewLayout layoutAttributesForDecorationViewOfKind:attr.representedElementKind
atIndexPath:newKey.indexPath];
newAttr = [layout layoutAttributesForDecorationViewOfKind:attr.representedElementKind
atIndexPath:newKey.indexPath];
}
else if (newKey.type == PSTCollectionViewItemTypeCell) {
prevAttr = [self.collectionViewLayout layoutAttributesForItemAtIndexPath:newKey.indexPath];
newAttr = [layout layoutAttributesForItemAtIndexPath:newKey.indexPath];
}
else {
prevAttr = [self.collectionViewLayout layoutAttributesForSupplementaryViewOfKind:attr.representedElementKind
atIndexPath:newKey.indexPath];
newAttr = [layout layoutAttributesForSupplementaryViewOfKind:attr.representedElementKind
atIndexPath:newKey.indexPath];
}
if (prevAttr != nil && newAttr != nil) {
layoutInterchangeData[newKey] = @{@"previousLayoutInfos": prevAttr, @"newLayoutInfos": newAttr};
}
}
for (PSTCollectionViewItemKey *key in previouslyVisibleItemsKeysSet) {
PSTCollectionViewLayoutAttributes *prevAttr = nil;
PSTCollectionViewLayoutAttributes *newAttr = nil;
if (key.type == PSTCollectionViewItemTypeDecorationView) {
PSTCollectionReusableView *decorView = _allVisibleViewsDict[key];
prevAttr = [self.collectionViewLayout layoutAttributesForDecorationViewOfKind:decorView.reuseIdentifier
atIndexPath:key.indexPath];
newAttr = [layout layoutAttributesForDecorationViewOfKind:decorView.reuseIdentifier
atIndexPath:key.indexPath];
}
else if (key.type == PSTCollectionViewItemTypeCell) {
prevAttr = [self.collectionViewLayout layoutAttributesForItemAtIndexPath:key.indexPath];
newAttr = [layout layoutAttributesForItemAtIndexPath:key.indexPath];
}
else if (key.type == PSTCollectionViewItemTypeSupplementaryView) {
PSTCollectionReusableView *suuplView = _allVisibleViewsDict[key];
prevAttr = [self.collectionViewLayout layoutAttributesForSupplementaryViewOfKind:suuplView.layoutAttributes.representedElementKind
atIndexPath:key.indexPath];
newAttr = [layout layoutAttributesForSupplementaryViewOfKind:suuplView.layoutAttributes.representedElementKind
atIndexPath:key.indexPath];
}
NSMutableDictionary *layoutInterchangeDataValue = [NSMutableDictionary dictionary];
if (prevAttr) layoutInterchangeDataValue[@"previousLayoutInfos"] = prevAttr;
if (newAttr) layoutInterchangeDataValue[@"newLayoutInfos"] = newAttr;
layoutInterchangeData[key] = layoutInterchangeDataValue;
}
for (PSTCollectionViewItemKey *key in [layoutInterchangeData keyEnumerator]) {
if (key.type == PSTCollectionViewItemTypeCell) {
PSTCollectionViewCell *cell = _allVisibleViewsDict[key];
if (!cell) {
cell = [self createPreparedCellForItemAtIndexPath:key.indexPath
withLayoutAttributes:layoutInterchangeData[key][@"previousLayoutInfos"]];
_allVisibleViewsDict[key] = cell;
[self addControlledSubview:cell];
}
else [cell applyLayoutAttributes:layoutInterchangeData[key][@"previousLayoutInfos"]];
}
else if (key.type == PSTCollectionViewItemTypeSupplementaryView) {
PSTCollectionReusableView *view = _allVisibleViewsDict[key];
if (!view) {
PSTCollectionViewLayoutAttributes *attrs = layoutInterchangeData[key][@"previousLayoutInfos"];
view = [self createPreparedSupplementaryViewForElementOfKind:attrs.representedElementKind
atIndexPath:attrs.indexPath
withLayoutAttributes:attrs];
_allVisibleViewsDict[key] = view;
[self addControlledSubview:view];
}
}
else if (key.type == PSTCollectionViewItemTypeDecorationView) {
PSTCollectionReusableView *view = _allVisibleViewsDict[key];
if (!view) {
PSTCollectionViewLayoutAttributes *attrs = layoutInterchangeData[key][@"previousLayoutInfos"];
view = [self dequeueReusableOrCreateDecorationViewOfKind:attrs.representedElementKind forIndexPath:attrs.indexPath];
_allVisibleViewsDict[key] = view;
[self addControlledSubview:view];
}
}
};
CGRect contentRect = [_collectionViewData collectionViewContentRect];
void (^applyNewLayoutBlock)(void) = ^{
NSEnumerator *keys = [layoutInterchangeData keyEnumerator];
for (PSTCollectionViewItemKey *key in keys) {
// TODO: This is most likely not 100% the same time as in UICollectionView. Needs to be investigated.
PSTCollectionViewCell *cell = (PSTCollectionViewCell *)_allVisibleViewsDict[key];
[cell willTransitionFromLayout:_layout toLayout:layout];
[cell applyLayoutAttributes:layoutInterchangeData[key][@"newLayoutInfos"]];
[cell didTransitionFromLayout:_layout toLayout:layout];
}
};
void (^freeUnusedViews)(void) = ^{
NSMutableSet *toRemove = [NSMutableSet set];
for (PSTCollectionViewItemKey *key in [_allVisibleViewsDict keyEnumerator]) {
if (![newlyVisibleItemsKeys containsObject:key]) {
if (key.type == PSTCollectionViewItemTypeCell) {
[self reuseCell:_allVisibleViewsDict[key]];
[toRemove addObject:key];
}
else if (key.type == PSTCollectionViewItemTypeSupplementaryView) {
[self reuseSupplementaryView:_allVisibleViewsDict[key]];
[toRemove addObject:key];
}
else if (key.type == PSTCollectionViewItemTypeDecorationView) {
[self reuseDecorationView:_allVisibleViewsDict[key]];
[toRemove addObject:key];
}
}
}
for (id key in toRemove)
[_allVisibleViewsDict removeObjectForKey:key];
};
if (animated) {
[UIView animateWithDuration:.3 animations:^{
_collectionViewFlags.updatingLayout = YES;
self.contentOffset = targetOffset;
self.contentSize = contentRect.size;
applyNewLayoutBlock();
} completion:^(BOOL finished) {
freeUnusedViews();
_collectionViewFlags.updatingLayout = NO;
// layout subviews for updating content offset or size while updating layout
if (!CGPointEqualToPoint(self.contentOffset, targetOffset)
|| !CGSizeEqualToSize(self.contentSize, contentRect.size)) {
[self layoutSubviews];
}
}];
}
else {
self.contentOffset = targetOffset;
self.contentSize = contentRect.size;
applyNewLayoutBlock();
freeUnusedViews();
}
}
}
- (void)setCollectionViewLayout:(PSTCollectionViewLayout *)layout {
[self setCollectionViewLayout:layout animated:NO];
}
- (id<PSTCollectionViewDelegate>)delegate {
return self.extVars.collectionViewDelegate;
}
- (void)setDelegate:(id<PSTCollectionViewDelegate>)delegate {
self.extVars.collectionViewDelegate = delegate;
// Managing the Selected Cells
_collectionViewFlags.delegateShouldSelectItemAtIndexPath = (unsigned int)[self.delegate respondsToSelector:@selector(collectionView:shouldSelectItemAtIndexPath:)];
_collectionViewFlags.delegateDidSelectItemAtIndexPath = (unsigned int)[self.delegate respondsToSelector:@selector(collectionView:didSelectItemAtIndexPath:)];
_collectionViewFlags.delegateShouldDeselectItemAtIndexPath = (unsigned int)[self.delegate respondsToSelector:@selector(collectionView:shouldDeselectItemAtIndexPath:)];
_collectionViewFlags.delegateDidDeselectItemAtIndexPath = (unsigned int)[self.delegate respondsToSelector:@selector(collectionView:didDeselectItemAtIndexPath:)];
// Managing Cell Highlighting
_collectionViewFlags.delegateShouldHighlightItemAtIndexPath = (unsigned int)[self.delegate respondsToSelector:@selector(collectionView:shouldHighlightItemAtIndexPath:)];
_collectionViewFlags.delegateDidHighlightItemAtIndexPath = (unsigned int)[self.delegate respondsToSelector:@selector(collectionView:didHighlightItemAtIndexPath:)];
_collectionViewFlags.delegateDidUnhighlightItemAtIndexPath = (unsigned int)[self.delegate respondsToSelector:@selector(collectionView:didUnhighlightItemAtIndexPath:)];
// Tracking the Removal of Views
_collectionViewFlags.delegateDidEndDisplayingCell = (unsigned int)[self.delegate respondsToSelector:@selector(collectionView:didEndDisplayingCell:forItemAtIndexPath:)];
_collectionViewFlags.delegateDidEndDisplayingSupplementaryView = (unsigned int)[self.delegate respondsToSelector:@selector(collectionView:didEndDisplayingSupplementaryView:forElementOfKind:atIndexPath:)];
// Managing Actions for Cells
_collectionViewFlags.delegateSupportsMenus = (unsigned int)[self.delegate respondsToSelector:@selector(collectionView:shouldShowMenuForItemAtIndexPath:)];
// These aren't present in the flags which is a little strange. Not adding them because that will mess with byte alignment which will affect cross compatibility.
// The flag names are guesses and are there for documentation purposes.
// _collectionViewFlags.delegateCanPerformActionForItemAtIndexPath = [self.delegate respondsToSelector:@selector(collectionView:canPerformAction:forItemAtIndexPath:withSender:)];
// _collectionViewFlags.delegatePerformActionForItemAtIndexPath = [self.delegate respondsToSelector:@selector(collectionView:performAction:forItemAtIndexPath:withSender:)];
}
// Might be overkill since two are required and two are handled by PSTCollectionViewData leaving only one flag we actually need to check for
- (void)setDataSource:(id<PSTCollectionViewDataSource>)dataSource {
if (dataSource != _dataSource) {
_dataSource = dataSource;
// Getting Item and Section Metrics
_collectionViewFlags.dataSourceNumberOfSections = (unsigned int)[_dataSource respondsToSelector:@selector(numberOfSectionsInCollectionView:)];
// Getting Views for Items
_collectionViewFlags.dataSourceViewForSupplementaryElement = (unsigned int)[_dataSource respondsToSelector:@selector(collectionView:viewForSupplementaryElementOfKind:atIndexPath:)];
}
}
- (BOOL)allowsSelection {
return _collectionViewFlags.allowsSelection;
}
- (void)setAllowsSelection:(BOOL)allowsSelection {
_collectionViewFlags.allowsSelection = (unsigned int)allowsSelection;
}
- (BOOL)allowsMultipleSelection {
return _collectionViewFlags.allowsMultipleSelection;
}
- (void)setAllowsMultipleSelection:(BOOL)allowsMultipleSelection {
_collectionViewFlags.allowsMultipleSelection = (unsigned int)allowsMultipleSelection;
// Deselect all objects if allows multiple selection is false
if (!allowsMultipleSelection && _indexPathsForSelectedItems.count) {
// Note: Apple's implementation leaves a mostly random item selected. Presumably they
// have a good reason for this, but I guess it's just skipping the last or first index.
for (NSIndexPath *selectedIndexPath in [_indexPathsForSelectedItems copy]) {
if (_indexPathsForSelectedItems.count == 1) continue;
[self deselectItemAtIndexPath:selectedIndexPath animated:YES notifyDelegate:YES];
}
}
}
- (CGRect)visibleBoundRects {
// in original UICollectionView implementation they
// check for _visibleBounds and can union self.bounds
// with this value. Don't know the meaning of _visibleBounds however.
return self.bounds;
}
///////////////////////////////////////////////////////////////////////////////////////////
#pragma mark - Private
- (PSTCollectionViewExt *)extVars {
return objc_getAssociatedObject(self, &kPSTColletionViewExt);
}
- (void)invalidateLayout {
[self.collectionViewLayout invalidateLayout];
[self.collectionViewData invalidate]; // invalidate layout cache
}
// update currently visible cells, fetches new cells if needed
// TODO: use now parameter.
- (void)updateVisibleCellsNow:(BOOL)now {
NSArray *layoutAttributesArray = [_collectionViewData layoutAttributesForElementsInRect:self.bounds];
if (layoutAttributesArray == nil || layoutAttributesArray.count == 0) {
// If our layout source isn't providing any layout information, we should just
// stop, otherwise we'll blow away all the currently existing cells.
return;
}
// create ItemKey/Attributes dictionary
NSMutableDictionary *itemKeysToAddDict = [NSMutableDictionary dictionary];
// Add new cells.
for (PSTCollectionViewLayoutAttributes *layoutAttributes in layoutAttributesArray) {
PSTCollectionViewItemKey *itemKey = [PSTCollectionViewItemKey collectionItemKeyForLayoutAttributes:layoutAttributes];
itemKeysToAddDict[itemKey] = layoutAttributes;
// check if cell is in visible dict; add it if not.
PSTCollectionReusableView *view = _allVisibleViewsDict[itemKey];
if (!view) {
if (itemKey.type == PSTCollectionViewItemTypeCell) {
view = [self createPreparedCellForItemAtIndexPath:itemKey.indexPath withLayoutAttributes:layoutAttributes];
}else if (itemKey.type == PSTCollectionViewItemTypeSupplementaryView) {
view = [self createPreparedSupplementaryViewForElementOfKind:layoutAttributes.representedElementKind
atIndexPath:layoutAttributes.indexPath
withLayoutAttributes:layoutAttributes];
}else if (itemKey.type == PSTCollectionViewItemTypeDecorationView) {
view = [self dequeueReusableOrCreateDecorationViewOfKind:layoutAttributes.representedElementKind forIndexPath:layoutAttributes.indexPath];
}
// Supplementary views are optional
if (view) {
_allVisibleViewsDict[itemKey] = view;
[self addControlledSubview:view];
// Always apply attributes. Fixes #203.
[view applyLayoutAttributes:layoutAttributes];
}
}else {
// just update cell
[view applyLayoutAttributes:layoutAttributes];
}
}
// Detect what items should be removed and queued back.
NSMutableSet *allVisibleItemKeys = [NSMutableSet setWithArray:[_allVisibleViewsDict allKeys]];
[allVisibleItemKeys minusSet:[NSSet setWithArray:[itemKeysToAddDict allKeys]]];
// Finally remove views that have not been processed and prepare them for re-use.
for (PSTCollectionViewItemKey *itemKey in allVisibleItemKeys) {
PSTCollectionReusableView *reusableView = _allVisibleViewsDict[itemKey];
if (reusableView) {
[reusableView removeFromSuperview];
[_allVisibleViewsDict removeObjectForKey:itemKey];
if (itemKey.type == PSTCollectionViewItemTypeCell) {
if (_collectionViewFlags.delegateDidEndDisplayingCell) {
[self.delegate collectionView:self didEndDisplayingCell:(PSTCollectionViewCell *)reusableView forItemAtIndexPath:itemKey.indexPath];
}
[self reuseCell:(PSTCollectionViewCell *)reusableView];
}
else if (itemKey.type == PSTCollectionViewItemTypeSupplementaryView) {
if (_collectionViewFlags.delegateDidEndDisplayingSupplementaryView) {
[self.delegate collectionView:self didEndDisplayingSupplementaryView:reusableView forElementOfKind:itemKey.identifier atIndexPath:itemKey.indexPath];
}
[self reuseSupplementaryView:reusableView];
}
else if (itemKey.type == PSTCollectionViewItemTypeDecorationView) {
[self reuseDecorationView:reusableView];
}
}
}
}
// fetches a cell from the dataSource and sets the layoutAttributes
- (PSTCollectionViewCell *)createPreparedCellForItemAtIndexPath:(NSIndexPath *)indexPath withLayoutAttributes:(PSTCollectionViewLayoutAttributes *)layoutAttributes {
PSTCollectionViewCell *cell = [self.dataSource collectionView:self cellForItemAtIndexPath:indexPath];
// Apply attributes
[cell applyLayoutAttributes:layoutAttributes];
// reset selected/highlight state
[cell setHighlighted:[_indexPathsForHighlightedItems containsObject:indexPath]];
[cell setSelected:[_indexPathsForSelectedItems containsObject:indexPath]];
// voiceover support
cell.isAccessibilityElement = YES;
return cell;
}
- (PSTCollectionReusableView *)createPreparedSupplementaryViewForElementOfKind:(NSString *)kind
atIndexPath:(NSIndexPath *)indexPath
withLayoutAttributes:(PSTCollectionViewLayoutAttributes *)layoutAttributes {
if (_collectionViewFlags.dataSourceViewForSupplementaryElement) {
PSTCollectionReusableView *view = [self.dataSource collectionView:self
viewForSupplementaryElementOfKind:kind
atIndexPath:indexPath];
[view applyLayoutAttributes:layoutAttributes];
return view;
}
return nil;
}
// @steipete optimization
- (void)queueReusableView:(PSTCollectionReusableView *)reusableView inQueue:(NSMutableDictionary *)queue withIdentifier:(NSString *)identifier {
NSParameterAssert(identifier.length > 0);
[reusableView removeFromSuperview];
[reusableView prepareForReuse];
// enqueue cell
NSMutableArray *reuseableViews = queue[identifier];
if (!reuseableViews) {
reuseableViews = [NSMutableArray array];
queue[identifier] = reuseableViews;
}
[reuseableViews addObject:reusableView];
}
// enqueue cell for reuse
- (void)reuseCell:(PSTCollectionViewCell *)cell {
[self queueReusableView:cell inQueue:_cellReuseQueues withIdentifier:cell.reuseIdentifier];
}
// enqueue supplementary view for reuse
- (void)reuseSupplementaryView:(PSTCollectionReusableView *)supplementaryView {
NSString *kindAndIdentifier = [NSString stringWithFormat:@"%@/%@", supplementaryView.layoutAttributes.elementKind, supplementaryView.reuseIdentifier];
[self queueReusableView:supplementaryView inQueue:_supplementaryViewReuseQueues withIdentifier:kindAndIdentifier];
}
// enqueue decoration view for reuse
- (void)reuseDecorationView:(PSTCollectionReusableView *)decorationView {
[self queueReusableView:decorationView inQueue:_decorationViewReuseQueues withIdentifier:decorationView.reuseIdentifier];
}
- (void)addControlledSubview:(PSTCollectionReusableView *)subview {
// avoids placing views above the scroll indicator
// If the collection view is not displaying scrollIndicators then self.subviews.count can be 0.
// We take the max to ensure we insert at a non negative index because a negative index will silently fail to insert the view
NSInteger insertionIndex = MAX((NSInteger)(self.subviews.count - (self.dragging ? 1 : 0)), 0);
[self insertSubview:subview atIndex:insertionIndex];
UIView *scrollIndicatorView = nil;
if (self.dragging) {
scrollIndicatorView = [self.subviews lastObject];
}
NSMutableArray *floatingViews = [[NSMutableArray alloc] init];
for (UIView *uiView in self.subviews) {
if ([uiView isKindOfClass:PSTCollectionReusableView.class] && [[(PSTCollectionReusableView *)uiView layoutAttributes] zIndex] > 0) {
[floatingViews addObject:uiView];
}
}
[floatingViews sortUsingComparator:^NSComparisonResult(PSTCollectionReusableView *obj1, PSTCollectionReusableView *obj2) {
CGFloat z1 = [[obj1 layoutAttributes] zIndex];
CGFloat z2 = [[obj2 layoutAttributes] zIndex];
if (z1 > z2) {
return (NSComparisonResult)NSOrderedDescending;
}else if (z1 < z2) {
return (NSComparisonResult)NSOrderedAscending;
}else {
return (NSComparisonResult)NSOrderedSame;
}
}];
for (PSTCollectionReusableView *uiView in floatingViews) {
[self bringSubviewToFront:uiView];
}
if (floatingViews.count && scrollIndicatorView) {
[self bringSubviewToFront:scrollIndicatorView];
}
}
///////////////////////////////////////////////////////////////////////////////////////////
#pragma mark - Updating grid internal functionality
- (void)suspendReloads {
_reloadingSuspendedCount++;
}
- (void)resumeReloads {
if (0 < _reloadingSuspendedCount) _reloadingSuspendedCount--;
}
- (NSMutableArray *)arrayForUpdateAction:(PSTCollectionUpdateAction)updateAction {
NSMutableArray *updateActions = nil;
switch (updateAction) {
case PSTCollectionUpdateActionInsert:
if (!_insertItems) _insertItems = [NSMutableArray new];
updateActions = _insertItems;
break;
case PSTCollectionUpdateActionDelete:
if (!_deleteItems) _deleteItems = [NSMutableArray new];
updateActions = _deleteItems;
break;
case PSTCollectionUpdateActionMove:
if (!_moveItems) _moveItems = [NSMutableArray new];
updateActions = _moveItems;
break;
case PSTCollectionUpdateActionReload:
if (!_reloadItems) _reloadItems = [NSMutableArray new];
updateActions = _reloadItems;
break;
default: break;
}
return updateActions;
}
- (void)prepareLayoutForUpdates {
NSMutableArray *array = [[NSMutableArray alloc] init];
[array addObjectsFromArray:[_originalDeleteItems sortedArrayUsingSelector:@selector(inverseCompareIndexPaths:)]];
[array addObjectsFromArray:[_originalInsertItems sortedArrayUsingSelector:@selector(compareIndexPaths:)]];
[array addObjectsFromArray:[_reloadItems sortedArrayUsingSelector:@selector(compareIndexPaths:)]];
[array addObjectsFromArray:[_moveItems sortedArrayUsingSelector:@selector(compareIndexPaths:)]];
[_layout prepareForCollectionViewUpdates:array];
}
- (void)updateWithItems:(NSArray *)items {
[self prepareLayoutForUpdates];
NSMutableArray *animations = [[NSMutableArray alloc] init];
NSMutableDictionary *newAllVisibleView = [[NSMutableDictionary alloc] init];
NSMutableDictionary *viewsToRemove = [NSMutableDictionary dictionaryWithObjectsAndKeys:
[NSMutableArray array], @(PSTCollectionViewItemTypeCell),
[NSMutableArray array], @(PSTCollectionViewItemTypeDecorationView),
[NSMutableArray array], @(PSTCollectionViewItemTypeSupplementaryView), nil];
for (PSTCollectionViewUpdateItem *updateItem in items) {
if (updateItem.isSectionOperation && updateItem.updateAction != PSTCollectionUpdateActionDelete) continue;
if (updateItem.isSectionOperation && updateItem.updateAction == PSTCollectionUpdateActionDelete) {
NSInteger numberOfBeforeSection = [_update[@"oldModel"] numberOfItemsInSection:updateItem.indexPathBeforeUpdate.section];
for (NSInteger i = 0; i < numberOfBeforeSection; i++) {
NSIndexPath *indexPath = [NSIndexPath indexPathForItem:i inSection:updateItem.indexPathBeforeUpdate.section];
PSTCollectionViewLayoutAttributes *finalAttrs = [_layout finalLayoutAttributesForDisappearingItemAtIndexPath:indexPath];
PSTCollectionViewItemKey *key = [PSTCollectionViewItemKey collectionItemKeyForCellWithIndexPath:indexPath];
PSTCollectionReusableView *view = _allVisibleViewsDict[key];
if (view) {
PSTCollectionViewLayoutAttributes *startAttrs = view.layoutAttributes;
if (!finalAttrs) {
finalAttrs = [startAttrs copy];
finalAttrs.alpha = 0;
}
[animations addObject:@{@"view" : view, @"previousLayoutInfos" : startAttrs, @"newLayoutInfos" : finalAttrs}];
[_allVisibleViewsDict removeObjectForKey:key];
[(NSMutableArray *)viewsToRemove[@(key.type)] addObject:view];
}
}
continue;
}
if (updateItem.updateAction == PSTCollectionUpdateActionDelete) {
NSIndexPath *indexPath = updateItem.indexPathBeforeUpdate;
PSTCollectionViewLayoutAttributes *finalAttrs = [_layout finalLayoutAttributesForDisappearingItemAtIndexPath:indexPath];
PSTCollectionViewItemKey *key = [PSTCollectionViewItemKey collectionItemKeyForCellWithIndexPath:indexPath];
PSTCollectionReusableView *view = _allVisibleViewsDict[key];
if (view) {
PSTCollectionViewLayoutAttributes *startAttrs = view.layoutAttributes;
if (!finalAttrs) {
finalAttrs = [startAttrs copy];
finalAttrs.alpha = 0;
}
[animations addObject:@{@"view" : view, @"previousLayoutInfos" : startAttrs, @"newLayoutInfos" : finalAttrs}];
[_allVisibleViewsDict removeObjectForKey:key];
[(NSMutableArray *)viewsToRemove[@(key.type)] addObject:view];
}
}
else if (updateItem.updateAction == PSTCollectionUpdateActionInsert) {
NSIndexPath *indexPath = updateItem.indexPathAfterUpdate;
PSTCollectionViewItemKey *key = [PSTCollectionViewItemKey collectionItemKeyForCellWithIndexPath:indexPath];
PSTCollectionViewLayoutAttributes *startAttrs = [_layout initialLayoutAttributesForAppearingItemAtIndexPath:indexPath];
PSTCollectionViewLayoutAttributes *finalAttrs = [_layout layoutAttributesForItemAtIndexPath:indexPath];
CGRect startRect = startAttrs.frame;
CGRect finalRect = finalAttrs.frame;
if (CGRectIntersectsRect(self.visibleBoundRects, startRect) || CGRectIntersectsRect(self.visibleBoundRects, finalRect)) {
if (!startAttrs) {
startAttrs = [finalAttrs copy];
startAttrs.alpha = 0;
}
PSTCollectionReusableView *view = [self createPreparedCellForItemAtIndexPath:indexPath
withLayoutAttributes:startAttrs];
[self addControlledSubview:view];
newAllVisibleView[key] = view;
[animations addObject:@{@"view" : view, @"previousLayoutInfos" : startAttrs, @"newLayoutInfos" : finalAttrs}];
}
}
else if (updateItem.updateAction == PSTCollectionUpdateActionMove) {
NSIndexPath *indexPathBefore = updateItem.indexPathBeforeUpdate;
NSIndexPath *indexPathAfter = updateItem.indexPathAfterUpdate;
PSTCollectionViewItemKey *keyBefore = [PSTCollectionViewItemKey collectionItemKeyForCellWithIndexPath:indexPathBefore];
PSTCollectionViewItemKey *keyAfter = [PSTCollectionViewItemKey collectionItemKeyForCellWithIndexPath:indexPathAfter];
PSTCollectionReusableView *view = _allVisibleViewsDict[keyBefore];
PSTCollectionViewLayoutAttributes *startAttrs = nil;
PSTCollectionViewLayoutAttributes *finalAttrs = [_layout layoutAttributesForItemAtIndexPath:indexPathAfter];
if (view) {
startAttrs = view.layoutAttributes;
[_allVisibleViewsDict removeObjectForKey:keyBefore];
newAllVisibleView[keyAfter] = view;
}
else {
startAttrs = [finalAttrs copy];
startAttrs.alpha = 0;
view = [self createPreparedCellForItemAtIndexPath:indexPathAfter withLayoutAttributes:startAttrs];
[self addControlledSubview:view];
newAllVisibleView[keyAfter] = view;
}
[animations addObject:@{@"view" : view, @"previousLayoutInfos" : startAttrs, @"newLayoutInfos" : finalAttrs}];
}
}
for (PSTCollectionViewItemKey *key in [_allVisibleViewsDict keyEnumerator]) {
PSTCollectionReusableView *view = _allVisibleViewsDict[key];
if (key.type == PSTCollectionViewItemTypeCell) {
NSUInteger oldGlobalIndex = [_update[@"oldModel"] globalIndexForItemAtIndexPath:key.indexPath];
NSArray *oldToNewIndexMap = _update[@"oldToNewIndexMap"];
NSUInteger newGlobalIndex = NSNotFound;
if (NSNotFound != oldGlobalIndex && oldGlobalIndex < oldToNewIndexMap.count) {
newGlobalIndex = [oldToNewIndexMap[oldGlobalIndex] unsignedIntegerValue];
}
NSIndexPath *newIndexPath = newGlobalIndex == NSNotFound ? nil : [_update[@"newModel"] indexPathForItemAtGlobalIndex:(int)newGlobalIndex];
NSIndexPath *oldIndexPath = oldGlobalIndex == NSNotFound ? nil : [_update[@"oldModel"] indexPathForItemAtGlobalIndex:(int)oldGlobalIndex];
if (newIndexPath) {
PSTCollectionViewLayoutAttributes *startAttrs = nil;
PSTCollectionViewLayoutAttributes *finalAttrs = nil;
startAttrs = [_layout initialLayoutAttributesForAppearingItemAtIndexPath:oldIndexPath];
finalAttrs = [_layout layoutAttributesForItemAtIndexPath:newIndexPath];
NSMutableDictionary *dic = [NSMutableDictionary dictionaryWithDictionary:@{@"view" : view}];
if (startAttrs) dic[@"previousLayoutInfos"] = startAttrs;
if (finalAttrs) dic[@"newLayoutInfos"] = finalAttrs;
[animations addObject:dic];
PSTCollectionViewItemKey *newKey = [key copy];
[newKey setIndexPath:newIndexPath];
newAllVisibleView[newKey] = view;
}
}else if (key.type == PSTCollectionViewItemTypeSupplementaryView) {
PSTCollectionViewLayoutAttributes *startAttrs = nil;
PSTCollectionViewLayoutAttributes *finalAttrs = nil;
startAttrs = view.layoutAttributes;
finalAttrs = [_layout layoutAttributesForSupplementaryViewOfKind:view.layoutAttributes.representedElementKind atIndexPath:key.indexPath];
NSMutableDictionary *dic = [NSMutableDictionary dictionaryWithDictionary:@{@"view" : view}];
if (startAttrs) dic[@"previousLayoutInfos"] = startAttrs;
if (finalAttrs) dic[@"newLayoutInfos"] = finalAttrs;
[animations addObject:dic];
PSTCollectionViewItemKey *newKey = [key copy];
newAllVisibleView[newKey] = view;
}
}
NSArray *allNewlyVisibleItems = [_layout layoutAttributesForElementsInRect:self.visibleBoundRects];
for (PSTCollectionViewLayoutAttributes *attrs in allNewlyVisibleItems) {
PSTCollectionViewItemKey *key = [PSTCollectionViewItemKey collectionItemKeyForLayoutAttributes:attrs];
if (key.type == PSTCollectionViewItemTypeCell && ![[newAllVisibleView allKeys] containsObject:key]) {
PSTCollectionViewLayoutAttributes *startAttrs =
[_layout initialLayoutAttributesForAppearingItemAtIndexPath:attrs.indexPath];
PSTCollectionReusableView *view = [self createPreparedCellForItemAtIndexPath:attrs.indexPath
withLayoutAttributes:startAttrs];
[self addControlledSubview:view];
newAllVisibleView[key] = view;
[animations addObject:@{@"view" : view, @"previousLayoutInfos" : startAttrs ? startAttrs : attrs, @"newLayoutInfos" : attrs}];
}
}
//In here I think it doesn't need the animation but the transaction, it would cause some issue of display.
//I resolve the bug when user insert the new sections, the cell will display with a blink animation at the first operation.
//But I don't know why the next operation wouldn't reproduction in the pre version.
_allVisibleViewsDict = newAllVisibleView;
for (NSDictionary *animation in animations) {
PSTCollectionReusableView *view = animation[@"view"];
PSTCollectionViewLayoutAttributes *attr = animation[@"previousLayoutInfos"];
[view applyLayoutAttributes:attr];
};
_collectionViewFlags.updatingLayout = YES;
[CATransaction begin];
[CATransaction setAnimationDuration:0];
[CATransaction setCompletionBlock:^{
// Iterate through all the views that we are going to remove.
[viewsToRemove enumerateKeysAndObjectsUsingBlock:^(NSNumber *keyObj, NSArray *views, BOOL *stop) {
PSTCollectionViewItemType type = [keyObj unsignedIntegerValue];
for (PSTCollectionReusableView *view in views) {
if (type == PSTCollectionViewItemTypeCell) {
[self reuseCell:(PSTCollectionViewCell *)view];
} else if (type == PSTCollectionViewItemTypeSupplementaryView) {
[self reuseSupplementaryView:view];
} else if (type == PSTCollectionViewItemTypeDecorationView) {
[self reuseDecorationView:view];
}
}
}];
_collectionViewFlags.updatingLayout = NO;
//In here I think when the block is called, the flag is YES. So the _updateCopletionHandler's paramer is YES.
if (_updateCompletionHandler) {
_updateCompletionHandler(YES);
_updateCompletionHandler = nil;
}
}];
for (NSDictionary *animation in animations) {
PSTCollectionReusableView *view = animation[@"view"];
PSTCollectionViewLayoutAttributes *attrs = animation[@"newLayoutInfos"];
[view applyLayoutAttributes:attrs];
}
[CATransaction commit];
[_layout finalizeCollectionViewUpdates];
}
- (void)setupCellAnimations {
[self updateVisibleCellsNow:YES];
[self suspendReloads];
_collectionViewFlags.updating = YES;
}
- (void)endItemAnimations {
_updateCount++;
PSTCollectionViewData *oldCollectionViewData = _collectionViewData;
_collectionViewData = [[PSTCollectionViewData alloc] initWithCollectionView:self layout:_layout];
[_layout invalidateLayout];
[_collectionViewData prepareToLoadData];
NSMutableArray *someMutableArr1 = [[NSMutableArray alloc] init];
NSArray *removeUpdateItems = [[self arrayForUpdateAction:PSTCollectionUpdateActionDelete]
sortedArrayUsingSelector:@selector(inverseCompareIndexPaths:)];
NSArray *insertUpdateItems = [[self arrayForUpdateAction:PSTCollectionUpdateActionInsert]
sortedArrayUsingSelector:@selector(compareIndexPaths:)];
NSMutableArray *sortedMutableReloadItems = [[_reloadItems sortedArrayUsingSelector:@selector(compareIndexPaths:)] mutableCopy];
NSMutableArray *sortedMutableMoveItems = [[_moveItems sortedArrayUsingSelector:@selector(compareIndexPaths:)] mutableCopy];
_originalDeleteItems = [removeUpdateItems copy];
_originalInsertItems = [insertUpdateItems copy];
NSMutableArray *someMutableArr2 = [[NSMutableArray alloc] init];
NSMutableArray *someMutableArr3 = [[NSMutableArray alloc] init];
NSMutableDictionary *operations = [[NSMutableDictionary alloc] init];
for (PSTCollectionViewUpdateItem *updateItem in sortedMutableReloadItems) {
NSAssert(updateItem.indexPathBeforeUpdate.section < [oldCollectionViewData numberOfSections],
@"attempt to reload item (%@) that doesn't exist (there are only %ld sections before update)",
updateItem.indexPathBeforeUpdate, (long)[oldCollectionViewData numberOfSections]);
if (updateItem.indexPathBeforeUpdate.item != NSNotFound) {
NSAssert(updateItem.indexPathBeforeUpdate.item < [oldCollectionViewData numberOfItemsInSection:updateItem.indexPathBeforeUpdate.section],
@"attempt to reload item (%@) that doesn't exist (there are only %ld items in section %ld before update)",
updateItem.indexPathBeforeUpdate,
(long)[oldCollectionViewData numberOfItemsInSection:updateItem.indexPathBeforeUpdate.section],
(long)updateItem.indexPathBeforeUpdate.section);
}
[someMutableArr2 addObject:[[PSTCollectionViewUpdateItem alloc] initWithAction:PSTCollectionUpdateActionDelete
forIndexPath:updateItem.indexPathBeforeUpdate]];
[someMutableArr3 addObject:[[PSTCollectionViewUpdateItem alloc] initWithAction:PSTCollectionUpdateActionInsert
forIndexPath:updateItem.indexPathAfterUpdate]];
}
NSMutableArray *sortedDeletedMutableItems = [[_deleteItems sortedArrayUsingSelector:@selector(inverseCompareIndexPaths:)] mutableCopy];
NSMutableArray *sortedInsertMutableItems = [[_insertItems sortedArrayUsingSelector:@selector(compareIndexPaths:)] mutableCopy];
for (PSTCollectionViewUpdateItem *deleteItem in sortedDeletedMutableItems) {
if ([deleteItem isSectionOperation]) {
NSAssert(deleteItem.indexPathBeforeUpdate.section < [oldCollectionViewData numberOfSections],
@"attempt to delete section (%ld) that doesn't exist (there are only %ld sections before update)",
(long)deleteItem.indexPathBeforeUpdate.section,
(long)[oldCollectionViewData numberOfSections]);
for (PSTCollectionViewUpdateItem *moveItem in sortedMutableMoveItems) {
if (moveItem.indexPathBeforeUpdate.section == deleteItem.indexPathBeforeUpdate.section) {
if (moveItem.isSectionOperation)
NSAssert(NO, @"attempt to delete and move from the same section %ld", (long)deleteItem.indexPathBeforeUpdate.section);
else
NSAssert(NO, @"attempt to delete and move from the same section (%@)", moveItem.indexPathBeforeUpdate);
}
}
}else {
NSAssert(deleteItem.indexPathBeforeUpdate.section < [oldCollectionViewData numberOfSections],
@"attempt to delete item (%@) that doesn't exist (there are only %ld sections before update)",
deleteItem.indexPathBeforeUpdate,
(long)[oldCollectionViewData numberOfSections]);
NSAssert(deleteItem.indexPathBeforeUpdate.item < [oldCollectionViewData numberOfItemsInSection:deleteItem.indexPathBeforeUpdate.section],
@"attempt to delete item (%@) that doesn't exist (there are only %ld items in section%ld before update)",
deleteItem.indexPathBeforeUpdate,
(long)[oldCollectionViewData numberOfItemsInSection:deleteItem.indexPathBeforeUpdate.section],
(long)deleteItem.indexPathBeforeUpdate.section);
for (PSTCollectionViewUpdateItem *moveItem in sortedMutableMoveItems) {
NSAssert(![deleteItem.indexPathBeforeUpdate isEqual:moveItem.indexPathBeforeUpdate],
@"attempt to delete and move the same item (%@)", deleteItem.indexPathBeforeUpdate);
}
if (!operations[@(deleteItem.indexPathBeforeUpdate.section)])
operations[@(deleteItem.indexPathBeforeUpdate.section)] = [NSMutableDictionary dictionary];
operations[@(deleteItem.indexPathBeforeUpdate.section)][@"deleted"] =
@([operations[@(deleteItem.indexPathBeforeUpdate.section)][@"deleted"] intValue] + 1);
}
}
for (NSUInteger i = 0; i < sortedInsertMutableItems.count; i++) {
PSTCollectionViewUpdateItem *insertItem = sortedInsertMutableItems[i];
NSIndexPath *indexPath = insertItem.indexPathAfterUpdate;
BOOL sectionOperation = [insertItem isSectionOperation];
if (sectionOperation) {
NSAssert([indexPath section] < [_collectionViewData numberOfSections],
@"attempt to insert %ld but there are only %ld sections after update",
(long)[indexPath section], (long)[_collectionViewData numberOfSections]);
for (PSTCollectionViewUpdateItem *moveItem in sortedMutableMoveItems) {
if ([moveItem.indexPathAfterUpdate isEqual:indexPath]) {
if (moveItem.isSectionOperation)
NSAssert(NO, @"attempt to perform an insert and a move to the same section (%ld)", (long)indexPath.section);
}
}
NSUInteger j = i + 1;
while (j < sortedInsertMutableItems.count) {
PSTCollectionViewUpdateItem *nextInsertItem = sortedInsertMutableItems[j];
if (nextInsertItem.indexPathAfterUpdate.section == indexPath.section) {
NSAssert(nextInsertItem.indexPathAfterUpdate.item < [_collectionViewData numberOfItemsInSection:indexPath.section],
@"attempt to insert item %ld into section %ld, but there are only %ld items in section %ld after the update",
(long)nextInsertItem.indexPathAfterUpdate.item,
(long)indexPath.section,
(long)[_collectionViewData numberOfItemsInSection:indexPath.section],
(long)indexPath.section);
[sortedInsertMutableItems removeObjectAtIndex:j];
}
else break;
}
}else {
NSAssert(indexPath.item < [_collectionViewData numberOfItemsInSection:indexPath.section],
@"attempt to insert item to (%@) but there are only %ld items in section %ld after update",
indexPath,
(long)[_collectionViewData numberOfItemsInSection:indexPath.section],
(long)indexPath.section);
if (!operations[@(indexPath.section)])
operations[@(indexPath.section)] = [NSMutableDictionary dictionary];
operations[@(indexPath.section)][@"inserted"] =
@([operations[@(indexPath.section)][@"inserted"] intValue] + 1);
}
}
for (PSTCollectionViewUpdateItem *sortedItem in sortedMutableMoveItems) {
if (sortedItem.isSectionOperation) {
NSAssert(sortedItem.indexPathBeforeUpdate.section < [oldCollectionViewData numberOfSections],
@"attempt to move section (%ld) that doesn't exist (%ld sections before update)",
(long)sortedItem.indexPathBeforeUpdate.section,
(long)[oldCollectionViewData numberOfSections]);
NSAssert(sortedItem.indexPathAfterUpdate.section < [_collectionViewData numberOfSections],
@"attempt to move section to %ld but there are only %ld sections after update",
(long)sortedItem.indexPathAfterUpdate.section,
(long)[_collectionViewData numberOfSections]);
}else {
NSAssert(sortedItem.indexPathBeforeUpdate.section < [oldCollectionViewData numberOfSections],
@"attempt to move item (%@) that doesn't exist (%ld sections before update)",
sortedItem, (long)[oldCollectionViewData numberOfSections]);
NSAssert(sortedItem.indexPathBeforeUpdate.item < [oldCollectionViewData numberOfItemsInSection:sortedItem.indexPathBeforeUpdate.section],
@"attempt to move item (%@) that doesn't exist (%ld items in section %ld before update)",
sortedItem,
(long)[oldCollectionViewData numberOfItemsInSection:sortedItem.indexPathBeforeUpdate.section],
(long)sortedItem.indexPathBeforeUpdate.section);
NSAssert(sortedItem.indexPathAfterUpdate.section < [_collectionViewData numberOfSections],
@"attempt to move item to (%@) but there are only %ld sections after update",
sortedItem.indexPathAfterUpdate,
(long)[_collectionViewData numberOfSections]);
NSAssert(sortedItem.indexPathAfterUpdate.item < [_collectionViewData numberOfItemsInSection:sortedItem.indexPathAfterUpdate.section],
@"attempt to move item to (%@) but there are only %ld items in section %ld after update",
sortedItem,
(long)[_collectionViewData numberOfItemsInSection:sortedItem.indexPathAfterUpdate.section],
(long)sortedItem.indexPathAfterUpdate.section);
}
if (!operations[@(sortedItem.indexPathBeforeUpdate.section)])
operations[@(sortedItem.indexPathBeforeUpdate.section)] = [NSMutableDictionary dictionary];
if (!operations[@(sortedItem.indexPathAfterUpdate.section)])
operations[@(sortedItem.indexPathAfterUpdate.section)] = [NSMutableDictionary dictionary];
operations[@(sortedItem.indexPathBeforeUpdate.section)][@"movedOut"] =
@([operations[@(sortedItem.indexPathBeforeUpdate.section)][@"movedOut"] intValue] + 1);
operations[@(sortedItem.indexPathAfterUpdate.section)][@"movedIn"] =
@([operations[@(sortedItem.indexPathAfterUpdate.section)][@"movedIn"] intValue] + 1);
}
#if !defined NS_BLOCK_ASSERTIONS
for (NSNumber *sectionKey in [operations keyEnumerator]) {
NSInteger section = [sectionKey integerValue];
NSInteger insertedCount = [operations[sectionKey][@"inserted"] integerValue];
NSInteger deletedCount = [operations[sectionKey][@"deleted"] integerValue];
NSInteger movedInCount = [operations[sectionKey][@"movedIn"] integerValue];
NSInteger movedOutCount = [operations[sectionKey][@"movedOut"] integerValue];
NSAssert([oldCollectionViewData numberOfItemsInSection:section] + insertedCount - deletedCount + movedInCount - movedOutCount ==
[_collectionViewData numberOfItemsInSection:section],
@"invalid update in section %ld: number of items after update (%ld) should be equal to the number of items before update (%ld) "\
"plus count of inserted items (%ld), minus count of deleted items (%ld), plus count of items moved in (%ld), minus count of items moved out (%ld)",
(long)section,
(long)[_collectionViewData numberOfItemsInSection:section],
(long)[oldCollectionViewData numberOfItemsInSection:section],
(long)insertedCount, (long)deletedCount, (long)movedInCount, (long)movedOutCount);
}
#endif
[someMutableArr2 addObjectsFromArray:sortedDeletedMutableItems];
[someMutableArr3 addObjectsFromArray:sortedInsertMutableItems];
[someMutableArr1 addObjectsFromArray:[someMutableArr2 sortedArrayUsingSelector:@selector(inverseCompareIndexPaths:)]];
[someMutableArr1 addObjectsFromArray:sortedMutableMoveItems];
[someMutableArr1 addObjectsFromArray:[someMutableArr3 sortedArrayUsingSelector:@selector(compareIndexPaths:)]];
NSMutableArray *layoutUpdateItems = [[NSMutableArray alloc] init];
[layoutUpdateItems addObjectsFromArray:sortedDeletedMutableItems];
[layoutUpdateItems addObjectsFromArray:sortedMutableMoveItems];
[layoutUpdateItems addObjectsFromArray:sortedInsertMutableItems];
NSMutableArray *newModel = [NSMutableArray array];
for (NSInteger i = 0; i < [oldCollectionViewData numberOfSections]; i++) {
NSMutableArray *sectionArr = [NSMutableArray array];
for (NSInteger j = 0; j < [oldCollectionViewData numberOfItemsInSection:i]; j++)
[sectionArr addObject:@([oldCollectionViewData globalIndexForItemAtIndexPath:[NSIndexPath indexPathForItem:j inSection:i]])];
[newModel addObject:sectionArr];
}
for (PSTCollectionViewUpdateItem *updateItem in layoutUpdateItems) {
switch (updateItem.updateAction) {
case PSTCollectionUpdateActionDelete: {
if (updateItem.isSectionOperation) {
// section updates are ignored anyway in animation code. If not commented, mixing rows and section deletion causes crash in else below
// [newModel removeObjectAtIndex:updateItem.indexPathBeforeUpdate.section];
}else {
[(NSMutableArray *)newModel[(NSUInteger)updateItem.indexPathBeforeUpdate.section]
removeObjectAtIndex:(NSUInteger)updateItem.indexPathBeforeUpdate.item];
}
}
break;
case PSTCollectionUpdateActionInsert: {
if (updateItem.isSectionOperation) {
[newModel insertObject:[[NSMutableArray alloc] init]
atIndex:(NSUInteger)updateItem.indexPathAfterUpdate.section];
}else {
[(NSMutableArray *)newModel[(NSUInteger)updateItem.indexPathAfterUpdate.section]
insertObject:@(NSNotFound)
atIndex:(NSUInteger)updateItem.indexPathAfterUpdate.item];
}
}
break;
case PSTCollectionUpdateActionMove: {
if (updateItem.isSectionOperation) {
id section = newModel[(NSUInteger)updateItem.indexPathBeforeUpdate.section];
[newModel insertObject:section atIndex:(NSUInteger)updateItem.indexPathAfterUpdate.section];
}
else {
id object = @([oldCollectionViewData globalIndexForItemAtIndexPath:updateItem.indexPathBeforeUpdate]);
[newModel[(NSUInteger)updateItem.indexPathBeforeUpdate.section] removeObject:object];
[newModel[(NSUInteger)updateItem.indexPathAfterUpdate.section] insertObject:object
atIndex:(NSUInteger)updateItem.indexPathAfterUpdate.item];
}
}
break;
default: break;
}
}
NSMutableArray *oldToNewMap = [NSMutableArray arrayWithCapacity:(NSUInteger)[oldCollectionViewData numberOfItems]];
NSMutableArray *newToOldMap = [NSMutableArray arrayWithCapacity:(NSUInteger)[_collectionViewData numberOfItems]];
for (NSInteger i = 0; i < [oldCollectionViewData numberOfItems]; i++)
[oldToNewMap addObject:@(NSNotFound)];
for (NSInteger i = 0; i < [_collectionViewData numberOfItems]; i++)
[newToOldMap addObject:@(NSNotFound)];
for (NSUInteger i = 0; i < newModel.count; i++) {
NSMutableArray *section = newModel[i];
for (NSUInteger j = 0; j < section.count; j++) {
NSUInteger newGlobalIndex = [_collectionViewData globalIndexForItemAtIndexPath:[NSIndexPath indexPathForItem:(NSInteger)j inSection:(NSInteger)i]];
if ([section[j] integerValue] != NSNotFound)
oldToNewMap[[section[j] unsignedIntegerValue]] = @(newGlobalIndex);
if (newGlobalIndex != NSNotFound)
newToOldMap[newGlobalIndex] = section[j];
}
}
_update = @{@"oldModel" : oldCollectionViewData, @"newModel" : _collectionViewData, @"oldToNewIndexMap" : oldToNewMap, @"newToOldIndexMap" : newToOldMap};
[self updateWithItems:someMutableArr1];
_originalInsertItems = nil;
_originalDeleteItems = nil;
_insertItems = nil;
_deleteItems = nil;
_moveItems = nil;
_reloadItems = nil;
_update = nil;
_updateCount--;
_collectionViewFlags.updating = NO;
[self resumeReloads];
}
- (void)updateRowsAtIndexPaths:(NSArray *)indexPaths updateAction:(PSTCollectionUpdateAction)updateAction {
BOOL updating = _collectionViewFlags.updating;
if (!updating) [self setupCellAnimations];
NSMutableArray *array = [self arrayForUpdateAction:updateAction]; //returns appropriate empty array if not exists
for (NSIndexPath *indexPath in indexPaths) {
PSTCollectionViewUpdateItem *updateItem = [[PSTCollectionViewUpdateItem alloc] initWithAction:updateAction forIndexPath:indexPath];
[array addObject:updateItem];
}
if (!updating) [self endItemAnimations];
}
- (void)updateSections:(NSIndexSet *)sections updateAction:(PSTCollectionUpdateAction)updateAction {
BOOL updating = _collectionViewFlags.updating;
if (!updating) [self setupCellAnimations];
NSMutableArray *updateActions = [self arrayForUpdateAction:updateAction];
[sections enumerateIndexesUsingBlock:^(NSUInteger section, BOOL *stop) {
PSTCollectionViewUpdateItem *updateItem = [[PSTCollectionViewUpdateItem alloc] initWithAction:updateAction forIndexPath:[NSIndexPath indexPathForItem:NSNotFound inSection:(NSInteger)section]];
[updateActions addObject:updateItem];
}];
if (!updating) [self endItemAnimations];
}
///////////////////////////////////////////////////////////////////////////////////////////
#pragma mark - PSTCollection/UICollection interoperability
#ifdef kPSUIInteroperabilityEnabled
#import <objc/message.h>
- (NSMethodSignature *)methodSignatureForSelector:(SEL)selector {
NSMethodSignature *sig = [super methodSignatureForSelector:selector];
if(!sig) {
NSString *selString = NSStringFromSelector(selector);
if ([selString hasPrefix:@"_"]) {
SEL cleanedSelector = NSSelectorFromString([selString substringFromIndex:1]);
sig = [super methodSignatureForSelector:cleanedSelector];
}
}
return sig;
}
- (void)forwardInvocation:(NSInvocation *)inv {
NSString *selString = NSStringFromSelector([inv selector]);
if ([selString hasPrefix:@"_"]) {
SEL cleanedSelector = NSSelectorFromString([selString substringFromIndex:1]);
if ([self respondsToSelector:cleanedSelector]) {
// dynamically add method for faster resolving
Method newMethod = class_getInstanceMethod(self.class, [inv selector]);
IMP underscoreIMP = imp_implementationWithBlock(^(id _self) {
return objc_msgSend(_self, cleanedSelector);
});
class_addMethod(self.class, [inv selector], underscoreIMP, method_getTypeEncoding(newMethod));
// invoke now
inv.selector = cleanedSelector;
[inv invokeWithTarget:self];
}
}else {
[super forwardInvocation:inv];
}
}
#endif
@end
///////////////////////////////////////////////////////////////////////////////////////////
#pragma mark - Runtime Additions to create UICollectionView
@implementation PSUICollectionView_ @end
@implementation PSUICollectionViewCell_ @end
@implementation PSUICollectionReusableView_ @end
@implementation PSUICollectionViewLayout_ @end
@implementation PSUICollectionViewFlowLayout_ @end
@implementation PSUICollectionViewLayoutAttributes_ @end
@implementation PSUICollectionViewController_ @end
static void PSTRegisterClasses() {
NSDictionary *map = @{
@"UICollectionView": PSUICollectionView_.class,
@"UICollectionViewCell": PSUICollectionViewCell_.class,
@"UICollectionReusableView": PSUICollectionReusableView_.class,
@"UICollectionViewLayout": PSUICollectionViewLayout_.class,
@"UICollectionViewFlowLayout": PSUICollectionViewFlowLayout_.class,
@"UICollectionViewLayoutAttributes": PSUICollectionViewLayoutAttributes_.class,
@"UICollectionViewController": PSUICollectionViewController_.class
};
// Ensure that superclass replacement is all-or-nothing for the PSUI*_ types. Either use exclusively
// UICollectionView*, or exclusively PSTCollectionView*.
__block BOOL canOverwrite = YES;
[map enumerateKeysAndObjectsUsingBlock:^(NSString* UIClassName, id PSTClass, BOOL *stop) {
Class UIClass = NSClassFromString(UIClassName);
if (UIClass) {
// Class size need to be the same for class_setSuperclass to work.
// If the UIKit class is smaller then our subclass, ivars won't clash, so there's no issue.
long sizeDifference = (long)class_getInstanceSize(UIClass) - class_getInstanceSize(PSTClass);
if (sizeDifference > 0) {
canOverwrite = NO;
NSLog(@"Warning! ivar size mismatch in %@ of %tu bytes - can't change the superclass.", PSTClass, sizeDifference);
}
} else {
canOverwrite = NO;
// We're most likely on iOS5, the requested UIKit class doesn't exist, so we create it dynamically.
if ((UIClass = objc_allocateClassPair(PSTClass, UIClassName.UTF8String, 0))) {
objc_registerClassPair(UIClass);
}
}
}];
if (canOverwrite) {
// All UICollectionView types were found and appropriately sized, so it is safe to replace the super-class.
[map enumerateKeysAndObjectsUsingBlock:^(NSString* UIClassName, id PSTClass, BOOL *stop) {
Class UIClass = NSClassFromString(UIClassName);
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
// class_setSuperclass is deprecated, but still exists and works on iOS6/7.
class_setSuperclass(PSTClass, UIClass);
#pragma clang diagnostic pop
}];
}
}
// Create subclasses that pose as UICollectionView et al, if not available at runtime.
__attribute__((constructor)) static void PSTCreateUICollectionViewClasses(void) {
if (objc_getClass("PSTCollectionViewDisableForwardToUICollectionViewSentinel")) return;
@autoreleasepool {
// Change superclass at runtime. This allows seamless switching from PST* to UI* at runtime.
PSTRegisterClasses();
// add PSUI classes at runtime to make Interface Builder sane
// (IB doesn't allow adding the PSUICollectionView_ types but doesn't complain on unknown classes)
// The class name may already be in use. This may happen if this code is running for the second time (first for an app bundle, then again for a unit test bundle).
Class c;
if ((c = objc_allocateClassPair(PSUICollectionView_.class, "PSUICollectionView", 0))) objc_registerClassPair(c);
if ((c = objc_allocateClassPair(PSUICollectionViewCell_.class, "PSUICollectionViewCell", 0))) objc_registerClassPair(c);
if ((c = objc_allocateClassPair(PSUICollectionReusableView_.class, "PSUICollectionReusableView", 0))) objc_registerClassPair(c);
if ((c = objc_allocateClassPair(PSUICollectionViewLayout_.class, "PSUICollectionViewLayout", 0))) objc_registerClassPair(c);
if ((c = objc_allocateClassPair(PSUICollectionViewFlowLayout_.class, "PSUICollectionViewFlowLayout", 0))) objc_registerClassPair(c);
if ((c = objc_allocateClassPair(PSUICollectionViewLayoutAttributes_.class, "PSUICollectionViewLayoutAttributes", 0)))objc_registerClassPair(c);
if ((c = objc_allocateClassPair(PSUICollectionViewController_.class, "PSUICollectionViewController", 0))) objc_registerClassPair(c);
}
}
CGFloat PSTSimulatorAnimationDragCoefficient(void) {
static CGFloat (*UIAnimationDragCoefficient)(void) = NULL;
#if TARGET_IPHONE_SIMULATOR
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
UIAnimationDragCoefficient = (CGFloat (*)(void))dlsym(RTLD_DEFAULT, "UIAnimationDragCoefficient");
});
#endif
return UIAnimationDragCoefficient ? UIAnimationDragCoefficient() : 1.f;
}
// helper to check for ivar layout
#if 0
static void PSTPrintIvarsForClass(Class aClass) {
unsigned int varCount;
Ivar *vars = class_copyIvarList(aClass, &varCount);
for (int i = 0; i < varCount; i++) {
NSLog(@"%s %s", ivar_getTypeEncoding(vars[i]), ivar_getName(vars[i]));
}
free(vars);
}
__attribute__((constructor)) static void PSTCheckIfIVarLayoutIsEqualSize(void) {
@autoreleasepool {
NSLog(@"PSTCollectionView size = %zd, UICollectionView size = %zd", class_getInstanceSize(PSTCollectionView.class),class_getInstanceSize(UICollectionView.class));
NSLog(@"PSTCollectionViewCell size = %zd, UICollectionViewCell size = %zd", class_getInstanceSize(PSTCollectionViewCell.class),class_getInstanceSize(UICollectionViewCell.class));
NSLog(@"PSTCollectionViewController size = %zd, UICollectionViewController size = %zd", class_getInstanceSize(PSTCollectionViewController.class),class_getInstanceSize(UICollectionViewController.class));
NSLog(@"PSTCollectionViewLayout size = %zd, UICollectionViewLayout size = %zd", class_getInstanceSize(PSTCollectionViewLayout.class),class_getInstanceSize(UICollectionViewLayout.class));
NSLog(@"PSTCollectionViewFlowLayout size = %zd, UICollectionViewFlowLayout size = %zd", class_getInstanceSize(PSTCollectionViewFlowLayout.class),class_getInstanceSize(UICollectionViewFlowLayout.class));
//PSTPrintIvarsForClass(PSTCollectionViewFlowLayout.class); NSLog(@"\n\n\n");PSTPrintIvarsForClass(UICollectionViewFlowLayout.class);
}
}
#endif