UITableView öğesini içeriğe sığacak şekilde yeniden boyutlandırma

Bir soru UILabelve görüntülenen çoktan seçmeli cevaplar UITableView, her satır çoktan seçmeli gösteren bir uygulama oluşturacağım. Sorular ve cevaplar değişecektir, bu yüzden UITableViewbunun dinamik olması gerekir .

sizeToFitMasa için etrafta bir çalışma bulmak istiyorum . Tablonun çerçevesinin tüm içeriğinin yüksekliğine ayarlandığı yer.

Herkes bunu nasıl başarabileceğim konusunda tavsiyede bulunabilir mi?

Aslında cevabı kendim buldum.

Sadece yeni oluşturmak CGRectiçin tableView.framebirlikte heightbirtable.contentSize.height

Yani yüksekliğini ayarlar UITableViewiçin heightiçeriğinin. Kod kullanıcı arayüzünü değiştirdiğinden, ana iş parçacığında çalıştırmayı unutmayın:

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

KVO, DispatchQueue veya ayar kısıtlamaları olmadan Swift 5 ve 4.2 çözümü.

Bu çözüm Gulz'un cevabına dayanıyor .

1) Aşağıdakilerin bir alt sınıfını oluşturun 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) UITableViewDüzeninize bir ekleyin ve her tarafta kısıtlamalar ayarlayın. Sınıfını olarak ayarlayın ContentSizedTableView.

3) Bazı hatalar görmelisiniz, çünkü Storyboard alt sınıfımızı dikkate almıyor ' intrinsicContentSize. Boyut denetçisini açıp intrinsicContentSize değerini bir yer tutucu değerine geçersiz kılarak bunu düzeltin. Bu, tasarım zamanı için bir geçersiz kılmadır. Çalışma zamanında ContentSizedTableViewsınıfımızdaki geçersiz kılmayı kullanır

Güncelleme: Swift 4.2 için kod değiştirildi. Önceki bir sürümü kullanıyorsanız, UIViewNoIntrinsicMetricyerineUIView.noIntrinsicMetric

Hızlı Çözüm

Bu adımları takip et:

1- Tablo için yükseklik sınırlamasını film şeridinden ayarlayın.

2- Yükseklik sınırlamasını film şeridinden sürükleyin ve görünüm denetleyicisi dosyasında bunun için @IBOutlet oluşturun.

    @IBOutlet weak var tableHeight: NSLayoutConstraint!

3- Sonra bu kodu kullanarak tablonun yüksekliğini dinamik olarak değiştirebilirsiniz:

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

Güncelleme

Son satır sizin için kesilirse, willDisplay hücre işlevinde viewWillLayoutSubviews () öğesini çağırmayı deneyin:

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

Bunu iOS 7'de denedim ve benim için çalıştı

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

Tablo görünümünde contentSize özelliği için bir gözlemci ekleyin ve çerçeve boyutunu buna göre ayarlayın

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

sonra geri aramada:

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

Umarım bu size yardımcı olacaktır.

Kaydırma görünümü içinde bir tablo görünümü vardı ve tableView yüksekliğini hesaplamak ve buna göre yeniden boyutlandırmak zorunda kaldı. Bunlar attığım adımlar:

0) scrollView için bir UIView ekleyin (muhtemelen bu adım olmadan çalışacaktır, ancak olası çakışmalardan kaçınmak için yaptım) - bu tablo görünümünüz için bir includer görünümü olacaktır. Bu adımı uygularsanız, görünüm sınırlarını doğrudan tablo görünümünün kenarlarına ayarlayın.

1) UITableView'in bir alt sınıfını oluşturun:

class IntrinsicTableView: UITableView {

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

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

}

2) Storyboard'daki bir tablo görünümü sınıfını IntrinsicTableView olarak ayarlayın: ekran görüntüsü: http://joxi.ru/a2XEENpsyBWq0A

3) heightConstraint'i tablo görünümünüze ayarlayın

4) Tablonuzun IBoutlet'ini ViewController'ınıza sürükleyin

5) tablonuzun yükseklik kısıtlamasının IBoutlet'ini ViewController'ınıza sürükleyin

6) bu yöntemi ViewController'ınıza ekleyin:

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

Bu yardımcı olur umarım

Tablo görünümünün içerik boyutu değişikliklerini kendiniz izlemek istemiyorsanız, bu alt sınıfı yararlı bulabilirsiniz.

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

ContentSize öğenizin doğru olmaması durumunda bunun tahminiRowHeight'a (otomatik) bağlı olması, bunu daha önce kullanın

tableView.estimatedRowHeight = 0;

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

Swift 3, iOS 10.3

Çözüm 1: Hemen koymakself.tableview.sizeToFit()içindecellForRowAt indexPathişlevi. Tablo görünümü yüksekliğini ihtiyacınızdan daha yükseğe ayarladığınızdan emin olun. Tablo görünümünün altında görünümleriniz yoksa bu iyi bir çözümdür. Ancak, varsa, alt tableview kısıtlaması güncellenmeyecek (2. çözümü bulduğum için düzeltmeye çalışmadım)

Misal:

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

Çözüm 2: Film şeridinde tablo görünümü yükseklik sınırlamasını ayarlayın ve ViewController'a sürükleyin. Hücrenizin ortalama yüksekliğini biliyorsanız ve dizinizin kaç öğe içerdiğini biliyorsanız, şöyle bir şey yapabilirsiniz:

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

*DÜZENLE:

Tüm çözümlerin sonra denedim ve bunların her şey sabitleme, ama tamamen değil, bu tamamen bu sorunu açıklıyor ve düzeltmeler cevaptır.

Mimo'nun yanıtı ve Anooj VM'nin yanıtı da harika, ancak büyük bir listeniz varsa küçük bir sorun var, çerçevenin yüksekliğinin bazı hücrelerinizi kesmesi mümkündür.

Yani. Cevabı biraz değiştirdim:

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

AutoLayout kullanıyorsanız bunu yapmanın çok daha iyi bir yolu vardır: yüksekliği belirleyen kısıtlamayı değiştirin. Sadece tablo içeriğinizin yüksekliğini hesaplayın, ardından kısıtlamayı bulun ve değiştirin. İşte bir örnek (tablonuzun yüksekliğini belirleyen kısıtlamanın aslında "Eşit" ilişkisiyle bir yükseklik kısıtlaması olduğu varsayılarak):

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

Bu, benim için yalnızca bir bölümlü bir tablo görünümü olan Otomatik Düzen'i kullanarak çalışır.

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
    }

Bu işlevi Otomatik Mizanpaj kurarken çağırıyorum (Buradaki örnek SnapKit kullanıyor, ancak fikri anlıyorsunuz):

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

UITableView sadece hücrelerin birleşik yüksekliği kadar uzun olmasını istiyorum; Hücreler arasında dolaşıyorum ve hücrelerin toplam yüksekliğini biriktiriyorum. Tablo görünümünün boyutu bu noktada CGRect.zero olduğundan, hücre tarafından tanımlanan Otomatik Düzen kurallarına uymak için sınırları ayarlamam gerekiyor. Boyutu yeterince büyük olması gereken keyfi bir değere ayarladım. Gerçek boyut daha sonra Otomatik Düzen sistemi tarafından hesaplanacaktır.

Ben biraz farklı bir şekilde yaptım, Aslında benim TableView scrollview içinde oldu, bu yüzden 0 olarak yükseklik kısıtlaması vermek zorunda kaldı.

Sonra çalışma zamanında aşağıdaki değişiklikleri yaptım,

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

Anooj VM'nin cevabının bir uzantısı olarak, içerik boyutunu yalnızca değiştiğinde yenilemek için aşağıdakileri öneriyorum .

Bu yaklaşım ayrıca kaydırmayı düzgün bir şekilde devre dışı bırakır ve daha büyük listeler ile döndürmeyi destekler . ContentSize değişiklikleri ana iş parçacığında gönderildiği için dispatch_async öğesine gerek yoktur.

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

Musa almatri'nin objc versiyonu

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

Bu Özel'i deneyebilirsiniz AGTableView

TableView Yükseklik Kısıtlaması Ayarlamak için Film şeridini veya programlı olarak kullanma. (Bu sınıf otomatik olarak bir yükseklik sınırlaması getirir ve içerik görüntüleme yüksekliğini, görüntülenebilir görüntüleme yüksekliğinize ayarlar).

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

Not Yükseklik ayarlamak için herhangi bir sorun varsa yourTableView.layoutSubviews().

Cevabını dayanarak fl034 . Ancak Xamarin.iOS kullanıcıları için:

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

Swift 5 uygulaması, tableView öğesinin yükseklik sınırlamasını içeriğinin boyutuna ayarlamaktır ( contentSize.height). Bu yöntem, otomatik düzen kullandığınızı varsayar. Bu kod cellForRowAttableView yönteminin içine yerleştirilmelidir .

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

Tablonuzun dinamik olmasını istiyorsanız, yukarıda açıklandığı gibi tablo içeriğine dayalı bir çözüm kullanmanız gerekecektir. Yalnızca daha küçük bir tablo görüntülemek istiyorsanız, bir kapsayıcı görünümü kullanabilir ve içine bir UITableViewController gömebilirsiniz - UITableView kap boyutuna göre yeniden boyutlandırılır.

Bu, birçok hesaplama ve düzen çağrısını önler.

Hızlı 3'te bunun için bir çözüm :viewDidAppear

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