Wstawka separatora UITableView iOS 8 nie działa

Mam aplikację, w której UITableViewwstawka separatora jest ustawiona na niestandardowe wartości - prawo 0, lewo 0. Działa to doskonale w iOS 7.x, ale iOS 8.0widzę, że wstawka separatora jest ustawiona na domyślną wartość 15po prawej stronie. Mimo że w plikach xib ustawiono na0 nadal wyświetla się niepoprawnie.

Jak usunąć UITableViewCellmarginesy separatora?

iOS 8.0 wprowadza właściwość layoutMargins do komórek ORAZ widoków tabeli.

Ta właściwość nie jest dostępna w systemie iOS 7.0, dlatego musisz ją sprawdzić przed przypisaniem!

Łatwym rozwiązaniem jest podklasowanie komórki i zastąpienie właściwości marginesów układu, zgodnie z sugestią @ user3570727. Utracisz jednak zachowanie systemu, takie jak dziedziczenie marginesów z obszaru bezpiecznego, więc nie polecam poniższego rozwiązania:

(Cel C)

-(UIEdgeInsets)layoutMargins { 
     return UIEdgeInsetsZero // override any margins inc. safe area
}

(szybkie 4.2):

override var layoutMargins: UIEdgeInsets { get { return .zero } set { } }

Jeśli nie chcesz przesłonić właściwości lub musisz ustawić ją warunkowo, czytaj dalej.

Oprócz tej layoutMarginswłaściwości firma Apple dodała do komórki właściwość , która uniemożliwi dziedziczenie ustawień marginesów widoku tabeli. Po ustawieniu tej właściwości komórki mogą konfigurować własne marginesy niezależnie od widoku tabeli. Potraktuj to jako nadpisanie.

Ta właściwość jest wywoływana preservesSuperviewLayoutMargins, a jej ustawienie NOpozwoli na layoutMarginzastąpienie ustawienia komórki tym, co layoutMarginjest ustawione na TableView. Oba oszczędzają czas ( nie musisz modyfikować ustawień Widoku tabeli ) i są bardziej zwięzłe. Szczegółowe wyjaśnienie znajduje się w odpowiedzi Mike'a Abdullaha.

UWAGA: poniżej znajduje się czysta implementacja ustawienia marginesu na poziomie komórki , wyrażona w odpowiedzi Mike'a Abdullaha. Ustawienie komórki preservesSuperviewLayoutMargins=NOzapewni, że widok tabeli nie zastąpi ustawień komórki. Jeśli chcesz, aby cały widok tabeli miał spójne marginesy, odpowiednio dostosuj kod.

Skonfiguruj marginesy komórkowe:

-(void)tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath
{
    // Remove seperator inset
    if ([cell respondsToSelector:@selector(setSeparatorInset:)]) {
           [cell setSeparatorInset:UIEdgeInsetsZero];
    }

    // Prevent the cell from inheriting the Table View's margin settings
    if ([cell respondsToSelector:@selector(setPreservesSuperviewLayoutMargins:)]) {
        [cell setPreservesSuperviewLayoutMargins:NO];
    }

    // Explictly set your cell's layout margins
    if ([cell respondsToSelector:@selector(setLayoutMargins:)]) {
        [cell setLayoutMargins:UIEdgeInsetsZero];
    }
}

Swift 4:

func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
    // Remove seperator inset
    if cell.responds(to: #selector(setter: UITableViewCell.separatorInset)) {
        cell.separatorInset = .zero
    }
    // Prevent the cell from inheriting the Table View's margin settings
    if cell.responds(to: #selector(setter: UITableViewCell.preservesSuperviewLayoutMargins)) {
        cell.preservesSuperviewLayoutMargins = false
    }
    // Explictly set your cell's layout margins
    if cell.responds(to: #selector(setter: UITableViewCell.layoutMargins)) {
        cell.layoutMargins = .zero
    }
}

Ustawienie preservesSuperviewLayoutMarginswłaściwości w komórce na NIE powinno uniemożliwić widok tabeli nadpisujący marginesy komórki. W niektórych przypadkach wydaje się, że nie działa poprawnie.

Jeśli wszystko zawiedzie, możesz brutalnie wymusić marginesy widoku tabeli:

-(void)viewDidLayoutSubviews
{
    [super viewDidLayoutSubviews];

    // Force your tableview margins (this may be a bad idea)
    if ([self.tableView respondsToSelector:@selector(setSeparatorInset:)]) {
        [self.tableView setSeparatorInset:UIEdgeInsetsZero];
    }

    if ([self.tableView respondsToSelector:@selector(setLayoutMargins:)]) {
        [self.tableView setLayoutMargins:UIEdgeInsetsZero];
    }
} 

Swift 4:

func viewDidLayoutSubviews() {
    super.viewDidLayoutSubviews()
    // Force your tableview margins (this may be a bad idea)
    if tableView.responds(to: #selector(setter: UITableView.separatorInset)) {
        tableView.separatorInset = .zero
    }
    if tableView.responds(to: #selector(setter: UITableView.layoutMargins)) {
        tableView.layoutMargins = .zero
    }
}

... i proszę bardzo! To powinno działać na iOS 7 i 8.

EDIT: Mohamed Saleh zwrócił moją uwagę ewentualne zmiany w iOS 9. Być może trzeba ustawić Table View na cellLayoutMarginsFollowReadableWidthceluNO , jeśli chcesz dostosować wypustki lub marże. Twój przebieg może się różnić, nie jest to dobrze udokumentowane.

Ta właściwość istnieje tylko w iOS 9, więc sprawdź ją przed ustawieniem.

if([myTableView respondsToSelector:@selector(setCellLayoutMarginsFollowReadableWidth:)])
{
    myTableView.cellLayoutMarginsFollowReadableWidth = NO;
} 

Swift 4:

if myTableView.responds(to: #selector(setter: self.cellLayoutMarginsFollowReadableWidth)) {
    myTableView.cellLayoutMarginsFollowReadableWidth = false
}

(powyższy kod z wstawki 0 separatora UITableView dla systemu iOS 8 nie działa )

EDYCJA: Oto czysta metoda Konstruktora interfejsów:

UWAGA: iOS 11 zmienia i upraszcza wiele z tego zachowania, nadchodzi aktualizacja ...

Arg !!! Po rozegraniu jednej z tych czynności w Cellpodklasie:

- (UIEdgeInsets)layoutMargins
{
    return UIEdgeInsetsZero;
}

lub ustawienie cell.layoutMargins = UIEdgeInsetsZero;naprawione dla mnie.

Poświęć chwilę na zrozumienie problemu, zanim zaczniesz ślepo ładować, aby spróbować go naprawić.

Szybkie przeczesywanie w debuggerze powie ci, że linie separatora są widokami podrzędnymi UITableViewCell . Wygląda na to, że sama komórka bierze znaczną odpowiedzialność za układ tych linii.

iOS 8 wprowadza pojęcie marginesów układu . Domyślnie marginesy układu widoku są 8ptze wszystkich stron i są dziedziczone z widoków przodka.

Jak najlepiej możemy powiedzieć, układając linię separatora, UITableViewCell decyduje się przestrzegać marginesu układu po lewej stronie, używając go do ograniczenia lewej wstawki.

Łącząc to wszystko, aby osiągnąć pożądany przedział naprawdę zerowy, musimy:

• Ustaw lewy margines układu na 0
• Zatrzymaj wszelkie odziedziczone marginesy zastępujące to

Mówiąc tak, jest to dość proste zadanie do osiągnięcia:

cell.layoutMargins = UIEdgeInsetsZero;
cell.preservesSuperviewLayoutMargins = NO;

Ważne uwagi:

• Ten kod wymaga tylko być uruchamiany tylko raz na komórkę (w końcu konfigurujesz właściwości komórki) i nie ma nic specjalnego, kiedy zdecydujesz się go wykonać. Rób to, co wydaje ci się najczystsze.
• Niestety żadna właściwość nie jest dostępna do skonfigurowania w Konstruktorze interfejsów, ale w preservesSuperviewLayoutMarginsrazie potrzeby można określić zdefiniowany przez użytkownika atrybut środowiska wykonawczego .
• Oczywiście, jeśli aplikacja jest kierowana również na wcześniejsze wersje systemu operacyjnego, musisz unikać wykonywania powyższego kodu, dopóki nie uruchomisz go w systemie iOS 8 i nowszych.
• Zamiast ustawienia preservesSuperviewLayoutMargins, to można skonfigurować przodek widoki (takie jak w tabeli), aby 0lewy margines też, ale to wydaje się z natury bardziej podatne na błędy, jak nie kontrolują tego całą hierarchię.
• Prawdopodobnie byłoby nieco czystsze ustawienie tylko lewego marginesu 0i pozostawienie pozostałych.
• Jeśli chcesz mieć wstawkę 0 na „dodatkowych” separatorach, które UITableViewrysują na dole zwykłych tabel, zgaduję, że będzie to wymagało określenia tych samych ustawień również na poziomie tabeli (nie próbowałem tego!)

Sądzę, że to to samo pytanie, które tutaj zadałem: Usuń SeparatorInset na iOS 8 UITableView dla XCode 6 iPhone Simulator

W iOS 8 istnieje jedna nowa właściwość dla wszystkich dziedziczonych obiektów UIView. Tak więc rozwiązanie, aby ustawićSeparatorInset w iOS 7.x nie będzie w stanie usunąć białych znaków widocznych na UITableView w iOS 8.

Nowa właściwość nosi nazwę „ layoutMargins ”.

@property(nonatomic) UIEdgeInsets layoutMargins
Description   The default spacing to use when laying out content in the view.
Availability  iOS (8.0 and later)
Declared In   UIView.h
Reference UIView Class Reference

Rozwiązanie:-

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

    if ([tableView respondsToSelector:@selector(setSeparatorInset:)]) {
        [tableView setSeparatorInset:UIEdgeInsetsZero];
    }

    if ([tableView respondsToSelector:@selector(setLayoutMargins:)]) {
        [tableView setLayoutMargins:UIEdgeInsetsZero];
    }

   if ([cell respondsToSelector:@selector(setLayoutMargins:)]) {
        [cell setLayoutMargins:UIEdgeInsetsZero];
   }
}

Jeśli ustawisz cell.layoutMargins = UIEdgeInsetsZero;bez sprawdzania, czy layoutMarginsistnieje, aplikacja ulegnie awarii w systemie iOS 7.x. Najlepszym sposobem byłoby sprawdzenie, czy layoutMarginsistnieje wcześniej setLayoutMargins:UIEdgeInsetsZero.

Możesz użyć UIAppearance raz, podczas uruchamiania aplikacji (przed załadowaniem interfejsu użytkownika), aby ustawić go jako domyślne ustawienia globalne:

// iOS 7:
[[UITableView appearance] setSeparatorStyle:UITableViewCellSeparatorStyleSingleLine];
[[UITableView appearance] setSeparatorInset:UIEdgeInsetsZero];

[[UITableViewCell appearance] setSeparatorInset:UIEdgeInsetsZero];

// iOS 8:
if ([UITableView instancesRespondToSelector:@selector(setLayoutMargins:)]) {

    [[UITableView appearance] setLayoutMargins:UIEdgeInsetsZero];
    [[UITableViewCell appearance] setLayoutMargins:UIEdgeInsetsZero];
    [[UITableViewCell appearance] setPreservesSuperviewLayoutMargins:NO];

}

W ten sposób utrzymujesz kod UIViewController w czystości i zawsze możesz go zastąpić, jeśli chcesz.

iOS wprowadza właściwość layoutMargins do komórek ORAZ widoków tabeli.

Ta właściwość nie jest dostępna w iOS 7.0, więc musisz ją sprawdzić przed przypisaniem!

Apple dodał jednak do komórki właściwość o nazwieservesSuperviewLayoutMargins , która uniemożliwi dziedziczenie ustawień marginesów w widoku tabeli. W ten sposób komórki mogą konfigurować własne marginesy niezależnie od widoku tabeli. Potraktuj to jako nadpisanie.

Ta właściwość jest nazywany preservesSuperviewLayoutMargins i ustawienie go na NO może zezwolić, aby zastąpić ustawienia layoutMargin stole widok jest z ustawieniem layoutMargin swojej własnej komórki. Oba oszczędzają czas ( nie musisz modyfikować ustawień Widoku tabeli ) i są bardziej zwięzłe. Szczegółowe wyjaśnienie znajduje się w odpowiedzi Mike'a Abdullaha.

UWAGA: jest to właściwa, mniej niechlujna implementacja, wyrażona w odpowiedzi Mike'a Abdullaha; ustawienie zachowań komórki w komórceSuperviewLayoutMargins = NIE zapewni, że widok tabeli nie zastąpi ustawień komórki.

Pierwszy krok - skonfiguruj marginesy komórkowe:

/*
    Tells the delegate that the table view is about to draw a cell for a particular row.
*/
override func tableView(tableView: UITableView, willDisplayCell cell: UITableViewCell,
    forRowAtIndexPath indexPath: NSIndexPath)
{
    // Remove separator inset
    if cell.respondsToSelector("setSeparatorInset:") {
        cell.separatorInset = UIEdgeInsetsZero
    }

    // Prevent the cell from inheriting the Table View's margin settings
    if cell.respondsToSelector("setPreservesSuperviewLayoutMargins:") {
        cell.preservesSuperviewLayoutMargins = false
    }

    // Explictly set your cell's layout margins
    if cell.respondsToSelector("setLayoutMargins:") {
        cell.layoutMargins = UIEdgeInsetsZero
    }
}

Ustawienie właściwościserveesSuperviewLayoutMargins w komórce na NIE powinno uniemożliwić widok tabeli nadpisujący marginesy komórki. W niektórych przypadkach wydaje się, że nie działa poprawnie.

Drugi krok - tylko jeśli wszystko zawiedzie, możesz brutalnie wymusić marginesy widoku tabeli:

/*
    Called to notify the view controller that its view has just laid out its subviews.
*/
override func viewDidLayoutSubviews() {
    super.viewDidLayoutSubviews()

    // Force your tableview margins (this may be a bad idea)
    if self.tableView.respondsToSelector("setSeparatorInset:") {
        self.tableView.separatorInset = UIEdgeInsetsZero
    }

    if self.tableView.respondsToSelector("setLayoutMargins:") {
        self.tableView.layoutMargins = UIEdgeInsetsZero
    }
}

... i proszę bardzo! To powinno działać na iOS 8, a także iOS 7.

Uwaga: testowane na iOS 8.1 i 7.1, w moim przypadku potrzebowałem tylko pierwszego kroku tego wyjaśnienia.

Drugi krok jest wymagany tylko wtedy, gdy pod renderowanymi komórkami znajduje się niepopulowana komórka, tj. jeśli tabela jest większa niż liczba wierszy w modelu tabel. Nie wykonanie drugiego kroku spowoduje różne przesunięcia separatora.

W Swift jest to trochę bardziej irytujące, ponieważ layoutMarginsjest właściwością, więc musisz zastąpić gettera i setera.

override var layoutMargins: UIEdgeInsets {
  get { return UIEdgeInsetsZero }
  set(newVal) {}
}

To skutecznie zrobi layoutMarginstylko do odczytu, co w moim przypadku jest w porządku.

W systemie iOS 9 musisz dodać:

if([myTableView respondsToSelector:@selector(setCellLayoutMarginsFollowReadableWidth:)])
{
    myTableView.cellLayoutMarginsFollowReadableWidth = NO;
} 

Więcej informacji znajduje się w pytaniu .

Rozszerzenie Swift 2.0

Chciałem tylko udostępnić rozszerzenie, które zrobiłem, aby usunąć marginesy z separatorów komórek widoku tabeli.

extension UITableViewCell {
    func removeMargins() {

        if self.respondsToSelector("setSeparatorInset:") {
            self.separatorInset = UIEdgeInsetsZero
        }

        if self.respondsToSelector("setPreservesSuperviewLayoutMargins:") {
            self.preservesSuperviewLayoutMargins = false
        }

        if self.respondsToSelector("setLayoutMargins:") {
            self.layoutMargins = UIEdgeInsetsZero
        }
    }
}

Używany w kontekście:

    let cell = tableView.dequeueReusableCellWithIdentifier("Cell", forIndexPath: indexPath) as! CustomCell

    cell.removeMargins()
    return cell

Szybki:

override func viewDidLoad() {
    super.viewDidLoad()

    if self.tableView.respondsToSelector("setSeparatorInset:") {
        self.tableView.separatorInset = UIEdgeInsetsZero
    }
    if self.tableView.respondsToSelector("setLayoutMargins:") {
        self.tableView.layoutMargins = UIEdgeInsetsZero
    }

    self.tableView.layoutIfNeeded()            // <--- this do the magic
}

override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
     ...

    if cell.respondsToSelector("setSeparatorInset:") {
        cell.separatorInset = UIEdgeInsetsZero
    }
    if cell.respondsToSelector("setLayoutMargins:") {
        cell.layoutMargins = UIEdgeInsetsZero
    }

    return cell
}

Sprawiłem, że działało to:

tableView.separatorInset = UIEdgeInsetsZero;
tableView.layoutMargins = UIEdgeInsetsZero;
cell.layoutMargins = UIEdgeInsetsZero;

Jeśli chodzi o to, co sugeruje cdstamper zamiast widoku tabeli, dla mnie działa dodawanie poniżej linii w układzie layoutSubview komórki.

- (void)layoutSubviews 
{
    [super layoutSubviews];

    if ([self respondsToSelector:@selector(setSeparatorInset:)])
                [self setSeparatorInset:UIEdgeInsetsZero];

        if ([self respondsToSelector:@selector(setPreservesSuperviewLayoutMargins:)])
        {
            [self setPreservesSuperviewLayoutMargins:NO];;
        }

        if ([self respondsToSelector:@selector(setLayoutMargins:)]) 
        {
            [self setLayoutMargins:UIEdgeInsetsZero];
        }
}

Przykład Swift 3.0:

func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
    // removing seperator inset
    if cell.responds(to: #selector(setter: UITableViewCell.separatorInset)) {
        cell.separatorInset = .zero
    }
    // prevent the cell from inheriting the tableView's margin settings
    if cell.responds(to: #selector(setter: UIView.preservesSuperviewLayoutMargins)) {
        cell.preservesSuperviewLayoutMargins = false
    }
    // explicitly setting cell's layout margins
    if cell.responds(to: #selector(setter: UITableViewCell.layoutMargins)) {
        cell.layoutMargins = .zero
    }
}

Po długim dochodzeniu ...

Oto jedyny sposób, aby w pełni kontrolować te rzeczy (które mogłem znaleźć)

Aby w pełni kontrolować zarówno wstawki separatora, jak i marginesy układu w każdej komórce. Zrób to w willDisplayCellmetodzie na swoim UITableviewDelegate.

func tableView(tableView: UITableView, willDisplayCell cell: UITableViewCell, forRowAtIndexPath indexPath: NSIndexPath) {
    cell.layoutMargins = UIEdgeInsetsZero
    cell.contentView.layoutMargins = UIEdgeInsetsMake(0, 10, 0, 10)
    cell.separatorInset = UIEdgeInsetsMake(0, 0, 0, 0)
}

Obiekt komórki kontroluje separator, a contentViewkontroluje wszystko inne. Jeśli wstawiane przestrzenie separatora są wyświetlane w nieoczekiwanym kolorze, powinno to rozwiązać:

cell.backgroundColor = cell.contentView.backgroundColor

Proste rozwiązanie w Swift na iOS 8 z niestandardowymUITableViewCell

override func awakeFromNib() {
    super.awakeFromNib()

    self.layoutMargins = UIEdgeInsetsZero
    self.separatorInset = UIEdgeInsetsZero
}

W ten sposób ustawiasz layoutMargini separatorInsettylko raz zamiast robić to dla każdegowillDisplayCell jak sugeruje większość powyższych odpowiedzi.

Jeśli korzystasz z niestandardowego, UITableViewCelljest to właściwe miejsce, aby to zrobić. W przeciwnym razie powinieneś to zrobićtableView:cellForRowAtIndexPath .

Kolejna wskazówka: nie trzeba ustawiać, preservesSuperviewLayoutMargins = falseponieważ wartość domyślna już jest NO!

Dla mnie prosta linia zadziałała

cell.layoutMargins = UIEdgeInsetsZero

Wystarczy dodać poniższy kod, aby rozwiązać ten program.

Powodzenia!

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

       if ([cell respondsToSelector:@selector(setSeparatorInset:)]) {
           [cell setSeparatorInset:UIEdgeInsetsZero];
       }

       if ([cell respondsToSelector:@selector(setLayoutMargins:)]) {
           [cell setLayoutMargins:UIEdgeInsetsZero];
       }

}

Łukasz odpowiedział w Swift:

    // iOS 7:
    UITableView.appearance().separatorStyle = .SingleLine
    UITableView.appearance().separatorInset = UIEdgeInsetsZero
    UITableViewCell.appearance().separatorInset = UIEdgeInsetsZero

    // iOS 8:
    if UITableView.instancesRespondToSelector("setLayoutMargins:") {
        UITableView.appearance().layoutMargins = UIEdgeInsetsZero
        UITableViewCell.appearance().layoutMargins = UIEdgeInsetsZero
        UITableViewCell.appearance().preservesSuperviewLayoutMargins = false
    }

Oto kod, który działa dla mnie w Swift:

override func viewDidLoad() 
{
    super.viewDidLoad()
    ...
    if tableView.respondsToSelector("setSeparatorInset:") {
        tableView.separatorInset = UIEdgeInsetsZero
    }
}

func tableView(tableView: UITableView, willDisplayCell cell: UITableViewCell,forRowAtIndexPath indexPath: NSIndexPath)
{
    if cell.respondsToSelector("setSeparatorInset:") {
        cell.separatorInset.left = CGFloat(0.0)
    }
    if tableView.respondsToSelector("setLayoutMargins:") {
        tableView.layoutMargins = UIEdgeInsetsZero
    }
    if cell.respondsToSelector("setLayoutMargins:") {
        cell.layoutMargins.left = CGFloat(0.0)
    }
}

Wydaje mi się to najczystsze (na razie), ponieważ wszystkie korekty krawędzi / marginesu cell / tableView są wykonywane w tableView:willDisplayCell:forRowAtIndexPath:metodzie, bez wrzucania niepotrzebnego kodu tableView:cellForRowAtIndexPath:.

Przy okazji, ustawiam tylko lewy separator komórki Inset / layoutMargins, ponieważ w tym przypadku nie chcę zepsuć moich ograniczeń, które ustawiłem w komórce.

Zaktualizowano kod do Swift 2.2:

 override func viewDidLoad() {
   super.viewDidLoad()       

    if tableView.respondsToSelector(Selector("setSeparatorInset:")) {
      tableView.separatorInset = UIEdgeInsetsZero
        }
    }

 override func tableView(tableView: UITableView, willDisplayCell cell: UITableViewCell,forRowAtIndexPath indexPath: NSIndexPath) {
        if cell.respondsToSelector(Selector("setSeparatorInset:")) {
            cell.separatorInset.left = CGFloat(0.0)
        }
        if tableView.respondsToSelector(Selector("setLayoutMargins:")) {
            tableView.layoutMargins = UIEdgeInsetsZero
        }
        if cell.respondsToSelector(Selector("setLayoutMargins:")) {
            cell.layoutMargins.left = CGFloat(0.0)
        }
    }

Większość odpowiedzi pokazują wypustki separujące i marginesy układ jest ustawiony nad różnymi metodami (tj viewDidLayoutSubviews, willDisplayCellitp) do komórek i tableviews, ale odkryłem, że tylko wprowadzenie w nich cellForRowAtIndexPathdziała świetnie. Wydaje się, że to najczystszy sposób.

// kill insets for iOS 8
if ([[UIDevice currentDevice].systemVersion floatValue] >= 8) {
    cell.preservesSuperviewLayoutMargins = NO;
    [cell setLayoutMargins:UIEdgeInsetsZero];
}
// iOS 7 and later
if ([cell respondsToSelector:@selector(setSeparatorInset:)])
    [cell setSeparatorInset:UIEdgeInsetsZero];

Użyj poniższego fragmentu kodu, aby uniknąć niepożądanego problemu wypełniania UITableView w IOS 8 i 7.

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

    if ([tableView respondsToSelector:@selector(setSeparatorInset:)])
    {
        [tableView setSeparatorInset:UIEdgeInsetsZero];
    }

    if ([tableView respondsToSelector:@selector(setLayoutMargins:)])
    {
        [tableView setLayoutMargins:UIEdgeInsetsZero];
    }

    if ([cell respondsToSelector:@selector(setLayoutMargins:)])
    {
        [cell setLayoutMargins:UIEdgeInsetsZero];
    }
}

Zamiast aktualizować preservesSuperviewLayoutMarginsi za layoutMarginskażdym razem, gdy komórka przewija się (używa willDisplayCell), sugeruję zrobić to raz cellForRowAtIndexPath::

override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {

    let cell = super.tableView(tableView, cellForRowAtIndexPath: indexPath)

    cell.preservesSuperviewLayoutMargins = false
    cell.layoutMargins = UIEdgeInsetsZero

    return cell

}

Oto prosty sposób na globalne usunięcie wstawki.

W UITableViewCell+Extensions.swift:

import UIKit

extension UITableViewCell {

  override public var layoutMargins: UIEdgeInsets {
    get { return UIEdgeInsetsZero }
    set { }
  }

}

W AppDelegate application:didFinishLaunchingWithOptions::

  UITableViewCell.appearance().separatorInset = UIEdgeInsetsZero

Możesz pomyśleć o a) po prostu zastąpić separatorInsetrozszerzenie lub b) layoutMarginszamiast tego ustawić proxy wyglądu . Żadne nie zadziała. Mimo że separatorInsetjest wskazana jako właściwość, próba zastąpienia jej jako właściwości (lub metody) generuje błędy kompilatora. Oraz ustawianie proxy wygląd UITableViewCell„s layoutMargins(lub, jeśli o to chodzi, również ustawienie proxy wygląd UITableView” s layoutMarginsi separatorInset) nie ma żadnego wpływu.

W iOS8:

Dodanie tego do mojej podklasy UITableViewCell:

- (UIEdgeInsets)layoutMargins {
    return UIEdgeInsetsZero;
}

i to do „tableView: cellForRowAtIndexPath” lub „tableView: willDisplayCell”:

[editCell setSeparatorInset:UIEdgeInsetsZero];

DZIAŁAŁ dla mnie.

-(UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
        // ... Get the cell
        cell.separatorInset = UIEdgeInsetsMake(0.f, 20.f, 0.f, [UIScreen mainScreen].bounds.size.width - 20);
        // others
        return cell;
}

Dla dowolnej określonej komórki chcesz ukryć separator.

Po obejrzeniu odpowiedzi na 3. piętrze próbowałem dowiedzieć się, jaki jest związek między ustawieniem separatora między TableView a TableViewCell i wykonałem test. Oto moje wnioski:

1. możemy rozważyć, że ustawienie separatora komórki na zero musi przesunąć separator w dwóch krokach: pierwszym krokiem jest ustawienie zestawu separatorów komórki na zero. drugim krokiem jest ustawienie marginesu komórki na zero.

2. ustaw tabelę separatora TableView, a marginesout może wpływać na separator komórki . Jednak z testu wynika, że ​​zestaw separatora TableView wydaje się być bezużyteczny, marginesy TableView mogą faktycznie wpływać na marginesy komórki .

3. set Cell's PreservesSuperviewLayoutMargins = false, może odciąć efekt marginlayout TableView na komórkach.

4. jedno z rozwiązań:

   func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
       var cell = UITableViewCell()
   
       cell.preservesSuperviewLayoutMargins = false
       cell.separatorInset = UIEdgeInsetsZero
       cell.layoutMargins = UIEdgeInsetsZero
   
       return cell
   }

To jest moje rozwiązanie. Dotyczy to niestandardowej podklasy komórek, wystarczy dodać je obie do podklasy.

1. - (UIEdgeInsets)layoutMargins {    
       return UIEdgeInsetsMake(0, 10, 0, 10);
   }

2)

self.separatorInset = UIEdgeInsetsMake(0, 10, 0, 10);

Wygodne jest dostosowanie pozycji separatora bez konieczności rysowania go przez projektanta ..........

W bardziej zwarty sposób niż najczęściej głosowana odpowiedź ...

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

    if ([cell respondsToSelector:@selector(setSeparatorInset:)] && [cell respondsToSelector:@selector(setPreservesSuperviewLayoutMargins:)] && [cell respondsToSelector:@selector(setLayoutMargins:)]) {
         [cell setSeparatorInset:UIEdgeInsetsZero];
         [cell setPreservesSuperviewLayoutMargins:NO];
         [cell setLayoutMargins:UIEdgeInsetsZero];
    }

}

Dodanie tego fragmentu, prosty elegancki w Swift działa dla mnie w iOS8 :)

    // tableview single line
func tableView(tableView: UITableView, willDisplayCell cell: UITableViewCell, forRowAtIndexPath indexPath: NSIndexPath) {
    cell.preservesSuperviewLayoutMargins = false
    cell.layoutMargins = UIEdgeInsetsZero
}

Działa to idealnie dla mnie w iOS 8 i iOS 9.

Dla OBJ-C

 - (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath  { 
        if ([tableView respondsToSelector:@selector(setSeparatorInset:)])
        {
            [tableView setSeparatorInset:UIEdgeInsetsZero];
        }

        if ([tableView respondsToSelector:@selector(setLayoutMargins:)])
        {
            [tableView setLayoutMargins:UIEdgeInsetsZero];
        }

        if ([cell respondsToSelector:@selector(setLayoutMargins:)])
        {
            [cell setLayoutMargins:UIEdgeInsetsZero];
        }
         return cell;
    }