A subvisão UITableViewCell desaparece quando a célula é selecionada

Estou implementando uma exibição de tabela de seleção de cores em que o usuário pode selecionar, por exemplo, 10 cores (depende do produto). O usuário também pode selecionar outras opções (como capacidade do disco rígido, ...).

Todas as opções de cores estão dentro de sua própria seção de tableview.

Quero exibir um pequeno quadrado à esquerda do textLabel mostrando a cor real.

No momento, estou adicionando um UIView quadrado simples, fornecendo a cor de fundo correta, desta forma:

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:RMProductAttributesCellID];
    if (cell == nil) {
        cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleValue1 reuseIdentifier:RMProductAttributesCellID] autorelease];
        cell.indentationWidth = 44 - 8;

        UIView *colorThumb = [[[UIView alloc] initWithFrame:CGRectMake(8, 8, 28, 28)] autorelease];
        colorThumb.tag = RMProductAttributesCellColorThumbTag;
        colorThumb.hidden = YES;
        [cell.contentView addSubview:colorThumb];
    }

    RMProductAttribute *attr = (RMProductAttribute *)[_product.attributes objectAtIndex:indexPath.section];
    RMProductAttributeValue *value = (RMProductAttributeValue *)[attr.values objectAtIndex:indexPath.row];
    cell.textLabel.text = value.name;
    cell.textLabel.backgroundColor = [UIColor clearColor];

    UIView *colorThumb = [cell viewWithTag:RMProductAttributesCellColorThumbTag];
    colorThumb.hidden = !attr.isColor;
    cell.indentationLevel = (attr.isColor ? 1 : 0);

    if (attr.isColor) {
        colorThumb.layer.cornerRadius = 6.0;
        colorThumb.backgroundColor = value.color;
    }

    [self updateCell:cell atIndexPath:indexPath];

    return cell;
}

Isso é exibido sem problemas.

Meu único problema é que, quando seleciono uma linha "colorida", durante a animação de seleção de desbotamento para azul, meu UIView personalizado (colorThumb) fica oculto. Torna-se visível novamente logo após o término da animação de seleção / desmarcação, mas isso produz um artefato feio.

O que devo fazer para corrigir isso? Não insiro a subvisão no lugar certo?

(Não há nada de especial no didSelectRowAtIndexPath, basta alterar o acessório da célula para uma caixa de seleção ou nada e desmarcar o indexPath atual).

UITableViewCellmuda a cor de todos os pontos de vista sub fundo quando a célula é selecionada ou destacado, você pode resolver este problema, substituindo célula Tableview setSelected:animatede setHighlighted:animatede redefinir cor fundo vista.

No objetivo C:

- (void)setSelected:(BOOL)selected animated:(BOOL)animated {
   UIColor *color = self.yourView.backgroundColor;        
   [super setSelected:selected animated:animated];

    if (selected){
        self.yourView.backgroundColor = color;
    }
}

-(void)setHighlighted:(BOOL)highlighted animated:(BOOL)animated{
    UIColor *color = self.yourView.backgroundColor;        
    [super setHighlighted:highlighted animated:animated];

    if (highlighted){
        self.yourView.backgroundColor = color;
    }
}

No Swift 3.1:

override func setSelected(_ selected: Bool, animated: Bool) {
    let color = yourView.backgroundColor         
    super.setSelected(selected, animated: animated)

    if selected {
        yourView.backgroundColor = color
    }
}

override func setHighlighted(_ highlighted: Bool, animated: Bool) {
    let color = yourView.backgroundColor
    super.setHighlighted(highlighted, animated: animated)

    if highlighted {
        yourView.backgroundColor = color
    }
}

É porque a célula de exibição de tabela altera automaticamente a cor de plano de fundo de todas as visualizações na exibição de conteúdo para o estado destacado. Você pode considerar a subclasse UIViewpara desenhar sua cor ou usar uma UIImageViewimagem esticada personalizada de 1x1 px.

Encontrei uma solução bastante elegante em vez de mexer nos métodos de seleção / destaque tableViewCell. Você pode criar uma subclasse do UIView que ignore a configuração da cor do plano de fundo para limpar a cor.

Swift 3/4:

class NeverClearView: UIView {
    override var backgroundColor: UIColor? {
        didSet {
            if backgroundColor != nil && backgroundColor!.cgColor.alpha == 0 {
                backgroundColor = oldValue
            }
        }
    }
}

Swift 2:

class NeverClearView: UIView {
    override var backgroundColor: UIColor? {
        didSet {
            if CGColorGetAlpha(backgroundColor!.CGColor) != 0 {
                backgroundColor = oldValue
            }
        }
    }
}

Versão Obj-C:

@interface NeverClearView : UIView

@end

@implementation NeverClearView

- (void)setBackgroundColor:(UIColor *)backgroundColor {
    if (CGColorGetAlpha(backgroundColor.CGColor) != 0) {
        [super setBackgroundColor:backgroundColor];
    }
}

@end

Outra maneira de gerenciar o problema é preencher a visualização com gradiente de gráficos principais, como:

CAGradientLayer* gr = [CAGradientLayer layer];
gr.frame = mySubview.frame;
gr.colors = [NSArray arrayWithObjects:
                     (id)[[UIColor colorWithRed:0 green:0 blue:0 alpha:.5] CGColor]
                     ,(id)[[UIColor colorWithRed:0 green:0 blue:0 alpha:.5] CGColor]
                     , nil];

gr.locations = [NSArray arrayWithObjects:[NSNumber numberWithFloat:0],[NSNumber numberWithFloat:1],nil];

[mySubview.layer insertSublayer:gr atIndex:0];

Para o Swift 2.2, isso funciona

cell.selectionStyle = UITableViewCellSelectionStyle.None

e a razão é explicada por @ Andriy

É porque a célula de exibição de tabela altera automaticamente a cor de plano de fundo de todas as visualizações na exibição de conteúdo para o estado destacado.

Inspirado por Yatheesha BL 's resposta eu criei um UITableViewCell categoria / extensão que lhe permite ligar e desligar esse 'recurso' transparência.

Rápido

let cell = <Initialize Cell>
cell.keepSubviewBackground = true  // Turn  transparency "feature" off
cell.keepSubviewBackground = false // Leave transparency "feature" on

Objetivo-C

UITableViewCell* cell = <Initialize Cell>
cell.keepSubviewBackground = YES;  // Turn  transparency "feature" off
cell.keepSubviewBackground = NO;   // Leave transparency "feature" on

KeepBackgroundCell é compatível com CocoaPods. Você pode encontrá-lo no GitHub

Você pode cell.selectionStyle = UITableViewCellSelectionStyleNone;definir o backgroundColor como- (void)tableView:(UITableView *)tableView didHighlightRowAtIndexPath:(NSIndexPath *)indexPath

Inspirado pela resposta de Yatheesha BL .

Se você chamar super.setSelected (selecionado, animado: animado), ele limpará toda a cor de fundo que você definir . Portanto, não chamaremos super método.

Em Swift:

override func setSelected(selected: Bool, animated: Bool) {    
    if(selected)  {
        contentView.backgroundColor = UIColor.red 
    } else {
        contentView.backgroundColor = UIColor.white
    }
}

override func setHighlighted(highlighted: Bool, animated: Bool) {
    if(highlighted) {
        contentView.backgroundColor = UIColor.red 
    } else {
        contentView.backgroundColor = UIColor.white
    }
}

Para maiúsculas e minúsculas, estas são as tentativas para evitar a cor cinza de todos os itens da célula (caso você esteja usando a célula de exibição de tabela personalizada):

1. Defina o SelectionStyle para .none 👉 selectionStyle = .none

2. Substitua esse método.

   func setHighlighted (_ realçado: Bool, animado: Bool)

3. Ligue para o super, para obter o benefício da super configuração.

   super.setHighlighted (realçado, animado: animado)

4. Faça o que sempre destacando a lógica que você deseja.

   override func setHighlighted(_ highlighted: Bool, animated: Bool) {
         super.setHighlighted(highlighted, animated: animated)
         // Your Highlighting Logic goes here...
   }

UITableViewCell altera o backgroundColor de todas as subvisões na seleção por algum motivo.

Isso pode ajudar:

DVColorLockView

Use algo assim para impedir que o UITableView altere a cor da exibição durante a seleção.

Desenhe a vista em vez de definir a cor de fundo

import UIKit

class CustomView: UIView {

    var fillColor:UIColor!

    convenience init(fillColor:UIColor!) {
        self.init()
        self.fillColor = fillColor
    }

    override func drawRect(rect: CGRect) {
        if let fillColor = fillColor {
            let context = UIGraphicsGetCurrentContext()
            CGContextSetFillColorWithColor(context, fillColor.CGColor);
            CGContextFillRect (context, self.bounds);

        }
    }


}

Solução MAIS SIMPLES sem bugs com animação (como na resposta mais votada) e sem subclassificação e desenho - defina a cor da borda da camada em vez de backgroundColor e defina uma largura de borda muito grande.

colorThumb.layer.cornerRadius = 6
colorThumb.layer.borderWidth = colorThumb.frame.width
colorThumb.layer.borderColor = value.color

Tente o seguinte código:

-(void)setHighlighted:(BOOL)highlighted animated:(BOOL)animated
{     
[super setHighlighted:highlighted animated:animated];
//Set your View's Color here.
}

Não se esqueça de substituir setSelected, bem comosetHighlighted

override func setHighlighted(highlighted: Bool, animated: Bool) {

    super.setHighlighted(highlighted, animated: animated)
    someView.backgroundColor = .myColour()
}

override func setSelected(selected: Bool, animated: Bool) {

    super.setSelected(selected, animated: animated)
    someView.backgroundColor = .myColour()
}

Isso é semelhante à resposta de Pavel Gurov, mas mais flexível na medida em que permite que qualquer cor seja permanente.

class PermanentBackgroundColorView: UIView {
    var permanentBackgroundColor: UIColor? {
        didSet {
            backgroundColor = permanentBackgroundColor
        }
    }

    override var backgroundColor: UIColor? {
        didSet {
            if backgroundColor != permanentBackgroundColor {
                backgroundColor = permanentBackgroundColor
            }
        }
    }
}

Eu queria manter o comportamento de seleção padrão, exceto uma subvisão de célula que desejava ignorar a alteração automática da cor de fundo. Mas eu também precisava mudar a cor do plano de fundo em outros momentos.

A solução que encontrei foi a subclasse, UIViewpara que ela ignore a configuração da cor de fundo normalmente e adicione uma função separada para ignorar a proteção.

Swift 4

class MyLockableColorView: UIView {
    func backgroundColorOverride(_ color: UIColor?) {
            super.backgroundColor = color
    }

    override var backgroundColor: UIColor? {
        set {
            return
        }
        get {
            return super.backgroundColor
        }
    }
}

Aqui está a minha solução, use contentView para mostrar a seleçãoColor, ele funciona perfeitamente

#import "BaseCell.h"

@interface BaseCell ()
@property (nonatomic, strong) UIColor *color_normal;
@property (nonatomic, assign) BOOL needShowSelection;
@end


@implementation BaseCell
@synthesize color_customSelection;
@synthesize color_normal;
@synthesize needShowSelection;

- (void)awakeFromNib
{
    [super awakeFromNib];
    [self setup];
}

- (void)setup
{
    //save normal contentView.backgroundColor
    self.color_normal = self.backgroundColor;
    if (self.color_normal == nil) {
        self.color_normal = [UIColor colorWithRGBHex:0xfafafa];
    }
    self.color_customSelection = [UIColor colorWithRGBHex:0xF1F1F1];
    self.accessoryView.backgroundColor = [UIColor clearColor];
    if (self.selectionStyle == UITableViewCellSelectionStyleNone) {
        needShowSelection = NO;
    }
    else {
        //cancel the default selection
        needShowSelection = YES;
        self.selectionStyle = UITableViewCellSelectionStyleNone;
    }
}

/*
 solution is here
 */
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
{
    [super touchesBegan:touches withEvent:event];
    if (needShowSelection) {
        self.contentView.backgroundColor = self.backgroundColor = color_customSelection;
    }
}

- (void)touchesCancelled:(NSSet *)touches withEvent:(UIEvent *)event
{
    [super touchesCancelled:touches withEvent:event];
    if (needShowSelection) {
        self.contentView.backgroundColor = self.backgroundColor = color_normal;
    }
}

- (void)setSelected:(BOOL)selected animated:(BOOL)animated
{
    [super setSelected:selected animated:animated];
    if (needShowSelection) {
        UIColor *color  = selected ? color_customSelection:color_normal;
        self.contentView.backgroundColor = self.backgroundColor = color;
    }
}

Coloque esse código na sua subclasse de UITableViewCell

Sintaxe do Swift 3

override func setSelected(_ selected: Bool, animated: Bool) {
    super.setSelected(selected, animated: animated)

    if(selected) {
        lockerSmall.backgroundColor = UIColor.init(red: 233/255, green: 106/255, blue: 49/255, alpha: 1.0)
    }
}


override func setHighlighted(_ highlighted: Bool, animated: Bool) {
    super.setHighlighted(highlighted, animated: animated)

    if(highlighted) {
        lockerSmall.backgroundColor = UIColor.init(red: 233/255, green: 106/255, blue: 49/255, alpha: 1.0)
    }
}

Adicionando outra solução se você estiver usando storyboards. Crie uma subclasse UIViewque não permita que ela backgroundColorseja configurada depois de configurada inicialmente.

@interface ConstBackgroundColorView : UIView

@end

@implementation ConstBackgroundColorView

- (void)setBackgroundColor:(UIColor *)backgroundColor {
    if (nil == self.backgroundColor) {
        [super setBackgroundColor:backgroundColor];
    }
}

@end

Se a solução em segundo plano mencionada acima não estiver solucionando o problema, seu problema poderá estar presente no datasourceseu tableView.

Para mim, eu estava criando uma instância de um objeto DataSource (chamado BoxDataSource) para manipular os métodos delegate e dataSource tableView, da seguinte maneira:

//In cellForRowAtIndexPath, when setting up cell
let dataSource = BoxDataSource(delegate: self)
cell.tableView.dataSource = dataSource
return cell

Isso fazia com que o dataSource fosse desalocado sempre que a célula era tocada e, portanto, todo o conteúdo desaparecia. O motivo é que a ARC está desalocando / coletando a natureza.

Para corrigir isso, eu tive que ir para a célula personalizada, adicionar uma variável de fonte de dados:

//CustomCell.swift
var dataSource: BoxDataSource?

Em seguida, é necessário definir o dataSource para o dataSource da célula que varvocê acabou de criar no cellForRow, para que isso não seja desalocado com o ARC.

cell.statusDataSource = BoxAssigneeStatusDataSource(delegate: self)
cell.detailsTableView.dataSource = cell.statusDataSource
return cell

Espero que ajude.