iOS 8 séparateur UITableView inset 0 ne fonctionne pas

Arg!!! Après avoir joué autour de l'un ou l'autre faisant ceci dans votre Cell sous-classe:

- (UIEdgeInsets)layoutMargins
{
    return UIEdgeInsetsZero;
}

ou le réglage du cell.layoutMargins = UIEdgeInsetsZero; l'a fixé pour moi.

prenons un moment pour comprendre le problème avant de charger aveuglément pour tenter de le corriger.

un rapide tour dans le débogueur vous dira que les lignes de séparation sont des sous-vues de UITableViewCell . Il semble que la cellule elle-même assume une bonne part de responsabilité pour la disposition de ces lignes.

iOS 8 introduit le concept de layout margins . Par défaut, les marges de disposition d'une vue sont 8pt de tous les côtés, et ils sont hérité des vues des ancêtres.

comme on peut le constater, lors de la mise en place de sa ligne de séparation, UITableViewCell choisit de respecter la marge d'agencement de gauche, en l'utilisant pour contraindre l'insertion de gauche.

mettre tout cela ensemble, pour atteindre l'encas désiré de vraiment zéro, nous avons besoin de:

• Réglez la marge de gauche à 0
• Arrêter la tout hérité des marges primordial que

mis ainsi, c'est une tâche assez simple à réaliser:

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

choses à noter:

• ce code seulement nécessite pour être exécuté une fois par cellule (vous configurez simplement les propriétés de la cellule après tout), et il n'y a rien de spécial quand vous choisissez de l'exécuter. Faire ce qui semble le plus propre à vous.
• malheureusement aucune propriété n'est disponible pour configurer dans Interface Builder, mais vous pouvez spécifier un attribut d'exécution défini par l'utilisateur pour preservesSuperviewLayoutMargins si désiré.
• clairement, si votre application cible aussi les versions précédentes du système D'exploitation, vous devrez éviter d'exécuter le code ci-dessus jusqu'à ce qu'il soit exécuté sur iOS 8 et au-dessus.
• plutôt que de définir preservesSuperviewLayoutMargins , vous can configurer les vues ancêtre (comme la table) pour avoir 0 marge de gauche aussi, mais cela semble intrinsèquement plus sujet aux erreurs que vous ne contrôlez pas toute cette hiérarchie.
• il serait probablement un peu plus propre de ne fixer que la marge gauche à 0 et de laisser les autres être.
• si vous voulez avoir un 0 inset sur les séparateurs" extra "que UITableView dessine au bas des tables de style simple, je suppose que cela exigera de spécifier les mêmes paramètres au niveau de la table aussi (n'ont pas essayé celui-ci!)

je crois que c'est la même question que j'ai posée ici: supprimer le séparateur sur iOS 8 UITableView pour Xcode 6 iPhone simulateur

In iOS 8 , il y a une nouvelle propriété pour tous les objets hérités de UIView . Donc, la solution pour mettre le SeparatorInset dans iOS 7.x ne pourra pas supprimer l'espace blanc que vous voyez sur la vue UITableView dans iOS 8.

la nouvelle propriété s'appelle " 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

la solution: -

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

si vous définissez cell.layoutMargins = UIEdgeInsetsZero; sans vérifier si le layoutMargins existe, l'application se plantera sur iOS 7.x. Donc, la meilleure façon serait de vérifier si le layoutMargins existe avant le setLayoutMargins:UIEdgeInsetsZero .

vous pouvez utiliser UIAppearance une fois, au démarrage de votre application (avant que L'interface utilisateur ne soit chargée), pour la définir comme paramètres globaux par défaut:

// 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];

}

de cette façon, vous gardez le code de votre UIViewController propre et pouvez toujours l'annuler si vous le voulez.

version Swift

iOS introduit la propriété layoutMargins sur les cellules et les vues de table.

cette propriété n'est pas disponible dans iOS 7.0 donc vous devez vous assurer de vérifier avant de l'assigner!

cependant, Apple a ajouté un propriété appelé préservessuperviewlayoutmargins à votre cellule qui l'empêchera d'hériter de votre vue de Table les paramètres de marge. De cette façon, vos cellules peuvent configurer leurs propres marges indépendamment de la vue de la table. Vois ça comme un contrôleur.

cette propriété s'appelle preservesSuperviewLayoutMargins , et le paramétrer à NO peut vous permettre de modifier les paramètres layoutMargin de votre vue Table avec le paramétrage layoutMargin de votre propre cellule. Il permet à la fois de gagner du temps ( vous n'avez pas à modifier les paramètres de la vue de Table ), et est plus concis. Veuillez vous reporter à la réponse de Mike Abdullah pour une explication détaillée.

NOTE: il s'agit de la mise en œuvre appropriée, moins salissante, telle qu'exprimée dans la réponse de Mike Abdullah; la mise en place de préservessuperviewlayoutmargins=NO de votre cellulaire permettra de s'assurer que votre vue de la Table ne supplante pas les paramètres de la cellule.

première étape-Configurer vos marges de cellules:

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

conservez la propriété uperviewlayoutmargins sur votre cellule au NO devrait empêcher votre vue de table de dépasser vos marges de cellules. Dans certains cas, il semble ne pas fonctionner correctement.

Deuxième étape Seulement, en cas d'échec, vous pouvez forcer votre Vue de la Table des marges:

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

...et là vous allez! Cela devrait fonctionner sur iOS 8 aussi bien que iOS 7.

Note: testé avec iOS 8.1 et 7.1, dans mon cas, j'ai seulement besoin d'utiliser la première étape de cette explication.

la deuxième étape n'est nécessaire que si vous avez une cellule non peuplée sous les cellules rendues, c.-à-d. si le tableau est plus grand que le nombre de lignes dans la table de modèle. Ne pas faire la deuxième étape de résultat dans les différents séparateur de décalages.

dans Swift c'est un peu plus ennuyeux parce que layoutMargins est une propriété, donc vous devez Outrepasser le setter et .

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

cela fera effectivement layoutMargins readonly, qui dans mon cas est très bien.

pour iOS 9 Vous devez ajouter:

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

pour plus de détails, veuillez vous référer à question .

Swift 2.0 Extension

je voulais juste partager une extension que j'ai faite pour supprimer les marges des séparateurs de cellules tableview.

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

utilisé dans le contexte:

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

    cell.removeMargins()
    return cell

Swift:

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
}

j'ai fait le travail en faisant ceci:

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

Swift 3.0 exemple:

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

après une longue enquête...

voici le seul moyen de contrôler complètement ce truc (que j'ai pu trouver)

pour contrôler entièrement les deux séparateurs inserts et les marges de mise en page sur chaque cellule. Faites ceci dans la méthode willDisplayCell sur votre 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)
}

l'objet cellulaire contrôle le séparateur, et le contentView contrôle tout le reste. Si votre séparateur encart espaces apparaissent dans une couleur différente de ce devrait le résoudre:

cell.backgroundColor = cell.contentView.backgroundColor

Pour moi, le simple fait la job

cell.layoutMargins = UIEdgeInsetsZero

quant à ce que cdstamper a suggéré au lieu de la vue de table, en ajoutant ci-dessous des lignes dans la méthode layoutSubview de la cellule fonctionne pour moi.

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

solution Simple Swift pour iOS 8 avec un UITableViewCell

override func awakeFromNib() {
    super.awakeFromNib()

    self.layoutMargins = UIEdgeInsetsZero
    self.separatorInset = UIEdgeInsetsZero
}

de cette façon, vous mettez layoutMargin et separatorInset juste une fois au lieu de le faire pour chaque willDisplayCell comme la plupart des réponses ci-dessus suggèrent.

si vous utilisez un custom UITableViewCell c'est le bon endroit pour le faire. Sinon, vous devriez le faire dans tableView:cellForRowAtIndexPath .

juste un autre indice: vous n'avez pas besoin de définir preservesSuperviewLayoutMargins = false parce que la valeur par défaut est déjà NO !

il suffit d'ajouter le code ci-dessous peut résoudre ce programme.

Bonne chance à vous!

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

}

utiliser le code ci-dessous.

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

C'est le code qui fonctionne pour moi, dans 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)
    }
}

cela me semble le plus propre (pour le moment), car tous les réglages de bord/marge de cell/tableView sont effectués dans la méthode tableView:willDisplayCell:forRowAtIndexPath: , sans avoir à graver un code inutile dans tableView:cellForRowAtIndexPath: .

Btw, Je ne fais que configurer le séparateur gauche de la cellule enset / layoutMargins, parce que dans ce cas je ne veux pas gâcher mes contraintes que j'ai installées dans ma cellule.

code mis à jour à 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)
        }
    }

la plupart des réponses montrent des inserts de séparateur et des marges de mise en page étant mis sur une variété de méthodes (i.e., viewDidLayoutSubviews , willDisplayCell , etc) pour les cellules et les vues de table, mais j'ai trouvé que juste mettre ces dans cellForRowAtIndexPath fonctionne très bien. Me semble que la façon la plus propre.

// 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];

au lieu de mettre à jour preservesSuperviewLayoutMargins et layoutMargins chaque fois que la cellule entre (en utilisant willDisplayCell ), je suggérerais de le faire une fois dans 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

}

Lukasz réponse rapide:

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

In iOS8:

ajoutant ceci à ma sous-classe Uitable Viewcell:

- (UIEdgeInsets)layoutMargins {
    return UIEdgeInsetsZero;
}

et ceci à "tableView: cellForRowAtIndexPath" ou "tableView: willDisplayCell":

[editCell setSeparatorInset:UIEdgeInsetsZero];

travaillait pour moi.

voici un moyen facile de supprimer globalement l'inset.

Dans UITableViewCell+Extensions.swift :

import UIKit

extension UITableViewCell {

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

}

Dans AppDelegate application:didFinishLaunchingWithOptions: :

  UITableViewCell.appearance().separatorInset = UIEdgeInsetsZero

vous pourriez penser à a) aussi juste outrepasser separatorInset dans l'extension, ou b) définir le mandataire d'apparence pour layoutMargins , à la place. Aucun ne fonctionne. Même s'il est indiqué que separatorInset est une propriété, tenter de l'annuler en tant que propriété (ou méthode) génère des erreurs de compilation. Et le fait de définir le proxy d'apparence pour UITableViewCell 's layoutMargins (ou, d'ailleurs, de définir également les proxy d'apparence pour UITableView 's layoutMargins et separatorInset ) n'a aucun effet.

après avoir vu les réponses au troisième étage, j'ai essayé de comprendre quelle était la relation entre la configuration du séparateur entre TableView et TableViewCell et j'ai fait quelques tests. Voici mes conclusions:

1. nous pouvons considérer que le réglage du séparateur de la cellule à zéro doit déplacer le séparateur en deux étapes: la première étape est de régler le séparateur de la cellule à zéro. la deuxième étape consiste à définir le de cell marginlayout à zéro.

2. positionnez le séparateur de TableView séparatorinset et marginlayout peut affecter le séparateur de Cell séparatorinset . Cependant, d'après le test, je trouve que le séparateur de TableView semble inutile, le de TableView "marginlayout peut en fait affecter le de cell marginlayout".

3. ensemble de la Cellule PreservesSuperviewLayoutMargins = false, pouvez couper TableView marginlayout effet sur les Cellules.

4. l'une des solutions:

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

C'est ma solution. Cela s'applique à la cellule personnalisé sous-classe, il suffit d'ajouter les deux à la sous-classe.

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

2.

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

Et il est commode que vous pouvez personnaliser la position du séparateur sans demander à votre graphiste pour dessiner un pour vous..........

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

pour chaque cellule spécifique que vous voulez cacher le séparateur.

d'une manière plus compacte que la réponse la plus votée...

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

}

ajouter cet extrait, simple élégant dans Swift fonctionne pour moi dans iOS8:)

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

cela a fonctionné parfaitement pour moi dans iOS 8 et iOS 9.

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