ChatGPT解决这个技术问题 Extra ChatGPT

UITableview: How to Disable Selection for Some Rows but Not Others

I am displaying in a group tableview contents parsed from XML. I want to disable the click event on it (I should not be able to click it at all) The table contains two groups. I want to disable selection for the first group only but not the second group. Clicking the first row of second group navigates to my tube player view.

How can I make just specific groups or rows selectable?

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath 
{
    if(indexPath.section!=0)
    if(indexPath.row==0)    

    [[UIApplication sharedApplication] openURL:[NSURL URLWithString:tubeUrl]];   
}

Thanks.


r
rmaddy

You just have to put this code into cellForRowAtIndexPath

To disable the cell's selection property: (while tapping the cell)

cell.selectionStyle = UITableViewCellSelectionStyleNone;

To enable being able to select (tap) the cell: (tapping the cell)

// Default style
cell.selectionStyle = UITableViewCellSelectionStyleBlue;

// Gray style
cell.selectionStyle = UITableViewCellSelectionStyleGray;

Note that a cell with selectionStyle = UITableViewCellSelectionStyleNone; will still cause the UI to call didSelectRowAtIndexPath when touched by the user. To avoid this, do as suggested below and set.

cell.userInteractionEnabled = NO;

instead. Also note you may want to set cell.textLabel.enabled = NO; to gray out the item.


This method will generate bug if you try to swipe to delete.
This is hack! Do do that, use answer below - using willSelectRowAtIndexPath with returning nil!
The userInteractionEnabled stuff is not correct, hook willSelectRowAtIndexPath instead as people note.
On iOS 6.0 and later, tableView:shouldHighlightRowAtIndexPath: is a new UITableViewDelegate method that returns a BOOL based on whether or not the passed indexPath should be highlighted. If you're building for 6.0 and later, I strongly recommend this new API.
if you're doing this in Swift and you're having trouble but ended up here, you'll need to set cell!.selectionStyle = .None which force unwraps the cell, allowing you to access its properties.
R
Rishil Patel

If you want to make a row (or subset of rows) non-selectable, implement the UITableViewDelegate method -tableView:willSelectRowAtIndexPath: (also mentioned by TechZen). If the indexPath should be not be selectable, return nil, otherwise return the indexPath. To get the default selection behavior, you just return the indexPath passed to your delegate method, but you can also alter the row selection by returning a different indexPath.

example:

- (NSIndexPath *)tableView:(UITableView *)tableView willSelectRowAtIndexPath:(NSIndexPath *)indexPath {
    // rows in section 0 should not be selectable
    if ( indexPath.section == 0 ) return nil;

    // first 3 rows in any section should not be selectable
    if ( indexPath.row <= 2 ) return nil;

    // By default, allow row to be selected
    return indexPath;
}

Small detail: you ment <= 2, not =< 2. Bad smiley! :)
I would also like to add that this is the correct answer, but you should also set the selectionStyle to UITableViewCellSelectionStyleNone in cellForRowAtIndexPath. Why? because without this selection style the cell cannot be selected but it will still display "as selected" when touched down (so it changes to the selected color, if there is one for the other cells)
this should have more upvotes than the accepted answer
I think the main reason this isn't the accepted answer is because the accepted answer is easier. While it's not the 'best way' to do it because your table will still call setSelected: on your cells, it still works, visually. This answer here takes more work but is the proper way to do it (you must combine @TooManyEduardos suggestion as well) to avoid any unforeseen consequences of the table calling setSelected: on your cells.
I like this answer, but if you don't want to duplicate your logic in cellForRowAtIndexPath and willSelectRowAtIndexPath, just check if cell.selectionStyle == none in willSelectRowAtIndexPath to return nil (see my answer below)
B
Benjohn

Starting in iOS 6, you can use

-tableView:shouldHighlightRowAtIndexPath:

If you return NO, it disables both the selection highlighting and the storyboard triggered segues connected to that cell.

The method is called when a touch comes down on a row. Returning NO to that message halts the selection process and does not cause the currently selected row to lose its selected look while the touch is down.

UITableViewDelegate Protocol Reference


Agreed. For iOS 7 & above this should be the preferred method (in fact on iOS 8 other methods weren't working for me.)
This should be the top answer.
M
MightyMouse

None from the answers above really addresses the issue correctly. The reason is that we want to disable selection of the cell but not necessarily of subviews inside the cell.

In my case I was presenting a UISwitch in the middle of the row and I wanted to disable selection for the rest of the row (which is empty) but not for the switch! The proper way of doing that is hence in the method

- (void)tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath

where a statement of the form

[cell setSelectionStyle:UITableViewCellSelectionStyleNone];

disables selection for the specific cell while at the same time allows the user to manipulate the switch and hence use the appropriate selector. This is not true if somebody disables user interaction through the

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath

method which merely prepares the cell and does not allow interaction with the UISwitch.

Moreover, using the method

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath

in order to deselect the cell with a statement of the form

[tableView deselectRowAtIndexPath:indexPath animated:NO];

still shows the row being selected while the user presses on the original contentView of the cell.

Just my two cents. I am pretty sure many will find this useful.


Agree. And returning nil in willSelectRowAtIndexPath has the same issue, subviews are not selectable.
Also note that if you have a static table you can just set the Selection to None in the Interface Builder for the cells you don't want the selection to appear.
A
Alessandro Ornano

For Swift 4.0 for example:

cell.isUserInteractionEnabled = false
cell.contentView.alpha = 0.5

This is the approach I have historically used, but it no longer appears to work when cells are configured using content configuration vs. text and detail labels.
Update - this approach does still work as long as the content view's alpha value is set after setting the cell's content configuration.
T
TechZen

You trap selections with these data source methods.

– tableView:willSelectRowAtIndexPath: 
– tableView:didSelectRowAtIndexPath: 
– tableView:willDeselectRowAtIndexPath: 
– tableView:didDeselectRowAtIndexPath:

In these methods, you check if the selected row is one you want to be selectable. If it is, take an action, if not, do nothing.

Unfortunately, you can't turn off selection for just one section. It's the whole table or nothing.

You can however set the table cells selectionStyle property to UITableViewCellSelectionStyleNone. I believe that will make the selection invisible. Combined with the above methods that should make the cells look completely inert from the user's perspective.

Edit01:

If you have a table in which only some of the rows are selectable it is important that the cells of the selectable rows be visually distinct from the non-selectable rows. The chevron accessory button is the default way to do this.

However you do it, you don't want your users trying to select rows and thinking the app has malfed because the row doesn't do anything.


please elaborate how to use these methods or give some sample program links
@Warrior: If you have installed the SDK you can open up Xcode, go to Help -> Developer documentation, then copy those method names into the search field to see how it works. The Developer documentation also contains sample code.
B
Baum mit Augen

You need to do something like the following to disable cell selection within the cellForRowAtIndexPath method:

[cell setSelectionStyle:UITableViewCellSelectionStyleNone];
[cell setUserInteractionEnabled:NO];

To show the cell grayed out, put the following within the tableView:WillDisplayCell:forRowAtIndexPath method:

[cell setAlpha:0.5];

One method allows you to control the interactivity, the other allows you to control the UI appearance.


N
Nilesh

For swift 4.0 This will do the trick. It will disable the Cell in didSelectRowAtIndexPath method but keep the subviews clickable.

func tableView(_ tableView: UITableView, willSelectRowAt indexPath: IndexPath) -> IndexPath? {
         if (indexPath.row == clickableIndex ) { 
            return indexPath
         }else{
            return nil
        }
    }

Or for short: return indexPath.row == clickableIndex ? indexPath : nil, keeps your code a bit cleaner ;-)
J
JosephH

To stop just some cells being selected use:

cell.userInteractionEnabled = NO;

As well as preventing selection, this also stops tableView:didSelectRowAtIndexPath: being called for the cells that have it set.


A weird thing happen all the time: when I set userInteractionEnabled to NO on one cell (more clearly, one indexPath), user interaction of some OTHER cells are disabled. I have no clue why this happen every time I use userInteractionEnabled on table view cells. Is it a known bug or I did something wrong?
@Philip007 Are the "NO" cells being reused? If so you may need to make sure you set it to "YES" when you dequeue a cell.
Why set it to "YES"? I want it to to be NO (disallow user interaction).. A typical example is that I set user interaction of the first row (if [indexPath row] == 0) to NO in tableView:cellForRowAtIndexPath: after dequeueing the cell. It usually works OK at first. Then after several calls of reloadData, suddenly the fifth row is disallowed interaction, then the fourth row.. I can't figure out when it will happen. The whole thing looks random.
@Philip007 If you are reusing cells, you will need to reset it to "YES" for the cells you DO want to be interactive. Otherwise if a "NO" cell is reused in a row you do want to be interactive, it will still be disabled. ie: if [indexPath row] == 0) { set to NO } else { set to YES }
E
Esqarrouth

For swift:

cell.selectionStyle = .None
cell.userInteractionEnabled = false

This has been the best solution for me, except I leave isUserInteractiveEnabled. I created many reusable cells programmatically with different controls, i.e. a cell with a UISwitch, a UISlider, a UIPickerView etc. The cell itself cannot be touched and the accessory control remains user-interactive. No need to keep re-implementing this in the delegate.
A
Abdul Rahman

You can use the tableView:willDisplayCell method to do all the kinds of customization to a tableViewCell.

- (void)tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath
{
     [cell setSelectionStyle:UITableViewCellSelectionStyleNone];
     [cell setUserInteractionEnabled:NO];

     if (indexPath.section == 1 && indexPath.row == 0)
     {
         [cell setSelectionStyle:UITableViewCellSelectionStyleGray];
         [cell setUserInteractionEnabled:YES];
     }
} 

In this above code, the user can only select the first row in the second section of the tableView. The rest all rows can't be selected. Thanks!~


S
SoftDesigner

My solution based on data model:

func tableView(_ tableView: UITableView, willSelectRowAt indexPath: IndexPath) -> IndexPath? {
    let rowDetails = viewModel.rowDetails(forIndexPath: indexPath)
    return rowDetails.enabled ? indexPath : nil
}

func tableView(_ tableView: UITableView, shouldHighlightRowAt indexPath: IndexPath) -> Bool {
    let rowDetails = viewModel.rowDetails(forIndexPath: indexPath)
    return rowDetails.enabled
}

y
ySgPjx

Use this to make the cell look like it is disabled and non-selectable:

cell.selectionStyle = UITableViewCellSelectionStyleNone;

Important: note that this is only a styling property, and does not actually disable the cell. In order to do that, you have to check for selectionStylein your didSelectRowAtIndexPath: delegate implementation:

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath {
    UITableViewCell *cell = [tableView cellForRowAtIndexPath:indexPath];
    if(cell.selectionStyle == UITableViewCellSelectionStyleNone) {
        return;
    }

    // do your cell selection handling here
}

E
Eric D'Souza

I like Brian Chapados answer above. However, this means that you may have logic duplicated in both cellForRowAtIndexPath and then in willSelectRowAtIndexPath which can easily get out of sync. Instead of duplicating the logic, just check the selectionStyle:

- (NSIndexPath *)tableView:(UITableView *)tableView willSelectRowAtIndexPath:(NSIndexPath *)indexPath
{
    UITableViewCell *cell = [tableView cellForRowAtIndexPath:indexPath];
    if (cell.selectionStyle == UITableViewCellSelectionStyleNone)
        return nil;

    else
        return indexPath;
}

J
Jeffery Jones

I found this handy as it works with both static and dynamic tables. I only set the disclosure indicator on those cells I want to allow selection.

- (NSIndexPath *)tableView:(UITableView *)tableView willSelectRowAtIndexPath:(NSIndexPath *)indexPath {
    UITableViewCell *cell = [tableView cellForRowAtIndexPath:indexPath];
    if (cell.accessoryType != UITableViewCellAccessoryDisclosureIndicator) {
        return nil;
    }
    return indexPath;
}

T
Tung Fam

on Xcode 7 without coding you can simply do the following:

In the outline view, select Table View Cell. (The cell is nested under Table View Controller Scene > Table View Controller > Table View. You may have to disclose those objects to see the table view cell)

In the Attributes inspector, find the field labeled Selection and select None. atribute inspector With this option, the cell won’t get a visual highlight when a user taps it.


r
rgkobashi

appart from tableView.allowsMultipleSelection = true you will need to deselect the rest of the cells of the section when selecting:

func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
    if indexPath.section does not support multiple selection {
        // deselect the rest of cells
        tableView
            .indexPathsForSelectedRows?.compactMap { $0 }
            .filter { $0.section == indexPath.section && $0.row != indexPath.row }
            .forEach { tableView.deselectRow(at: $0, animated: true) }
    }
}

H
Helton Malambane

Swift 5: Place the following line inside your cellForRowAt function:

cell.selectionStyle = UITableViewCell.SelectionStyle.none

P
Peter

I agree with Bryan's answer.

If I do cell.isUserInteractionEnabled = false then the subviews within the cell won't be user interacted.

On the other hand, setting cell.selectionStyle = .none will trigger the didSelect method despite not updating the selection color.

Using willSelectRowAt is the way I solved my problem. Example:

func tableView(_ tableView: UITableView, willSelectRowAt indexPath: IndexPath) -> IndexPath? {
    switch (indexPath.section, indexPath.row) {
    case (0, 0), (1, 0): return nil
    default: return indexPath
    }
}

R
Rick Royd Aban

SIMPLE

Just use cell.userInteractionEnabled = YES; to the cell if it can navigate and cell.userInteractionEnabled = NO; otherwise


This also prevents interaction with any accessory view within the cell, which may not be the desired behavior.
佚名

Implement just the method tableView:willSelectRowAtIndexPath: in the data source for your table. If you want the row at the path to highlight, return the given indexPath. If you do not, return nil.

Example from my app:

- (NSIndexPath *)tableView:(UITableView *)tableView
    willSelectRowAtIndexPath:(NSIndexPath *)indexPath
{
    MySelectableObj* obj = [self objectAtPath:indexPath];
    if(obj==nil) return nil;
    return indexPath;
}

The nice thing about this is that shouldPerformSegueWithIdentifier:sender: will not be called if the above method returns nil, although I repeat the test above just for completeness.


u
uplearned.com

For Xcode 6.3:

 cell.selectionStyle = UITableViewCellSelectionStyle.None;

佚名

for swift 3.0 you can use below code to disable user interaction to UITableView cell

 cell.isUserInteractionEnabled = false