Cambiar el tamaño de un UITextField mientras se escribe (mediante el uso de Autodiseño)

No se por qué UITextField solo actualiza su intrinsicContentSize cuando renuncia a su estado de primer respondedor. Esto sucede tanto para iOS 7 como para iOS 8.

Como solución temporal, sobreescribo intrinsicContentSize y determino el tamaño usando typingAttributes. Esto explica leftView y rightView también

// This method is target-action for UIControlEventEditingChanged
func textFieldEditingChanged(textField: UITextField) {
  textField.invalidateIntrinsicContentSize()
}


override var intrinsicContentSize: CGSize {
    if isEditing {
      let string = (text ?? "") as NSString
      let size = string.size(attributes: typingAttributes)
      return CGSize(width: size.width + (rightView?.bounds.size.width ?? 0) + (leftView?.bounds.size.width ?? 0) + 2,
                    height: size.height)
    }

    return super.intrinsicContentSize
  }

Aquí lo hago más amplio para dar cuenta del caret

Aquí está la respuesta en Swift. Como beneficio adicional, este fragmento no colapsa el campo de texto si hay un marcador de posición.

// UITextField subclass

override func awakeFromNib() {
    super.awakeFromNib()
    self.addTarget(self, action: #selector(textFieldTextDidChange), forControlEvents: .EditingChanged)
}

func textFieldTextDidChange(textField: UITextField) {
    textField.invalidateIntrinsicContentSize()
}

override func intrinsicContentSize() -> CGSize {
    if self.editing {
        let textSize: CGSize = NSString(string: ((text ?? "" == "") ? self.placeholder : self.text) ?? "").sizeWithAttributes(self.typingAttributes)
        return CGSize(width: textSize.width + (self.leftView?.bounds.size.width ?? 0) + (self.rightView?.bounds.size.width ?? 0) + 2, height: textSize.height)
    } else {
        return super.intrinsicContentSize()
    }
}

Tenía un requisito similar con un UITextView (tenía que aumentar dinámicamente su altura y algunas otras cosas).

Lo que hice fue algo similar a esto: {[10]]}

Considerando self.contentView es el superview de textField

- (IBAction)textFieldDidChange:(UITextField *)textField {
    //You can also use "textField.superview" instead of "self.contentView"
    [self.contentView setNeedsUpdateConstraints];

    //Since you wish to animate that expansion right away...
    [UIView animateWithDuration:0.1 animations:^{
        [self.contentView updateConstraintsIfNeeded];
    }];
    NSLog(@"%@", NSStringFromCGSize(textField.intrinsicContentSize));
}

Además, teniendo en cuenta los requisitos que tenía, tuve que anular el método updateConstraints de mis UITextView's superview.

Si eliges optar por esa solución (tal vez por un enfoque más afinado), puedes hacer:

- (void)updateConstraints {
    [super updateConstraints];

    //Firstly, remove the width constraint from the textField.
    [self.myTextField removeConstraint:self.textFieldWidthConstraint];
    self.textFieldWidthConstraint = nil;

    CGSize contentSize = self.myTextField.intrinsicContentSize;
    self.textFieldWidthConstraint = [NSLayoutConstraint constraintWithItem:self.myTextField attribute:NSLayoutAttributeWidth relatedBy:NSLayoutRelationGreaterThanOrEqual toItem:nil attribute:NSLayoutAttributeNotAnAttribute multiplier:1 constant:contentSize.width];

    [self.myTextField addConstraint:self.textFieldWidthConstraint];
}

Como se mencionó, la opción anular fue utilizado por mí porque necesitaba un enfoque más afinado.

Además, como siempre, tendrá que asegurarse de que está comprobando los casos extremos (en términos de valores de tamaño) que cree que podría encontrar.

Espero que esto ayude!

Salud!

First things first: en Swift 4, el intrinsicContentSize de UITextField es una variable calculada, no un método.

A continuación se muestra una solución Swift4 con un caso de uso especializado. Un campo de texto justificado a la derecha puede redimensionarse y extenderse hacia la izquierda hasta cierto límite de píxeles. El textfield se asigna a la clase CurrencyTextField que hereda de UITextField . CurrencyTextField se extiende para proporcionar un comportamiento personalizado para devolver el objeto intrinsicContentSize, una variable calculada. .
El evento" editing changed " de la instancia CurrencyTextField se asigna al método repositionAndResize IBAction en su clase host UIViewController. Este método simplemente invalida el tamaño de contenido intrínseco actual de la instancia de CurrencyTextField. Invocar el método invalidateIntrinsicContentSize de CurrencyTextField (forma heredada UITextField ) desencadena un intento de obtener el valor intrínseco del objeto tamaño del contenido.

La lógica personalizada en el método intrinsicContentSize getter de CurrencyTextField tiene que convertir la propiedad text de CurrentTextField a NSString para determinar su tamaño, que devuelve como intrinsicContentSize si la coordenada x del CurrencyTextField es mayor que el límite de píxeles estipulado.

class CurrencyTextField:UITextField {

}

extension CurrencyTextField {


     override open var intrinsicContentSize: CGSize {

        if isEditing {
            let string = (text ?? "") as NSString
            let stringSize:CGSize = string.size(withAttributes: 
             [NSAttributedStringKey.font: UIFont.systemFont(ofSize: 
             19.0)])
             if self.frame.minX > 71.0 {
                return stringSize
             }
       }

       return super.intrinsicContentSize
    }


}

class TestController: UIViewController {

    @IBAction func repositionAndResize(_ sender: CurrencyTextField) {
        sender.invalidateIntrinsicContentSize()
    }


    override func viewDidLoad() {
        super.viewDidLoad()

    }

}

Otra solución para esto es establecer restricciones iniciales/finales en el campo de texto y usar isActive para activarlas/desactivarlas.

Al iniciar la edición, enciéndalos, si el texto está centrado, el efecto será el mismo (el texto parece redimensionarse automáticamente al escribir). Cuando se detenga la edición, desactive las restricciones, que envolverán el marco alrededor del texto.

Para mí también agregué un destino al campo de texto (UIControlEventEditingChanged)

- (void)textFieldChanged:(UITextField *)textField {
    [textField sizeToFit];
}

Si tiene un color de fondo, simplemente actualícelo en el método delegado:

- (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string {

    textField.backgroundColor = [UIColor grayColor];
    return YES;
}

Puede agregar este código en viewDidLoad para resolver el problema.

if ([self respondsToSelector:@selector(setEdgesForExtendedLayout:)])
{
    self.edgesForExtendedLayout = UIRectEdgeNone;
}

Por alguna razón, llamar a invalidateIntrinsicContentSize tampoco funcionó para mí, pero también me encontré con problemas con las otras soluciones debido a los márgenes y los controles de edición.

Esta solución no siempre es necesaria; si invalidateIntrinsicContentSize funciona, entonces todo lo que hay que hacer es agregar una llamada a eso cuando se cambia el texto, como en las otras respuestas. Si eso no está funcionando, entonces aquí hay una solución (adaptada de aquí ) que encontré que también funciona con un control claro:

class AutoResizingUITextField: UITextField {
    var lastTextBeforeEditing: String?

    override init(frame: CGRect) {
        super.init(frame: frame)
        setupTextChangeNotification()
    }

    required init?(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
        setupTextChangeNotification()
    }                

    func setupTextChangeNotification() {
        NotificationCenter.default.addObserver(
            forName: Notification.Name.UITextFieldTextDidChange,
            object: self,
            queue: OperationQueue.main) { (notification) in                   
                self.invalidateIntrinsicContentSize()
        }
        NotificationCenter.default.addObserver(
            forName: Notification.Name.UITextFieldTextDidBeginEditing,
            object: self,
            queue: OperationQueue.main) { (notification) in
                self.lastTextBeforeEditing = self.text
        }
    }                

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

        if isEditing, let text = text, let lastTextBeforeEditing = lastTextBeforeEditing {
            let string = text as NSString
            let stringSize = string.size(attributes: typingAttributes)
            let origSize = (lastTextBeforeEditing as NSString).size(attributes: typingAttributes)
            size.width = size.width + (stringSize.width - origSize.width)
        }

        return size
    }

    deinit {
        NotificationCenter.default.removeObserver(self)
    }
}

Si invalidateIntrinsicContentSize está funcionando por sí mismo , esto terminará contando dos veces el cambio, por lo que primero debe verificarse.