Cancel swipe left on tableview cell when showing more buttons in swift

Question

I was wondering if there was a proper way to cancel the swipe left on a tableview cell so that it slides back to hide the buttons. I'm not really sure how to correctly say that, lol. But please see the GIF below. In the first GIF I have no code after the cancel button gets pressed, and the buttons stay visible.

The only idea I had was to reload the cell with this code self.tableView.reloadRowsAtIndexPaths([indexPath], withRowAnimation: UITableViewRowAnimation.Automatic) But this gives a look of the buttons shifting up, whereas I'd prefer it to appear the cell shifts backing into place to the right. See the reload GIF below.

How should I be doing this properly? See below for my code that adds the buttons and what their functions are.

override func tableView(tableView: UITableView, editActionsForRowAtIndexPath indexPath: NSIndexPath) -> [UITableViewRowAction]? {

    let edit = UITableViewRowAction(style: UITableViewRowActionStyle.Normal, title: "Edit") {
        (action, indexPath) in

        if (indexPath == self.indexSelect) {
            print("Editting Selected Cell")
        } else {
            print("Editting a difference cell than selected")
        }

        let section: Sections = self.frc.objectAtIndexPath(indexPath) as! Sections
        let count: Int = self.sectionCount(section.section!)
        var msg: String?
        let sectionName: String = section.section!

        if (count > 0) {
            msg = "There are \(count) other Items using this Section currently. Editing the Section name \"\(sectionName)\" will affect them all. \n\nThis will be changed immediately!"
        }

        let alert = UIAlertController(title: "Edit Section Name", message: msg, preferredStyle: UIAlertControllerStyle.Alert)
        let editAction = UIAlertAction(title: "Edit", style: UIAlertActionStyle.Destructive) {
            UIAlertAction in

            let sectionName = Util.trimSpaces(alert.textFields![0].text!)

            if (sectionName != section.section) {
                if (Util.checkSectionName(sectionName, moc: self.moc!) == false) {
                    let entityDesc = NSEntityDescription.entityForName("Sections", inManagedObjectContext: self.moc!)
                    let newSection: Sections = Sections(entity: entityDesc!, insertIntoManagedObjectContext: self.moc)
                    newSection.section = sectionName

                    do {
                        try self.moc!.save()
                    } catch {
                        fatalError("New item save failed")
                    }

                    let oldSection: Sections = section

                    let fetchReq = NSFetchRequest(entityName: "Catalog")
                    let pred = NSPredicate(format: "sections.section == %@", oldSection.section!)
                    fetchReq.predicate = pred

                    do {
                        let results = try self.moc!.executeFetchRequest(fetchReq)
                        for rec in results {
                            let catalog: Catalog = rec as! Catalog
                            catalog.sections = newSection
                        }

                        do {
                            try self.moc!.save()
                        } catch {
                            fatalError("Failed to Save after Delete")
                        }
                    } catch {
                        fatalError("Fetching Items to delete section failed")
                    }

                    self.moc!.deleteObject(oldSection)

                    do {
                        try self.moc!.save()
                    } catch {
                        fatalError("Failed to Save after Delete")
                    }
                } else {
                    Util.msgAlert("Duplicate Section Name", msg: "\"\(sectionName)\" section name already exists.", curVC: self)
                    self.tableView.reloadRowsAtIndexPaths([indexPath], withRowAnimation: UITableViewRowAnimation.Automatic)
                }
            } else {
                self.tableView.reloadRowsAtIndexPaths([indexPath], withRowAnimation: UITableViewRowAnimation.Automatic)
            }
        }
        let cancel = UIAlertAction(title: "Cancel", style: UIAlertActionStyle.Cancel) {
            UIAlertAction in

            //self.tableView.reloadRowsAtIndexPaths([indexPath], withRowAnimation: UITableViewRowAnimation.Automatic)
        }

        alert.addAction(editAction)
        alert.addAction(cancel)
        alert.addTextFieldWithConfigurationHandler {
            (txtFld) -> Void in

            txtFld.text = section.section
            txtFld.autocapitalizationType = UITextAutocapitalizationType.Words
            txtFld.autocorrectionType = UITextAutocorrectionType.Default
            txtFld.clearButtonMode = UITextFieldViewMode.WhileEditing
        }

        self.presentViewController(alert, animated: true, completion: nil)
    }

    edit.backgroundColor = UIColor.init(red: 84/255, green: 200/255, blue: 214/255, alpha: 1)

    let delete = UITableViewRowAction(style: .Destructive, title: "Delete") {
        (action, indexPath) in

        let section: Sections = self.frc.objectAtIndexPath(indexPath) as! Sections
        let count: Int = self.sectionCount(section.section!)

        if (count > 0) {
            let alert = UIAlertController(title: "Confirm Delete", message: "There are \(count) Items using this Section currently. Deleting this Section will reset them all to blank. \n\nThis can't be undone and will take affect immediately!", preferredStyle: UIAlertControllerStyle.Alert)
            let cancel = UIAlertAction(title: "Cancel", style: UIAlertActionStyle.Cancel) { UIAlertAction in }
            let deleteAction = UIAlertAction(title: "Delete", style: UIAlertActionStyle.Destructive) { UIAlertAction in
                var blankSection: Sections?

                var fetchReq = NSFetchRequest(entityName: "Sections")
                var pred = NSPredicate(format: "section == %@", "")
                fetchReq.predicate = pred

                do {
                    let results = try self.moc!.executeFetchRequest(fetchReq)
                    blankSection = (results.first as! Sections)
                } catch {
                    fatalError("Fetching blank section failed")
                }

                fetchReq = NSFetchRequest(entityName: "Catalog")
                pred = NSPredicate(format: "sections.section == %@", section.section!)
                fetchReq.predicate = pred

                do {
                    let group = try self.moc!.executeFetchRequest(fetchReq)
                    for rec in group {
                        let catalog: Catalog = rec as! Catalog
                        catalog.sections = blankSection
                    }

                } catch {
                    fatalError("Fetching Items to delete section failed")
                }

                self.moc!.deleteObject(section)

                do {
                    try self.moc!.save()
                } catch {
                    fatalError("Failed to Save after Delete")
                }

                if (self.sectionUpdateProtocol != nil) {
                    self.sectionUpdateProtocol!.sectionUpdate(self, section: blankSection!)
                }

                //self.navigationController!.popViewControllerAnimated(true)
            }

            alert.addAction(deleteAction)
            alert.addAction(cancel)

            self.presentViewController(alert, animated: true, completion: nil)
        } else {
            self.moc!.deleteObject(section)

            do {
                try self.moc!.save()
            } catch {
                fatalError("Failed to Save after Delete")
            }
        }

    }

    return [delete, edit]
}

Answer 1

Just call:

tableView.setEditing(false, animated: true)