Scroll UITableView to certain indexPath depending on selection - ios

Question

I have a UITableView with a custom cell. The custom cell as three buttons covering the entire span of the cell. I am trying to scroll the tableview automatically depending on which label the user selects.
I tried using NotificationCenter but it crashes when trying to scroll. Is there a more elegant solution?
Edit: My end goal is to have the user click on optionOne and have it scroll to the cell immediately below. The trick is doing this without cellForRowAt because I'm handling it in the cell due to the multiple buttons.
Custom Cell:
#IBOutlet weak var optionOneLabel: UILabel!
#IBOutlet weak var optionTwoLabel: UILabel!
#IBOutlet weak var optionThreeLabel: UILabel!
override func prepareForReuse() {
super.prepareForReuse()
let optionOne = UITapGestureRecognizer(target: self, action: #selector(CustomCell.optionOnePressed(_:)))
optionOneLabel.addGestureRecognizer(optionOne)
let optionTwo = UITapGestureRecognizer(target: self, action: #selector(CustomCell.optionTwoPressed(_:)))
optionTwoLabel.addGestureRecognizer(optionTwo)
let optionThree = UITapGestureRecognizer(target: self, action: #selector(CustomCell.optionThreePressed(_:)))
optionThreeLabel.addGestureRecognizer(optionThree)
}
#objc func optionOnePressed(_ sender: UITapGestureRecognizer) {
NotificationCenter.default.post(name: NSNotification.Name(rawValue: "scrollTableOptionOne"), object: nil)
}
#objc func optionTwoPressed(_ sender: UITapGestureRecognizer) {
NotificationCenter.default.post(name: NSNotification.Name(rawValue: "scrollTableOptionTwo"), object: nil)
}
#objc func optionThreePressed(_ sender: UITapGestureRecognizer) {
NotificationCenter.default.post(name: NSNotification.Name(rawValue: "scrollTableOptionthree"), object: nil)
}
TableViewController
override func viewDidLoad() {
super.viewDidLoad()
NotificationCenter.default.addObserver(self, selector: #selector(optionOne), name: NSNotification.Name(rawValue: "scrollTableOptionOne"), object: nil)
NotificationCenter.default.addObserver(self, selector: #selector(optionTwo), name: NSNotification.Name(rawValue: "scrollTableOptionTwo"), object: nil)
NotificationCenter.default.addObserver(self, selector: #selector(optionThree), name: NSNotification.Name(rawValue: "scrollTableOptionThree"), object: nil)
}
#objc func optionOne() {
let indexPath = NSIndexPath(item: posts.count, section: 0)
tableView.scrollToRow(at: indexPath as IndexPath, at: UITableViewScrollPosition.init(rawValue: indexPath.row + 2)!, animated: true)
}
#objc func optionTwo() {
print("Don't scroll this one for now")
}
#objc func optionThree() {
print("Don't scroll this one for now")
}
Let me know if you need more information. Thanks.

Answer 1

Rather than use notifications, you could set up a callback on the cell with the buttons so that when one of them is tapped, the callback is run with the information about which button was tapped so that the view controller can do what it needs to with it:
As an example of what you want to do I've created a sample project which you can download and look at (Xcode 9.4.1, Swift 4.1) It's a bit messy, but it does what you need: https://bitbucket.org/abizern/so51758928/src/master/
The specifics are, firstly, set up the cell with the buttons to handle the callback:
class SelectionCell: UITableViewCell {
enum Button {
case first
case second
case third
}
var callback: ((Button) -> Void)?
#IBAction func firstButtonSelected(_ sender: UIButton) {
callback?(.first)
}
#IBAction func secondButtonSelected(_ sender: UIButton) {
callback?(.second)
}
#IBAction func thirdButtonSelected(_ sender: UIButton) {
callback?(.third)
}
}
Using an enum for the buttons makes the code cleaner than just raw numbers to identify a button. Each button calls the callback identifying itself.
In the table view controller, when you set up the cells in the delegate, you pass this callback to the cell:
override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let value = values[indexPath.row]
switch value {
case .header:
let cell = tableView.dequeueReusableCell(withIdentifier: "Selection", for: indexPath) as! SelectionCell
cell.callback = handler
return cell
case .value:
let cell = tableView.dequeueReusableCell(withIdentifier: "Display", for: indexPath) as! DisplayCell
cell.configure(with: value)
return cell
}
}
Note, I've passed handler not handler() so that it passed the closure, not the result of running the closure, to the cell. It's the cell that runs the closure.
The callback looks like this (for my example, your needs will be different)
I'm using the button identifier that is passed in to the closure to identify the IndexPath that I'm interested in and scrolling it to the top
private func handler(button: SelectionCell.Button) -> Void {
print("selected \(button)")
let index: Int?
switch button {
case .first:
index = values.index(where: { (value) -> Bool in
if case .value("First") = value {
return true
}
return false
})
case .second:
index = values.index(where: { (value) -> Bool in
if case .value("Second") = value {
return true
}
return false
})
case .third:
index = values.index(where: { (value) -> Bool in
if case .value("Third") = value {
return true
}
return false
})
}
guard let row = index else { return }
let indexPath = IndexPath(row: row, section: 0)
tableView.scrollToRow(at: indexPath, at: .top, animated: true)
}
As I've already said, you can look at the example project to see how this all works, but these are the important steps.

Answer 2

Use the cell that sends the notification as the sender object instead of nil. In your cell do:
NotificationCenter.default.post(
name: NSNotification.Name(rawValue: "scrollTableOptionOne"),
object: self)
Change your notification handler so that it can access to the notification. Retrieve the cell from the notification and find out the indexPath.
#objc func optionOne(ntf: Notification) {
let cell = ntf.object as! UITableViewCell
if let indexPath = tableView.indexPath(for: cell) {
tableView.scrollToRow(at: indexPath,
at: .bottom, animated: true)
}
}

Answer 3

I think this is the reason for crashing.
For performance reasons, you should only reset attributes of the cell
that are not related to content, for example, alpha, editing, and
selection state. The table view's delegate in
tableView(_:cellForRowAt:) should always reset all content when
reusing a cell
Refer this
You can make use of Closures or Delegate instead of going with notification

Answer 4

I think you need to change code like this
let indexPath = IndexPath(row: posts.count - 1, section: 0)
tableView.scrollToRow(at: indexPath, at: .top, animated: true)
This will scroll your row to top in table view.

Answer 5

ScrollToRow method having some problem. UITableViewScrollPosition holds the values - none, top, middle, bottom enum values.
Change the line:
tableView.scrollToRow(at: indexPath as IndexPath, at: UITableViewScrollPosition.init(rawValue: indexPath.row + 2)!, animated: true)
To:
tableView.scrollToRow(at: indexPath as IndexPath, at: .top, animated: true)
In order to track indexpath, set row value to cell's tag, in cellForRow:
cell.tag = indexPath.row
And post notification as:
NotificationCenter.default.post(name: NSNotification.Name(rawValue: "scrollTableOptionOne"), object: self.tag)
#objc func optionOne(_ notification: Notification) {
let indexPath = NSIndexPath(item: notification.object+1, section: 0)
tableView.scrollToRow(at: indexPath as IndexPath, at: UITableViewScrollPosition.init(rawValue: indexPath.row + 2)!, animated: true)
}

Answer 6

Better approach will be using closures:
#IBOutlet weak var optionOneLabel: UILabel!
#IBOutlet weak var optionTwoLabel: UILabel!
#IBOutlet weak var optionThreeLabel: UILabel!
var callBackOnLabel : (()->())? /// Add this in cell.
override func awakeFromNib() {
super.awakeFromNib()
// Initialization code
let optionOne = UITapGestureRecognizer(target: self, action: #selector(CustomCell.optionOnePressed(_:)))
optionOneLabel.addGestureRecognizer(optionOne)
}
#objc func optionOnePressed(_ sender: UITapGestureRecognizer) {
self.callBackOnLabel?()
}
Then in your cellForRowAt:
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
cell.callBackOnLabel = {
let selectedIndex = IndexPath(row: posts.count, section: 0)
tableView.scrollToRow(at: selectedIndex, at: .middle, animated: true)
}
}
In the same way you can add for other two labels or you can make it generic to accept the response in single call back and perform the animation.