UITableview: Como desativar a seleção para algumas linhas, mas não para outras

Estou exibindo em um tableviewconteúdo de grupo analisado de XML. Desejo desativar o evento click nele (não devo clicar nele). A tabela contém dois grupos. Desejo desativar a seleção apenas para o primeiro grupo, mas não para o segundo. Clicando na primeira linha do segundo grupo navigatesno meu tube player view.

Como posso selecionar apenas grupos ou linhas específicos?

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

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

Obrigado.

Você só precisa colocar esse código em cellForRowAtIndexPath

Para desativar a propriedade de seleção da célula: (ao tocar na célula)

cell.selectionStyle = UITableViewCellSelectionStyleNone;

Para permitir poder selecionar (toque) na célula: (tocando na célula)

// Default style
cell.selectionStyle = UITableViewCellSelectionStyleBlue;

// Gray style
cell.selectionStyle = UITableViewCellSelectionStyleGray;

Observe que uma célula com selectionStyle = UITableViewCellSelectionStyleNone;ainda fará com que a interface do usuário chame didSelectRowAtIndexPathquando tocada pelo usuário. Para evitar isso, faça o sugerido abaixo e defina.

cell.userInteractionEnabled = NO;

em vez de. Observe também que você pode definir cell.textLabel.enabled = NO;para esmaecer o item.

Se você deseja tornar uma linha (ou subconjunto de linhas) não selecionável , implemente o UITableViewDelegatemétodo -tableView:willSelectRowAtIndexPath:(também mencionado pelo TechZen). Se indexPathnão puder ser selecionado , retorne nil, caso contrário, retorne indexPath. Para obter o comportamento de seleção padrão, basta retornar o indexPathpassado ao seu delegatemétodo, mas você também pode alterar a seleção de linha retornando um diferente indexPath.

exemplo:

- (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;
}

A partir do iOS 6, você pode usar

-tableView:shouldHighlightRowAtIndexPath:

Se você retornar NO, desabilitará o destaque da seleção e os seguimentos acionados pelo storyboard conectados a essa célula.

O método é chamado quando um toque é pressionado em uma linha. Retornar NOa essa mensagem interrompe o processo de seleção e não faz com que a linha atualmente selecionada perca a aparência selecionada enquanto o toque é pressionado.

Referência do protocolo UITableViewDelegate

Nenhuma das respostas acima realmente resolve o problema corretamente. O motivo é que queremos desativar a seleção da célula, mas não necessariamente de subvisões dentro da célula.

No meu caso, eu estava apresentando um UISwitch no meio da linha e queria desativar a seleção para o restante da linha (que está vazia), mas não para o comutador! A maneira correta de fazer isso está no método

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

onde uma declaração do formulário

[cell setSelectionStyle:UITableViewCellSelectionStyleNone];

desabilita a seleção para a célula específica e, ao mesmo tempo, permite ao usuário manipular a opção e, portanto, usar o seletor apropriado. Isso não é verdade se alguém desabilitar a interação do usuário através do

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

método que apenas prepara a célula e não permite a interação com o UISwitch.

Além disso, usando o método

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

para desmarcar a célula com uma declaração do formulário

[tableView deselectRowAtIndexPath:indexPath animated:NO];

ainda mostra a linha sendo selecionada enquanto o usuário pressiona o contentView original da célula.

Apenas meus dois centavos. Tenho certeza de que muitos acharão isso útil.

Você intercepta seleções com esses métodos de fonte de dados.

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

Nesses métodos, você verifica se a linha selecionada é aquela que deseja ser selecionável. Se for, execute uma ação, se não, não faça nada.

Infelizmente, você não pode desativar a seleção em apenas uma seção. É a mesa inteira ou nada.

No entanto, você pode definir a selectionStylepropriedade de células da tabela como UITableViewCellSelectionStyleNone. Acredito que tornará a seleção invisível. Combinado com os métodos acima, que devem fazer com que as células pareçam completamente inertes da perspectiva do usuário.

Edit01:

Se você possui uma tabela na qual apenas algumas das linhas são selecionáveis, é importante que as células das linhas selecionáveis ​​sejam visualmente distintas das linhas não selecionáveis. O botão de acessórios da chevron é a maneira padrão de fazer isso.

Seja como for, você não quer que seus usuários tentem selecionar linhas e pensem que o aplicativo falhou porque a linha não faz nada.

Para o Swift 4.0, por exemplo:

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

Você precisa fazer algo como o seguinte para desativar a seleção de células dentro do cellForRowAtIndexPathmétodo:

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

Para mostrar a célula acinzentada, coloque o seguinte no tableView:WillDisplayCell:forRowAtIndexPathmétodo:

[cell setAlpha:0.5];

Um método permite controlar a interatividade, o outro permite controlar a aparência da interface do usuário.

Para interromper a seleção de algumas células, use:

cell.userInteractionEnabled = NO;

Além de impedir a seleção, isso também impede que tableView: didSelectRowAtIndexPath: seja chamado pelas células que o definiram.

Você pode usar o tableView:willDisplayCellmétodo para fazer todos os tipos de personalização em um 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];
     }
} 

Nesse código acima, o usuário pode selecionar apenas a primeira linha na segunda seção do tableView. O restante de todas as linhas não pode ser selecionado. Obrigado!

Para rápida:

cell.selectionStyle = .None
cell.userInteractionEnabled = false

Minha solução baseada no modelo de dados:

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
}

Para o Swift 4.0, isso fará o truque. Ele desativará a célula no método didSelectRowAtIndexPath, mas manterá as subvisões clicáveis.

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

Use isso para fazer com que a célula pareça desabilitada e não selecionável:

cell.selectionStyle = UITableViewCellSelectionStyleNone;

Importante: observe que essa é apenas uma propriedade de estilo e, na verdade, não desativa a célula. Para fazer isso, você deve verificar selectionStylea didSelectRowAtIndexPath:implementação do seu delegado:

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

    // do your cell selection handling here
}

Eu gosto da resposta de Brian Chapados acima. No entanto, isso significa que você pode ter a lógica duplicada no cellForRowAtIndexPath e depois no willSelectRowAtIndexPath, que pode facilmente ficar fora de sincronia. Em vez de duplicar a lógica, basta verificar o selectionStyle:

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

    else
        return indexPath;
}

Achei isso útil, pois trabalha com tabelas estáticas e dinâmicas. Defino apenas o indicador de divulgação nas células que desejo permitir a seleção.

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

no Xcode 7 sem codificação, você pode simplesmente fazer o seguinte:

Na exibição de estrutura de tópicos, selecione Célula de exibição de tabela. (A célula está aninhada em Cena do controlador de exibição de tabela> Controlador de exibição de tabela> Exibição de tabela. Talvez seja necessário divulgar esses objetos para ver a célula de exibição de tabela)

No inspetor Atributos, localize o campo Seleção e selecione Nenhum. Atribuir inspetor Com esta opção, a célula não receberá um destaque visual quando um usuário toca nela.

SIMPLES

Basta usar cell.userInteractionEnabled = YES;a célula se ela puder navegar e de cell.userInteractionEnabled = NO;outra forma

Implemente apenas o método tableView:willSelectRowAtIndexPath: na fonte de dados para sua tabela. Se você deseja destacar a linha no caminho, retorne o indexPath fornecido. Caso contrário, retorne zero.

Exemplo do meu aplicativo:

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

O bom disso é que shouldPerformSegueWithIdentifier:sender:não será chamado se o método acima retornar nulo, embora eu repita o teste acima apenas por completo.

Para o Xcode 6.3:

 cell.selectionStyle = UITableViewCellSelectionStyle.None;

Eu concordo com a resposta de Bryan

se eu fizer

cell.isUserInteractionEnabled = false 

as subvisões dentro da célula não serão interagidas pelo usuário.

No outro site, definindo

cell.selectionStyle = .none

acionará o método didSelect, apesar de não atualizar a cor da seleção.

Usar willSelectRowAt é a maneira que resolvi meu problema. Exemplo:

func tableView(_ tableView: UITableView, willSelectRowAt indexPath: IndexPath) -> IndexPath? {

    if indexPath.section == 0{

        if indexPath.row == 0{
            return nil
        }

    }
    else if indexPath.section == 1{

        if indexPath.row == 0{
            return nil
        }

    }

    return indexPath

}

além de tableView.allowsMultipleSelection = truevocê precisará desmarcar o restante das células da seção ao selecionar:

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) }
    }
}

para o swift 3.0, você pode usar o código abaixo para desativar a interação do usuário com a célula UITableView

 cell.isUserInteractionEnabled = false