Swift 3 - Conditional expanded table view cell height - ios

Question

I am using Swift 3. I have expandable table view cells but is it possible to get a different row height depending on which cell was clicked? For example, if the first cell is clicked, I want it to return 420 for height and if other cells are clicked, I want it to return 300 for height.
Here is my cell class.
class ResultsCell: UITableViewCell {
#IBOutlet weak var introPara : UITextView!
#IBOutlet weak var section_heading : UILabel!
class var expandedHeight : CGFloat = { get { return 420.0 } }
class var defaultHeight : CGFloat { get { return 44.0 } }
var frameAdded = false
required init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
}
override func awakeFromNib() {
super.awakeFromNib()
section_heading.translatesAutoresizingMaskIntoConstraints = false
}
func checkHeight() {
introPara.isHidden = (frame.size.height < ResultsCell.expandedHeight)
}
func watchFrameChanges() {
if(!frameAdded) {
addObserver(self, forKeyPath: "frame", options: .new, context: nil)
checkHeight()
}
}
func ignoreFrameChanges() {
if(frameAdded){
removeObserver(self, forKeyPath: "frame")
}
}
deinit {
print("deinit called");
ignoreFrameChanges()
}
// when our frame changes, check if the frame height is appropriate and make it smaller or bigger depending
override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
if keyPath == "frame" {
checkHeight()
}
}
}
What I have tried is something like this.
var _expandedHeight : CGFloat = 420.0
class var expandedHeight : CGFloat { get { return _expandedHeight } set (newHeight) { _expandedHeight = newHeight } }
var isRow0 = false
override func awakeFromNib() {
super.awakeFromNib()
section_heading.translatesAutoresizingMaskIntoConstraints = false
if isRow0 {
ResultsCell.expandedHeight = 300.0
}
else {
ResultsCell.expandedHeight = 420.0
}
}
And then in the TableViewController...
// return the actual view for the cell
override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let resultcell = tableView.dequeueReusableCell(withIdentifier: "resultCellTemplate", for: indexPath) as! ResultsCell
if indexPath.row == 0 {
resultcell.isRow0 = true
} else {
resultcell.isRow0 = false
}
return resultcell
}
But I'm getting errors on the getter/setter line: instance member _expandedHeight cannot be used on type ResultsCell
How can I achieve the behavior that I want?

Answer 1

Use tableview update methods to reevaluate each cell's height
self.tableView.beginUpdates()
self.tableView.endUpdates()
Changes to the tableview cells' heights will automatically be calculated with heightForRowAtIndexPath
try setting your height w.r.t indexpath
make user you mention the heightForRowAtIndexPath to calculate the right height.

Answer 2

You should do this in the delegate of your TableView.
Your TableView has a delegate private instance variable, whose value should implement protocol UITableViewDelegate. This protocol contains many functions which the UITableView calls in order to set its own appearance.
For more info:
The UITableViewDelegate protocol:
https://developer.apple.com/reference/uikit/uitableviewdelegate
The UITableView delegate instance variable:
https://developer.apple.com/reference/uikit/uitableview#delegate
What you want to do is to implement the tableView(_:heightForRowAt:) method on your UITableViewDelegate object. This method gets two parameters: The first is the UITableView itself, and the second is the IndexPath of the row being prepared for rendering. An IndexPath is an object which has section and row properties corresponding to the cell being rendered.
What you want to do is have some way of computing whether a cell is expanded or not based on its IndexPath.
Swift IndexPath reference: https://developer.apple.com/reference/foundation/indexpath
Trying to do this based on the UITableViewCell itself is an incorrect approach, as you usually should not analyze the cell before it is rendered.
A way to do this would be to have your UITableView-inheriting class keep a (possibly nested) array of booleans indicating which cells should be expanded or not. Then you could use the IndexPath's row and possibly section as indices into this array in order to determine whether the cell is expanded or not. Something like this:
class MyTableView: UITableView, UITableViewDelegate {
/* ... */
private var expanded: [Bool] = []
init() {
super.init()
self.delegate = self
}
func setData(data: [SomeType]) {
//set the data for the table here
expanded = [Bool](repeating: false, count: data.count)
}
/* ...logic to expand and collapse cells... */
func tableView(_ view: UITableView,
heightForRowAt indexPath: IndexPath) {
if expanded[indexPath.row] {
return expandedHeight
} else {
return collapsedHeight
}
}
/* ... */
}
The proper way to set your data would be to call a method on your UITableViewDataSource, but I'm assuming you'd set data on the TableView itself for the sake of simplicity.
Don't try to set the UITableView's properties by hand. The delegate and dataSource-based workflow of UITableViews is set up so that your table view works efficiently and only updates itself when it needs to.