Chciałem użyć niestandardowego tła dla mojego UITextFields. Działa to dobrze, z wyjątkiem tego, że muszę użyć, UITextBorderStyleNoneaby wyglądać ładnie. To zmusza tekst do przylgnięcia w lewo bez dopełniania.

Czy mogę ustawić dopełnienie ręcznie, aby wyglądało podobnie, z UITextBorderStyleRoundedRectwyjątkiem korzystania z niestandardowego obrazu tła?

Znalazłem schludny mały hack, aby ustawić lewą wyściółkę dla tej dokładnej sytuacji.

Zasadniczo ustawiasz właściwość leftView UITextFieldna pusty widok rozmiaru wypełnienia, który chcesz:

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

Dla mnie zadziałało jak urok!

W Swift 3 / Swift 4 można to zrobić

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

Utworzyłem tę kategorię implementacji i dodałem ją na początku .mpliku.

@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

Na podstawie linku udostępnionego przez Piotra Blasiaka. Wydawało się to prostsze niż stworzenie zupełnie nowej podklasy, a także prostsze niż dodanie dodatkowej UIView. Mimo to wydaje się, że czegoś brakuje, aby nie móc kontrolować wypełnienia w polu tekstowym.

Rozwiązanie 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)
    }
}

Wersja Swift 3 dla Xcode> 6, w której można edytować wartość wstawki w Konstruktorze / 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)
    }

}

Edycja: Nadal działa w systemie iOS 11.3.1

W iOS 6 myTextField.leftView = paddingView;powoduje problem

To rozwiązuje problem

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

W przypadku wyrównanego do prawej pola tekstowego użyj CATransform3DMakeTranslation(-5, 0, 0)jako wzmianki przez latenitecoder w komentarzach

Dobrym podejściem do dodawania dopełnienia do UITextField jest podklasa i dodanie właściwości edgeInsets. Następnie ustawisz edgeInsets, a pole UITextField zostanie odpowiednio narysowane. Będzie to również działać poprawnie z niestandardowym zestawem leftView lub 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

Wystarczy podklasować UITextField w następujący sposób:

@implementation DFTextField


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

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


@end

Dodaje poziomą wyściółkę po 10 punktów z każdej strony.

Kod celu 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. Utwórz niestandardowe pole tekstowe

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. Ustaw klasę pola tekstowego na PaddingTextField i dostosuj dopełnianie, jak chcesz

3. Ciesz się

W oparciu o odpowiedź Evil Trout możesz chcieć utworzyć kategorię, aby ułatwić korzystanie z wielu aplikacji.

Plik nagłówka:

@interface UITextField (PaddingText)

-(void) setLeftPadding:(int) paddingValue;

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

Plik implementacyjny:

#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

Przykład użycia

#import "UITextField+PaddingText.h"

[self.YourTextField setLeftPadding:20.0f];

Mam nadzieję, że to wam pomoże

Twoje zdrowie

Wersja szybka:

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

Abyś mógł przypisać wartość w IB

Nie możesz ustawić paddingu. Zamiast tego UIViewumieść obraz tła i jego UITextFieldwnętrze. Ustaw UITextFieldszerokość jako UIViewWidth-(paddingSize x 2)i wysokość w podobny sposób, a następnie ustaw ją w punkcie paddingSize,paddingSize.

Wystarczy podklasę UITextField jak ta ( wersja 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)
    }

}

Dodaje to dopełnienie w poziomie 25,0 punktów z każdej strony.

Opierałem się na rozwiązaniu Nate'a, ale potem odkryłem, że powoduje to problemy, gdy używasz właściwości leftView / rightView, więc lepiej dostrój implementację super, ponieważ weźmie ona pod uwagę lewy / prawy widok.

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

Zaktualizowana wersja dla 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)
    }
}

Ustaw wypełnianie dla UITextField za pomocą UITextBorderStyleNone: Swift

Na podstawie najbardziej głosowanej odpowiedzi @Evil Trout stworzyłem niestandardową metodę w mojej klasie ViewController, jak pokazano poniżej:

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

Teraz mogę wywołać tę metodę wewnątrz (metoda viewDidLoad) i wysłać dowolny z moich TextFields do tej metody i dodać dopełnienie dla prawej i lewej strony oraz podać kolory tekstu i tła, pisząc tylko jedną linię kodu w następujący sposób:

[self modifyTextField:self.firstNameTxtFld];

Działa to doskonale na iOS 7! Wiem, że dodanie zbyt dużej liczby widoków może spowodować, że ta klasa będzie nieco cięższa do załadowania. Ale zaniepokojony trudnością związaną z innymi rozwiązaniami, byłem bardziej stronniczy w stosunku do tej metody i bardziej elastyczny w używaniu tej metody. ;)

Dzięki za Hack „Evil Trout”! (kokarda)

Pomyślałem, że powinienem zaktualizować fragment kodu tej odpowiedzi za pomocą Swift:

Ponieważ Swift pozwala nam pisać rozszerzenia dla istniejących klas, napiszmy to w ten sposób.

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

Stosowanie:

self.firstNameTxtFld.addPaddingToTextField()

Mam nadzieję, że pomogłoby to komuś innemu!
Twoje zdrowie!

Oto jak to osiągnąć w 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
}
}

Ratunek

Wersja Swift 2.0:

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

^ te sugestie są świetne dla tych, którzy programowo tworzą interfejs.

Ale dla tych z nas, którzy używają konstruktora interfejsu Xcode, są dwa LUŹNE ŁATWE SPOSOBY:

• łatwiej: umieść UIImageView za polem tekstowym

• najłatwiej: zmień styl obramowania na prosty czarny kwadrat (drugi od lewej opcji), a następnie dodaj obraz jako obraz tła. Obraz ma pierwszeństwo przed kwadratem, więc nadal dostajesz wypełnienie potrzebne do normalnego tła obrazu, bez faktycznego narysowania kwadratu.

EDYCJA: możesz również użyć czarnej kuli (trzecia od lewej opcja przy wybieraniu UITextBox w IB), nie działa ona w skrajnie prawym stylu „kuli graficznej”.

Jeśli ktoś szuka Swift 4.0wersji, poniżej extensionjest praca. Posiada zarówno Lefti Rightdopełnienie dla UITextField. W rzeczywistości jest to IBInspectablekonfiguracja scenorysu. Możesz ustawić wartość bezpośrednio z Konstruktora interfejsów / Storyboard. Jest to testowany kod w wersji Swift 4.0 i Xcode 9.0

Pamiętaj, że jeśli chcesz włączyć Clear Buttonto samoUITextField musisz pozostawić Right Padding puste.

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

Najlepszym sposobem na to jest utworzenie klasy za pomocą podklasy UITextField i pliku .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;

 }

w ten sposób przejdź do swojej serii ujęć lub Xib i kliknij Inspektora tożsamości i zastąp UITextfield własną opcją „CustomTextField” w klasie.

Uwaga: jeśli po prostu podasz dopełnienie z automatycznym układem pola tekstowego, aplikacja nie będzie działać i wyświetli się tylko pusty ekran.

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

Odpowiedź Nate Flink jest moją ulubioną, ale nie zapominaj o widokach z prawej / lewej strony. Np. Dla UITextFieldpodklasy:

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

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

Powyższy kod tuż za wyściółkę rightViewz UITextField.

Rozwiązanie 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)
 }
}

Oto kod Swift, który podaje padding w polu UIText

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

i dzwoń za pomocą

self.txtPaddingVw(txtPin)

możesz użyć kategorii. ustaw padding w lewo i prawo

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

możesz ustawić padding w ten sposób self.phoneNumTF.paddingValue = 10.f; lub self.phoneNumTF.leftPadding = 10.f;

Odpowiedź @ Evil pstrąga jest świetna. Używam tego podejścia od dłuższego czasu. Jedyne, czego brakuje, to „radzenie sobie z wieloma polami tekstowymi”. Próbowałem innych metod, ale nie działa.

Podklasowanie UITextField po prostu dodanie dopełnienia nie miało dla mnie sensu. Powtórzyłem wszystkie pola UITextField, aby dodać dopełnienie.

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

Rozwiązanie Brody działało idealnie dla mnie. Musiałem dodać widoki z boku na polu tekstowym i dodać dodatkowe wypełnienie. Dzięki wdrożeniu niestandardowej właściwości UIEdgeInsets do podklasy UITextField udało mi się osiągnąć to zadanie. Użyję tej nowej podklasy we wszystkich moich projektach.

Najlepszym rozwiązaniem, jakie do tej pory znalazłem, jest kategoria. W ten sposób dodaję 5-punktowe wypełnienie po lewej i prawej stronie:

@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

# Pragma służy tylko do usuwania irytujących ostrzeżeń

textField.layer.borderWidth = 3;

doda obramowanie, które działało dla mnie jako wypełnienie.

Inną kwestią jest to, że jeśli masz więcej niż jedno miejsce, w UITextFieldktórym dodajesz dopełnienie, jest utworzenie osobnego UIViewdla każdego pola tekstowego - ponieważ nie można ich udostępniać.