Question

I have a view based NSTableView that I sometimes filter using NSPredicate. Is there any way to animate the items being removed/added/reordered throughout the tableview to have the same effect as beginUpdates, endUpdates and insertRowsAtIndexes:withAnimation, etc?

I’ve explored ways such as manually filtering out my array but my attempts proved to be futile so now I am wondering if there is a better (or built in way) to do this. I have wondered if NSArrayController does this automatically but I don’t think it does.

Answer 1

I’ve written code to do this myself – given ‘before’ and ‘after’ arrays, compute the required parameters to insertRowsAtIndexPaths:, deleteRowsAtIndexPaths:, etc. The code is a bit fiddly so probably has bugs – use at your discretion!

@interface NSArray (ArrayDifference)
  - (void) computeDifferenceTo:(NSArray *)newArray returningAdded:(NSMutableArray **)rowsAdded andDeleted:(NSMutableArray **)rowsDeleted;
@end

@implementation NSArray (ArrayDifference)

// Given two arrays that are expected have items added or removed but not re-ordered, compute the differences
// in a way usable for UITable insertRows and deleteRows
- (void) computeDifferenceTo:(NSArray *)newArray returningAdded:(NSMutableArray **)rowsAdded andDeleted:(NSMutableArray **)rowsDeleted
{
  NSArray *oldArray = self;
  *rowsAdded = [[[NSMutableArray alloc] init] autorelease];
  *rowsDeleted = [[[NSMutableArray alloc] init] autorelease];

  NSUInteger oldCount = [oldArray count];
  NSUInteger newCount = [newArray count];
  // Step through the two arrays
  NSInteger oldIndex = 0, newIndex=0;
  for (; newIndex < newCount && oldIndex < oldCount; )
  {
    id newItem = [newArray objectAtIndex:newIndex];
    id oldItem = [oldArray objectAtIndex:oldIndex];
    // If the two objects match, we step forward on both sides
    if (newItem == oldItem) {
        ++newIndex;
        ++oldIndex;
    }
    else {
        // Look for the old item to appear later in the new array, which would mean we have to add the rows in between
        NSRange range = { newIndex+1, newCount - newIndex-1 };
        NSUInteger foundIndex = [newArray indexOfObject:oldItem inRange:range];
        if (foundIndex != NSNotFound)
            for (; newIndex < foundIndex; ++newIndex)
                [*rowsAdded addObject:[NSIndexPath indexPathForRow:newIndex inSection:0]];
        else {
            // Look for the new item to appear later in the old array, which would mean we have to remove the rows in between
            NSRange range = { oldIndex+1, oldCount - oldIndex-1 };
            NSUInteger foundIndex = [oldArray indexOfObject:newItem inRange:range];
            if (foundIndex != NSNotFound)
                for (; oldIndex < foundIndex; ++oldIndex)
                    [*rowsDeleted addObject:[NSIndexPath indexPathForRow:oldIndex inSection:0]];
            else {
                // Old item must be removed and new item added, then we carry on
                [*rowsAdded addObject:[NSIndexPath indexPathForRow:newIndex++ inSection:0]];
                [*rowsDeleted addObject:[NSIndexPath indexPathForRow:oldIndex++ inSection:0]];
            }
        }
    }
  }
  // Once the loop is finished, add in what's left in the new array and remove what is left in the old array
  for (; newIndex < newCount; ++newIndex)
    [*rowsAdded addObject:[NSIndexPath indexPathForRow:newIndex inSection:0]];
  for (; oldIndex < oldCount; ++oldIndex)
    [*rowsDeleted addObject:[NSIndexPath indexPathForRow:oldIndex inSection:0]];
}

@end

Then you call it like this:

    NSMutableArray *rowsAdded=nil, *rowsDeleted=nil;
    [myArray computeDifferenceTo:newArray returningAdded:&rowsAdded andDeleted:&rowsDeleted];
    [myTableView beginUpdates];
    [myTableView insertRowsAtIndexPaths:rowsAdded withRowAnimation:UITableViewRowAnimationBottom];
    [myTableView deleteRowsAtIndexPaths:rowsDeleted withRowAnimation:UITableViewRowAnimationFade];
    [myTableView endUpdates];