I have checked out every similar question and every answer,I have implemented with code. I have set
self.tableView.allowsMultipleSelection = NO;
self.tableView.allowsSelection = YES;
self.tableView.userInteractionEnabled = YES;
Check out the method name of what i expect of is didSelectRowAtIndexPath . There is
no UITapGestureRecognizer.UI Hierarchy shows nothing on the cell.
I have not implemented the method: willSelectRowAtIndexPath, shouldHighlightRowAtIndexPath, tableView:didDeselectRowAtIndexPath.
My custom cell is clean without xib.
Tapping the cell doesn't work ,but dragging the cell works and calls didSelectRowAtIndexPath.
Is there anyone know any other reason that can cause this bug?
wired! I have try take this UITableViewController into a demo and show, but in this demo it worked. Maybe some method in my project block didSelectRowAtIndexPath. How can find which method has blocked? How can I catch the tap event ,and find out which method has happened
If you are using UITableViewController inside a UIViewController, please check if you set the delegate & datasource of the UITableViewController or not.
- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath
check return height is correct. You can set cell backgroundColor to check cell frame.
I subclassed NSTextField and overwrite the textDidChange: as:
- (void)textDidChange:(NSNotification *)notification
{
// ... My own operation
}
But when I drag a input text box into my .xib file and control drag another class to assign the delegate I found the delegate's controlTextDidChange: method was never called.
Now tryingto solve this problem, I tried two ways al below:
I. calling super:
- (void)textDidChange:(NSNotification *)notification
{
// ... My own operation
[super textDidChange:notification];
}
But I got an error in runtime: attempt to insert nil object from objects[0]
II. calling delegate's method
- (void)textDidChange:(NSNotification *)notification
{
// ... My own operation
if ([self.delegate responseToSelector:#selector(controlTextDidChange:)])
{
[self.delegate ...]; // <--- Opps, something not happerned here.
}
}
What not happerned? I expected that the auto-complete should display the controlTextDidChange: method at the position of ... above. But it did not, actually. I typed the method directly, compilation fail because method not found.
How should I make my sub-class call the delegate normally? How should I overwrite the textDidChange: method correctly?
Further question for Vytautas:
I am sure I was using NSTextField. And I set a break point inside controlTextDidChange: method. As it was called, I should have known.
I did control-drag the text field to the delegate object, and I print delegate object in the textDidChange: method, it was sure that the delegate was set correctly.
The other delegate methods, such as controlTextDidBeginEditing: were called correctly. But controlTextDidChange: not called
I tried comment out the over-written in the subclassed NSTextField class, then controlTextDidChange: was called.
Therefore I was quite sure that I am not overwritting the textDidChange: right. But I do not known how to fix it.
What made me confused mostly was that why auto-completion did not show the controlTextDidChange: method when I attempted to call it.
About the auto-completion, here is how it showed:
No - controlTextDidChange: method.
2nd further reply for Vytautas:
I tried calling '[self controlTextDidChange]' but it did not work, and error occurred (as highlighted below):
I can say that - controlTextDidChange: is called for sure.
Maybe there is something wrong with you bindings in your *.xib.
Also it can be that in *.xib you are using NSTextView, not NSTextField.
In this case - controlTextDidChange: won't be called for sure.
If that is the case then you should take a look to NSTextView, NSTextViewDelegate and NSTextDelegate. NSTextView delegate has an alternative method for this - textDidChange:
CollectionCell is a UICollectionViewCell subclass. For learning purposes, the only difference is a single subview.
No interface builder. All in code.
I can do it like this for iOS 5…
[_collectionView registerClass:[CollectionCell class]
forCellWithReuseIdentifier:#"CollectionCell"];
…but it breaks in iOS 6, and I can't find any information.
Your subclassed CollectionCell doesn't have the "registerClass: forCellWithReuseIdentifier" method.
Your "UICollectionView" (which uses and displays CollectionCell objects) does.
Call "registerClass: forCellWithReuseIdentifier" on your collection view instead of the cell.
Make sure that your UICollectionViewCell classes extend PSUICollectionViewCell. I had the same issue happen to me and found out that my cells were extending PSTCollectionViewCell.
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")
}
}
}
Could anyone explain the meaning of someViewController.delegate = self and self.delegate? Where do they help us?
Delegates send messages to you.
For example: if you use the accelerometer delegate, you will get messages about the accelerometer.
If you use that new neutrino-detection delegate, you will get messages about any neutrinos detected in the area.
If you use PopUps, PopUps send you messages. And the way that is done, is with the PopUp's delegate. There are many, many examples.
So, delegates send messages.
It's that simple.
You might ask, "WHERE does it send these messages?"
The answer is this: it sends the messages to where you set the ".delegate" thingy.
When you "set the delegate," what you are doing is saying where you want the messages to go.
Hence,
blah.delegate = amazingPlace will send the messages to "amazingPlace".
blah.delegate = somewhereElse will send the messages to "somewhereElse".
blah.delegate = self will send the messages ...... to you.
Very often, you want the messages to come to "you", so you just say "blah.delegate = self"
It is a very common mistake, to forget that line of code.
If you forget that line of code, you are stuffed. The messages go nowhere, and you are left scratching your head trying to figure out what went wrong.
Something else you have to do: when you use a delegate, you have to announce beforehand, that, you want to use the delegate.
How to do that?
It's very easy...
In the old days with Objective-C...
// old days!
#interface AppDelegate_Pad : NSObject <UIApplicationDelegate>
#interface BigTop : UIViewController <ASIHTTPRequestDelegate,
UIPopoverControllerDelegate>
#interface Flying : UIViewController <UIAccelerometerDelegate>
You can see that 'BigTop' wants to use two delegates, namely the ASIHTTPRequestDelegate and the UIPopoverControllerDelegate. Whereas 'Flying' only wants to use one delegate - it wants to use the accelerometer.
In Swift...
class YourClass:UIViewController, SomeDelegate, AnotherDelegate
You can't really do much on the iPhone without using delegates all over the place.
Delegates are used everywhere and all the time in iOS.
It is perfectly normal that a class might use a dozen delegates. That is to say, your class will want to get messages from a dozen delegates.
Nowadays with Swift you simply type
blah.delegate = self
and that's all there is to it.
So that's what you're doing. Delegates send messages. You have to say where you want the messages to go. Very typically, you want them to go to "you," so in that case you simply say blah.delegate=self.
Delegate is used to pass/communicate data/message b/w two objects of classes. Here, tableView(Sender) sends data/message to viewController(Receiver).
Consider example of implementing UITableView in custom viewController
Here, UITableViewDataSource & UITableViewDelegate are actually protocols. Unfortunately, UIKit Framework is not open source. But I will assure this what internally happens after referring many articles.
Protocol is like basketball coach with some requirements in it. He/She tells players like class, struct, enum what to do? by using those requirements. But He/She doesn't knows how to do?by themself. So, the class or struct which conforms that protocol should provide implementation to those requirements while achieving to dunk the ball.
protocol UITableViewDelegate {
func tableView(_ tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath)
}
A Protocol is said to be DataSource protocol then it always contains required functions with "return type" as shown below.
protocol UITableViewDataSource {
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int
func tableView(_ tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell
}
Implementing UITableView inside custom viewController
class viewController: UIViewController, UITableViewDelegate, UITableViewDataSource {
let tableView = UITableView()
override func viewDidLoad {
tableView.delegate = self
tableView.dataSource = self
}
Here, tableView acts as Delegator(sender) & viewController object i.e (self) as Delegate(receiver).
In order to get UITableView in viewController.It should to conform to both the Protocols.
So, viewController class object has implemented all those required functions of both the protocols. Now self can be used either as UITableViewDelegate type or UITableViewDataSource type because Protocol can be used as type for an object of class which conforms to it.
Now, both properties of tableView i.e delegate & dataSource are assigned to self because its having same respective protocol types.
The non-optional functions of both Protocols are implemented in viewController class object as below
Protocol UITableViewDelegate functions
func tableView(_ tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {
// Do further processes like pushing or poping another viewController
}
Protocol UITableViewDataSource functions
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return 10
}
func tableView(_ tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
return UITableViewCell(style: UITableViewCellStyle.Value1, reuseIdentifier: "Cell")
}
1) When the user select a row in a section then tableview(Sender) i.e UItableView() calls the UITableViewDelegate func below shown by passing data to parameters tableView & indexPath which resides in viewController object(Receiver) through its delegate property. Now viewController uses those passed data to do further processes like pushing or poping to new custom viewController.
tableView.delegate?.tableView(UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath)
2) Functions inside UITableViewDatasource protocol provides custom data to tableview(Sender). The tableview asks the viewController object by calling Datasource functions with passing data to parameters tableView & indexPath which resides in viewController object(Receiver) through its datasource property. Now viewController uses those passed data & returns custom data back tableview. Now tableview uses those data to create "10" cells in a section & kind of "cell" at indexpath
tableView.dataSource?.tableView(UITableView, numberOfRowsInSection section: Int) -> returns "10"
tableView.dataSource?.tableView(UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> returns "cell"
Finally, whole UIKit Framework uses delegate & datasource design patterns in all its classes such as UIApplication, UITableView, UICollectionView, UITextField & so on to communicate data. Unfortunately, UIKit Framework is not open source.
If in any case Bourne's answer doesn't help .. a delegate is basically the reaction of an event on an object and saying ".delegate=self" means those protocols have been adopted in self ... for eg.. what happens when a row is selected in tableview is told by tableview's delegate method "didSelectRowAtIndexPath" ... and if a viewcontroller has a tableview ..
and "didSelectRowAtIndexPath" is defined in that viewcontroller only then we will say ... tableview.delegate = self"...
and "self.anything" is used to say that "anything" is a property of self..
for eg.
NSString* anything;
#property(nonatomic,retain) NSString* anything;
then "self.anything"