Ridimensionamento di UITableView per adattarlo al contenuto

Sto creando un'app che avrà una domanda in una UILabele una risposta a risposta multipla visualizzata in UITableView, ogni riga che mostra una scelta multipla. Le domande e le risposte possono variare, quindi ho bisogno che questo UITableViewsia dinamico in altezza.

Vorrei trovare un sizeToFitlavoro per il tavolo. Dove la cornice del tavolo è impostata all'altezza di tutto il suo contenuto.

Qualcuno può consigliare su come posso raggiungere questo obiettivo?

In realtà ho trovato la risposta da solo.

Ho appena creato un nuovo CGRectper il tableView.framecon il heightditable.contentSize.height

Ciò imposta l'altezza del UITableViewal heightsuo contenuto. Poiché il codice modifica l'interfaccia utente, non dimenticare di eseguirlo nel thread principale:

dispatch_async(dispatch_get_main_queue(), ^{
        //This code will run in the main thread:
        CGRect frame = self.tableView.frame;
        frame.size.height = self.tableView.contentSize.height;
        self.tableView.frame = frame;
    });

Soluzione Swift 5 e 4.2 senza KVO, DispatchQueue o impostazione dei vincoli.

Questa soluzione si basa sulla risposta di Gulz .

1) Creare una sottoclasse di UITableView:

import UIKit

final class ContentSizedTableView: UITableView {
    override var contentSize:CGSize {
        didSet {
            invalidateIntrinsicContentSize()
        }
    }

    override var intrinsicContentSize: CGSize {
        layoutIfNeeded()
        return CGSize(width: UIView.noIntrinsicMetric, height: contentSize.height)
    }
}

2) Aggiungi a UITableViewal layout e imposta i vincoli su tutti i lati. Impostare la classe su ContentSizedTableView.

3) Dovresti vedere degli errori, perché Storyboard non tiene conto della nostra sottoclasse ' intrinsicContentSize. Risolvilo aprendo la finestra di ispezione delle dimensioni e sovrascrivendo intrinsicContentSize su un valore segnaposto. Questa è una sostituzione per i tempi di progettazione. In fase di esecuzione utilizzerà l'override nella nostra ContentSizedTableViewclasse

Aggiornamento: codice modificato per Swift 4.2. Se stai usando una versione precedente, usa UIViewNoIntrinsicMetricinvece diUIView.noIntrinsicMetric

Soluzione rapida

Segui questi passi:

1- Imposta il vincolo di altezza per la tabella dallo storyboard.

2- Trascinare il vincolo di altezza dallo storyboard e creare @IBOutlet per esso nel file del controller di visualizzazione.

    @IBOutlet weak var tableHeight: NSLayoutConstraint!

3- Quindi puoi modificare l'altezza per la tabella in modo dinamico usando questo codice:

override func viewWillLayoutSubviews() {
    super.updateViewConstraints()
    self.tableHeight?.constant = self.table.contentSize.height
}

Aggiornare

Se l'ultima riga viene tagliata per te, prova a chiamare viewWillLayoutSubviews () nella funzione della cella willDisplay:

func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
    self.viewWillLayoutSubviews()
}

L'ho provato su iOS 7 e ha funzionato per me

- (void)viewDidLoad
{
    [super viewDidLoad];
    [self.tableView sizeToFit];
}

Aggiungi un osservatore per la proprietà contentSize nella vista tabella e regola le dimensioni della cornice di conseguenza

[your_tableview addObserver:self forKeyPath:@"contentSize" options:0 context:NULL];

quindi nel callback:

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
    {
         CGRect frame = your_tableview.frame;
         frame.size = your_tableview.contentSize;
         your_tableview.frame = frame;
    }

Spero che questo ti possa aiutare.

Avevo una vista tabella all'interno della vista scorrimento e dovevo calcolare l'altezza di tableView e ridimensionarla di conseguenza. Questi sono i passi che ho preso:

0) aggiungi una UIView a scrollView (probabilmente funzionerà senza questo passaggio ma l'ho fatto per evitare possibili conflitti) - questa sarà una vista contenitiva per la vista della tabella. Se fai questo passaggio, imposta i bordi delle viste su quelli della vista tabella.

1) creare una sottoclasse di UITableView:

class IntrinsicTableView: UITableView {

    override var contentSize:CGSize {
        didSet {
            self.invalidateIntrinsicContentSize()
        }
    }

    override var intrinsicContentSize: CGSize {
        self.layoutIfNeeded()
        return CGSize(width: UIViewNoIntrinsicMetric, height: contentSize.height)
    }

}

2) imposta la classe di una vista tabella nello Storyboard su IntrinsicTableView: screenshot: http://joxi.ru/a2XEENpsyBWq0A

3) Imposta l'altezzaConstraint sulla vista della tabella

4) trascina l'IBoutlet della tabella sul ViewController

5) trascina l'IBoutlet del vincolo di altezza del tuo tavolo sul ViewController

6) aggiungi questo metodo nel tuo ViewController:

override func viewWillLayoutSubviews() {
        super.updateViewConstraints()
        self.yourTableViewsHeightConstraint?.constant = self.yourTableView.intrinsicContentSize.height
    }

Spero che questo ti aiuti

Nel caso in cui non si desideri tenere traccia delle modifiche alle dimensioni del contenuto della vista tabella, è possibile che questa sottoclasse sia utile.

protocol ContentFittingTableViewDelegate: UITableViewDelegate {
    func tableViewDidUpdateContentSize(_ tableView: UITableView)
}

class ContentFittingTableView: UITableView {

    override var contentSize: CGSize {
        didSet {
            if !constraints.isEmpty {
                invalidateIntrinsicContentSize()
            } else {
                sizeToFit()
            }

            if contentSize != oldValue {
                if let delegate = delegate as? ContentFittingTableViewDelegate {
                    delegate.tableViewDidUpdateContentSize(self)
                }
            }
        }
    }

    override var intrinsicContentSize: CGSize {
        return contentSize
    }

    override func sizeThatFits(_ size: CGSize) -> CGSize {
        return contentSize
    }
}

Nel caso in cui contentSize non sia corretto, ciò è dovuto al fatto che si è stimato in RowHeight (automatico), utilizzare prima

tableView.estimatedRowHeight = 0;

fonte: https://forums.developer.apple.com/thread/81895

Swift 3, iOS 10.3

Soluzione 1: Basta mettereself.tableview.sizeToFit()incellForRowAt indexPath funzione. Assicurati di impostare l'altezza della vista del tavolo più alta del necessario. Questa è una buona soluzione se non hai viste sotto tableview. Tuttavia, se lo hai, il vincolo di tableview inferiore non verrà aggiornato (non ho provato a risolverlo perché ho trovato la soluzione 2)

Esempio:

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    if let cell = tableView.dequeueReusableCell(withIdentifier: "TestCell", for: indexPath) as? TestCell {
        cell.configureCell(data: testArray[indexPath.row])
        self.postsTableView.sizeToFit()
        return cell
    }

    return UITableViewCell()
}

Soluzione 2: imposta il vincolo dell'altezza della vista tabella nello storyboard e trascinalo sul ViewController. Se conosci l'altezza media della tua cella e sai quanti elementi contiene il tuo array, puoi fare qualcosa del genere:

tableViewHeightConstraint.constant = CGFloat(testArray.count) * 90.0     // Let's say 90 is the average cell height

*MODIFICARE:

Dopo tutte le soluzioni che ho provato e ognuna di esse stava risolvendo qualcosa, ma non completamente, questa è la risposta che spiega e risolve completamente questo problema.

La risposta di mimo e risposta Anooj VM s' entrambi sono impressionanti, ma c'è un piccolo problema se si dispone di un elenco di grandi dimensioni, è possibile che l'altezza del telaio sarà cutoff alcune delle vostre cellule.

Così. Ho modificato un po 'la risposta:

dispatch_async(dispatch_get_main_queue()) {
    //This code will run in the main thread:
    CGFloat newHeight=self.tableView.contentSize.height;
    CGFloat screenHeightPermissible=(self.view.bounds.size.height-self.tableView.frame.origin.y);
    if (newHeight>screenHeightPermissible)
    {
        //so that table view remains scrollable when 'newHeight'  exceeds the screen bounds
        newHeight=screenHeightPermissible;
    }

    CGRect frame = self.tableView.frame;
    frame.size.height = newHeight;
    self.tableView.frame = frame;
}

Esiste un modo molto migliore per farlo se si utilizza AutoLayout: modificare il vincolo che determina l'altezza. Basta calcolare l'altezza del contenuto della tabella, quindi trovare il vincolo e modificarlo. Ecco un esempio (supponendo che il vincolo che determina l'altezza della tabella sia in realtà un vincolo di altezza con relazione "Uguale"):

override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)

    for constraint in tableView.constraints {
        if constraint.firstItem as? UITableView == tableView {
            if constraint.firstAttribute == .height {
                constraint.constant = tableView.contentSize.height
            }
        }
    }
}

Questo funziona per me usando il layout automatico, con una vista tabella con una sola sezione.

func getTableViewContentHeight(tableView: UITableView) -> CGFloat {
        tableView.bounds = CGRect(x: 0, y: 0, width: 300, height: 40)
        let rows = tableView.numberOfRows(inSection: 0)
        var height = CGFloat(0)
        for n in 0...rows - 1 {
            height = height + tableView.rectForRow(at: IndexPath(row: n, section: 0)).height
        }
        return height
    }

Questa funzione viene chiamata durante l'impostazione del layout automatico (l'esempio qui utilizza SnapKit, ma si ottiene l'idea):

    let height = getTableViewContentHeight(tableView: myTableView)
    myTableView.snp.makeConstraints {
        ...
        ...
        $0.height.equalTo(height)
    }

Voglio che UITableView sia alto solo quanto l'altezza combinata delle celle; Ciclo attraverso le celle e accumulo l'altezza totale delle celle. Poiché la dimensione della vista tabella è CGRect.zero a questo punto, devo impostare i limiti per poter rispettare le regole di layout automatico definite dalla cella. Ho impostato la dimensione su un valore arbitrario che dovrebbe essere abbastanza grande. Le dimensioni effettive verranno calcolate in seguito dal sistema di layout automatico.

L'ho fatto in un modo un po 'diverso, in realtà il mio TableView era all'interno di scrollview quindi ho dovuto dare un vincolo di altezza come 0.

Quindi in fase di esecuzione ho apportato le seguenti modifiche,

       func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
            self.viewWillLayoutSubviews()
       }
    
       override func viewWillLayoutSubviews() {
            super.updateViewConstraints()
             DispatchQueue.main.async {
               self.tableViewHeightConstraint?.constant = self.myTableView.contentSize.height
               self.view.layoutIfNeeded()
          }
       }

Come estensione della risposta di Anooj VM, suggerisco quanto segue per aggiornare le dimensioni del contenuto solo quando cambia.

Questo approccio disabilita anche lo scorrimento corretto e supporta elenchi e rotazioni più grandi . Non è necessario dispatch_async perché le modifiche di contentSize vengono inviate sul thread principale.

- (void)viewDidLoad {
        [super viewDidLoad];
        [self.tableView addObserver:self forKeyPath:@"contentSize" options:NSKeyValueObservingOptionOld|NSKeyValueObservingOptionNew context:NULL]; 
}


- (void)resizeTableAccordingToContentSize:(CGSize)newContentSize {
        CGRect superviewTableFrame  = self.tableView.superview.bounds;
        CGRect tableFrame = self.tableView.frame;
        BOOL shouldScroll = newContentSize.height > superviewTableFrame.size.height;
        tableFrame.size = shouldScroll ? superviewTableFrame.size : newContentSize;
        [UIView animateWithDuration:0.3
                                    delay:0
                                    options:UIViewAnimationOptionCurveLinear
                                    animations:^{
                            self.tableView.frame = tableFrame;
        } completion: nil];
        self.tableView.scrollEnabled = shouldScroll;
}

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSString *,id> *)change context:(void *)context {
    if ([change[NSKeyValueChangeKindKey] unsignedIntValue] == NSKeyValueChangeSetting &&
        [keyPath isEqualToString:@"contentSize"] &&
        !CGSizeEqualToSize([change[NSKeyValueChangeOldKey] CGSizeValue], [change[NSKeyValueChangeNewKey] CGSizeValue])) {
        [self resizeTableAccordingToContentSize:[change[NSKeyValueChangeNewKey] CGSizeValue]];
    } 
}

- (void)didRotateFromInterfaceOrientation:(UIInterfaceOrientation)fromInterfaceOrientation {
    [super didRotateFromInterfaceOrientation:fromInterfaceOrientation];
    [self resizeTableAccordingToContentSize:self.tableView.contentSize]; }

- (void)dealloc {
    [self.tableView removeObserver:self forKeyPath:@"contentSize"];
}

versione objc di Musa almatri

(void)viewWillLayoutSubviews
{
    [super updateViewConstraints];
    CGFloat desiredHeight = self.tableView.contentSize.height;
    // clamp desired height, if needed, and, in that case, leave scroll Enabled
    self.tableHeight.constant = desiredHeight;
    self.tableView.scrollEnabled = NO;
}

Puoi provare questa abitudine AGTableView

Per impostare un vincolo di altezza TableView utilizzando lo storyboard o a livello di codice. (Questa classe recupera automaticamente un vincolo di altezza e imposta l'altezza della vista del contenuto sull'altezza della vista della piattaforma).

class AGTableView: UITableView {

    fileprivate var heightConstraint: NSLayoutConstraint!

    override init(frame: CGRect, style: UITableViewStyle) {
        super.init(frame: frame, style: style)
        self.associateConstraints()
    }

    required public init?(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
        self.associateConstraints()
    }

    override open func layoutSubviews() {
        super.layoutSubviews()

        if self.heightConstraint != nil {
            self.heightConstraint.constant = self.contentSize.height
        }
        else{
            self.sizeToFit()
            print("Set a heightConstraint to Resizing UITableView to fit content")
        }
    }

    func associateConstraints() {
        // iterate through height constraints and identify

        for constraint: NSLayoutConstraint in constraints {
            if constraint.firstAttribute == .height {
                if constraint.relation == .equal {
                    heightConstraint = constraint
                }
            }
        }
    }
}

Nota In caso di problemi per impostare un'altezza, allora yourTableView.layoutSubviews().

Basato sulla risposta di fl034 . Ma per gli utenti Xamarin.iOS :

    [Register("ContentSizedTableView")]
    public class ContentSizedTableView : UITableView
    {
        public ContentSizedTableView(IntPtr handle) : base(handle)
        {
        }

        public override CGSize ContentSize { get => base.ContentSize; set { base.ContentSize = value; InvalidateIntrinsicContentSize(); } }
        public override CGSize IntrinsicContentSize
        {
            get
            {
                this.LayoutIfNeeded();
                return new CGSize(width: NoIntrinsicMetric, height: ContentSize.Height);
            }
        }
    }

La mia implementazione di Swift 5 consiste nell'impostare il vincolo alto di tableView sulla dimensione del suo contenuto ( contentSize.height). Questo metodo presuppone che tu stia utilizzando il layout automatico. Questo codice deve essere inserito nel cellForRowAtmetodo tableView.

tableView.heightAnchor.constraint(equalToConstant: tableView.contentSize.height).isActive = true

Se vuoi che la tua tabella sia dinamica, dovrai usare una soluzione basata sul contenuto della tabella come descritto sopra. Se si desidera semplicemente visualizzare una tabella più piccola, è possibile utilizzare una vista contenitore e incorporare un UITableViewController in esso: UITableView verrà ridimensionato in base alle dimensioni del contenitore.

Questo evita molti calcoli e chiamate al layout.

Soluzione Mu per questo in rapido 3 : chiama questo metodo inviewDidAppear

func UITableView_Auto_Height(_ t : UITableView)
{
        var frame: CGRect = t.frame;
        frame.size.height = t.contentSize.height;
        t.frame = frame;        
}