Volevo usare uno sfondo personalizzato per il mio UITextFields. Funziona bene, tranne per il fatto che devo usarlo UITextBorderStyleNoneper renderlo carino. In questo modo il testo si attacca a sinistra senza alcuna imbottitura.

Posso impostare manualmente un'imbottitura in modo che appaia simile UITextBorderStyleRoundedRecttranne per l'utilizzo della mia immagine di sfondo personalizzata?

Ho trovato un piccolo trucco per impostare l'imbottitura sinistra per questa situazione esatta.

Fondamentalmente, imposti la proprietà leftView di UITextFieldcome una vista vuota della dimensione del pad che desideri:

UIView *paddingView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 5, 20)];
textField.leftView = paddingView;
textField.leftViewMode = UITextFieldViewModeAlways;

Ha funzionato benissimo per me!

In Swift 3 / Swift 4 , è possibile farlo

let paddingView: UIView = UIView(frame: CGRect(x: 0, y: 0, width: 5, height: 20))
textField.leftView = paddingView
textField.leftViewMode = .always

Ho creato l'implementazione di questa categoria e l'ho aggiunta all'inizio del .mfile.

@implementation UITextField (custom)
    - (CGRect)textRectForBounds:(CGRect)bounds {
        return CGRectMake(bounds.origin.x + 10, bounds.origin.y + 8,
                          bounds.size.width - 20, bounds.size.height - 16);
    }
    - (CGRect)editingRectForBounds:(CGRect)bounds {
        return [self textRectForBounds:bounds];
    }
@end

Basato sul link fornito da Piotr Blasiak. Sembrava più semplice quindi creare una sottoclasse completamente nuova e anche più semplice aggiungere l'aggiunta UIView. Tuttavia, sembra che manchi qualcosa per non poter controllare il riempimento all'interno di un campo di testo.

Soluzione Swift 4:

class CustomTextField: UITextField {
    struct Constants {
        static let sidePadding: CGFloat = 10
        static let topPadding: CGFloat = 8
    }

    override func textRect(forBounds bounds: CGRect) -> CGRect {
        return CGRect(
            x: bounds.origin.x + Constants.sidePadding,
            y: bounds.origin.y + Constants.topPadding,
            width: bounds.size.width - Constants.sidePadding * 2,
            height: bounds.size.height - Constants.topPadding * 2
        )
    }

    override func editingRect(forBounds bounds: CGRect) -> CGRect {
        return self.textRect(forBounds: bounds)
    }
}

Una versione di Swift 3 per Xcode> 6, in cui puoi modificare il valore dell'inserzione in Interface Builder / Storyboard.

import UIKit

@IBDesignable
class FormTextField: UITextField {

    @IBInspectable var inset: CGFloat = 0

    override func textRect(forBounds bounds: CGRect) -> CGRect {
        return bounds.insetBy(dx: inset, dy: inset)
    }

    override func editingRect(forBounds bounds: CGRect) -> CGRect {
        return textRect(forBounds: bounds)
    }

}

Modifica: funziona ancora su iOS 11.3.1

In iOS 6 myTextField.leftView = paddingView;sta causando problemi

Questo risolve il problema

myTextField.layer.sublayerTransform = CATransform3DMakeTranslation(5, 0, 0)

Per il campo di testo allineato a destra, utilizzare CATransform3DMakeTranslation(-5, 0, 0)come citato da latenitecoder nei commenti

Un buon approccio per aggiungere il riempimento a UITextField è la sottoclasse e l'aggiunta di una proprietà edgeInsets. Quindi impostare edgeInsets e UITextField verrà disegnato di conseguenza. Funzionerà anche correttamente con un set personalizzato leftView o rightView.

OSTextField.h

#import <UIKit/UIKit.h>

@interface OSTextField : UITextField

@property (nonatomic, assign) UIEdgeInsets edgeInsets;

@end

OSTextField.m

#import "OSTextField.h"

@implementation OSTextField

- (id)initWithFrame:(CGRect)frame{
    self = [super initWithFrame:frame];
    if (self) {
        self.edgeInsets = UIEdgeInsetsZero;
    }
    return self;
}

-(id)initWithCoder:(NSCoder *)aDecoder{
    self = [super initWithCoder:aDecoder];
    if(self){
        self.edgeInsets = UIEdgeInsetsZero;
    }
    return self;
}

- (CGRect)textRectForBounds:(CGRect)bounds {
    return [super textRectForBounds:UIEdgeInsetsInsetRect(bounds, self.edgeInsets)];
}

- (CGRect)editingRectForBounds:(CGRect)bounds {
    return [super editingRectForBounds:UIEdgeInsetsInsetRect(bounds, self.edgeInsets)];
}

@end

Sottoclasse UITextField in questo modo:

@implementation DFTextField


- (CGRect)textRectForBounds:(CGRect)bounds
{
    return CGRectInset(bounds, 10.0f, 0);
}

- (CGRect)editingRectForBounds:(CGRect)bounds
{
    return [self textRectForBounds:bounds];
}


@end

Ciò aggiunge un'imbottitura orizzontale di 10 punti per lato.

Codice obiettivo C.

MyTextField.h

#import <UIKit/UIKit.h>

@interface MyTextField : UITextField

@property (nonatomic) IBInspectable CGFloat padding;

@end

MyTextField.m

#import "MyTextField.h"

IB_DESIGNABLE
@implementation MyTextField

@synthesize padding;

-(CGRect)textRectForBounds:(CGRect)bounds{
    return CGRectInset(bounds, padding, padding);
}

-(CGRect)editingRectForBounds:(CGRect)bounds{
    return [self textRectForBounds:bounds];
}

@end

1. Crea un campo di testo personalizzato

PaddingTextField.swift

import UIKit
class PaddingTextField: UITextField {

@IBInspectable var paddingLeft: CGFloat = 0
@IBInspectable var paddingRight: CGFloat = 0

override func textRectForBounds(bounds: CGRect) -> CGRect {
    return CGRectMake(bounds.origin.x + paddingLeft, bounds.origin.y,
        bounds.size.width - paddingLeft - paddingRight, bounds.size.height);
}

override func editingRectForBounds(bounds: CGRect) -> CGRect {
    return textRectForBounds(bounds)
}}

2. Imposta la classe del tuo campo di testo su PaddingTextField e personalizza il tuo riempimento come desideri

3. Divertirsi

Sulla base della risposta di Evil Trout potresti voler creare una categoria per renderne più semplice l'utilizzo su più applicazioni.

File di intestazione:

@interface UITextField (PaddingText)

-(void) setLeftPadding:(int) paddingValue;

-(void) setRightPadding:(int) paddingValue;
@end

File di implementazione:

#import "UITextField+PaddingText.h"

@implementation UITextField (PaddingText)

-(void) setLeftPadding:(int) paddingValue
{
    UIView *paddingView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, paddingValue, self.frame.size.height)];
    self.leftView = paddingView;
    self.leftViewMode = UITextFieldViewModeAlways;
}

-(void) setRightPadding:(int) paddingValue
{
    UIView *paddingView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, paddingValue, self.frame.size.height)];
    self.rightView = paddingView;
    self.rightViewMode = UITextFieldViewModeAlways;
}

@end

Esempio di utilizzo

#import "UITextField+PaddingText.h"

[self.YourTextField setLeftPadding:20.0f];

Spero che ti aiuti ragazzi

Saluti

Versione rapida:

extension UITextField {
    @IBInspectable var padding_left: CGFloat {
        get {
            LF.log("WARNING no getter for UITextField.padding_left")
            return 0
        }
        set (f) {
            layer.sublayerTransform = CATransform3DMakeTranslation(f, 0, 0)
        }
    }
}

In modo che tu possa assegnare valore in IB

Non è possibile impostare il riempimento. Invece ha un UIViewche ha la tua immagine di sfondo e l' UITextFieldinterno di essa. Impostare la UITextFieldlarghezza come UIViewWidth-(paddingSize x 2)e l'altezza in modo simile e quindi impostarlo nel punto paddingSize,paddingSize.

Sottoclasse UITextField in questo modo ( versione Swift ):

import UIKit

class CustomTextField: UITextField {

    override func textRectForBounds(bounds: CGRect) -> CGRect {
       return CGRectInset(bounds, 25.0, 0)
    }

    override func editingRectForBounds(bounds: CGRect) -> CGRect {
       return self.textRectForBounds(bounds)
    }

}

Ciò aggiunge un'imbottitura orizzontale di 25,0 punti su entrambi i lati.

Ero basato sulla soluzione di Nate, ma poi ho scoperto che ciò causa problemi quando si utilizzano le proprietà leftView / rightView, quindi è meglio ottimizzare l'implementazione del super, perché terrà conto della vista sinistra / destra.

- (CGRect)textRectForBounds:(CGRect)bounds {
    CGRect ret = [super textRectForBounds:bounds];
    ret.origin.x = ret.origin.x + 5;
    ret.size.width = ret.size.width - 10;
    return ret;
}

- (CGRect)editingRectForBounds:(CGRect)bounds {
    return [self textRectForBounds:bounds];
}

Versione aggiornata per Swift 3:

@IBDesignable
class FormTextField: UITextField {

    @IBInspectable var paddingLeft: CGFloat = 0
    @IBInspectable var paddingRight: CGFloat = 0

    override func textRect(forBounds bounds: CGRect) -> CGRect {
        return CGRect(x: bounds.origin.x + paddingLeft, y: bounds.origin.y, width: bounds.size.width - paddingLeft - paddingRight, height: bounds.size.height)
    }

    override func editingRect(forBounds bounds: CGRect) -> CGRect {
        return textRect(forBounds: bounds)
    }
}

Imposta il riempimento per UITextField con UITextBorderStyleNone: Swift

Sulla base della risposta più votata di @Evil Trout, ho creato un metodo personalizzato nella mia classe ViewController, come mostrato di seguito:

- (void) modifyTextField:(UITextField *)textField
{
    UIView *paddingView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 5, 20)];
    textField.leftView = paddingView;
    textField.leftViewMode = UITextFieldViewModeAlways;
    textField.rightView = paddingView;
    textField.rightViewMode = UITextFieldViewModeAlways;

    [textField setBackgroundColor:[UIColor whiteColor]];
    [textField setTextColor:[UIColor blackColor]];
}

Ora posso chiamare quel metodo all'interno (metodo viewDidLoad) e inviare uno qualsiasi dei miei campi di testo a quel metodo e aggiungere il riempimento sia a destra che a sinistra e dare testo e colori di sfondo scrivendo solo una riga di codice, come segue:

[self modifyTextField:self.firstNameTxtFld];

Funzionava perfettamente su iOS 7! So che l'aggiunta di troppe viste potrebbe rendere questa classe un po 'più pesante da caricare. Ma quando sono preoccupato per la difficoltà di altre soluzioni, mi sono trovato più parziale a questo metodo e più flessibile nell'uso di questo modo. ;)

Grazie per l'hack "Evil Trout"! (arco)

Ho pensato di aggiornare lo snippet di codice di questa risposta con Swift:

Poiché Swift ci consente di scrivere estensioni per le classi esistenti, scriviamola in quel modo.

extension UITextField {
    func addPaddingToTextField() {
        let paddingView: UIView = UIView.init(frame: CGRectMake(0, 0, 8, 20))
        self.leftView = paddingView;
        self.leftViewMode = .Always;
        self.rightView = paddingView;
        self.rightViewMode = .Always;


        self.backgroundColor = UIColor.whiteColor()
        self.textColor = UIColor.blackColor()
    }
}

Uso:

self.firstNameTxtFld.addPaddingToTextField()

Spero che questo possa essere utile a qualcun altro là fuori!
Saluti!

Ecco come ottenere questo risultato in SWIFT

@IBOutlet weak var yourTextField: UITextField!

override func viewDidLoad() {
super.viewDidLoad()
let paddingView = UIView(frame: CGRectMake(0, 0, 10, self.yourTextField.frame.height))
yourTextField.leftView = paddingView
yourTextField.leftViewMode = UITextFieldViewMode.Always
}
}

Risorsa

Versione Swift 2.0:

let paddingView: UIView = UIView(frame: CGRectMake(0, 0, 5, 20))
textField.leftView = paddingView
textField.leftViewMode = UITextFieldViewMode.Always;

^ questi suggerimenti sono ottimi per coloro che stanno creando un'interfaccia a livello di codice.

Ma ci sono due MODI FACILMENTE FANTASTICI per quelli di noi che usano il builder di interfaccia Xcode:

• più semplice: inserisci un UIImageView dietro un campo di testo

• più semplice: cambia lo stile del bordo sul tuo semplice quadrato nero (seconda opzione da sinistra), quindi aggiungi la tua immagine come immagine di sfondo. L'immagine ha la precedenza sul quadrato, quindi ottieni ancora il riempimento necessario per uno sfondo normale dell'immagine, senza che il quadrato sia effettivamente disegnato.

EDIT: puoi anche usare la sfera nera (terza opzione da sinistra quando selezioni UITextBox in IB), non funziona con lo stile "sfera grafica" all'estrema destra.

Se qualcuno è alla ricerca di una Swift 4.0versione, allora sotto extensionfunziona. Ha sia Lefte Rightimbottitura perUITextField . In realtà è IBInspectableper la configurazione dello storyboard. È possibile impostare il valore direttamente da Interface Builder / Storyboard. Questo è un codice testato nella versione Swift 4.0 e Xcode 9.0

Tieni presente che se vuoi abilitare Clear Buttonlo stesso, devi UITextFieldmantenere vuoto il padding destro.

import UIKit

extension UITextField {

    @IBInspectable var paddingLeft: CGFloat {
        get {
            return leftView!.frame.size.width
        }
        set {
            let paddingView = UIView(frame: CGRect(x: 0, y: 0, width: newValue, height: frame.size.height))
            leftView = paddingView
            leftViewMode = .always
        }
    }

    @IBInspectable var paddingRight: CGFloat {
        get {
            return rightView!.frame.size.width
        }
        set {
            let paddingView = UIView(frame: CGRect(x: 0, y: 0, width: newValue, height: frame.size.height))
            rightView = paddingView
            rightViewMode = .always     
        }
    }
}  

Il modo migliore per farlo è semplicemente creare una classe usando la sottoclasse di UITextField e nel file .m

 #import "CustomTextField.h"
 #import <QuartzCore/QuartzCore.h>
 @implementation CustomTextField


- (id)initWithCoder:(NSCoder*)coder 
 {
  self = [super initWithCoder:coder];

  if (self) {

//self.clipsToBounds = YES;
//[self setRightViewMode:UITextFieldViewModeUnlessEditing];

self.leftView = [[UIView alloc] initWithFrame:CGRectMake(0, 0,15,46)];
self.leftViewMode=UITextFieldViewModeAlways;
   }

  return self;

 }

facendo questo vai sul tuo storyboard o xib e fai clic su Inspector identità e sostituisci UITextfield con la tua opzione "CustomTextField" nella classe.

Nota: se si fornisce semplicemente un'imbottitura con layout automatico per il campo di testo, l'applicazione non verrà eseguita e verrà visualizzata solo una schermata vuota.

Versione Swift 3:

class CustomTextField:UITextField{

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

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

    override func textRect(forBounds bounds: CGRect) -> CGRect {
        return CGRect.init(x: bounds.origin.x + 8, y: bounds.origin.y, width: bounds.width, height: bounds.height)
    }

    override func editingRect(forBounds bounds: CGRect) -> CGRect {
        return self.textRect(forBounds:bounds)
    }
}

La risposta di Nate Flink è la mia preferita, ma non dimenticare le visualizzazioni destra / sinistra. Ad esempio per la UITextFieldsottoclasse:

override func rightViewRectForBounds(bounds: CGRect) -> CGRect {
    let rightViewBounds = super.rightViewRectForBounds(bounds)

    return CGRectMake(CGRectGetMinX(rightViewBounds) - 10, CGRectGetMinY(rightViewBounds), CGRectGetWidth(rightViewBounds), CGRectGetHeight(rightViewBounds))
}

Sopra il codice impostare l'imbottitura giusta per rightViewof UITextField.

Soluzione Swift 3

class CustomTextField: UITextField {

 override func textRect(forBounds bounds: CGRect) -> CGRect {
  return CGRect(x: bounds.origin.x + 10, y: bounds.origin.y + 8, width: bounds.size.width - 20, height: bounds.size.height - 16)
 }

 override func editingRect(forBounds bounds: CGRect) -> CGRect {
  return self.textRect(forBounds: bounds)
 }
}

Ecco un codice Swift per dare il riempimento in UITextfield

 func txtPaddingVw(txt:UITextField) {
     let paddingView = UIView(frame: CGRectMake(0, 0, 10, 10))
     txt.leftViewMode = .Always
     txt.leftView = paddingView
 }

e chiama usando

self.txtPaddingVw(txtPin)

puoi usare la categoria. imposta l'imbottitura a sinistra e a destra

UITextField + Padding.h

@interface UITextField (Padding)
@property (nonatomic, assign) CGFloat paddingValue;
@property (nonatomic, assign) CGFloat leftPadding;
@property (nonatomic, assign) CGFloat rightPadding;

//overwrite
-(CGRect)textRectForBounds:(CGRect)bounds;
-(CGRect)editingRectForBounds:(CGRect)bounds;
@end

UITextField + Padding.m

#import "UITextField+Padding.h"
#import <objc/runtime.h>

static char TAG_LeftPaddingKey;
static char TAG_RightPaddingKey;
static char TAG_Left_RightPaddingKey;

@implementation UITextField (Padding)

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-protocol-method-implementation"
-(CGRect)textRectForBounds:(CGRect)bounds {

CGFloat offset_Left=0;
CGFloat offset_Right=0;
if (self.paddingValue>0) {
    offset_Left=self.paddingValue;
    offset_Right=offset_Left;
}else{
    if (self.leftPadding>0){
        offset_Left=self.leftPadding;
    }
    if (self.rightPadding>0){
        offset_Right=self.rightPadding;
    }
}

if (offset_Left>0||offset_Right>0) {
    return CGRectMake(bounds.origin.x+ offset_Left ,bounds.origin.y ,
                      bounds.size.width- (offset_Left+offset_Right), bounds.size.height-2 );
 }else{
    return bounds;
 }
}



-(CGRect)editingRectForBounds:(CGRect)bounds {
    return [self textRectForBounds:bounds];
}
#pragma clang diagnostic pop


#pragma maek -setter&&getter
- (CGFloat)paddingValue
{
    return [objc_getAssociatedObject(self,&TAG_Left_RightPaddingKey) floatValue];
}
-(void)setPaddingValue:(CGFloat)paddingValue
{
    objc_setAssociatedObject(self, &TAG_Left_RightPaddingKey, @(paddingValue), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

-(CGFloat)leftPadding
{
    return [objc_getAssociatedObject(self,&TAG_LeftPaddingKey) floatValue];
}

-(void)setLeftPadding:(CGFloat)leftPadding
{
    objc_setAssociatedObject(self, &TAG_LeftPaddingKey, @(leftPadding), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

-(CGFloat)rightPadding
{
    return [objc_getAssociatedObject(self,&TAG_RightPaddingKey) floatValue];
}

-(void)setRightPadding:(CGFloat)rightPadding
{
    objc_setAssociatedObject(self, &TAG_RightPaddingKey, @(rightPadding), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

@end

puoi impostare il padding in questo modo self.phoneNumTF.paddingValue = 10.f; o self.phoneNumTF.leftPadding = 10.f;

La risposta di @Evil Trout è ottima. Uso questo approccio da un po 'di tempo ormai. L'unica cosa che manca è "occuparsi di numerosi campi di testo". Ho provato altri approcci ma non sembra funzionare.

Sottoclasse UITextField solo per aggiungere un'imbottitura non aveva alcun senso per me. Quindi, ho iterato su tutti gli UITextFields per aggiungere il padding.

-(void) addPaddingToAllTextFields:(UIView*)view {

    for(id currentView in [view subviews]){
        if([currentView isKindOfClass:[UITextField class]]) {
            // Change value of CGRectMake to fit ur need
            [currentView setLeftView:[[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 20)]];
            [currentView setLeftViewMode:UITextFieldViewModeAlways];
        }

        if([currentView respondsToSelector:@selector(subviews)]){
            [textfieldarray addObjectsFromArray:[self addPaddingToAllTextFields:currentView]];
        }
    }
}

La soluzione di Brody ha funzionato perfettamente per me. Ho dovuto aggiungere viste laterali su un campo di testo e aggiungere un'imbottitura aggiuntiva. Quindi implementando la proprietà UIEdgeInsets personalizzata in una sottoclasse UITextField sono riuscito a raggiungere il compito. Userò questa nuova sottoclasse in tutti i miei progetti.

La migliore soluzione che ho trovato finora è una categoria. È così che aggiungo un'imbottitura di 5 punti a sinistra e a destra:

@implementation UITextField (Padding)

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-protocol-method-implementation"
- (CGRect)textRectForBounds:(CGRect)bounds {
    return CGRectMake(bounds.origin.x + 5, bounds.origin.y,
                      bounds.size.width - 10, bounds.size.height);
}
- (CGRect)editingRectForBounds:(CGRect)bounds {
    return [self textRectForBounds:bounds];
}
#pragma clang diagnostic pop

@end

I # pragma sono solo per rimuovere i fastidiosi avvertimenti

textField.layer.borderWidth = 3;

aggiungerò il bordo, che ha funzionato come imbottitura per me.

Un'altra considerazione è che, se ne hai più di uno in UITextFieldcui stai aggiungendo il riempimento, è quello di creare un campo separato UIViewper ogni campo di testo, perché non possono essere condivisi.