#import "AQGridView.h"

#import "AQGridViewUpdateItem.h"

#import "AQGridViewAnimatorItem.h"

#import "AQGridViewData.h"

#import "AQGridViewUpdateInfo.h"

#import "AQGridViewCell+AQGridViewCellPrivate.h"

#import "AQGridView+CellLocationDelegation.h"

#import "AQGridView+Hackery.h"

#import "NSIndexSet+AQIsSetContiguous.h"

#import "NSIndexSet+AQIndexesOutsideSet.h"

#import <libkern/OSAtomic.h>

@interface UserSelectItemIndexParams : NSObject

{

NSUInteger _indexNum;

NSUInteger _numFingers;

};

@property (nonatomic, assign) NSUInteger indexNum;

@property (nonatomic, assign) NSUInteger numFingers;

@implementation UserSelectItemIndexParams

@synthesize indexNum = _indexNum;

@synthesize numFingers = _numFingers;

NSString * const AQGridViewSelectionDidChangeNotification = @"AQGridViewSelectionDidChangeNotification";

@interface AQGridView (AQCellGridMath)

- (NSUInteger) visibleCellListIndexForItemIndex: (NSUInteger) itemIndex;

@interface AQGridView (AQCellLayout)

- (void) layoutCellsInVisibleCellRange: (NSRange) range;

- (void) layoutAllCells;

- (CGRect) fixCellFrame: (CGRect) cellFrame forGridRect: (CGRect) gridRect;

- (void) updateVisibleGridCellsNow;

- (AQGridViewCell *) createPreparedCellForIndex: (NSUInteger) index;

- (void) insertVisibleCell: (AQGridViewCell *) cell atIndex: (NSUInteger) visibleCellListIndex;

- (void) deleteVisibleCell: (AQGridViewCell *) cell atIndex: (NSUInteger) visibleCellListIndex appendingNewCell: (AQGridViewCell *) newLastCell;

@interface AQGridView ()

@property (nonatomic, copy) NSIndexSet * animatingIndices;

@implementation AQGridView

@synthesize dataSource=_dataSource, backgroundView=_backgroundView, separatorColor=_separatorColor, animatingCells=_animatingCells, animatingIndices=_animatingIndices;

- (void) _sharedGridViewInit

{

_gridData = [[AQGridViewData alloc] initWithGridView: self];

[_gridData setDesiredCellSize: CGSizeMake(96.0, 128.0)];

_visibleBounds = self.bounds;

_visibleCells = [[NSMutableArray alloc] init];

_reusableGridCells = [[NSMutableDictionary alloc] init];

_highlightedIndices = [[NSMutableIndexSet alloc] init];

_updateInfoStack = [[NSMutableArray alloc] init];

self.clipsToBounds = YES;

self.separatorColor = [UIColor colorWithWhite: 0.85 alpha: 1.0];

self.canCancelContentTouches = YES;

_selectedIndices = [[NSMutableIndexSet alloc] init];

_pendingSelectionIndex = NSNotFound;

_flags.resizesCellWidths = 0;

_flags.numColumns = [_gridData numberOfItemsPerRow];

_flags.separatorStyle = AQGridViewCellSeparatorStyleEmptySpace;

_flags.selectable = 1;

_flags.allowsMultipleSelection = 0;

_flags.usesPagedHorizontalScrolling = NO;

_flags.contentSizeFillsBounds = 1;

}

- (id)initWithFrame: (CGRect) frame

{

self = [super initWithFrame:frame];

if ( self == nil )

return ( nil );

[self _sharedGridViewInit];

return ( self );

}

- (id) initWithCoder: (NSCoder *) aDecoder

{

self = [super initWithCoder: aDecoder];

if ( self == nil )

return ( nil );

[self _sharedGridViewInit];

return ( self );

}

- (void) awakeFromNib

{

[super awakeFromNib];

[self _sharedGridViewInit];

}

#pragma mark -

#pragma mark Properties

- (void) setDelegate: (id<AQGridViewDelegate>) obj

{

if ( (obj != nil) && ([obj conformsToProtocol: @protocol(AQGridViewDelegate)] == NO ))

[NSException raise: NSInvalidArgumentException format: @"Argument to -setDelegate must conform to the AQGridViewDelegate protocol"];

[super setDelegate: obj];

_flags.delegateWillDisplayCell = [obj respondsToSelector: @selector(gridView:willDisplayCell:forItemAtIndex:)];

_flags.delegateWillSelectItem = [obj respondsToSelector: @selector(gridView:willSelectItemAtIndex:)];

_flags.delegateWillSelectItemMultiTouch = [obj respondsToSelector: @selector(gridView:willSelectItemAtIndex:numFingersTouch:)];

_flags.delegateWillDeselectItem = [obj respondsToSelector: @selector(gridView:willDeselectItemAtIndex:)];

_flags.delegateDidSelectItem = [obj respondsToSelector: @selector(gridView:didSelectItemAtIndex:)];

_flags.delegateDidSelectItemMultiTouch = [obj respondsToSelector: @selector(gridView:didSelectItemAtIndex:numFingersTouch:)];

_flags.delegateDidDeselectItem = [obj respondsToSelector: @selector(gridView:didDeselectItemAtIndex:)];

_flags.delegateGestureRecognizerActivated = [obj respondsToSelector: @selector(gridView:gestureRecognizer:activatedForItemAtIndex:)];

_flags.delegateAdjustGridCellFrame = [obj respondsToSelector: @selector(gridView:adjustCellFrame:withinGridCellFrame:)];

_flags.delegateDidEndUpdateAnimation = [obj respondsToSelector:@selector(gridViewDidEndUpdateAnimation:)];

}

- (id<AQGridViewDelegate>) delegate

{

id obj = [super delegate];

if ( [obj conformsToProtocol: @protocol(AQGridViewDelegate)] == NO )

return ( nil );

return ( obj );

}

- (void) setDataSource: (id<AQGridViewDataSource>) obj

{

if ((obj != nil) && ([obj conformsToProtocol: @protocol(AQGridViewDataSource)] == NO ))

[NSException raise: NSInvalidArgumentException format: @"Argument to -setDataSource must conform to the AQGridViewDataSource protocol"];

_dataSource = obj;

_flags.dataSourceGridCellSize = [obj respondsToSelector: @selector(portraitGridCellSizeForGridView:)];

}

- (AQGridViewLayoutDirection) layoutDirection

{

return ( _gridData.layoutDirection );

}

- (void) setLayoutDirection: (AQGridViewLayoutDirection) direction

{

_gridData.layoutDirection = direction;

}

- (NSUInteger) numberOfItems

{

return ( _gridData.numberOfItems );

}

- (NSUInteger) numberOfColumns

{

if ( _flags.numColumns == 0 )

_flags.numColumns = 1;

return ( _flags.numColumns );

}

- (NSUInteger) numberOfRows

{

return ( _gridData.numberOfItems / _flags.numColumns );

}

- (BOOL) selectable {

return _flags.selectable;

}

- (void) setSelectable:(BOOL)selectable {

_flags.selectable = (selectable ? 1 : 0);

}

- (BOOL) allowsMultipleSelection {

return _flags.allowsMultipleSelection;

}

- (void) setAllowsMultipleSelection:(BOOL)allowsMultipleSelection {

_flags.allowsMultipleSelection = (allowsMultipleSelection ? 1 : 0);

}

- (BOOL) backgroundViewExtendsDown

{

return ( _flags.backgroundViewExtendsDown);

}

- (void) setBackgroundViewExtendsDown: (BOOL) value

{

_flags.backgroundViewExtendsDown = (value ? 1 : 0);

}

- (BOOL) backgroundViewExtendsUp

{

return ( _flags.backgroundViewExtendsUp);

}

- (void) setBackgroundViewExtendsUp: (BOOL) value

{

_flags.backgroundViewExtendsUp = (value ? 1 : 0);

}

- (BOOL) requiresSelection

{

return ( _flags.requiresSelection );

}

- (void) setRequiresSelection: (BOOL) value

{

_flags.requiresSelection = (value ? 1 : 0);

}

- (BOOL) resizesCellWidthToFit

{

return ( _flags.resizesCellWidths );

}

- (void) setResizesCellWidthToFit: (BOOL) value

{

int i = (value ? 1 : 0);

if ( _flags.resizesCellWidths == i )

return;

_flags.resizesCellWidths = i;

[self setNeedsLayout];

}

- (BOOL) usesPagedHorizontalScrolling

{

return ( _flags.usesPagedHorizontalScrolling );

}

- (void) setUsesPagedHorizontalScrolling: (BOOL) value

{

int i = (value ? 1 : 0);

if ( _flags.usesPagedHorizontalScrolling == i )

return;

_flags.usesPagedHorizontalScrolling = i;

[self setNeedsLayout];

}

- (AQGridViewCellSeparatorStyle) separatorStyle

{

return ( _flags.separatorStyle );

}

- (void) setSeparatorStyle: (AQGridViewCellSeparatorStyle) style

{

if ( style == _flags.separatorStyle )

return;

_flags.separatorStyle = style;

for ( AQGridViewCell * cell in _visibleCells )

{

cell.separatorStyle = style;

}

[self setNeedsLayout];

}

- (CGFloat) leftContentInset

{

return ( _gridData.leftPadding );

}

- (void) setLeftContentInset: (CGFloat) inset

{

_gridData.leftPadding = inset;

}

- (CGFloat) rightContentInset

{

return ( _gridData.rightPadding );

}

- (void) setRightContentInset: (CGFloat) inset

{

_gridData.rightPadding = inset;

}

- (CGSize) gridCellSize

{

return ( [_gridData cellSize] );

}

- (UIView *) gridHeaderView

{

return ( _headerView );

}

- (void) setGridHeaderView: (UIView *) newHeaderView

{

if ( newHeaderView == _headerView )

return;

[_headerView removeFromSuperview];

_headerView = newHeaderView;

if ( _headerView == nil )

{

_gridData.topPadding = 0.0;

}

else

{

[self addSubview: _headerView];

_gridData.topPadding = _headerView.frame.size.height;

}

[self setNeedsLayout];

}

- (UIView *) gridFooterView

{

return ( _footerView );

}

- (void) setGridFooterView: (UIView *) newFooterView

{

if ( newFooterView == _footerView )

return;

[_footerView removeFromSuperview];

_footerView = newFooterView;

if ( _footerView == nil )

{

_gridData.bottomPadding = 0.0;

}

else

{

[self addSubview: _footerView];

_gridData.bottomPadding = _footerView.frame.size.height;

}

[self setNeedsLayout];

}

- (BOOL) contentSizeGrowsToFillBounds

{

return ( _flags.contentSizeFillsBounds == 1 );

}

- (void) setContentSizeGrowsToFillBounds: (BOOL) value

{

_flags.contentSizeFillsBounds = (value ? 1 : 0);

}

- (void) setAnimatingCells: (NSSet *) set

{

_animatingCells = set;

NSMutableIndexSet * indices = [[NSMutableIndexSet alloc] init];

for ( AQGridViewAnimatorItem * item in set )

{

if ( item.index != NSNotFound )

[indices addIndex: item.index];

}

self.animatingIndices = indices;

}

- (BOOL) isAnimatingUpdates

{

return ( _animationCount > 0 );

}

- (void) updateContentRectWithOldMaxLocation: (CGPoint) oldMaxLocation gridSize: (CGSize) gridSize

{

// The following line prevents an update leading to unneccessary auto-scrolling

// Before this fix, AQGridView animation always caused scrolling to the most bottom line

if (CGSizeEqualToSize(self.contentSize, gridSize)) return;

// update content size

self.contentSize = gridSize;

// fix content offset if applicable

CGPoint offset = self.contentOffset;

CGPoint oldOffset = offset;

if ( offset.y + self.bounds.size.height > gridSize.height )

{

offset.y = MAX(0.0, self.contentSize.height - self.bounds.size.height);

}

else if ( !CGPointEqualToPoint(oldOffset, CGPointZero) ) // stick-to-top takes precedence

{

if ( [_gridData pointIsInLastRow: oldMaxLocation] )

{

// we were scrolled to the bottom-- stay there as our height decreases

if ( self.layoutDirection == AQGridViewLayoutDirectionVertical )

offset.y = MAX(0.0, self.contentSize.height - self.bounds.size.height);

else

offset.x = MAX(0.0, self.contentSize.width - self.bounds.size.width);

}

}

//NSLog( @"Resetting offset from %@ to %@", NSStringFromCGPoint(oldOffset), NSStringFromCGPoint(offset) );

self.contentOffset = offset;

}

- (void) handleGridViewBoundsChanged: (CGRect) oldBounds toNewBounds: (CGRect) bounds

{

CGSize oldGridSize = [_gridData sizeForEntireGrid];

BOOL wasAtBottom = ((oldGridSize.height != 0.0) && (CGRectGetMaxY(oldBounds) == oldGridSize.height));

[_gridData gridViewDidChangeBoundsSize: bounds.size];

_flags.numColumns = [_gridData numberOfItemsPerRow];

CGSize newGridSize = [_gridData sizeForEntireGrid];

CGPoint oldMaxLocation = CGPointMake(CGRectGetMaxX(oldBounds), CGRectGetMaxY(oldBounds));

[self updateContentRectWithOldMaxLocation: oldMaxLocation gridSize: newGridSize];

if ( (wasAtBottom) && (!CGPointEqualToPoint(oldBounds.origin, CGPointZero)) && (newGridSize.height > oldGridSize.height) )

{

CGRect contentRect = self.bounds;

if ( CGRectGetMaxY(contentRect) < newGridSize.height )

{

contentRect.origin.y += (newGridSize.height - oldGridSize.height);

self.contentOffset = contentRect.origin;

}

}

[self updateVisibleGridCellsNow];

_flags.allCellsNeedLayout = 1;

}

- (void) setContentOffset:(CGPoint) offset

{

[super setContentOffset: offset];

}

- (void)setContentOffset: (CGPoint) contentOffset animated: (BOOL) animate

{

// Call our super duper method

[super setContentOffset: contentOffset animated: animate];

// for long grids, ensure there are visible cells when scrolled to

if (!animate)

{

[self updateVisibleGridCellsNow];

/*if (![_visibleCells count])

}

}

- (void) setContentSize: (CGSize) newSize

{

if ( (_flags.contentSizeFillsBounds == 1) && (newSize.height < self.bounds.size.height) )

newSize.height = self.bounds.size.height;

if (self.gridFooterView)

{

// In-call status bar influences footer position

CGRect statusRect = [UIApplication sharedApplication].statusBarFrame;

CGFloat statusHeight = MIN(CGRectGetWidth(statusRect), CGRectGetHeight(statusRect)) - 20;

CGFloat footerHeight = CGRectGetHeight(self.gridFooterView.bounds);

CGFloat minimumHeight = statusHeight + CGRectGetHeight(self.bounds) + footerHeight;

if (newSize.height < footerHeight + minimumHeight)

newSize.height = minimumHeight;

}

[super setContentSize: newSize];

if ( CGRectGetMaxY(self.bounds) > newSize.height )

{

CGRect b = self.bounds;

CGFloat diff = CGRectGetMaxY(b) - newSize.height;

b.origin.y = MAX(0.0, b.origin.y - diff);

self.bounds = b;

}

}

- (void) setFrame:(CGRect)frame {

CGRect fromBounds = self.bounds;

[super setFrame:frame];

CGRect toBounds = self.bounds;

if (!CGSizeEqualToSize(fromBounds.size, toBounds.size))

[self handleGridViewBoundsChanged:fromBounds toNewBounds:toBounds];

}

- (void) setBounds:(CGRect)bounds {

CGRect fromBounds = self.bounds;

[super setBounds:bounds];

CGRect toBounds = self.bounds;

if (!CGSizeEqualToSize(fromBounds.size, toBounds.size))

[self handleGridViewBoundsChanged:fromBounds toNewBounds:toBounds];

}

- (BOOL) isEditing

{

return ( _flags.isEditing == 1 );

}

- (void) setEditing: (BOOL) value

{

[self setEditing:value animated:NO];

}

#pragma mark -

#pragma mark Data Management

- (AQGridViewCell *) dequeueReusableCellWithIdentifier: (NSString *) reuseIdentifier

{

NSMutableSet * cells = [_reusableGridCells objectForKey: reuseIdentifier];

AQGridViewCell * cell = [cells anyObject];

if ( cell == nil )

return ( nil );

[cell prepareForReuse];

[cells removeObject: cell];

return ( cell );

}

- (void) enqueueReusableCells: (NSArray *) reusableCells

{

for ( AQGridViewCell * cell in reusableCells )

{

NSMutableSet * reuseSet = [_reusableGridCells objectForKey: cell.reuseIdentifier];

if ( reuseSet == nil )

{

reuseSet = [[NSMutableSet alloc] initWithCapacity: 32];

[_reusableGridCells setObject: reuseSet forKey: cell.reuseIdentifier];

}

else if ( [reuseSet member: cell] == cell )

{

NSLog( @"Warning: tried to add duplicate gridview cell" );

continue;

}

[reuseSet addObject: cell];

}

}

- (CGRect) gridViewVisibleBounds

{

CGRect result = CGRectZero;

result.origin = self.contentOffset;

result.size = self.bounds.size;

return ( result );

}

- (void) reloadData

{

if ( _reloadingSuspendedCount != 0 )

return;

if ( _flags.dataSourceGridCellSize == 1 )

{

[_gridData setDesiredCellSize: [_dataSource portraitGridCellSizeForGridView: self]];

_flags.numColumns = [_gridData numberOfItemsPerRow];

}

_gridData.numberOfItems = [_dataSource numberOfItemsInGridView: self];

// update our content size as appropriate

self.contentSize = [_gridData sizeForEntireGrid];

// fix up the visible index list

NSUInteger cutoff = MAX(0, _gridData.numberOfItems-_visibleIndices.length);

_visibleIndices.location = MIN(_visibleIndices.location, cutoff);

_visibleIndices.length = 0;

// remove all existing cells

[_visibleCells makeObjectsPerformSelector: @selector(removeFromSuperview)];

[self enqueueReusableCells: _visibleCells];

[_visibleCells removeAllObjects];

// -layoutSubviews will update the visible cell list

// layout -- no animation

[self setNeedsLayout];

_flags.allCellsNeedLayout = 1;

}

#define MAX_BOUNCE_DISTANCE (500.0f)

- (void) layoutSubviews

{

if ( (_flags.needsReload == 1) && (_animationCount == 0) && (_reloadingSuspendedCount == 0) )

[self reloadData];

if ( (_reloadingSuspendedCount == 0) && (!CGRectIsEmpty([self gridViewVisibleBounds])) )

{

[self updateVisibleGridCellsNow];

}

if ( _flags.allCellsNeedLayout == 1 )

{

_flags.allCellsNeedLayout = 0;

if ( _visibleIndices.length != 0 )

[self layoutAllCells];

}

CGRect rect = CGRectZero;

rect.size.width = self.bounds.size.width;

rect.size.height = self.contentSize.height - (_gridData.topPadding + _gridData.bottomPadding);

rect.origin.y += _gridData.topPadding;

// Make sure background is an integral number of rows tall. That way, it draws patterned colours correctly on all OSes.

CGRect backgroundRect = rect;

CGFloat minimumHeight = rect.size.height,

actualHeight = 0,

cellHeight = [_gridData cellSize].height;

if (([_gridData numberOfItems] == 0) || ([_gridData numberOfItemsPerRow] == 0)) {

actualHeight = cellHeight;

} else {

actualHeight = cellHeight * ([_gridData numberOfItems] / [_gridData numberOfItemsPerRow]);

}

if (actualHeight < minimumHeight)

actualHeight = fmodf(actualHeight, cellHeight) + cellHeight;

backgroundRect.size.height = MAX(actualHeight, CGRectGetHeight(self.bounds));

if ([self backgroundViewExtendsUp]) {

backgroundRect.origin.y = backgroundRect.origin.y - MAX_BOUNCE_DISTANCE;

backgroundRect.size.height += MAX_BOUNCE_DISTANCE; // don't just move it, grow it

}

if ([self backgroundViewExtendsDown]) {

backgroundRect.size.height = backgroundRect.size.height + MAX_BOUNCE_DISTANCE;

}

self.backgroundView.frame = backgroundRect;

if ( _headerView != nil )

{

rect = _headerView.frame;

rect.origin = CGPointZero;

rect.size.width = self.bounds.size.width;

_headerView.frame = rect;

}

if ( _footerView != nil )

{

rect = _footerView.frame;

rect.origin.x = 0.0;

rect.origin.y = self.contentSize.height - rect.size.height;

rect.size.width = self.bounds.size.width;

_footerView.frame = rect;

[self bringSubviewToFront:_footerView];

}

}

- (CGRect) rectForItemAtIndex: (NSUInteger) index

{

// simple case -- there's a cell already, we can just ask for its frame

if ( NSLocationInRange(index, _visibleIndices) )

return ( [[_visibleCells objectAtIndex: [self visibleCellListIndexForItemIndex: index]] frame] );

// complex case-- compute the frame manually

return ( [self fixCellFrame: CGRectZero forGridRect: [_gridData cellRectAtIndex: index]] );

}

- (AQGridViewCell *) cellForItemAtIndex: (NSUInteger) index

{

//if ( NSLocationInRange(index, _visibleIndices) == NO )

// return ( nil );

// we don't clip to visible range-- when animating edits the visible cell list can contain extra items

NSUInteger visibleCellListIndex = [self visibleCellListIndexForItemIndex: index];

if ( visibleCellListIndex < [_visibleCells count] )

return ( [_visibleCells objectAtIndex: visibleCellListIndex] );

return ( nil );

}

- (NSUInteger) indexForItemAtPoint: (CGPoint) point

{

return ( [_gridData itemIndexForPoint: point] );

}

- (NSUInteger) indexForCell: (AQGridViewCell *) cell

{

NSUInteger index = [_visibleCells indexOfObject:cell];

if (index == NSNotFound)

return NSNotFound;

return _visibleIndices.location + index;

}

- (AQGridViewCell *) cellForItemAtPoint: (CGPoint) point

{

return ( [self cellForItemAtIndex: [_gridData itemIndexForPoint: point]] );

}

- (NSArray *) visibleCells

{

return ( [_visibleCells copy] );

}

- (NSIndexSet *) visibleCellIndices

{

return ( [NSIndexSet indexSetWithIndexesInRange: _visibleIndices] );

}

- (void) scrollToItemAtIndex: (NSUInteger) index atScrollPosition: (AQGridViewScrollPosition) scrollPosition

animated: (BOOL) animated

{

CGRect gridRect = [_gridData cellRectAtIndex: index];

CGRect targetRect = self.bounds;

switch ( scrollPosition )

{

case AQGridViewScrollPositionNone:

default:

targetRect = gridRect; // no special coordinate handling

break;

case AQGridViewScrollPositionTop:

targetRect.origin.y = gridRect.origin.y; // set target y origin to cell's y origin

break;

case AQGridViewScrollPositionMiddle:

targetRect.origin.y = MAX(gridRect.origin.y - (CGFloat)ceilf((targetRect.size.height - gridRect.size.height) * 0.5), 0.0);

break;

case AQGridViewScrollPositionBottom:

targetRect.origin.y = MAX((CGFloat)floorf(gridRect.origin.y - (targetRect.size.height - gridRect.size.height)), 0.0);

break;

}

[self scrollRectToVisible: targetRect animated: animated];

// for long grids, ensure there are visible cells when scrolled to

if (!animated) {

[self updateVisibleGridCellsNow];

/*if (![_visibleCells count]) {

}

}

#pragma mark -

#pragma mark Cell Updates

- (BOOL) isRectVisible: (CGRect) frameRect

{

return ( CGRectIntersectsRect(frameRect, self.bounds) );

}

- (void) fixCellsFromAnimation

{

// the visible cell list might contain hidden cells-- make them visible now

for ( AQGridViewCell * cell in _visibleCells )

{

if ( cell.hiddenForAnimation )

{

cell.hiddenForAnimation = NO;

if ( _flags.delegateWillDisplayCell == 1 )

[self delegateWillDisplayCell: cell atIndex: cell.displayIndex];

cell.hidden = NO;

}

}

// update the visible item list appropriately

NSIndexSet * indices = [_gridData indicesOfCellsInRect: self.bounds];

if ( [indices count] == 0 )

{

_visibleIndices.location = 0;

_visibleIndices.length = 0;

[_visibleCells makeObjectsPerformSelector: @selector(removeFromSuperview)];

[self enqueueReusableCells: _visibleCells];

[_visibleCells removeAllObjects];

// update the content size/offset based on the new grid data

CGPoint oldMaxLocation = CGPointMake(CGRectGetMaxX(self.bounds), CGRectGetMaxY(self.bounds));

[self updateContentRectWithOldMaxLocation: oldMaxLocation gridSize: [_gridData sizeForEntireGrid]];

return;

}

_visibleIndices.location = [indices firstIndex];

_visibleIndices.length = [indices count];

NSMutableArray * newVisibleCells = [[NSMutableArray alloc] initWithCapacity: _visibleIndices.length];

for ( AQGridViewAnimatorItem * item in self.animatingCells )

{

if ( [item.animatingView isKindOfClass: [AQGridViewCell class]] == NO )

{

[item.animatingView removeFromSuperview];

continue;

}

if ( [self isRectVisible: [_gridData cellRectForPoint: item.animatingView.center]] == NO )

{

[item.animatingView removeFromSuperview];

continue;

}

[newVisibleCells addObject: item.animatingView];

}

//NSAssert([newVisibleCells count] == _visibleIndices.length, @"visible cell count after animation doesn't match visible indices");

[newVisibleCells sortUsingSelector: @selector(compareOriginAgainstCell:)];

[_visibleCells removeObjectsInArray: newVisibleCells];

[_visibleCells makeObjectsPerformSelector: @selector(removeFromSuperview)];

[_visibleCells setArray: newVisibleCells];

self.animatingCells = nil;

NSMutableSet * removals = [[NSMutableSet alloc] init];

for ( UIView * view in self.subviews )

{

if ( [view isKindOfClass: [AQGridViewCell class]] == NO )

continue;

if ( [_visibleCells containsObject: view] == NO )

[removals addObject: view];

}

[removals makeObjectsPerformSelector: @selector(removeFromSuperview)];

// update the content size/offset based on the new grid data

CGPoint oldMaxLocation = CGPointMake(CGRectGetMaxX(self.bounds), CGRectGetMaxY(self.bounds));

[self updateContentRectWithOldMaxLocation: oldMaxLocation gridSize: [_gridData sizeForEntireGrid]];

}

- (void) setupUpdateAnimations

{

_reloadingSuspendedCount++;

AQGridViewUpdateInfo * info = [[AQGridViewUpdateInfo alloc] initWithOldGridData: _gridData forGridView: self];

[_updateInfoStack addObject: info];

}

- (void) endUpdateAnimations {

NSAssert([_updateInfoStack count], @"_updateInfoStack should not be empty at this point" );

AQGridViewUpdateInfo *info = [_updateInfoStack lastObject];

if (!info.numberOfUpdates) {

[_updateInfoStack removeObject:info];

_reloadingSuspendedCount--;

return;

}

NSUInteger expectedItemCount = [info numberOfItemsAfterUpdates];

NSUInteger actualItemCount = [_dataSource numberOfItemsInGridView:self];

if (expectedItemCount != actualItemCount) {

NSUInteger numAdded = [[info sortedInsertItems] count];

NSUInteger numDeleted = [[info sortedDeleteItems] count];

[_updateInfoStack removeObject:info];

_reloadingSuspendedCount--;

[NSException raise: NSInternalInconsistencyException format: @"Invalid number of items in AQGridView: Started with %u, added %u, deleted %u. Expected %u items after changes, but got %u", (unsigned)_gridData.numberOfItems, (unsigned)numAdded, (unsigned)numDeleted, (unsigned)expectedItemCount, (unsigned)actualItemCount];

}

[info cleanupUpdateItems];

_animationCount++;

// TBD: Investigate

// NSAssert(_animationCount == 1, @"Stacked animations occurring!!");

[UIView animateWithDuration:0.3 delay:0 options:UIViewAnimationOptionCurveEaseInOut animations:^{

self.animatingCells = [info animateCellUpdatesUsingVisibleContentRect: [self gridViewVisibleBounds]];

_gridData = [info newGridViewData];

NSMutableIndexSet *newIndices = [[NSMutableIndexSet alloc] init];

[_selectedIndices enumerateIndexesUsingBlock: ^(NSUInteger idx, BOOL *stop) {

NSUInteger newIndex = [info newIndexForOldIndex:idx];

if (newIndex != NSNotFound) {

[newIndices addIndex:newIndex];

}

}];

_selectedIndices = newIndices;

_reloadingSuspendedCount--;

} completion:^(BOOL finished) {

// if nothing was animated, we don't have to do anything at all

// if ( self.animatingCells.count != 0 )

[self fixCellsFromAnimation];

// NB: info becomes invalid at this point

[_updateInfoStack removeObject:info];

_animationCount--;

// _reloadingSuspendedCount--;

if (_flags.delegateDidEndUpdateAnimation) {

[self.delegate gridViewDidEndUpdateAnimation:self];

}

}];

}

- (void) beginUpdates

{

if ( _updateCount++ == 0 )

[self setupUpdateAnimations];

}

- (void) endUpdates

{

if ( --_updateCount == 0 )

[self endUpdateAnimations];

}

- (void) _updateItemsAtIndices: (NSIndexSet *) indices updateAction: (AQGridViewUpdateAction) action withAnimation: (AQGridViewItemAnimation) animation

{

BOOL needsAnimationSetup = ([_updateInfoStack count] <= _animationCount);

// not in the middle of an update loop -- start animations here

if ( needsAnimationSetup )

[self setupUpdateAnimations];