La subvista UITableViewCell desaparece cuando se selecciona la celda

Estoy implementando una vista de tabla de selección de color donde el usuario puede seleccionar, por ejemplo, 10 colores (depende del producto). El usuario también puede seleccionar otras opciones (como la capacidad del disco duro, ...).

Todas las opciones de color están dentro de su propia sección de vista de tabla.

Quiero mostrar un pequeño cuadrado a la izquierda de la etiqueta de texto que muestra el color real.

En este momento estoy agregando un simple UIView cuadrado, darle el color de fondo correcto, como este:

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

Esto se muestra bien sin problemas.

Mi único problema es que cuando selecciono una fila de "color", durante la animación de selección de fundido a azul, se oculta mi UIView (colorThumb) personalizada. Se vuelve a ver justo después de que finalizó la animación de selección / deselección, pero esto produce un feo artefacto.

¿Qué debo hacer para corregir esto? ¿No inserto la subvista en el lugar correcto?

(No hay nada especial en didSelectRowAtIndexPath, solo cambio el accesorio de la celda a una casilla de verificación o nada, y deselecciono el indexPath actual).

UITableViewCellcambia el color de fondo de todos los puntos de vista sub cuando se selecciona o resalta celular, puede resolver este problema primordial de la célula TableView setSelected:animatedy setHighlighted:animatedy restablecer el color de fondo Vista.

En el 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;
    }
}

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

Esto se debe a que la celda de vista de tabla cambia automáticamente el color de fondo de todas las vistas dentro de la vista de contenido para el estado resaltado. Puede considerar subclasificar UIViewpara dibujar su color o usar UIImageViewcon una imagen estirada personalizada de 1x1 px.

Encontró una solución bastante elegante en lugar de jugar con los métodos de selección / resaltado tableViewCell. Puede crear una subclase de UIView que ignore establecer su color de fondo para borrar el color.

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

Versión Obj-C:

@interface NeverClearView : UIView

@end

@implementation NeverClearView

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

@end

Otra forma de manejar el problema es llenar la vista con un degradado de gráficos centrales, 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 Swift 2.2 esto funciona

cell.selectionStyle = UITableViewCellSelectionStyle.None

y la razón es explicada por @ Andriy

Esto se debe a que la celda de vista de tabla cambia automáticamente el color de fondo de todas las vistas dentro de la vista de contenido para el estado resaltado.

Inspirado por Yatheesha BL 's respuesta creé una categoría UITableViewCell / extensión que le permite encender y apagar esta 'característica' transparencia.

Rápido

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

C objetivo

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

KeepBackgroundCell es compatible con CocoaPods. Puedes encontrarlo en GitHub

Puede cell.selectionStyle = UITableViewCellSelectionStyleNone;, luego establecer el color de fondo en- (void)tableView:(UITableView *)tableView didHighlightRowAtIndexPath:(NSIndexPath *)indexPath

Inspirado por Yatheesha BL .

Si llama a super.setSelected (seleccionado, animado: animado), borrará todo el color de fondo que establezca . Por lo tanto, no llamaremos super método.

En 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 el caso de mayo, este es el Septs para evitar obtener el color gris para todos los elementos en la celda (en caso de que esté usando una celda de vista de tabla personalizada):

1. Establezca selectionStyle en .none 👉 selectionStyle = .none

2. Anular este método.

   func setHighlighted (_ resaltado: Bool, animado: Bool)

3. Llame al super, para obtener el beneficio de la super configuración.

   super.setHighlighted (resaltado, animado: animado)

4. Haz lo que quieras resaltando la lógica que quieras.

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

UITableViewCell cambia el color de fondo de todas las subvistas en la selección por alguna razón.

Esto podría ayudar:

DVColorLockView

Use algo así para evitar que UITableView cambie el color de su vista durante la selección.

Dibuje la vista en lugar de establecer el color de fondo

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

        }
    }


}

Solución SIMPLEST sin errores con animación (como en la respuesta mejor calificada) y sin subclases y dibujos: configure el color del borde de la capa en lugar de backgroundColor y establezca un ancho de borde muy grande.

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

Pruebe el siguiente código:

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

No olvide anular setSelectedtan bien 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()
}

Esto es similar a la respuesta de Pavel Gurov, pero más flexible ya que permite que cualquier color sea permanente.

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

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

Quería mantener el comportamiento de selección predeterminado, excepto para una subvista de celda que quería ignorar el cambio automático de color de fondo. Pero también necesitaba poder cambiar el color de fondo en otros momentos.

La solución que se me ocurrió fue crear una subclase, UIViewpor lo que ignora la configuración del color de fondo normalmente y agrega una función separada para evitar la protección.

Swift 4

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

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

aquí está mi solución, use contentView para mostrar selectionColor, funciona perfectamente

#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 este código en su subclase de UITableViewCell

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

Agregar otra solución si está usando guiones gráficos. Crear una subclase de UIVieweso no permite backgroundColorque se establezca después de que se establece inicialmente.

@interface ConstBackgroundColorView : UIView

@end

@implementation ConstBackgroundColorView

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

@end

Si la solución de fondo mencionada anteriormente no está solucionando su problema, su problema puede estar en su datasourcepara su TableView.

Para mí, estaba creando una instancia de un objeto DataSource (llamado BoxDataSource) para manejar los métodos delegado y dataSource tableView, así:

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

Esto causaba que la fuente de datos se desasignara cada vez que se tocaba la celda, y por lo tanto, todo el contenido desaparecía. La razón es que la asignación de ARC / recolección de basura es natural.

Para solucionar esto, tuve que ir a la celda personalizada, agregar una variable de fuente de datos:

//CustomCell.swift
var dataSource: BoxDataSource?

Luego, debe establecer el origen de datos en el origen de datos de la celda varque acaba de crear en cellForRow, por lo que esto no se desasigna con ARC.

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

Espero que ayude.