Swift: How can I bind an NSIndexPath to a addTarget - ios

Question

I have a UISwitch in each of my dynamically created rows of which I want to bind an NSIndexPath to an addTarget selector.
I had considered allowing the user to tap the row to toggle the switch, but from a UX perspective it makes more sense to have the switch handle this method, therefore using didSelectRowAtIndexPath is not an appropriate solution.
When my cell is created I currently bind a selector like this:
// Create listener for each switch
prefCell.subscribed?.addTarget(self,
action: "switchFlipped:",
forControlEvents: UIControlEvents.ValueChanged)
Which calls the corresponding method:
func switchFlipped(flipSwitch: UISwitch, indexPath: NSIndexPath) {}
Obviously this throws an error because NSIndexPath isn't a valid reference, as I believe it will only send the buttons reference. Is there any way I can bind the index path? If not, is there any way to get the current cell from the context of the UISwitch?

Answer 1

The target-action pattern does not allow arbitrary selectors. You can have f(sender:) and f(sender:event:). Both won't help you. But you can use code to figure out the indexPath in the function.
Code should be self explanatory:
func switchFlipped(flipSwitch: UISwitch) {
let switchOriginInTableView = flipSwitch.convertPoint(CGPointZero, toView: tableView)
if let indexPath = tableView.indexPathForRowAtPoint(switchOriginInTableView) {
println("flipped switched at \(indexPath)")
}
else {
// this should not happen
}
}

Answer 2

This should be the a good solution, not depending on a point. You call the superviews of the Switch and therefore calculate the index path of the cell.
func switchTapped(sender: UISwitch) -> NSIndexPath {
let cell = sender.superview!.superview! as UITableViewCell
return tableView.indexPathForCell(cell)!
}
This reliably works, that's why you can simply unwrap any optionals.

Answer 3

You can try 3 approaches, as you see fit.
Create a custom UISwitch class and add an NSIndexPath property to it. When you receive notification, type cast to your custom class and access the NSIndexPath.
Create a custom UITableViewCell class and save NSIndexPath to it. When you get notified of UISwitch, get its superviews and see which one is your customUITableViewCell instance and get the property.
If you only have one section, it means all you need to worry about are rows. Set the UISwitch tag as the row number and access it when switch is flipped.
The Most Tech-Savy Solution Use Extensions of Swift.
Extensions add new functionality to an existing class, structure, or enumeration type. This includes the ability to extend types for which you do not have access to the original source code
Apple Docs

Answer 4

Use delegation.
Your switch's target action should be a method in your custom UITableViewCell. That custom tableviewcell should declare a protocol and the tableview should be it's delegate. Then your tableviewcell should call its delegate method from within the switch's target function.
The delegate method for your tableviewcell should have a parameter in which the cell passes self. Then in your tableviewcontroller delegate implementation you can use indexPathForCell:
UPDATE:
Here is the apple doc for swift protocols and delegates:
https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Protocols.html
Simply put, you need to define a protocol
protocol CustomUITableViewCellDelegate {
func tableViewCellSubscribed(cell: myCustomUITableViewCell) -> Void
}
then you make your tableviewcontroller class conform to that protocol like this:
class myTableViewController: UITableViewController, CustomUITableViewCellDelegate {
func tableViewCellSubscribed(cell: myCustomUITableViewCell) -> Void {
//this is where you handle whatever operations you want to do regarding the switch being valuechanged
}
// class definition goes here
}
Then your custom UITableViewCell class should have a delegate property like this:
class myCustomUITableViewCell : UITableViewCell {
var delegate : CustomUITableViewCellDelegate?
//class definition goes here
}
Finally, set the cell's delegate in tableView:cellForRowAtIndexPath: and you're good to go. You just need to call your tableViewCellSubscribed: delegate function from within the target method of your switch action.

Answer 5

I've used this approach in many projects, you can just add a callback to your custom cell, each time your switch changes, you can run this callback and catch it inside your table datasource implementation, below a dirt and simple example.
1. Create a UITableViewCell custom class
// An example of custom UITableViewCell class
class CustomCell:UITableViewCell {
required init(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
var onSwitchChange:() -> Void?
}
class TableDataSource:UITableViewDataSource {
func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return 0
}
func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
let cell:CustomCell = tableView.dequeueReusableCellWithIdentifier("CustomCell") as CustomCell
cell.onSwitchChange = {
NSLog("Table: \(tableView) Cell:\(cell) Index Path: \(indexPath)")
}
}
}

Answer 6

Acctually,Apple has already provide API to get the indexPath.
Simply like this (in Objective-C)
NSIndexPath *indexPath = [self.tableView indexPathForSelectedRow];

Answer 7

Far easier, you can use the tag variable for this :
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
...
cell.mySwitch.tag = indexPath.item
cell.mySwitch.addTarget(self, action: #selector(switchChanged), for: UIControlEvents.valueChanged)
...
}
func switchChanged(mySwitch: UISwitch) {
let indexPathItem = mySwitch.tag
...
}
From official doc :
var tag: Int { get set }
An integer that you can use to identify view objects in your
application.
The default value is 0. You can set the value of this tag
and use that value to identify the view later.