l'encart séparateur iOS 8 UITableView ne fonctionne pas
J'ai une application où l'insert de séparateur de la UITableView est défini sur des valeurs personnalisées - Right 0, Left 0. Cela fonctionne parfaitement dans iOS 7.x, cependant dans iOS 8.0, je vois que le séparateur inséré est défini sur la valeur par défaut de 15 sur la droite. Même si, dans les fichiers xib, il est défini sur 0, il ne s'affiche toujours pas correctement.
Comment puis-je supprimer les marges de séparateur UITableViewCell?
Arg !!! Après avoir joué à cela, faites cela dans votre sous-classe Cell:
- (UIEdgeInsets)layoutMargins
{
return UIEdgeInsetsZero;
}
ou en fixant le cell.layoutMargins = UIEdgeInsetsZero; corrigé pour moi.
Prenons un moment pour comprendre le problème avant de charger aveuglément pour tenter de le résoudre.
Un rapide coup d'œil 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 part importante de la responsabilité de la mise en page de ces lignes.
iOS 8 introduit le concept de marges de présentation. Par défaut, les marges de présentation d'une vue sont 8pt sur tous les côtés et elles sont héritées à partir des vues ancêtres.
Comme nous pouvons le constater, lors de l’établissement de la ligne de séparation, UITableViewCell choisit de respecter la marge de présentation de gauche, en l’utilisant pour contraindre l’encart gauche.
En réunissant tout cela, pour atteindre l’encart souhaité de zéro, nous devons:
- Définissez la marge de la mise en page gauche sur
0 - Arrêtez les marges héritées en ignorant cette
Mis comme ça, c'est une tâche assez simple à réaliser:
cell.layoutMargins = UIEdgeInsetsZero;
cell.preservesSuperviewLayoutMargins = NO;
Choses à noter:
- Ce code seul nécessite doit être exécuté une fois par cellule (vous ne configurez que les propriétés de la cellule), et il n'y a rien de spécial à propos de son exécution. Faites ce qui vous semble le plus propre.
- Malheureusement, aucune propriété n'est disponible pour la configuration dans Interface Builder, mais vous pouvez spécifier un attribut d'exécution défini par l'utilisateur pour
preservesSuperviewLayoutMarginssi vous le souhaitez. - Il est clair que si votre application cible également des versions antérieures du système d'exploitation, vous devez éviter d'exécuter le code ci-dessus avant de s'exécuter sur iOS 8 et versions ultérieures.
- Plutôt que de définir
preservesSuperviewLayoutMargins, vous pouvez configurez les vues ancêtres (telles que la table) pour qu'elles aient aussi la marge gauche0, mais cela semble intrinsèquement plus sujet aux erreurs car vous ne contrôlez pas toute la hiérarchie. - Il serait probablement plus propre de ne définir que la marge gauche sur
0et de laisser les autres. - Si vous voulez avoir un encart 0 sur les séparateurs "supplémentaires" dessinés par
UITableViewau bas des tables de style brut, je suppose que cela nécessitera également de spécifier les mêmes paramètres au niveau de la table (je n'ai pas essayé celle-ci!)
Je crois que c'est la même question que j'ai posée ici: Supprimer SeparatorInset sur iOS 8 UITableView pour XCode 6 iPhone Simulator
Dans iOS 8, il existe une nouvelle propriété pour tous les objets hérités de UIView. Ainsi, la solution permettant de définir SeparatorInset dans iOS 7.x ne pourra pas supprimer l’espace vide que vous voyez sur 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 la layoutMargins existe, l'application se bloquera sur iOS 7.x. Ainsi, le meilleur moyen serait de vérifier si la layoutMargins existe avant le setLayoutMargins:UIEdgeInsetsZero.
Vous pouvez utiliser UIAppearance une fois, au démarrage de votre application (avant le chargement de l'interface utilisateur), pour le 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 vous pouvez toujours le remplacer si vous le souhaitez.
iOS introduit la propriété layoutMargins sur les cellules ET les vues sous forme de tableau.
Cette propriété n'est pas disponible dans iOS 7.0, vous devez donc vérifier avant de l'attribuer!
Cependant, Apple a ajouté à votre cellule une propriété appelée preserveesSuperviewLayoutMargins qui l'empêcherait d'hériter des paramètres de marge de votre vue Tableau. Ainsi, vos cellules peuvent configurer leurs propres marges indépendamment de la vue tableau. Pensez-y comme une dérogation.
Cette propriété s'appelle preserveesSuperviewLayoutMargins. Si vous la définissez sur NON, vous pouvez remplacer les paramètres layoutMargin de votre vue Table par le paramètre layoutMargin de votre propre cellule. Cela vous fait gagner du temps ( vous n'avez pas besoin de modifier les paramètres de la vue Tableau ), et est plus concis. Veuillez vous reporter à la réponse de Mike Abdullah pour une explication détaillée.
NOTE: c'est l'implémentation appropriée, moins compliquée, telle qu'exprimée dans la réponse de Mike Abdullah; Si vous définissez les valeurs préservées de votre cellule, SupersLayoutMargins = NO garantira que votre affichage Table ne remplace pas les paramètres de la cellule.
Première étape - Configurez les marges de votre cellule:
/*
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
}
}
Définissez la propriété preserveesSuperviewLayoutMargins sur votre cellule sur NO devrait empêcher votre vue de tableau de remplacer les marges de votre cellule. Dans certains cas, cela ne semble pas fonctionner correctement.
Deuxième étape - Vous pouvez forcer brutalement les marges de la vue tableau:
/*
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 voilà! Cela devrait fonctionner sur iOS 8 ainsi que sur iOS 7.
Remarque: testé avec iOS 8.1 et 7.1, dans mon cas, je n'avais besoin que de la première étape de cette explication.
La deuxième étape n'est requise que si vous avez des cellules non remplies sous les cellules rendues, c.-à-d. si la table est plus grande que le nombre de lignes du modèle de table. Ne pas faire la deuxième étape entraînerait des décalages de séparateur différents.
Dans Swift, c’est un peu plus gênant car layoutMargins est une propriété, vous devez donc remplacer le getter et setter.
override var layoutMargins: UIEdgeInsets {
get { return UIEdgeInsetsZero }
set(newVal) {}
}
Cela va effectivement rendre layoutMargins en lecture seule, ce qui est très bien dans mon cas.
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 simplement partager une extension que j'ai créée 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
Rapide:
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
}
Je l'ai fait fonctionner en faisant ceci:
tableView.separatorInset = UIEdgeInsetsZero;
tableView.layoutMargins = UIEdgeInsetsZero;
cell.layoutMargins = UIEdgeInsetsZero;
Exemple de 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
}
}
Après beaucoup de recherches ...
Voici le seul moyen de contrôler complètement ce genre de choses (que je pourrais trouver)
Pour contrôler pleinement les incrustations de séparateur et les marges de présentation de chaque cellule. Faites cela 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 de cellule contrôle le séparateur et la contentView contrôle tout le reste. Si les espaces insérés dans votre séparateur apparaissent dans une couleur inattendue, cela devrait résoudre le problème:
cell.backgroundColor = cell.contentView.backgroundColor
En ce qui concerne ce que cdstamper a suggéré à la place de la vue tableau, l'ajout de lignes sous la méthode layoutSubview de la cellule me convient.
- (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 dans Swift pour iOS 8 avec une variable UITableViewCell personnalisée
override func awakeFromNib() {
super.awakeFromNib()
self.layoutMargins = UIEdgeInsetsZero
self.separatorInset = UIEdgeInsetsZero
}
De cette manière, vous définissez layoutMargin et separatorInset juste une fois au lieu de le faire pour chaque willDisplayCell comme le suggèrent la plupart des réponses ci-dessus.
Si vous utilisez une variable UITableViewCell personnalisée, c’est le bon endroit pour le faire. Sinon, vous devriez le faire en tableView:cellForRowAtIndexPath.
Juste un autre indice: vous n'avez pas besoin de définir preservesSuperviewLayoutMargins = false car la valeur par défaut est déjà NO!
Pour moi la ligne simple a fait le travail
cell.layoutMargins = UIEdgeInsetsZero
Il suffit d’ajouter le code ci-dessous pour résoudre ce programme.
Bonne chance à toi!
-(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];
}
}
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 ajustements de cellule/tableView Edge/marge sont effectués dans la méthode tableView:willDisplayCell:forRowAtIndexPath:, sans que le code inutile soit écrasé dans tableView:cellForRowAtIndexPath:.
Au fait, je ne fais que régler le separatorInset/layoutMargins de gauche de la cellule, car dans ce cas, je ne veux pas bousiller les contraintes que j'ai définies 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 que des incrustations de séparateur et des marges de mise en page sont définies pour diverses méthodes (par exemple, viewDidLayoutSubviews, willDisplayCell, etc.) pour les cellules et les vues de table, mais j’ai constaté que le simple fait de les utiliser dans cellForRowAtIndexPath fonctionnait très bien. Cela semble être le moyen le 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];
Lukasz répond dans 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
}
Au lieu de mettre à jour preservesSuperviewLayoutMargins et layoutMargins chaque fois que la cellule fait défiler (avec willDisplayCell), je suggère 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
}
Utilisez l'extrait de code ci-dessous pour éviter les problèmes de remplissage non désirés pour UITableView dans IOS 8 & 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];
}
}
Dans iOS8:
Ajouter ceci à ma sous-classe UITableViewCell:
- (UIEdgeInsets)layoutMargins {
return UIEdgeInsetsZero;
}
et ceci pour "tableView: cellForRowAtIndexPath" ou "tableView: willDisplayCell":
[editCell setSeparatorInset:UIEdgeInsetsZero];
A travaillé pour moi.
-(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 toute cellule spécifique, vous souhaitez masquer le séparateur.
Ceci est ma solution. Ceci s’applique à la sous-classe de cellules personnalisée, il suffit d’ajouter les deux à la sous-classe.
- (UIEdgeInsets)layoutMargins { return UIEdgeInsetsMake(0, 10, 0, 10); }
2.
self.separatorInset = UIEdgeInsetsMake(0, 10, 0, 10);
Et il est pratique de pouvoir personnaliser la position du séparateur sans demander à votre concepteur de vous en dessiner un pour vous ..........
Après avoir vu les réponses au 3è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:
nous pouvons considérer que la définition du séparateur de cellule à zéro doit déplacer le séparateur en deux étapes: la première étape consiste à définir le separatorinset de la cellule à zéro. La deuxième étape consiste à définir le marginlayout de la cellule sur zéro.
définir les separatorinset et marginlayout de TableView peut affecter les separatorinset de la cellule. Cependant, d'après le test, je trouve que separatorinset de TableView semble être inutile, et que marginlayout de TableView peut réellement affecter les marginlayout de la cellule.
définissez PreservesSuperviewLayoutMargins de Cell = false, peut couper l'effet marginlayout de TableView sur les cellules.
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 }
De 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];
}
}
Cela fonctionnait parfaitement pour moi sous 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;
}
En ajoutant cet extrait, simple et é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
}
Ma solution consiste à ajouter UIView en tant que conteneur pour les sous-vues de cellules. Puis définissez ces contraintes UIView (haut, bas, fin, début) à 0 points. Et toute la masse inutile s'en va. l'image montrant la logique
Je n'ai eu aucune chance avec l'une des solutions ci-dessus. J'utilise des fichiers NIB pour mes cellules de tableaux. J'ai "corrigé" cela en ajoutant une étiquette de hauteur 1. J'ai remplacé l'arrière-plan de l'étiquette en noir, épinglé l'étiquette au bas de la pointe, puis le reste du contenu à l'épaisseur . Maintenant, j'ai une bordure noire au fond de mes cellules.
Pour moi, cela ressemble plus à un bidouillage, mais cela fonctionne.
Mon seul choix était d'éliminer complètement la frontière. Je suis encore en train de décider si je vais simplement aller avec ça.
laisse faire comme mon code:
-(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 ([tableView respondsToSelector:@selector(setLayoutMargins:)]) {
cell.preservesSuperviewLayoutMargins = NO;
[cell setLayoutMargins:UIEdgeInsetsZero];
}
if ([cell respondsToSelector:@selector(setSeparatorInset:)]){
[cell setSeparatorInset:UIEdgeInsetsZero];
}
}
utilisez le storyboard pour changer le séparateur Personnaliser gauche 0 et droite 0, si vous voulez masquer le séparateur sur Aucun
Remplacez simplement "cellForRowAtIndexPath" et définissez "cell.preservesSuperviewLayoutMargins = false" et "cell.separatorInset = UIEdgeInsets.zero" et "cell.layoutMargins = UIEdgeInsets.zero".
override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let cell: LayoutTableViewCell! = tableView.dequeueReusableCell(withIdentifier: "LayoutCell") as? LayoutTableViewCell
let currentLayout = OrderLayouts()[indexPath.row]
cell.NameLabel?.text = currentLayout.name
cell.DescrLabel?.text = currentLayout.descr
if(GlobalVariables.debug){
cell.DescrLabel?.text = "\(currentLayout.id) \n \(currentLayout.descr)"
}
cell.preservesSuperviewLayoutMargins = false
cell.separatorInset = UIEdgeInsets.zero
cell.layoutMargins = UIEdgeInsets.zero
return cell
}
Pour moi, aucun n'a fonctionné, à l'exception de cette solution ( Swift 3.0 ):
extension UIColor {
static func colorWith(hex:String, alpha: CGFloat) -> UIColor {
var cString = hex.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
if cString.hasPrefix("#") {
cString.remove(at: cString.startIndex)
}
if cString.characters.count != 6 {
return UIColor.gray
}
var rgbValue:UInt32 = 0
Scanner(string: cString).scanHexInt32(&rgbValue)
return UIColor(red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0,
green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0,
blue: CGFloat( rgbValue & 0x0000FF) / 255.0,
alpha: alpha)
}
}
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCell(withIdentifier: cellReuseIdendifier, for: indexPath)
cell.backgroundColor = UIColor.colorWith(hex: "c8c7cc", alpha: 1) // same color of line separator
return cell
}
après la réponse de @cdstamper, layoutSubviews of UITableViewCell est un meilleur endroit dans votre fichier de cellules (je définit l'espacement de 1%, vous pouvez le définir sur zéro).
-(void)layoutSubviews
{
[super layoutSubviews];
if ([self respondsToSelector:@selector(setSeparatorInset:)]) {
[self setSeparatorInset:UIEdgeInsetsMake(0,self.bounds.size.width*0.01,0,self.bounds.size.width*0.01)];
}
if ([self respondsToSelector:@selector(setLayoutMargins:)]) {
[self setLayoutMargins:UIEdgeInsetsMake(0,self.bounds.size.width*0.01,0,self.bounds.size.width*0.01)];
}
}
Dans Swift, vous pouvez utiliser cette
cell.selectionStyle = UITableViewCellSelectionStyle.None
cell.preservesSuperviewLayoutMargins = false
cell.separatorInset = UIEdgeInsetsZero
cell.layoutMargins = UIEdgeInsetsZero
J'ai parcouru toutes ces réponses fantastiques et me suis rendu compte que la plupart d'entre elles ne fonctionnaient pas avec iOS 8, mais le séparateur change de taille pendant l'animation, ce qui provoque un clignotement indésirable. Voici ce que j'ai fini par faire dans mon délégué aux applications avant de créer la fenêtre:
[[UITableView appearance] setSeparatorInset:UIEdgeInsetsZero];
[[UITableViewCell appearance] setSeparatorInset:UIEdgeInsetsZero];
if ([UITableView instancesRespondToSelector:@selector(setLayoutMargins:)]) {
[[UITableView appearance] setLayoutMargins:UIEdgeInsetsZero];
[[UITableViewCell appearance] setLayoutMargins:UIEdgeInsetsZero];
[[UITableViewCell appearance] setPreservesSuperviewLayoutMargins:NO];
}
Et voici ce que j'ai ajouté à UITableViewController:
-(void)viewDidLayoutSubviews
{
[super viewDidLayoutSubviews];
if ([self.tableView respondsToSelector:@selector(setSeparatorInset:)]) {
[self.tableView setSeparatorInset:UIEdgeInsetsZero];
}
if ([self.tableView respondsToSelector:@selector(setLayoutMargins:)]) {
[self.tableView setLayoutMargins:UIEdgeInsetsZero];
}
}
Je n'avais besoin d'ajouter rien d'autre. Merci à tous ceux qui ont fourni les éléments cruciaux.
il suffit de mettre ces deux lignes dans la méthode cellForRowAtIndexPath
- si vous souhaitez que toutes les lignes de séparation commencent à zéro.
si vous voulez que la ligne de séparation spécifique commence à partir de zéro, supposons que la dernière ligne commence à zéro
if (indexPath.row == array.count-1)
{
[cell setSeparatorInset:UIEdgeInsetsZero];
[cell setLayoutMargins:UIEdgeInsetsZero];
}
else
tblView.separatorInset=UIEdgeInsetsMake(0, 10, 0, 0);
iOS 8 et plus tard. Swift 2.0 et plus tard:
override func tableView(tableView: UITableView, willDisplayCell cell: UITableViewCell, forRowAtIndexPath indexPath: NSIndexPath) {
cell.separatorInset = UIEdgeInsetsZero
if #available(iOS 8.0, *) {
cell.layoutMargins = UIEdgeInsetsZero
} else {
// Fallback on earlier versions
}
}