Question

I have a multi-section tableview. In edit mode I allow rows to be moved from one section to another. Once the final row is removed from one section I delete that section. So I am using deleteSection inside moveRowAtIndexPath.

When the final item is moved from the section, the section header disappears as planned. But there is a very strange animation bug, where the moved row seems to ‘merge’ with the row it is dropped above, and an empty row is displayed at the bottom of the ‘to’ section (probably because the numberOfRows for that section is correct, but 2 rows are in the same position). Even stranger, when I click the reorder control for this row (not moving the item, simply touching and releasing), the two items ‘unmerge’.

I have posted a video demonstrating this.

I have tried wrapping my data changes and view changes in begin/end updates, but to no avail.

I have uploaded a test project here, and I will also post the code below. A couple of points:

• I have tried to replicate my data source’s format in the demo project, in case this is where the problem originates. The key thing is that my source is a composite array of two other arrays (though I can’t see why this would be an issue).
• To see the behavior in question, move the two rows in the bottom section, up into the top section. Don’t drop them in the last row on the top section though, since this seems to work ok.
• Moving rows the other way, from the top section to the bottom section, is buggy in this demo project.

Code (all of this is in the demo project):

I set up my arrays in loadView:

- (void)loadView{
array1 = [NSMutableArray array];
[array1 addObject:@"test 0"];
[array1 addObject:@"test 1"];
[array1 addObject:@"test 2"];

    array2 = [NSMutableArray array];
    [array2 addObject:@"test a"];
    [array2 addObject:@"test b"];

    [super loadView];
}

I also have a method that returns a combination of these arrays – this is used as the data source:

- (NSMutableArray *)sourceArray{
NSMutableArray *result = [NSMutableArray array];
if (array1.count > 0) {
    [result addObject:array1];
}
if (array2.count >0) {
    [result addObject:array2];
    }
    return result;
}

Which allows for very simple number of rows/sections:

   - (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView
{
    // Return the number of sections.
    return self.sourceArray.count;
}

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
    // Return the number of rows in the section.
    return [[self.sourceArray objectAtIndex:section] count];
}

Standard Cell/Header formatting:

  - (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    static NSString *CellIdentifier = @"Cell";
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
    cell.textLabel.text = [[self.sourceArray objectAtIndex:indexPath.section] objectAtIndex:indexPath.row];
    return cell;
}
- (NSString *)tableView:(UITableView *)tableView titleForHeaderInSection:(NSInteger)section {
    return [NSString stringWithFormat:@"Section %i", section];
}

This is where I do the magic

    // Override to support rearranging the table view.
- (void)tableView:(UITableView *)tableView moveRowAtIndexPath:(NSIndexPath *)fromIndexPath toIndexPath:(NSIndexPath *)toIndexPath
{
    NSMutableArray *fromArray = [self.sourceArray objectAtIndex:fromIndexPath.section]; 
    NSMutableArray *toArray = [self.sourceArray objectAtIndex:toIndexPath.section];

    NSString *movedObject = [[self.sourceArray objectAtIndex:fromIndexPath.section] objectAtIndex:fromIndexPath.row];

    [fromArray removeObject:movedObject];
    [toArray insertObject:movedObject atIndex:toIndexPath.row];

        if ([self.tableView numberOfRowsInSection: fromIndexPath.section] == 0) {
            [self.tableView deleteSections:[NSIndexSet indexSetWithIndex:fromIndexPath.section] withRowAnimation:UITableViewRowAnimationFade];
        }
    }

Answer 1

I notice that the row that comes from the to-be-deleted section is the one that disappears until you retouch the order control.

I suspect that when this datasource method is called by the tableview, its state is still in the middle of performing the move, so calling ‘deleteSections’ will make the table try and delete the row you’re moving. It’s not so much of a merge as the fact that it’s fading away at the same rate as the section header, and the one below it is just scooting back up to fill the space.

Tapping the control causes the table view to rejigger itself and realize that the row isn’t actually gone.

to try and work around this, try running the deletion in the next runloop, via a dispatch call, like:

if ([self.tableView numberOfRowsInSection: fromIndexPath.section] == 0) {
    dispatch_async(dispatch_get_main_queue(), ^() {
        [self.tableView deleteSections:[NSIndexSet indexSetWithIndex:fromIndexPath.section] withRowAnimation:UITableViewRowAnimationFade];
    });
}

this will cause the deletion to run on the main thread still, but allow the ‘moveRow’ and whatever call stack it happens to be in finish up its logic before the deletion call