Ich habe eine Ansicht, die vollständig mit dem automatischen Layout programmgesteuert angelegt ist. Ich habe eine UITextView in der Mitte der Ansicht mit Elementen darüber und darunter. Alles funktioniert gut, aber ich möchte UITextView erweitern können, wenn Text hinzugefügt wird. Dies sollte alles darunter drücken, wenn es sich ausdehnt.

Ich weiß, wie man das "Federn und Streben" macht, aber gibt es eine automatische Layout-Methode, um dies zu tun? Der einzige Weg, den ich mir vorstellen kann, besteht darin, die Einschränkung jedes Mal zu entfernen und wieder hinzuzufügen, wenn sie wachsen muss.

Die Ansicht mit UITextView wird setBoundsvon AutoLayout mit ihrer Größe versehen. Das habe ich also getan. In der Übersicht werden zunächst alle anderen Einschränkungen so eingerichtet, wie sie sein sollten. Am Ende habe ich eine spezielle Einschränkung für die Höhe von UITextView festgelegt und diese in einer Instanzvariablen gespeichert.

_descriptionHeightConstraint = [NSLayoutConstraint constraintWithItem:_descriptionTextView
                                 attribute:NSLayoutAttributeHeight 
                                 relatedBy:NSLayoutRelationEqual 
                                    toItem:nil 
                                 attribute:NSLayoutAttributeNotAnAttribute 
                                multiplier:0.f 
                                 constant:100];

[self addConstraint:_descriptionHeightConstraint];

In der setBoundsMethode habe ich dann den Wert der Konstante geändert.

-(void) setBounds:(CGRect)bounds
{
    [super setBounds:bounds];

    _descriptionTextView.frame = bounds;
    CGSize descriptionSize = _descriptionTextView.contentSize;

    [_descriptionHeightConstraint setConstant:descriptionSize.height];

    [self layoutIfNeeded];
}

Zusammenfassung: Deaktivieren Sie das Scrollen Ihrer Textansicht und beschränken Sie deren Höhe nicht.

Geben Sie dazu programmgesteuert den folgenden Code ein viewDidLoad:

let textView = UITextView(frame: .zero, textContainer: nil)
textView.backgroundColor = .yellow // visual debugging
textView.isScrollEnabled = false   // causes expanding height
view.addSubview(textView)

// Auto Layout
textView.translatesAutoresizingMaskIntoConstraints = false
let safeArea = view.safeAreaLayoutGuide
NSLayoutConstraint.activate([
    textView.topAnchor.constraint(equalTo: safeArea.topAnchor),
    textView.leadingAnchor.constraint(equalTo: safeArea.leadingAnchor),
    textView.trailingAnchor.constraint(equalTo: safeArea.trailingAnchor)
])

Wählen Sie dazu im Interface Builder die Textansicht aus, deaktivieren Sie im Attributinspektor die Option Bildlauf aktiviert und fügen Sie die Einschränkungen manuell hinzu.

Hinweis: Wenn Sie andere Ansichten über / unter Ihrer Textansicht haben, können Sie sie mit a UIStackViewanordnen.

Hier ist eine Lösung für Leute, die es vorziehen, alles mit automatischem Layout zu erledigen:

Im Größeninspektor:

1. Stellen Sie die Priorität des Inhaltskomprimierungswiderstands vertikal auf 1000 ein.

2. Verringern Sie die Priorität der Einschränkungshöhe, indem Sie in Einschränkungen auf "Bearbeiten" klicken. Machen Sie es einfach weniger als 1000.

Im Attributinspektor:

1. Deaktivieren Sie "Scrollen aktiviert".

UITextView bietet keine intrinsicContentSize, daher müssen Sie sie in Unterklassen unterteilen und eine bereitstellen. Damit es automatisch wächst, machen Sie die intrinsicContentSize in layoutSubviews ungültig. Wenn Sie etwas anderes als das Standard-ContentInset verwenden (was ich nicht empfehle), müssen Sie möglicherweise die intrinsicContentSize-Berechnung anpassen.

@interface AutoTextView : UITextView

@end

#import "AutoTextView.h"

@implementation AutoTextView

- (void) layoutSubviews
{
    [super layoutSubviews];

    if (!CGSizeEqualToSize(self.bounds.size, [self intrinsicContentSize])) {
        [self invalidateIntrinsicContentSize];
    }
}

- (CGSize)intrinsicContentSize
{
    CGSize intrinsicContentSize = self.contentSize;

    // iOS 7.0+
    if ([[[UIDevice currentDevice] systemVersion] floatValue] >= 7.0f) {
        intrinsicContentSize.width += (self.textContainerInset.left + self.textContainerInset.right ) / 2.0f;
        intrinsicContentSize.height += (self.textContainerInset.top + self.textContainerInset.bottom) / 2.0f;
    }

    return intrinsicContentSize;
}

@end

Sie können dies über das Storyboard tun, indem Sie einfach "Scrolling Enabled" deaktivieren :)

Ich habe festgestellt, dass dies in Situationen, in denen isScrollEnabled möglicherweise noch auf true gesetzt ist, nicht ungewöhnlich ist, um eine angemessene Interaktion mit der Benutzeroberfläche zu ermöglichen. Ein einfacher Fall hierfür ist, wenn Sie eine automatisch expandierende Textansicht zulassen möchten, die maximale Höhe jedoch in einer UITableView auf einen angemessenen Wert beschränken möchten.

Hier ist eine Unterklasse von UITextView, die ich mir ausgedacht habe und die eine automatische Erweiterung mit automatischem Layout ermöglicht, die Sie jedoch weiterhin auf eine maximale Höhe beschränken können und die verwaltet, ob die Ansicht abhängig von der Höhe scrollbar ist. Standardmäßig wird die Ansicht unbegrenzt erweitert, wenn Sie Ihre Einschränkungen auf diese Weise eingerichtet haben.

import UIKit

class FlexibleTextView: UITextView {
    // limit the height of expansion per intrinsicContentSize
    var maxHeight: CGFloat = 0.0
    private let placeholderTextView: UITextView = {
        let tv = UITextView()

        tv.translatesAutoresizingMaskIntoConstraints = false
        tv.backgroundColor = .clear
        tv.isScrollEnabled = false
        tv.textColor = .disabledTextColor
        tv.isUserInteractionEnabled = false
        return tv
    }()
    var placeholder: String? {
        get {
            return placeholderTextView.text
        }
        set {
            placeholderTextView.text = newValue
        }
    }

    override init(frame: CGRect, textContainer: NSTextContainer?) {
        super.init(frame: frame, textContainer: textContainer)
        isScrollEnabled = false
        autoresizingMask = [.flexibleWidth, .flexibleHeight]
        NotificationCenter.default.addObserver(self, selector: #selector(UITextInputDelegate.textDidChange(_:)), name: Notification.Name.UITextViewTextDidChange, object: self)
        placeholderTextView.font = font
        addSubview(placeholderTextView)

        NSLayoutConstraint.activate([
            placeholderTextView.leadingAnchor.constraint(equalTo: leadingAnchor),
            placeholderTextView.trailingAnchor.constraint(equalTo: trailingAnchor),
            placeholderTextView.topAnchor.constraint(equalTo: topAnchor),
            placeholderTextView.bottomAnchor.constraint(equalTo: bottomAnchor),
        ])
    }

    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    override var text: String! {
        didSet {
            invalidateIntrinsicContentSize()
            placeholderTextView.isHidden = !text.isEmpty
        }
    }

    override var font: UIFont? {
        didSet {
            placeholderTextView.font = font
            invalidateIntrinsicContentSize()
        }
    }

    override var contentInset: UIEdgeInsets {
        didSet {
            placeholderTextView.contentInset = contentInset
        }
    }

    override var intrinsicContentSize: CGSize {
        var size = super.intrinsicContentSize

        if size.height == UIViewNoIntrinsicMetric {
            // force layout
            layoutManager.glyphRange(for: textContainer)
            size.height = layoutManager.usedRect(for: textContainer).height + textContainerInset.top + textContainerInset.bottom
        }

        if maxHeight > 0.0 && size.height > maxHeight {
            size.height = maxHeight

            if !isScrollEnabled {
                isScrollEnabled = true
            }
        } else if isScrollEnabled {
            isScrollEnabled = false
        }

        return size
    }

    @objc private func textDidChange(_ note: Notification) {
        // needed incase isScrollEnabled is set to true which stops automatically calling invalidateIntrinsicContentSize()
        invalidateIntrinsicContentSize()
        placeholderTextView.isHidden = !text.isEmpty
    }
}

Als Bonus gibt es Unterstützung für das Einfügen von Platzhaltertext ähnlich wie bei UILabel.

Sie können dies auch ohne Unterklassen tun UITextView. Schauen Sie sich meine Antwort auf Wie kann ich eine UITextView unter iOS 7 an ihren Inhalt anpassen?

Verwenden Sie den Wert dieses Ausdrucks:

[textView sizeThatFits:CGSizeMake(textView.frame.size.width, CGFLOAT_MAX)].height

die Aktualisierung constantder textView‚s Höhe UILayoutConstraint.

Eine wichtige Sache zu beachten:

Da UITextView eine Unterklasse von UIScrollView ist, unterliegt es der Eigenschaft automaticAdjustsScrollViewInsets von UIViewController.

Wenn Sie das Layout einrichten und die Textansicht die erste Unteransicht in einer UIViewControllers-Hierarchie ist, werden die contentInsets geändert, wenn automatischAdjustsScrollViewInsets true ist, was manchmal zu unerwartetem Verhalten im automatischen Layout führt.

Wenn Sie also Probleme mit dem automatischen Layout und automaticallyAdjustsScrollViewInsets = falseden Textansichten haben , versuchen Sie, diese auf dem Ansichts-Controller festzulegen oder die Textansicht in der Hierarchie nach vorne zu verschieben.

_{Dies ist eher ein sehr wichtiger Kommentar}

Der Schlüssel zum Verständnis, warum die Antwort von Vitaminwater funktioniert, sind drei Dinge:

1. Wissen Sie, dass UITextView eine Unterklasse der UIScrollView-Klasse ist
2. Verstehen Sie, wie ScrollView funktioniert und wie die contentSize berechnet wird. Weitere Informationen finden Sie hier Antwort und seine verschiedenen Lösungen und Kommentare.
3. Verstehen Sie, was contentSize ist und wie es berechnet wird. Sehen Sie hier und hier . Es könnte auch dazu beitragen , diese Einstellung contentOffsetist wahrscheinlich nichts anderes als:

func setContentOffset(offset: CGPoint)
{
    CGRect bounds = self.bounds
    bounds.origin = offset
    self.bounds = bounds
}

Weitere Informationen finden Sie unter objc scrollview und zum Verständnis der scrollview

Wenn Sie die drei miteinander kombinieren, werden Sie leicht verstehen, dass Sie zulassen müssen, dass die intrinsische contentSize der textView entlang der AutoLayout-Einschränkungen der textView arbeitet, um die Logik zu steuern. Es ist fast so, als ob Sie textView wie ein UILabel funktionieren

Um dies zu erreichen, müssen Sie das Scrollen deaktivieren. Dies bedeutet im Grunde, dass die Größe der scrollView, die Größe der contentSize und im Falle des Hinzufügens einer containerView die Größe der containerView alle gleich ist. Wenn sie gleich sind, haben Sie KEIN Scrollen. Und du hättest . Haben bedeutet, dass Sie nicht nach unten gescrollt haben. Nicht einmal einen Punkt nach unten! Infolgedessen wird die Textansicht vollständig gestreckt.0 contentOffset0 contentOffSet

Es ist auch nichts wert, was bedeutet, dass die Grenzen und der Rahmen von scrollView identisch sind. Wenn Sie 5 Punkte nach unten scrollen, ist Ihr contentOffset gleich , während Ihr gleich ist0 contentOffset5scrollView.bounds.origin.y - scrollView.frame.origin.y5

Plug-and-Play-Lösung - Xcode 9

Automatische Anordnung ebenso wie UILabelmit der Link - Erkennung , Textauswahl , Bearbeitung und Scrollen von UITextView.

Handelt automatisch

• Sicherer Bereich
• Inhaltseinfügungen
• Linienfragmentauffüllung
• Textcontainer-Einfügungen
• Einschränkungen
• Stapelansichten
• Zugeschriebene Zeichenfolgen
• Was auch immer.

Viele dieser Antworten haben mich zu 90% dorthin gebracht, aber keine war narrensicher.

Wenn Sie diese UITextViewUnterklasse besuchen, sind Sie gut.

#pragma mark - Init

- (instancetype)initWithFrame:(CGRect)frame textContainer:(nullable NSTextContainer *)textContainer
{
    self = [super initWithFrame:frame textContainer:textContainer];
    if (self) {
        [self commonInit];
    }
    return self;
}

- (instancetype)initWithCoder:(NSCoder *)aDecoder
{
    self = [super initWithCoder:aDecoder];
    if (self) {
        [self commonInit];
    }
    return self;
}

- (void)commonInit
{
    // Try to use max width, like UILabel
    [self setContentCompressionResistancePriority:UILayoutPriorityRequired forAxis:UILayoutConstraintAxisHorizontal];
    
    // Optional -- Enable / disable scroll & edit ability
    self.editable = YES;
    self.scrollEnabled = YES;
    
    // Optional -- match padding of UILabel
    self.textContainer.lineFragmentPadding = 0.0;
    self.textContainerInset = UIEdgeInsetsZero;
    
    // Optional -- for selecting text and links
    self.selectable = YES;
    self.dataDetectorTypes = UIDataDetectorTypeLink | UIDataDetectorTypePhoneNumber | UIDataDetectorTypeAddress;
}

#pragma mark - Layout

- (CGFloat)widthPadding
{
    CGFloat extraWidth = self.textContainer.lineFragmentPadding * 2.0;
    extraWidth +=  self.textContainerInset.left + self.textContainerInset.right;
    if (@available(iOS 11.0, *)) {
        extraWidth += self.adjustedContentInset.left + self.adjustedContentInset.right;
    } else {
        extraWidth += self.contentInset.left + self.contentInset.right;
    }
    return extraWidth;
}

- (CGFloat)heightPadding
{
    CGFloat extraHeight = self.textContainerInset.top + self.textContainerInset.bottom;
    if (@available(iOS 11.0, *)) {
        extraHeight += self.adjustedContentInset.top + self.adjustedContentInset.bottom;
    } else {
        extraHeight += self.contentInset.top + self.contentInset.bottom;
    }
    return extraHeight;
}

- (void)layoutSubviews
{
    [super layoutSubviews];
    
    // Prevents flashing of frame change
    if (CGSizeEqualToSize(self.bounds.size, self.intrinsicContentSize) == NO) {
        [self invalidateIntrinsicContentSize];
    }
    
    // Fix offset error from insets & safe area
    
    CGFloat textWidth = self.bounds.size.width - [self widthPadding];
    CGFloat textHeight = self.bounds.size.height - [self heightPadding];
    if (self.contentSize.width <= textWidth && self.contentSize.height <= textHeight) {
        
        CGPoint offset = CGPointMake(-self.contentInset.left, -self.contentInset.top);
        if (@available(iOS 11.0, *)) {
            offset = CGPointMake(-self.adjustedContentInset.left, -self.adjustedContentInset.top);
        }
        if (CGPointEqualToPoint(self.contentOffset, offset) == NO) {
            self.contentOffset = offset;
        }
    }
}

- (CGSize)intrinsicContentSize
{
    if (self.attributedText.length == 0) {
        return CGSizeMake(UIViewNoIntrinsicMetric, UIViewNoIntrinsicMetric);
    }
    
    CGRect rect = [self.attributedText boundingRectWithSize:CGSizeMake(self.bounds.size.width - [self widthPadding], CGFLOAT_MAX)
                                                    options:NSStringDrawingUsesLineFragmentOrigin
                                                    context:nil];
    
    return CGSizeMake(ceil(rect.size.width + [self widthPadding]),
                      ceil(rect.size.height + [self heightPadding]));
}

Die Antwort von Vitaminwater funktioniert für mich.

Wenn der Text Ihrer Textansicht während der Bearbeitung nach dem Einstellen auf und ab springt [textView setScrollEnabled:NO];, legen Sie ihn festSize Inspector > Scroll View > Content Insets > Never .

Ich hoffe es hilft.

Platzieren Sie das versteckte UILabel unter Ihrer Textansicht. Beschriftungslinien = 0. Setzen Sie die Einschränkungen von UITextView so, dass sie dem UILabel entsprechen (centerX, centerY, width, height). Funktioniert auch, wenn Sie das Bildlaufverhalten von textView verlassen.

Übrigens habe ich eine expandierende UITextView mit einer Unterklasse erstellt und die intrinsische Inhaltsgröße überschrieben. Ich habe in UITextView einen Fehler entdeckt, den Sie möglicherweise in Ihrer eigenen Implementierung untersuchen möchten. Hier ist das Problem:

Die erweiterte Textansicht wird verkleinert, um den wachsenden Text aufzunehmen, wenn Sie jeweils einzelne Buchstaben eingeben. Wenn Sie jedoch eine Menge Text einfügen, wird dieser nicht verkleinert, sondern der Text wird nach oben gescrollt und der Text oben ist nicht sichtbar.

Die Lösung: SetBounds überschreiben: in Ihrer Unterklasse. Aus einem unbekannten Grund führte das Einfügen dazu, dass der Wert für bounds.origin.y nicht zee war (33 in jedem Fall, den ich sah). Also habe ich setBounds überschrieben: um die bounds.origin.y immer auf Null zu setzen. Das Problem wurde behoben.

Hier ist eine schnelle Lösung:

Dieses Problem kann auftreten, wenn Sie die Eigenschaft clipsToBounds in Ihrer Textansicht auf false gesetzt haben. Wenn Sie es einfach löschen, verschwindet das Problem.

myTextView.clipsToBounds = false //delete this line

Obj C:

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController

@property (nonatomic) UITextView *textView;
@end



#import "ViewController.h"

@interface ViewController ()

@end

@implementation ViewController

@synthesize textView;

- (void)viewDidLoad{
    [super viewDidLoad];
    [self.view setBackgroundColor:[UIColor grayColor]];
    self.textView = [[UITextView alloc] initWithFrame:CGRectMake(30,10,250,20)];
    self.textView.delegate = self;
    [self.view addSubview:self.textView];
}

- (void)didReceiveMemoryWarning{
    [super didReceiveMemoryWarning];
}

- (void)textViewDidChange:(UITextView *)txtView{
    float height = txtView.contentSize.height;
    [UITextView beginAnimations:nil context:nil];
    [UITextView setAnimationDuration:0.5];

    CGRect frame = txtView.frame;
    frame.size.height = height + 10.0; //Give it some padding
    txtView.frame = frame;
    [UITextView commitAnimations];
}

@end