Setting .reuseIdentifier on a UICollectionViewCell - objective-c

I have a particular UICollectionViewCell that I want to instantiate myself, and add to a UICollectionView. In order for this to work, the UICollectionViewCell instance needs its .reuseIdentifier property to be set.
Normally, the class or Nib that describes the cell is registered with the collection view, and the collection view instantiates the cell with its .reuseIdentifier already set, with these methods:
- registerClass:forCellWithReuseIdentifier:
- registerNib:forCellWithReuseIdentifier:
However, since I am constructing this cell outside of the collection view, these do not apply.
When I create the cell myself, there appears to be no way to set its .reuseIdentifier (because it is a readonly property, and there are no init... methods that initialize it).
When .reuseIdentifier is not set, the UICollectionView throws an exception when the cell is added. This behavior is different from UITableView, where reuse identifiers were optional.
An easy workaround to set the collection view cell's reuse identifier is to embed it in a .xib file and use the Identifier box, then create an instance of the cell with
[NSBundle.mainBundle loadNibNamed:#"MyCellName" owner:self options:nil][0];
I can then pass the above-instantiated UICollectionViewCell and everything works fine.
...but that seems like a pretty silly and arbitrary hoop to jump through. Is there some other way to get this property set on the cell instance without the .xib-wrapper detour?
Update: Apple's documentation says this:
To simplify the creation process for your code, the collection view requires that you always dequeue views, rather than create them explicitly in your code.
...which is actually not true, because it doesn't require this (i.e., externally-instanced cells work fine as long as their identifier is set somehow, e.g. if loaded from a .xib), and it also doesn't "simplify the creation process for my code" in my particular use case (rather requires an extra file; further it would be messy to require that the collection view create these few complex one-offs).
But the above does seem to imply that the answer to the question is no: it's intentionally "difficult" to create a usable cell except by having the collection view dequeue it.

I'm sorry to say it, but I think you're going to have to accept the fact that UICollectionView is the sole Apple-branded factory for producing UICollectionViewCells. So if you have two collection views in which you want to display the exact same object, you're out of luck!
The good news is that if you have two collection view in which you want to display a cell that looks exactly the same as in the other, then you can accomplish your task. It's easy:
#interface MyModelClass : NSObject
// a bunch of data
#end
#interface MyCollectionViewCell : UICollectionViewCell
-(void)refreshCellWithObject:(MyModelClass *)object;
#end
Meanwhile, in whichever classes own the UICollectionView cv1 and cv2
[[self cv1] registerClass:[MyCollectionViewCell class] forCellWithReuseIdentifier:#"MyCollectionViewCell"];
and
[[self cv2] registerClass:[MyCollectionViewCell class] forCellWithReuseIdentifier:#"MyCollectionViewCell"];
And their data sources can look the same
- (UICollectionViewCell *)collectionView:(UICollectionView *)collectionView cellForItemAtIndexPath:(NSIndexPath *)indexPath {
MyModelObject *obj = [self theObjectIWant];
MyCollectionViewCell *cell;
cell = [collectionView dequeueReusableCellWithReuseIdentifier:#"MyCollectionViewCell" forIndexPath:indexPath];
[cell refreshCellWithObject:obj];
return cell;
}

Use these two methods.
– registerNib:forCellWithReuseIdentifier:
– dequeueReusableCellWithReuseIdentifier:forIndexPath:
See apple's UICollectionView Class Reference

Related

View-based NSTableView From Xib

I have a NSTableView that is created programmatically. I have several options for customizing the cells in each column based on the column type and datasource (ie, it's very easy to have buttons or checkboxes based on the column type and what is in the datasource).
Now I need to be able to fully customize the cell, so I'm attempting to load an NSView from a xib and return it from the tables delegate's viewForTableColumn method. I haven't used IB much outside of iOS and I'm not very well versed as to how the various outlets and class types should be set, especially when the majority of the UI is created outside of IB. I've read many posts here and on other sites but the majority of examples either create all of the UI in IB or none of it.
Currently I have TestCell.xib which was created by selecting View from the New File dialog. I've also created an objective-c class called TestCell. In IB I've set the view's class to TestCell, and I've dragged outlets for a label control and a button to the TestCell class.
In the table's delegate class I have the following:
- (NSView*)tableView:(NSTableView*)tableView viewForTableColumn:(NSTableColumn*)tableColumn row:(NSInteger)row {
NSView* view = [tableView makeViewWithIdentifier:customRowXibName owner:self];
if( view == nil ) {
NSArray* nibObjects = nil;
if( [[NSBundle mainBundle] loadNibNamed:customRowXibName owner:self topLevelObjects:&nibObjects] ) {
view = [nibObjects lastObject];
}
}
return view;
}
However, the table view doesn't show anything. I'm also getting the following errors for both controls in the view when loading the xib:
Failed to connect (button) outlet from (TableListViewDelegate) to (NSButton): missing setter or instance variable
I'm assuming that's because I'm setting owner to self when loading the xib.
My questions are:
In IB, what should the File's Owner placeholder be set to? Currently it's set to TestCell but I don't believe that is correct.
Is it ok to use "TestCell" as the identifier? Does this identifier need to be set in IB? Or do I need to call registerNib:forIdentifier on the table view?
When calling loadNibNamed, what should owner be set to?
I was able to get this to work by doing the following:
In IB, set the File's Owner to be the class that is loading the Xib (in this case, the NSTableViewDelegate).
In the delegate, create an outlet for your custom cell and hook it up in IB (I used the Connection Inspector with the File's Owner selected).
In tableView:viewForTableColumn:row call:[tableView makeViewWithIdentifier:#"Xib Name" owner:self]
If that returns nil, then call:[[NSBundle mainBundle] loadNibNamed:#"Xib Name" owner:self topLevelObjects:&nibObjects] with nibObjects being a nil NSArray*.
If loadNibNamed returns YES, then the outlet you created in the delegate should now point to the newly loaded view. Make sure to set the views identifier to #"Xib Name" so you can make use of cached views.

Registered NIB, still getting assertion error when I use dequeueReusableCellWithIdentifier

I have a custom UITableViewCell class that I want to use to create custom table cells. I created the custom table cell's xib as well as its header and implementation files, all called RTRepairOrderTableCell.m/.h/.xib.
My issue is that even though I set the reuse identifier of the table cell to RTRepairOrderTableCell inside of the .xib file and registered the xib inside of my table view controller, I am still getting assertion errors when it tries to dequeue or create a new cell for use.
Inside of my view (table) controller I have the following:
- (void)viewDidLoad
{
[super viewDidLoad];
//Load the nib file
UINib *nib = [UINib nibWithNibName:#"RTRepairOrderTableCell"
bundle:nil];
// Register this Nib, which contains the cell
[self.tableView registerNib:nib
forCellReuseIdentifier:#"RTRepairOrderTableCell"];
}
There are no errors here and it finishes viewDidLoad just fine.
Inside of my cellForRowAtIndexPath I have the following:
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
RTRepairOrderTableCell *cell = [tableView dequeueReusableCellWithIdentifier:#"RTRepairOrderTableCell" forIndexPath:indexPath];
return cell;
}
According to every tutorial I've seen, this should work so long as I have the reuse identifier set properly inside the xib file and I register that xib inside of viewDidLoad in the view controller class that will display the table cells, so I am at a loss as to why I am getting
*** Assertion failure in -[UITableView _dequeueReusableViewOfType:withIdentifier:], /SourceCache/UIKit/UIKit-2935.138/UITableView.m:5413
Turns out I had a few orphaned UIImage objects inside the nib file but outside of the UITableViewCell area, so it was throwing errors saying that the UITableViewCell needed to be the topmost view.
I faced this and it was driving me crazy. But it was my fault. I had set identifier #"Abc" in Nib file and I was registering the same nib file with some other identifie #"Xyz". Removed the identifier from nib, left that part blank and it worked like a champ. :)
This might be a rare case, but due to some sloppy copy pasta two different UITableViewCell custom classes used in my table had the exact same Identifier specified in the Xib.
Switching one of these cells to have a different Identifier in the Attributes Inspector fixed my Assertion failures.
Check if in your .xib there are no UI component outside main layout:
Label is not accepted
In this example, Label is not accepted and cause the exception

UICollectionView: How to get item size for a specific item after setting them in delegate method

I am fiddling with the new UICollectionView and the UICollectionViewLayout classes. I have created a custom layout, subclassing UICollectionViewFlowLayout.
My cell sizes are changing dynamically and I set the item sizes using the delegate method below
- (CGSize)collectionView:(UICollectionView *)collectionView
layout:(UICollectionViewLayout*)collectionViewLayout
sizeForItemAtIndexPath:(NSIndexPath *)indexPath {
NSLog(#"SETTING SIZE FOR ITEM AT INDEX %d", indexPath.row);
return CGSizeMake(80, 80);
}
Now, under the prepareLayout method of my custom UICollectionViewFlowLayout class, I need to access these size variables so that I can make calculations how to place them and cache them for layoutAttributesForItemAtIndexPath.
However, I can't seem to find any property under UICollectionView or UICollectionViewFlowLayout to reach the custom item sizes I set in the delegate method.
Found it myself.
Implement the custom class like without omitting UICollectionViewDelegateFlowLayout
#interface SECollectionViewCustomLayout : UICollectionViewFlowLayout
<UICollectionViewDelegateFlowLayout>
and then you can call
CGSize size = [self collectionView:self.collectionView
layout:self
sizeForItemAtIndexPath:indexPath];
Looking at the various UICollectionView... header files, and watching the WWDC 2012 Session 219 - Advanced Collection Views and Building Custom Layouts video (from about 6:50 onwards), it seems the extensible delegate pattern takes advantage of dynamic typing to ensure the layout can properly access its extended delegate methods.
In short...
If you define a custom layout with its own delegate, define that delegate protocol in the layout's header file.
Your delegate object (typically the UI(Collection)ViewController that manages the collection view) should declare itself to support this custom protocol.
In the case that your layout is just a UICollectionViewFlowLayout or subclass thereof, this just means declaring conformance to UICollectionViewDelegateFlowLayout.
Feel free to do this in your class extension in the .m file if you'd rather not #import the layout header into the delegate's interface.
To access the delegate methods from the layout, call through to the collection view's delegate.
Use the layout's collectionView property, and cast the delegate to an object conforming to the required protocol to convince the compiler.
Don't forget to check that the delegate respondsToSelector: as usual prior to calling optional delegate methods. In fact, if you like, there's no harm in doing this for all methods, as the typecasting means there is no runtime guarantee the delegate will even implement the required methods.
In code...
So if you implement a custom layout that requires a delegate for some of its information, your header might look something like this:
#protocol CollectionViewDelegateCustomLayout <UICollectionViewDelegate>
- (BOOL)collectionView:(UICollectionView *)collectionView
layout:(UICollectionViewLayout *)layout
shouldDoSomethingMindblowingAtIndexPath:(NSIndexPath *)indexPath;
#end
#interface CustomLayout : UICollectionViewLayout
// ...
#end
Your delegate declares conformance (I've done so in the implementation file here):
#import "CustomLayout.h"
#interface MyCollectionViewController () <CollectionViewDelegateCustomLayout>
#end
#implementation
// ...
- (BOOL)collectionView:(UICollectionView *)collectionView
layout:(UICollectionViewLayout *)layout
shouldDoSomethingMindblowingAtIndexPath:(NSIndexPath *)indexPath
{
return [self canDoSomethingMindblowing];
}
// ...
#end
And in your layout's implementation, you access the method like this:
BOOL blowMind;
if ([self.collectionView.delegate respondsToSelector:#selecor(collectionView:layout:shouldDoSomethingMindblowingAtIndexPath:)]) {
blowMind = [(id<CollectionViewDelegateCustomLayout>)self.collectionView.delegate collectionView:self.collectionView
layout:self
shouldDoSomethingMindblowingAtIndexPath:indexPath];
} else {
// Perhaps the layout also has a property for this, if the delegate
// doesn't support dynamic layout properties...?
// blowMind = self.blowMind;
}
Note that it's safe to typecast here, as we're checking the delegate responds to that method beforehand anyway.
The evidence...
It's only speculation, but I suspect it is how Apple manages the UICollectionViewDelegateFlowLayout protocol.
There is no delegate property on the flow layout, so calls must go via the collection view's delegate.
UICollectionViewController does not publicly conform to extended flow layout delegate (and I doubt it does so in another private header).
UICollectionView's delegate property only declares conformance to the 'base' UICollectionViewDelegate protocol. Again, I doubt there is a private subclass/category of UICollectionView in use by the flow layout to prevent the need for typecasting. To add further weight to this point, Apple discourages subclassing UICollectionView at all in the docs (Collection View Programming Guide for iOS: Creating Custom Layouts):
Avoid subclassing UICollectionView. The collection view has little or no appearance of its own. Instead, it pulls all of its views from your data source object and all of the layout-related information from the layout object.
So there we go. Not complicated, but worth knowing how to do it paradigm-friendly way.
There is a swift version:
self.collectionView(self.collectionView, layout: self.collectionView.collectionViewLayout, sizeForItemAtIndexPath: indexPath)
Check out UICollectionView-FlowLayout on GitHub. Same idea, this just makes accessing the extended delegate methods of flowLayout a little cleaner.
For the later readers, IOS 7 has UICollectionViewFlowLayout which has defined it.
In my case everything about layout, cell layout etc. is being defined inside nib for UIViewController and separate nib for UICollectionViewCell. MyCollectionViewCell contains UIImageView with autolayout to cell with padding/margins but square-shaped.
I need round icons instead squared but don't want to take care which nib I use for iPhone or for iPad (I have separate nibs for devices and for orientation as well).
I don't want to implement #selector(collectionView:layout:sizeForItemAtIndexPath:) into my view controller.
So, inside collectionView:cellForItemAtIndexPath:
I can just use
CGSize size = cell.imageView.bounds.size;
cell.imageView.layer.masksToBounds = YES;
cell.imageView.layer.cornerRadius = size.height/2.0;
Because collectionView:layout:sizeForItemAtIndexPath: call before collectionView:cellForItemAtIndexPath: and layout done.
You can check round avatars on the bottom

In a storyboard, how do I make a custom cell for use with multiple controllers?

I'm trying to use storyboards in an app I'm working on. In the app there are Lists and Users and each contains a collection of the other (members of a list, lists owned by a user). So, accordingly, I have ListCell and UserCell classes. The goal is to have those be re-usable throughout the app (ie, in any of my tableview controllers).
That's where I'm running into a problem.
How do I create a custom tableview cell in the storyboard that can be re-used in any view controller?
Here are the specific things I've tried so far.
In Controller #1, added a prototype cell, set the class to my UITableViewCell subclass, set the reuse id, added the labels and wired them to the class's outlets. In Controller #2, added an empty prototype cell, set it to the same class and reuse id as before. When it runs, the labels never appear when the cells are shown in Controller #2. Works fine in Controller #1.
Designed each cell type in a different NIB and wired up to the appropriate cell class. In storyboard, added an empty prototype cell and set its class and reuse id to refer to my cell class. In controllers' viewDidLoad methods, registered those NIB files for the reuse id. When shown, cells in both controllers were empty like the prototype.
Kept prototypes in both controllers empty and set class and reuse id to my cell class. Constructed the cells' UI entirely in code. Cells work perfectly in all controllers.
In the second case I suspect that the prototype is always overriding the NIB and if I killed the prototype cells, registering my NIB for the reuse id would work. But then I wouldn't be able to setup segues from the cells to other frames, which is really the whole point of using storyboards.
At the end of the day, I want two things: wire up tableview based flows in the storyboard and define cell layouts visually rather than in code. I can't see how to get both of those so far.
As I understand it, you want to:
Design a cell in IB which can be used in multiple storyboard scenes.
Configure unique storyboard segues from that cell, depending on the scene the cell is in.
Unfortunately, there is currently no way to do this. To understand why your previous attempts didn't work, you need to understand more about how storyboards and prototype table view cells work. (If you don't care about why these other attempts didn't work, feel free to leave now. I've got no magical workarounds for you, other than suggesting that you file a bug.)
A storyboard is, in essence, not much more than a collection of .xib files. When you load up a table view controller that has some prototype cells out of a storyboard, here's what happens:
Each prototype cell is actually its own embedded mini-nib. So when the table view controller is loading up, it runs through each of the prototype cell's nibs and calls -[UITableView registerNib:forCellReuseIdentifier:].
The table view asks the controller for the cells.
You probably call -[UITableView dequeueReusableCellWithIdentifier:]
When you request a cell with a given reuse identifier, it checks whether it has a nib registered. If it does, it instantiates an instance of that cell. This is composed of the following steps:
Look at the class of the cell, as defined in the cell's nib. Call [[CellClass alloc] initWithCoder:].
The -initWithCoder: method goes through and adds subviews and sets properties that were defined in the nib. (IBOutlets probably get hooked up here as well, though I haven't tested that; it may happen in -awakeFromNib)
You configure your cell however you want.
The important thing to note here is there is a distinction between the class of the cell and the visual appearance of the cell. You could create two separate prototype cells of the same class, but with their subviews laid out completely differently. In fact, if you use the default UITableViewCell styles, this is exactly what's happening. The "Default" style and the "Subtitle" style, for example, are both represented by the same UITableViewCell class.
This is important: The class of the cell does not have a one-to-one correlation with a particular view hierarchy. The view hierarchy is determined entirely by what's in the prototype cell that was registered with this particular controller.
Note, as well, that the cell's reuse identifier was not registered in some global cell dispensary. The reuse identifier is only used within the context of a single UITableView instance.
Given this information, let's look at what happened in your above attempts.
In Controller #1, added a prototype cell, set the class to my
UITableViewCell subclass, set the reuse id, added the labels and wired
them to the class's outlets. In Controller #2, added an empty
prototype cell, set it to the same class and reuse id as before. When
it runs, the labels never appear when the cells are shown in
Controller #2. Works fine in Controller #1.
This is expected. While both cells had the same class, the view hierarchy that was passed to the cell in Controller #2 was entirely devoid of subviews. So you got an empty cell, which is exactly what you put in the prototype.
Designed each cell type in a different NIB and wired up to the
appropriate cell class. In storyboard, added an empty prototype cell
and set its class and reuse id to refer to my cell class. In
controllers' viewDidLoad methods, registered those NIB files for the
reuse id. When shown, cells in both controllers were empty like the
prototype.
Again, this is expected. The reuse identifier is not shared between storyboard scenes or nibs, so the fact that all of these distinct cells had the same reuse identifier was meaningless. The cell you get back from the tableview will have an appearance that matches the prototype cell in that scene of the storyboard.
This solution was close, though. As you noted, you could just programmatically call -[UITableView registerNib:forCellReuseIdentifier:], passing the UINib containing the cell, and you'd get back that same cell. (This isn't because the prototype was "overriding" the nib; you simply hadn't registered the nib with the tableview, so it was still looking at the nib embedded in the storyboard.) Unfortunately, there's a flaw with this approach — there's no way to hook up storyboard segues to a cell in a standalone nib.
Kept prototypes in both controllers empty and set class and reuse id
to my cell class. Constructed the cells' UI entirely in code. Cells
work perfectly in all controllers.
Naturally. Hopefully, this is unsurprising.
So, that's why it didn't work. You can design your cells in standalone nibs and use them in multiple storyboard scenes; you just can't currently hook up storyboard segues to those cells. Hopefully, though, you've learned something in the process of reading this.
In spite of the great answer by BJ Homer I feel like I have a solution. As far as my testing goes, it works.
Concept: Create a custom class for the xib cell. There you can wait for a touch event and perform the segue programmatically. Now all we need is a reference to the controller performing the Segue. My solution is to set it in tableView:cellForRowAtIndexPath:.
Example
I have a DetailedTaskCell.xib containing a table cell which I'd like to use in multiple table views:
There is a custom class TaskGuessTableCell for that cell:
This is where the magic happens.
// TaskGuessTableCell.h
#import <Foundation/Foundation.h>
#interface TaskGuessTableCell : UITableViewCell
#property (nonatomic, weak) UIViewController *controller;
#end
// TashGuessTableCell.m
#import "TaskGuessTableCell.h"
#implementation TaskGuessTableCell
#synthesize controller;
- (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event
{
NSIndexPath *path = [controller.tableView indexPathForCell:self];
[controller.tableView selectRowAtIndexPath:path animated:NO scrollPosition:UITableViewScrollPositionNone];
[controller performSegueWithIdentifier:#"FinishedTask" sender:controller];
[super touchesEnded:touches withEvent:event];
}
#end
I have multiple Segues but they all have the same name: "FinishedTask". If you need to be flexible here, I suggest to add another property.
The ViewController looks like this:
// LogbookViewController.m
#import "LogbookViewController.h"
#import "TaskGuessTableCell.h"
#implementation LogbookViewController
- (void)viewDidLoad
{
[super viewDidLoad]
// register custom nib
[self.tableView registerNib:[UINib nibWithNibName:#"DetailedTaskCell" bundle:[NSBundle mainBundle]] forCellReuseIdentifier:#"DetailedTaskCell"];
}
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
TaskGuessTableCell *cell;
cell = [tableView dequeueReusableCellWithIdentifier:#"DetailedTaskCell"];
cell.controller = self; // <-- the line that matters
// if you added the seque property to the cell class, set that one here
// cell.segue = #"TheSegueYouNeedToTrigger";
cell.taskTitle.text = [entry title];
// set other outlet values etc. ...
return cell;
}
- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender
{
if([[segue identifier] isEqualToString:#"FinishedTask"])
{
// do what you have to do, as usual
}
}
#end
There might be more elegant ways to achieve the same but - it works! :)
I was looking for this and I found this answer by Richard Venable. It works for me.
iOS 5 includes a new method on UITableView: registerNib:forCellReuseIdentifier:
To use it, put a UITableViewCell in a nib. It has to be the only root
object in the nib.
You can register the nib after loading your tableView, then when you
call dequeueReusableCellWithIdentifier: with the cell identifier, it
will pull it from the nib, just like if you had used a Storyboard
prototype cell.
BJ Homer has given an excellent explanation of what is going on.
From a practical standpoint I'd add that, given you can't have cells as xibs AND connect segues, the best one to choose is having the cell as a xib - transitions are far easier to maintain than cell layouts and properties across multiple places, and your segues are likely to be different from your different controllers anyway. You can define the segue directly from your table view controller to the next controller, and perform it in code. .
A further note is that having your cell as a separate xib file prevents you being able to connect any actions etc. directly to the table view controller (I haven't worked this out, anyway - you can't define file's owner as anything meaningful). I am working around this by defining a protocol that the cell's table view controller is expected to conform to and adding the controller as a weak property, similar to a delegate, in cellForRowAtIndexPath.
Swift 3
BJ Homer gave an excellent explanation, It helps me understand the concept. To make a custom cell reusable in storyboard, which can be used in any TableViewController we have to mix the Storyboard and xib approach. Suppose we have a cell named as CustomCell which is to be used in the TableViewControllerOne and TableViewControllerTwo. I am making it in steps.
1. File > New > Click File > Select Cocoa Touch Class > click Next > Give Name Of your class(for example CustomCell) > select Subclass as UITableVieCell > Tick the also create XIB file checkbox and press Next.
2. Customize the cell as you want and set the identifier in attribute inspector for cell, here we ll set as CellIdentifier. This identifier will be used in your ViewController to identify and reuse the Cell.
3. Now we just have to register this cell in our ViewController viewDidLoad. No need of any initialization method.
4. Now we can use this custom cell in any tableView.
In TableViewControllerOne
let reuseIdentifier = "CellIdentifier"
override func viewDidLoad() {
super.viewDidLoad()
tableView.register(UINib(nibName: "CustomCell", bundle: nil), forCellReuseIdentifier: reuseIdentifier)
}
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCell(withIdentifier:reuseIdentifier, for: indexPath) as! CustomCell
return cell!
}
I found a way to load the cell for the same VC, not tested for the segues. This could be a workaround for creating the cell in a separate nib
Let's say that you have one VC and 2 tables and you want to design a cell in storyboard and use it in both tables.
(ex: a table and a search field with a UISearchController with a table for results and you want to use the same Cell in both)
When the controller asks for the cell do this:
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
static NSString * identifier = #"CELL_ID";
ContactsCell *cell = [self.YOURTABLEVIEW dequeueReusableCellWithIdentifier:identifier];
// Ignore the "tableView" argument
}
And here you have your cell from the storyboard
If I understand your question correctly, this is fairly easy. Create a UIViewController in your storyboard that will hold your prototype cells and create a static shared instance that loads itself from the storyboard. To handle view controller segues, use the manual segue outlet and trigger on table view delegate didSelectRow (the manual segue outlet is the middle icon at the top of the view controller in the storyboard, in between 'First Responder' and 'Exit').
XCode 12.5, iOS 13.6
// A cell with a single UILabel
class UILabelCell: UITableViewCell {
#IBOutlet weak var label: UILabel!
}
// A cell with a signle UISwitch
class UISwitchCell: UITableViewCell {
#IBOutlet weak var uiSwitch: UISwitch!
}
// The TableViewController to hold the prototype cells.
class CellPrototypeTableViewController: UITableViewController {
// Loads the view controller from the storyboard
static let shared: CellPrototypeTableViewController = {
let storyboard = UIStoryboard(name: "Main", bundle: nil)
let viewController = storyboard.instantiateViewController(withIdentifier: "cellProtoypeVC") as! CellPrototypeTableViewController
viewController.loadViewIfNeeded() // Make sure to force view controller to load the view!
return viewController
}()
// Helper methods to deque the cells
func dequeUILabeCell() -> UILabelCell {
let cell = self.tableView.dequeueReusableCell(withIdentifier: "uiLabelCell") as! UILabelCell
return cell
}
func dequeUISwitchCell() -> UISwitchCell {
let cell = self.tableView.dequeueReusableCell(withIdentifier: "uiSwitchCell") as! UISwitchCell
return cell
}
}
Use:
class MyTableViewController: UITableViewController {
override func numberOfSections(in tableView: UITableView) -> Int {
return 1
}
override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return 2
}
override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
// Dequeue the cells from the shared instance
switch indexPath.row {
case 0:
let uiLabelCell = CellPrototypeTableViewController.shared.dequeUILabeCell()
uiLabelCell.label.text = "Hello World"
return uiLabelCell
case 1:
let uiSwitchCell = CellPrototypeTableViewController.shared.dequeUISwitchCell()
uiSwitchCell.uiSwitch.isOn = false
return uiSwitchCell
default:
fatalError("IndexPath out of bounds")
}
}
// Handling Segues
override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
switch indexPath.row {
case 0: self.performSegue(withIdentifier: "first", sender: nil)
case 1: self.performSegue(withIdentifier: "second", sender: nil)
default:
fatalError("IndexPath out of bounds")
}
}
}

Holding NSView instances in an array

Is it possible to store an NSView object in a mutable array? As I understand it, the view will be an object so the array should be able to hold it. Specifically, I want to hold several instances of a nib file, which I think would be loaded with an NSNib init, and then addObject to the array.
The idea is to display an NSView in each of the rows of a column in a TableView. I think it can be done because iTunes does something similar (with what I think is an NSImage) in displaying album artwork in a list view.
Still, any knowledge on the subject (or link to an example or tutorial) would be very appreciated.
TableViews usually don't hold an NSView for each item. They hold a number of NSViewTableCells (which are, system-wise, far more lightweight than NSViews), and they re-use these cells. They usually don't have many more cells than necessary to display the visible part of the TableView, AFAIK, and when the view is scrolled, cells that have become "invisible" are re-used.
So the best way to do this is to subclass the cell and to make the TableView display the contents using these. Using NSViews for every entry in a list of, say, my MP3 albums would be extremely expensive.
In Xcode goto File->New File and choose Objective-C class then in the drop down, choose to make it a subclass of UITableViewCell. Name it MyCell (for example)
Next in interface builder, create a new XIB and change its owner to your newly created class. You may also want to delete the default view and add a UITableViewCell. Set the owner's view outlet to this new tableview cell. Then add whatever you want to the UITableViewCell.
Then create a new UIViewController (which it may be helpful to create a new UITableViewController first and then change its type to UIViewController just so you get all the UITableViewDelegate methods added for you) and choose to add a XIB file for the UIViewController. Open the header file for the newly created UIViewController and add UITableViewDelegate protocol so the header may look like this:
#interface MyViewController: UIViewController <UITableViewDelegate, UITableViewDataSource>
On the view for the view controller (in interface builder) add a UITableView and then set its datasource and delegates to the owner. Make sure to import the MyCell.h header file. Then implement the tableViewMethods in particular for your UITableViewCell you would do something like this:
- (UITableViewCell *)tableView:(UITableView *) tableView
cellForRowAtIndexPath:(NSIndexPath *) indexPath
{
static NSString *MyCellIdentifier = #"MyCellIdentifier";
MyCell *cell = (MyCell *)[tableView dequeueReusableCellWithIdentifier:MyCellIdentifier];
if (cell == nil) {
NSArray *nib = [[NSBundle mainBundle] loadNibNamed:#"MyCell" owner:self options:nil];
cell = [nib objectAtIndex:0];
}
//Here you would set properties of the cells items like labels, etc.
return cell;
}