Ändern der Größe von UITableView an den Inhalt

Ich erstelle eine App, in der eine Frage in einer UILabelund eine Multiple-Choice-Antwort angezeigt UITableViewwerden. Jede Zeile zeigt eine Multiple-Choice- Antwort . Fragen und Antworten variieren, daher muss diese UITableViewHöhe dynamisch sein.

Ich würde gerne eine sizeToFitArbeit für den Tisch finden. Wo der Rahmen der Tabelle auf die Höhe des gesamten Inhalts eingestellt ist.

Kann mir jemand raten, wie ich das erreichen kann?

Eigentlich habe ich die Antwort selbst gefunden.

Ich erstelle gerade ein neues CGRectfür das tableView.framemit dem heightvontable.contentSize.height

Das setzt die Höhe des UITableViewauf den heightInhalt. Da der Code die Benutzeroberfläche ändert, vergessen Sie nicht, ihn im Hauptthread auszuführen:

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

Schnelle 5 und 4.2-Lösung ohne KVO, DispatchQueue oder das Festlegen von Einschränkungen.

Diese Lösung basiert auf Gulz 'Antwort .

1) Erstellen Sie eine Unterklasse von 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) Fügen Sie UITableViewIhrem Layout ein hinzu und legen Sie auf allen Seiten Einschränkungen fest. Setzen Sie die Klasse auf ContentSizedTableView.

3) Sie sollten einige Fehler sehen, da Storyboard unsere Unterklasse nicht intrinsicContentSizeberücksichtigt. Beheben Sie dies, indem Sie den Größeninspektor öffnen und die intrinsicContentSize auf einen Platzhalterwert überschreiben. Dies ist eine Überschreibung für die Entwurfszeit. Zur Laufzeit wird die Überschreibung in unserer ContentSizedTableViewKlasse verwendet

Update: Code für Swift 4.2 geändert. Wenn Sie eine frühere Version verwenden, verwenden Sie UIViewNoIntrinsicMetricanstelle vonUIView.noIntrinsicMetric

Schnelle Lösung

Folge diesen Schritten:

1- Legen Sie die Höhenbeschränkung für die Tabelle im Storyboard fest.

2- Ziehen Sie die Höhenbeschränkung aus dem Storyboard und erstellen Sie ein @IBOutlet dafür in der View Controller-Datei.

    @IBOutlet weak var tableHeight: NSLayoutConstraint!

3- Dann können Sie die Höhe für die Tabelle dynamisch mit diesem Code ändern:

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

Aktualisieren

Wenn die letzte Zeile für Sie ausgeschnitten ist, versuchen Sie, viewWillLayoutSubviews () in der willDisplay-Zellenfunktion aufzurufen:

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

Ich habe dies in iOS 7 versucht und es hat bei mir funktioniert

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

Fügen Sie in der Tabellenansicht einen Beobachter für die contentSize-Eigenschaft hinzu und passen Sie die Rahmengröße entsprechend an

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

dann im Rückruf:

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

Hoffe das wird dir helfen.

Ich hatte eine Tabellenansicht in der Bildlaufansicht und musste die Höhe von tableView berechnen und die Größe entsprechend ändern. Das sind Schritte, die ich unternommen habe:

0) Fügen Sie Ihrer scrollView eine UIView hinzu (funktioniert wahrscheinlich ohne diesen Schritt, aber ich habe es getan, um mögliche Konflikte zu vermeiden) - dies ist eine Containr-Ansicht für Ihre Tabellenansicht. Wenn Sie diesen Schritt ausführen, setzen Sie die Ansichtsrahmen direkt auf die der Tabellenansicht.

1) Erstellen Sie eine Unterklasse von 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) Setzen Sie die Klasse einer Tabellenansicht im Storyboard auf IntrinsicTableView: Screenshot: http://joxi.ru/a2XEENpsyBWq0A

3) Stellen Sie die heightConstraint auf Ihre Tabellenansicht ein

4) Ziehen Sie das IBoutlet Ihrer Tabelle auf Ihren ViewController

5) Ziehen Sie das IBoutlet der Höhenbeschränkung Ihrer Tabelle auf Ihren ViewController

6) Fügen Sie diese Methode Ihrem ViewController hinzu:

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

Hoffe das hilft

Falls Sie die Änderungen der Inhaltsgröße der Tabellenansicht nicht selbst verfolgen möchten, ist diese Unterklasse möglicherweise hilfreich.

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

Falls Ihre contentSize nicht korrekt ist, liegt dies daran, dass sie auf der geschätzten Zeilenhöhe (automatisch) basiert. Verwenden Sie diese zuvor

tableView.estimatedRowHeight = 0;

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

Swift 3, iOS 10.3

Lösung 1: Einfachself.tableview.sizeToFit()incellForRowAt indexPathFunktion setzen. Stellen Sie sicher, dass die Höhe der Tabellenansicht höher als erforderlich ist. Dies ist eine gute Lösung, wenn Sie keine Ansichten unterhalb der Tabellenansicht haben. Wenn dies jedoch der Fall ist, wird die Einschränkung für die untere Tabellenansicht nicht aktualisiert (ich habe nicht versucht, sie zu beheben, da ich Lösung 2 gefunden habe).

Beispiel:

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

Lösung 2: Legen Sie die Höhenbeschränkung für die Tabellenansicht im Storyboard fest und ziehen Sie sie auf den ViewController. Wenn Sie die durchschnittliche Höhe Ihrer Zelle kennen und wissen, wie viele Elemente Ihr Array enthält, können Sie Folgendes tun:

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

*BEARBEITEN:

Nach all den Lösungen, die ich ausprobiert habe und von denen jeder etwas repariert hat, aber nicht vollständig, ist dies die Antwort, die dieses Problem erklärt und vollständig behebt.

Mimo Antwort und Anooj VM ‚s Antwort beide sind genial , aber es ist ein kleines Problem , wenn Sie eine große Liste haben, ist es möglich , dass die Höhe des Rahmens werden einige Ihrer Zellen Cutoff.

So. Ich habe die Antwort ein wenig geändert:

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

Wenn Sie AutoLayout verwenden, gibt es eine viel bessere Möglichkeit: Ändern Sie die Einschränkung, die die Höhe bestimmt. Berechnen Sie einfach die Höhe Ihres Tabelleninhalts, suchen Sie die Einschränkung und ändern Sie sie. Hier ein Beispiel (unter der Annahme, dass die Einschränkung, die die Höhe Ihrer Tabelle bestimmt, tatsächlich eine Höhenbeschränkung mit der Beziehung "Gleich" ist):

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

Dies funktioniert bei Verwendung des automatischen Layouts mit einer Tabellenansicht mit nur einem Abschnitt.

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
    }

Ich rufe diese Funktion beim Einrichten des automatischen Layouts auf (Das Beispiel hier verwendet SnapKit, aber Sie haben die Idee):

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

Ich möchte, dass UITableView nur so hoch ist wie die kombinierte Höhe der Zellen. Ich durchlaufe die Zellen und sammle die Gesamthöhe der Zellen. Da die Größe der Tabellenansicht zu diesem Zeitpunkt CGRect.zero ist, muss ich die Grenzen festlegen, um die von der Zelle definierten Regeln für das automatische Layout einhalten zu können. Ich habe die Größe auf einen beliebigen Wert eingestellt, der groß genug sein sollte. Die tatsächliche Größe wird später vom Auto-Layout-System berechnet.

Ich habe es auf eine etwas andere Art gemacht. Eigentlich war meine TableView in der Bildlaufansicht, also musste ich die Höhenbeschränkung als 0 angeben.

Dann habe ich zur Laufzeit folgende Änderungen vorgenommen:

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

Als Erweiterung der Antwort von Anooj VM empfehle ich Folgendes, um die Inhaltsgröße nur zu aktualisieren, wenn sie sich ändert.

Dieser Ansatz deaktiviert auch das Scrollen ordnungsgemäß und unterstützt größere Listen und Rotationen . Dispatch_async ist nicht erforderlich, da Änderungen an contentSize im Hauptthread ausgelöst werden.

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

objc Version von 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;
}

Sie können diese benutzerdefinierte ausprobieren AGTableView

So legen Sie eine TableView-Höhenbeschränkung mithilfe des Storyboards oder programmgesteuert fest (Diese Klasse ruft automatisch eine Höhenbeschränkung ab und setzt die Höhe der Inhaltsansicht auf die Höhe Ihrer Tabellenansicht.)

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

Hinweis Wenn es Probleme beim Einstellen einer Höhe gibt, dann yourTableView.layoutSubviews().

Basierend auf der Antwort von fl034 . Aber für Xamarin.iOS- Benutzer:

    [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);
            }
        }
    }

Meine Swift 5-Implementierung besteht darin, die Höhenbeschränkung der tableView auf die Größe ihres Inhalts ( contentSize.height) festzulegen . Diese Methode setzt voraus, dass Sie das automatische Layout verwenden. Dieser Code sollte in die cellForRowAttableView-Methode eingefügt werden.

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

Wenn Ihre Tabelle dynamisch sein soll, müssen Sie eine Lösung verwenden, die auf dem oben beschriebenen Tabelleninhalt basiert. Wenn Sie einfach eine kleinere Tabelle anzeigen möchten, können Sie eine Containeransicht verwenden und einen UITableViewController darin einbetten. Die Größe der UITableView wird entsprechend der Containergröße geändert.

Dies vermeidet viele Berechnungen und Aufrufe des Layouts.

Mu Lösung dafür in schnell 3 : Rufen Sie diese Methode inviewDidAppear

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