Eu queria usar um plano de fundo personalizado para o meu UITextFields. Isso funciona bem, exceto pelo fato de que eu tenho que usar UITextBorderStyleNonepara torná-la bonita. Isso força o texto a ficar à esquerda sem nenhum preenchimento.

Posso definir um preenchimento manualmente para que fique semelhante a, UITextBorderStyleRoundedRectexceto pelo uso da minha imagem de plano de fundo personalizada?

Encontrei um pequeno truque para definir o preenchimento esquerdo para esta situação exata.

Basicamente, você define a propriedade leftView de UITextFieldcomo uma visualização vazia do tamanho do preenchimento desejado:

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

Caiu como uma luva para mim!

No Swift 3 / Swift 4 , isso pode ser feito fazendo isso

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

Eu criei essa implementação de categoria e a adicionei ao topo do .marquivo.

@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

Com base no link fornecido pela Piotr Blasiak. Pareceu mais simples criar uma subclasse totalmente nova e mais simples adicionar o adicional UIView. Ainda assim, parece que falta algo para não poder controlar o preenchimento dentro de um campo de texto.

Solução 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)
    }
}

Uma versão Swift 3 para Xcode> 6, onde você pode editar o valor inserido no 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)
    }

}

Editar: Ainda funciona no iOS 11.3.1

No iOS 6 myTextField.leftView = paddingView;está causando problema

Isso resolve o problema

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

Para o campo de texto alinhado à direita, use CATransform3DMakeTranslation(-5, 0, 0)como mencionado pelo codificador latenit nos comentários

Uma boa abordagem para adicionar preenchimento ao UITextField é subclassificar e adicionar uma propriedade edgeInsets. Você define o edgeInsets e o UITextField será desenhado de acordo. Isso também funcionará corretamente com um conjunto leftView ou rightView personalizado.

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

Apenas subclasse UITextField assim:

@implementation DFTextField


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

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


@end

Isso adiciona preenchimento horizontal de 10 pontos de cada lado.

Código do objetivo 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. Criar um campo de texto personalizado

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. Defina sua classe de campo de texto como PaddingTextField e personalize seu preenchimento conforme desejar

3. Aproveite

Com base na resposta da Evil Trout, você pode criar uma categoria para facilitar o uso em vários aplicativos.

Arquivo de cabeçalho:

@interface UITextField (PaddingText)

-(void) setLeftPadding:(int) paddingValue;

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

Arquivo de implementação:

#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

Exemplo de uso

#import "UITextField+PaddingText.h"

[self.YourTextField setLeftPadding:20.0f];

Espero que ajude vocês

Felicidades

Versão rápida:

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

Para que você possa atribuir valor no IB

Você não pode definir o preenchimento. Em vez disso, tenha um UIViewque tenha sua imagem de plano de fundo e seu UITextFieldinterior. Defina a UITextFieldlargura como UIViewWidth-(paddingSize x 2)e a altura da mesma forma e, em seguida, defina-a no ponto paddingSize,paddingSize.

Apenas subclasse UITextField assim ( versão 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)
    }

}

Isso adiciona preenchimento horizontal de 25,0 pontos de cada lado.

Eu baseei-me na solução do Nate, mas então achei que isso causa problemas quando você usa as propriedades leftView / rightView, por isso é melhor ajustar a implementação do super, porque ele levará em consideração a visão esquerda / direita.

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

Versão atualizada para o 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)
    }
}

Definir preenchimento para UITextField com UITextBorderStyleNone: Swift

Com base na resposta mais votada de @Evil Trout, criei um método personalizado na minha classe ViewController, como mostrado abaixo:

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

Agora eu posso chamar esse método dentro (método viewDidLoad) e enviar qualquer um dos meus TextFields para esse método, adicionar preenchimento para a direita e esquerda e fornecer cores de texto e plano de fundo escrevendo apenas uma linha de código, da seguinte maneira:

[self modifyTextField:self.firstNameTxtFld];

Isso funcionou perfeitamente no iOS 7! Sei que adicionar muitas visualizações pode tornar essa classe um pouco mais pesada para ser carregada. Mas, quando preocupado com a dificuldade em outras soluções, me vi mais inclinado a esse método e mais flexível ao usar esse método. ;)

Obrigado pelo hack "Evil Trout"! (arco)

Eu pensei em atualizar o snippet de código desta resposta com Swift:

Como o Swift nos permite escrever extensões para as classes existentes, vamos escrever dessa maneira.

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

Espero que isso seja útil para alguém lá fora!
Felicidades!

Veja como fazer isso no 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
}
}

Recurso

Versão Swift 2.0:

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

^ Essas sugestões são ótimas para quem está criando programaticamente uma interface.

Mas existem duas maneiras preguiçosas para aqueles que usam o construtor de interface do Xcode:

• mais fácil: coloque um UIImageView atrás de um campo de texto

• mais fácil: altere o estilo da borda para o quadrado preto simples (opção segundo da esquerda) e adicione sua imagem como imagem de fundo. A imagem tem precedência sobre o quadrado, então você ainda obtém o preenchimento necessário para um fundo de imagem normal, sem que o quadrado seja realmente desenhado.

EDIT: você também pode usar a esfera preta (terceira opção da esquerda ao selecionar o UITextBox no IB), ela não funciona com o estilo "esfera gráfica" da extrema direita.

Se alguém está procurando por Swift 4.0versão, abaixo extensionestá o trabalho. Tem ambos Lefte Rightpreenchimento para UITextField. Na verdade, é IBInspectablepara configuração de storyboard. Você pode definir o valor diretamente no Interface Builder / Storyboard. Este é um código testado na versão Swift 4.0 e no Xcode 9.0

Lembre-se de que, se você deseja ativar Clear Buttono mesmo UITextField, mantenha o preenchimento direito em branco.

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

A melhor maneira de fazer isso é simplesmente criar uma classe usando a subclasse de UITextField e no arquivo .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;

 }

fazendo isso, vá para o storyboard ou xib, clique no inspetor de identidade e substitua UITextfield pelo seu próprio "CustomTextField" na opção de classe.

Nota: Se você simplesmente fornecer preenchimento com layout automático para o campo de texto, seu aplicativo não será executado e exibirá apenas a tela em branco.

Versão 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)
    }
}

A resposta de Nate Flink é a minha favorita, mas não se esqueça das vistas direita / esquerda. Por exemplo, para UITextFieldsubclasse:

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

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

Acima do código, defina o preenchimento correto para rightViewof UITextField.

Solução 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)
 }
}

Aqui está um código Swift para dar preenchimento no UITextfield

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

e ligue usando

self.txtPaddingVw(txtPin)

você pode usar a categoria defina o preenchimento para esquerda e direita

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

você pode definir o preenchimento como este self.phoneNumTF.paddingValue = 10.f; ou self.phoneNumTF.leftPadding = 10.f;

A resposta da truta @Evil é ótima. Eu tenho usado essa abordagem já há algum tempo. A única coisa que falta é "lidar com vários campos de texto". Tentei outras abordagens, mas parece não funcionar.

Subclassificar o UITextField apenas para adicionar um preenchimento não fazia sentido para mim. Então, eu iterava sobre todos os UITextFields para adicionar o preenchimento.

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

A solução de Brody funcionou perfeita para mim. Eu tive que adicionar vistas laterais em um campo de texto e adicionar preenchimento adicional. Portanto, implementando a propriedade UIEdgeInsets customizada em uma subclasse UITextField, consegui realizar a tarefa. Vou usar essa nova subclasse em todos os meus projetos.

A melhor solução que encontrei até agora é uma categoria. É assim que eu adiciono um preenchimento de 5 pontos à esquerda e à direita:

@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

Os # pragma's são apenas para remover os avisos irritantes

textField.layer.borderWidth = 3;

adicionará borda, que funcionou como preenchimento para mim.

Outra consideração é que, se você tiver mais de um UITextFieldonde você está adicionando preenchimento, é criar um separado UIViewpara cada campo de texto - porque eles não podem ser compartilhados.