Kolor tła UIView znika po wybraniu opcji UITableViewCell

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

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

Kiedy twój UITableViewCell jest wybrany, są dwa stany, na które powinieneś zwrócić uwagę: Highlighted i Selected.

Tak więc, dla scenariuszy, w których masz niestandardową klasę komórki, która jest podklasą UITableViewCell, możesz łatwo zastąpić te dwie metody, aby uniknąć tej sytuacji (Swift):

class MyCell: UITableViewCell {

    @IBOutlet var myView: UIView!

    override func setHighlighted(highlighted: Bool, animated: Bool) {
        let myViewBackgroundColor = myView.backgroundColor
        super.setHighlighted(highlighted, animated: animated)
        myView.backgroundColor = myViewBackgroundColor
    }

    override func setSelected(selected: Bool, animated: Bool) {
        let myViewBackgroundColor = myView.backgroundColor
        super.setSelected(selected, animated: animated)
        myView.backgroundColor = myViewBackgroundColor
    }

}

Poprzednio robiłem tak, jak powiedział @P5ycH0 (rozciągnięty obraz 1x1), ale podążając za @Brooks stwierdziłem, że nadpisanie -(void)setHighlighted:(BOOL)highlighted animated:(BOOL)animated w mojej niestandardowej implementacji UITableViewCell i resetowanie kolorów tła po wywołaniu [super setHighlighted:highlighted animated:animated]; utrzymuje moje kolory tła, gdy komórka jest zaznaczona / podświetlona

-(void)setHighlighted:(BOOL)highlighted animated:(BOOL)animated {
    [super setHighlighted:highlighted animated:animated];
    myView.backgroundColor = myColor;
}

Brooks ma świetne wyjaśnienie, dlaczego tak się dzieje, ale myślę, że mam lepsze rozwiązanie.

W Twoim podkatalogu zmień setBackgroundColor: na dowolny kolor. Ustawiacz nadal będzie wywoływany, ale tylko podany kolor będzie wymuszony.

- (void)setBackgroundColor:(UIColor *)backgroundColor {
    [super setBackgroundColor:[UIColor whiteColor]];
}

Ok, utrata koloru tła klasy UIView jest normalnym zachowaniem, gdy jest w wybranej tableviewcell. Nie mogłem wymyślić, jak temu zapobiec. Teraz właśnie zamieniłem UIView na UIImageView zawierający rozciągnięty biały piksel 1x1. Brzydka imo, ale działa.

Musisz nadpisać dwie następne metody w komórce niestandardowej:

- (void) setSelected:(BOOL)selected animated:(BOOL)animated;
- (void) setHighlighted:(BOOL)highlighted animated:(BOOL)animated;

Zauważ, że:

• należy wywołać [super setSelected:animated:] i [super setHighlighted:animated:] na początku niestandardowej implementacji lub odpowiednich metod;
• powinieneś ustawić UITableViewCellSelectionStyleNone styl wyboru dla własnej komórki, aby wyłączyć domyślne style UITableViewCell;

Oto przykład realizacji:

- (void) setHighlighted:(BOOL)highlighted animated:(BOOL)animated
{
    [super setHighlighted:highlighted animated:animated];
    [self setHighlightedSelected:highlighted animated:animated];
}

- (void) setSelected:(BOOL)selected animated:(BOOL)animated
{
    [super setSelected:selected animated:animated];
    [self setHighlightedSelected:selected animated:animated];
}

- (void) setHighlightedSelected:(BOOL)selected animated:(BOOL)animated
{
    void(^selection_block)(void) =
    ^
    {
        self.contentView.backgroundColor = selected ? SELECTED_BACKGROUND_COLOR : NORMAL_BACKGROUND_COLOR;
    };

    if(animated)
    {
        [UIView animateWithDuration:SELECTION_ANIMATION_DURATION
                              delay:0.0
                            options:UIViewAnimationOptionBeginFromCurrentState
                         animations:selection_block
                         completion:NULL];
    }
    else
        selection_block();
}

Dodaj to do UITableViewCell

override func setHighlighted(highlighted: Bool, animated: Bool) {
    super.setHighlighted(false, animated: animated)
    if highlighted {
        self.backgroundColor = UIColor.blueColor()
    }else{
        UIView.animateWithDuration(0.2, animations: {
            self.backgroundColor = UIColor.clearColor()
        })
    }
}

W związku z odpowiedzią @ Brooks, to jest to, co zrobiłem, aby to działało w Swift i iOS8/iOS9.

• nadpisać setSelected i setHighlighted
• Don ' t call super
• Usuń contentView.backgroundColor, ponieważ nie musi rozciągać się na całą szerokość komórki (tj. akcesoria).

• Użyj backgroundColor samej komórki i ustaw ją odpowiednio.

  class AwesomeTableViewCell: UITableViewCell {
  
      private struct Constants {
  
          static var highlightedColor = UIColor.greenColor()
          static var selectedColor = UIColor.redColor()
  
          static let animationTime = NSTimeInterval(0.2)
      }
  
      override func awakeFromNib() {
          super.awakeFromNib()
  
          contentView.backgroundColor = UIColor.clearColor()
          backgroundColor = AppContext.sharedInstance.theme.colors.background
      }
  
      override func setHighlighted(highlighted: Bool, animated: Bool) {
          if animated {
              UIView.animateWithDuration(Constants.animationTime, animations: { () -> Void in
                  self.setHighlighted(highlighted)
              })
          } else {
              self.setHighlighted(highlighted)
          }
      }
  
      override func setSelected(selected: Bool, animated: Bool) {
  
          if animated {
              UIView.animateWithDuration(Constants.animationTime, animations: { () -> Void in
                  self.setSelected(selected)
              })
          } else {
              self.setSelected(selected)
          }
      }
  
      private func setHighlighted(highlighted: Bool) {
  
          backgroundColor = highlighted ? Constants.highlightedColor : UIColor.whiteColor()
      }
  
      private func setSelected(selected: Bool) {
  
          backgroundColor = selected ? Constants.selectedColor : UIColor.whiteColor()
      }
  }
  

Z tego, że powiedziałeś, że zbudowałeś tableViewCell używając IB, chciałbym sprawdzić, czy dodajesz swój Widok jako subview contentView z UITableViewCell, a nie view. Widok zawartości jest domyślnym podglądem zawartości wyświetlanej przez komórkę.

Od referencji:

Widok zawartości obiektu UITableViewCell jest domyślnym podglądem zawartości wyświetlanej przez komórkę. Jeśli chcesz dostosować komórki, po prostu dodając dodatkowe widoki, powinieneś dodać je do zawartości zobacz więc będą one odpowiednio ustawione, gdy komórka przechodzi do iz trybu edycji.

Możesz zmienić zachowanie tableViewCell przez nadpisanie funkcji setHighlighted w klasie UITableViewCell (będziesz musiał dziedziczyć z niej). Przykład mojego kodu, w którym zmieniam obraz tła mojej komórki:

// animate between regular and highlighted state
- (void)setHighlighted:(BOOL)highlighted animated:(BOOL)animated; {
    [super setHighlighted:highlighted animated:animated];

    //Set the correct background Image
    UIImageView* backgroundPicture = (UIImageView*)[self viewWithTag:HACK_BACKGROUND_VIEW_TAG];
    if (highlighted) {
        backgroundPicture.image = [UIImage imageNamed:@"FondSelected.png"]; 
    }
    else {
        backgroundPicture.image = [UIImage imageNamed:@"Fond.png"]; 
    }
}

Możesz również zmienić tryb wyboru na szary, niebieski lub żaden w kreatorze interfejsów.

W iOS 7, to co dla mnie zadziałało, to nadpisanie setSelected:animated: w podklasie UITableViewCell, ale w przeciwieństwie do końcówki @Brooks, zadzwoniłem [super setSelected:selected animated:animated].

- (void)setSelected:(BOOL)selected animated:(BOOL)animated
{
    [super setSelected:selected animated:animated];

    // Reassert the background color of the color view so that it shows
    // even when the cell is highlighted for selection.
    self.colorView.backgroundColor = [UIColor blueColor];
}

To pozwala mi zachować domyślną animację wyboru systemu, gdy użytkownik dotknie komórki, a także odznaczyć ją w widoku tabeli delegata didSelectRowAtIndexPath:.

Spędziłem trochę czasu nad tym dziwnym zagadnieniem. Nie chciałem ustawiać stylu uitableviewcellselectionstylenone, aby zachować ładną animację po wybraniu mojego wiersza. Ale żaden z sugerowanych pomysłów nie zadziałał dla mnie - próbowałem przesłaniać ustawione i ustawione podświetlenie i ustawić tam mój subview backgroundColor - utrzymywał Resetowanie przez iOS i nadal miga (nowy kolor -> stary kolor). Dla mnie poprawka była dość prosta. Gdy mój wiersz jest zaznaczony, inny kontroler widoku jest wypychany, użytkownik wybiera kilka opcja na tym ekranie i delegat jest wywoływana tam, gdzie zmieniam kolor na podstawie wyboru użytkownika. W tym delegacie robię tylko [cell setSelected: NO animated: NO] dla mojej komórki. (Mam statyczny UITableViewController i mam wyjścia do komórek). Możesz prawdopodobnie usunąć zaznaczenie komórki w metodzie didSelect, ale w moim przypadku używam segues.

Oto moje zdanie na ten temat. Mam podklasę, od której dziedziczą wszystkie moje komórki, więc robię to w ten sposób, aby uniknąć zmiany tła w moim UIImageViews: {]}

    override func setHighlighted(highlighted: Bool, animated: Bool) {
    var backgroundColors = [UIView: UIColor]()

    for view in contentView.subviews as [UIView] {
        if let imageView = view as? UIImageView {
            backgroundColors[imageView] = imageView.backgroundColor
        }
    }

    super.setHighlighted(highlighted, animated: animated)

    for view in contentView.subviews as [UIView] {
        if let imageView = view as? UIImageView {
            imageView.backgroundColor = backgroundColors[imageView]
        }
    }
}

override func setSelected(selected: Bool, animated: Bool) {
    var backgroundColors = [UIView: UIColor]()

    for view in contentView.subviews as [UIView] {
        if let imageView = view as? UIImageView {
            backgroundColors[imageView] = imageView.backgroundColor
        }
    }

    super.setSelected(selected, animated: animated)

    for view in contentView.subviews as [UIView] {
        if let imageView = view as? UIImageView {
            imageView.backgroundColor = backgroundColors[imageView]
        }
    }
}

To automatycznie naprawia problem dla wszystkich UIImageView.

Podsumowanie

To rozwiązanie pozwala zablokować niektóre kolory tła komórki , podczas gdy pozostałe są kontrolowane przez zachowanie systemu.

Na podstawie odpowiedzi mientusa , stworzyłem rozwiązanie, które pozwala określić, które widoki powinny zachować kolor tła .

To nadal pozwala na usunięcie tła innych podwidywań komórek przy podświetlaniu/zaznaczeniu i jest jedynym rozwiązaniem, które działa w naszym przypadku (dwa widoki wymagające stałego tła).

Użyłem podejścia zorientowanego na protokół, z protokołem BackgroundLockable zawierającym listę widoków do zablokowania i uruchamiającym zamknięcie przy zachowaniu kolorów:

protocol BackgroundLockable {
    var lockedBackgroundViews: [UIView] { get }
    func performActionWithLockedViews(_ action: @escaping () -> Void)
}

extension BackgroundLockable {
    func performActionWithLockedViews(_ action: @escaping () -> Void) {
        let lockedViewToColorMap = lockedBackgroundViews.reduce([:]) { (partialResult, view) -> [UIView: UIColor?] in
            var mutableResult = partialResult
            mutableResult[view] = view.backgroundColor
            return mutableResult
        }

        action()

        lockedViewToColorMap.forEach { (view: UIView, color: UIColor?) in
            view.backgroundColor = color
        }
    }
}

Następnie mam podklasę UITableViewCell, która nadpisuje podświetlenie i zaznaczenie, aby uruchomić zamknięcie protokołu wokół wywołania domyślnego (super) zachowania:

class LockableBackgroundTableViewCell: UITableViewCell, BackgroundLockable {

    var lockedBackgroundViews: [UIView] {
        return []
    }

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

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

Teraz muszę tylko podklasować LockableBackgroundTableViewCell lub użyć protokołu BackgroundLockable w klasie komórki, aby łatwo dodać blokowanie zachowanie do niektórych komórek!

class SomeCell: LockableBackgroundTableViewCell {

    @IBOutlet weak var label: UILabel!
    @IBOutlet weak var icon: UIImageView!
    @IBOutlet weak var button: UIButton!

    override var lockedBackgroundViews: [UIView] {
        return [label, icon]
    }
}

Swift 4

In your uitableviewcell class:

override func setSelected(_ selected: Bool, animated: Bool) {
    myView.backgroundColor = UIColor.blue
}

override func setHighlighted(_ highlighted: Bool, animated: Bool) {
    myView.backgroundColor = UIColor.blue
}