How to differentiate between instances of the same view in prototyped UITableViewCells

Question

I'm using a UITableViewCell prototype that contains a UIPickerView and use that prototype for 4 different cells with 4 different PickerView in the tableView. I use the following code to supply the cell to tableView (tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) and to set each picker to a different instance variable in order to differentiate between the pickers later (since the same UITableViewController instance is the delegate/datasource for all of them, for example).

However, when running the code, all 4 instance variables end up pointing to the same UIPickerView. How can I ensure that it uses 4 distinct UIPickerViews instead?

func PickerCell(tableView: UITableView, indexPath: NSIndexPath, inout picker: UIPickerView?) -> UITableViewCell {
    let cell = tableView.dequeueReusableCellWithIdentifier("PickerCell")
    if let pickerFromCell = cell?.contentView.viewWithTag(1) as? UIPickerView {
        pickerFromCell.reloadAllComponents()
        pickerFromCell.dataSource = self
        pickerFromCell.delegate = self
        picker = pickerFromCell
    }
    return cell!
}

Answer 1

I agree with Nirav, that you should use the cell to determine the NSIndexPath of the cell in question.

Personally, I'd make the cell subclass the data source and delegate of the picker and have it take responsibility for the picker. This completely eliminates any confusion about what picker is associated with which cell. But I'd have a protocol by which the cell can inform the view controller when the user selected a value from the picker and the view controller can update the model.

For example, consider this UITableViewCell subclass:

//  CustomCell.swift

import UIKit

/// Protocol that the view controller will conform to in order to receive updates
/// from the cell regarding which row in the picker was picked.
///
/// - note: This is a `class` protocol so that I can use `weak` reference.

protocol CustomCellDelegate: class {
    func cell(customCell: CustomCell, pickerView: UIPickerView, didSelectRow row: Int, inComponent component: Int)
}

/// Custom cell subclass, which is the picker's data source and delegate

class CustomCell: UITableViewCell, UIPickerViewDataSource, UIPickerViewDelegate {

    /// The delegate who we will inform of any picker changes.
    ///
    /// This is weak to avoid strong reference cycle.

    weak var delegate: CustomCellDelegate?

    /// The array of values to be shown in the picker.
    ///
    /// If the `values` changes, this reloads the picker view.

    var values: [String]? {
        didSet {
            pickerView.reloadComponent(0)
        }
    }

    /// The outlet to the picker in the cell.

    @IBOutlet weak var pickerView: UIPickerView!

    // MARK: UIPickerViewDataSource

    func numberOfComponentsInPickerView(pickerView: UIPickerView) -> Int {
        return 1
    }

    func pickerView(pickerView: UIPickerView, numberOfRowsInComponent component: Int) -> Int {
        return values?.count ?? 0
    }

    // MARK: UIPickerViewDelegate

    func pickerView(pickerView: UIPickerView, titleForRow row: Int, forComponent component: Int) -> String? {
        return values?[row] ?? ""
    }

    func pickerView(pickerView: UIPickerView, didSelectRow row: Int, inComponent component: Int) {
        delegate?.cell(self, pickerView: pickerView, didSelectRow: row, inComponent: component)
    }
}

And then the view controller:

//  ViewController.swift

import UIKit

class ViewController: UITableViewController, CustomCellDelegate {

    // an array of arrays of acceptable values

    let troupes = [
        ["Mo", "Larry", "Curly"],
        ["Abbott", "Costello"],
        ["Groucho", "Harpo", "Zeppo", "Chico", "Gummo"],
        ["Laurel", "Hardy"],
        ["Graham Chapman", "John Cleese", "Terry Gilliam", "Eric Idle", "Terry Jones", "Michael Palin"]
    ]

    /// An array that indicates which is item is selected for each table view cell

    var selectedItemForRow: [Int]!

    override func viewDidLoad() {
        super.viewDidLoad()

        selectedItemForRow = troupes.map { _ in return 0 }    // initialize the `selectedItemForRow` array with zeros

        // Whatever further initialization of the view controller goes here.
    }

    // MARK: UITableViewDataSource

    override func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return troupes.count
    }

    // Populate cell, setting delegate, list of acceptable values, and currently selected value.

    override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCellWithIdentifier("CustomCell", forIndexPath: indexPath) as! CustomCell
        cell.delegate = self
        cell.values = troupes[indexPath.row]
        cell.pickerView.selectRow(selectedItemForRow[indexPath.row], inComponent: 0, animated: false)
        return cell
    }

    // MARK: CustomCellDelegate

    // When the cell tells us that the user changed the selected row, let's update our model accordingly.

    func cell(customCell: CustomCell, pickerView: UIPickerView, didSelectRow row: Int, inComponent component: Int) {
        if let indexPath = tableView.indexPathForCell(customCell) {
            selectedItemForRow[indexPath.row] = row
        }
    }

}

Answer 2

Instead of using tag try something like this. Change your didSelectRow of PickerViewDelegate like this

func pickerView(pickerView: UIPickerView, didSelectRow row: Int, inComponent component: Int) {
    let cell = imageView.superview?.superview as! UITableViewCell //You have to use as may super as your UITableViewCell hierarchy 
    let indexPath = self.tabelView.indexPathForCell(cell)
    self.pickerSelectedIndexArr[indexpath.row] = row
}

Also add pickerSelectedIndexArr array in your file and assign it in viewDidLoad like following way

var pickerSelectedIndexArr: [Int] = [Int]()

override func viewDidLoad() {
    super.viewDidLoad()
    self.pickerSelectedIndexArr = [0, 0, 0 ,0]
}

Now you can easily get all the picker selected value any time you want
Hope this will help you.

Answer 3

As this question is tagged with Objective C, I am giving your answer in OBJC.

Here is what you can do, to deal with controls in reusable cell,

Tip for solving such problem, when you have controls in UICollectionViewCell or UITableViewCell, give tag to your controls depending upon your indexPath.

Giving example with collectionViewCell you can do it with tableViewCell case 1 : If CollectionView is sectional, then your tags will be like [0][0], [1][0] ... In such case do something like this,

collectionViewCell.picker.tag = [[NSString stringWithFormat:@"%ld%ld",(long)indexPath.section,(long)indexPath.item] intValue]; // If it is sectional collection view

case 2 : If Collection View is non-sectional,do something like this,

collectionViewCell.picker.tag = [[NSString stringWithFormat:@"%ld",(long)indexPath.item] intValue]; // If it is non-sectional collection view

Hope this will solve your problem or give you idea to manage accordingly. If you have more than one control in your cell then just give tags like indexPath.item + 1 + 2 ...

Answer 4

var dict: [Int, UIPickerView]

...

if dict[indexPath.row] == nil {
    // Create UIPickerView and assign it to dict[indexPath.row].
}