Text view

There are three views related with text.

UILabel displays one or more lines of informational text.

UITextField allows to input a single line of text.

UITextView displays one or more lines of text. Additionally user can select, edit, and scroll text.

You can specify text color, background color and font of text.

NSAttributedString and NSMutableAttributedString classes allow you to display formatted text. You can create it directly or from html text.

let label = UILabel()
label.text = "Hello world!"
label.font = UIFont.preferredFont(forTextStyle: .body)
label.adjustsFontForContentSizeCategory = true
label.textColor = .black
label.backgroundColor = .white
label.numberOfLines = 0
// ... add constraints and etc

let textField = UITextField()
textField.placeholder = "Enter your password"
textField.delegate = someDelegateObject // UITextFieldDelegate type
textField.textContentType = .password
textField.isSecureTextEntry = true
// ... add constraints and etc

let textView = UITextView()
textView.layer.cornerRadius = 10
textView.text = "Hello world!"
textView.isScrollEnabled = false
textView.isSelectable = false
textView.isEditable = false
// ... add constraints and etc

font

UIFont class provides access to the font’s characteristics. The default font is System with size 17.

UIFontDescriptor class represents a collection of attributes that describes a font. It can be used to create or modify a UIFont object.

UIFont.TextStyle contains constants for the predefined styles:

• body - the font for body text
• callout - the font for callouts
• caption1 - the font for standard captions
• caption2 - the font for alternate captions
• footnote - the font for footnotes
• headline - the font for headings
• subheadline - the font for subheadings
• largeTitle - the font style for large titles
• title1 - the font for first-level hierarchical headings
• title2 - the font for second-level hierarchical headings
• title3 - the font for third-level hierarchical headings

let font1 =  UIFont.preferredFont(forTextStyle: .body)
let font2 = UIFont(name: "Helvetica Neue", size: 15)
let font3 = .systemFont(ofSize: 14, weight: .regular)

text editing processing

UITextViewDelegate protocol allows you to adjust the text a user is editing (such as in the case of a spell-checker program) or to modify the intended insertion point.

UITextFieldDelegate protocol allows you to response to important changes in UITextField. For example you can validate text that was typed by the user.

Protocol methods are not called when changing text programmatically. You can call them manually.

var valValue: String? = nil {      
        didSet {
            if valEdit.text != valValue {
                valEdit.text = valValue
                textViewDidChange(valEdit)
            }
        }
    }

// implementation for UITextField
func textField(_ textField: UITextField, 
               shouldChangeCharactersIn range: NSRange, 
               replacementString string: String) -> Bool {
    
    let currentText = textField.text ?? ""

    // range for modify
    guard let stringRange = Range(range, in: currentText) 
    else { return false }

    // add their new text to the existing text
    let updatedText = currentText.replacingCharacters(in: stringRange, with: string)
    return updatedText.count <= 10
}

// implementation for UITextView
func textView(_ textView: UITextView, 
              shouldChangeTextIn range: NSRange, 
              replacementText text: String) -> Bool {
    
    let currentText = textView.text ?? ""

    //  range for modify
    guard let stringRange = Range(range, in: currentText) 
    else { return false }

    let updatedText = currentText.replacingCharacters(in: stringRange, with: text)
    return updatedText.count <= 10
}

extension KeyValueView: UITextViewDelegate {
    
    func textViewShouldBeginEditing(_ textView: UITextView) -> Bool {
        switch(mode) {
        case .dropdown, .dateEdit, .dropdownAddList: 
            tapOnValue() // call click handler
            return false // disallow edit
        default: // allow edit
            return true
        }
    }

attributed text

NSAttributedString object manages character strings and associated sets of attributes that apply to individual characters or ranges of characters in the string.

The default font for NSAttributedString objects is Helvetica 12-point, which may differ from the default system font for the platform.

NSMutableAttributedString is mutable version of NSAttributedString.

attributedText property of views such UILabel defines attributed text.

let txt = "Hello world"
        
// default style for text
let attributes1 = [NSAttributedString.Key.font: UIFont.systemFont(ofSize: 12)]
        
// large red text
let attributes2 = [NSAttributedString.Key.font: UIFont.boldSystemFont(ofSize: 24),
                   NSAttributedString.Key.foregroundColor: UIColor.red]
        
let attributedText = NSMutableAttributedString(string: txt, attributes: attributes1)

// change style of a part of the string ("lo wo")
attributedText.setAttributes(attributes2, range: NSRange(location: 3, length: 5))
       
label.attributedText = attributedText

let paragraphStyle = NSMutableParagraphStyle()
paragraphStyle.alignment = .justified

let attributes : [NSAttributedString.Key : Any] = [.paragraphStyle: paragraphStyle,
                                                   .baselineOffset: 0]

let aText = NSAttributedString(string: sampleText, attributes: attributes)

label.attributedText = aText

let attributes1: [NSAttributedString.Key: Any] = [.backgroundColor: UIColor.green,
                                                  .kern: 10]
let attributes2 = [NSAttributedString.Key.foregroundColor: UIColor.red]

let aText1 = NSMutableAttributedString(string: "Hello ", attributes: attributes1)
let aText2 = NSAttributedString(string: "world!", attributes: attributes2)
       
aText1.append(aText2)
     
label.attributedText=aText1

// search characters with bold font and apply them red color
aText.enumerateAttribute(.font, in: NSRange(0..<aText.length)) { value, range, stop in
    if let font = value as? UIFont {
        if font.fontDescriptor.symbolicTraits.contains(.traitBold) {
            aText.addAttribute(.foregroundColor, value: UIColor.red, range: range)
        }
    }
}

let html = """
        <html>
        <body>
        <p style="color: red;">My image description</p>
        </body>
        </html>
        """
        
let data = Data(html.utf8)
        
if let attributedString = try? 
       NSAttributedString(data: data, 
                 options: [.documentType: NSAttributedString.DocumentType.html], 
                 documentAttributes: nil) {
     label.attributedText = attributedString
}

clickable link

UITextView allows to detect and open links.

textView.isEditable = false
textView.dataDetectorTypes = UIDataDetectorTypes.Link
// a phone number will be displayed as a clickable phone number link.
textView.text = "my phone +7 (961) 000-00-00"

Also you can use an attributed string and a text view delegate to assign a custom click handler.

class ViewController: UIViewController, UITextViewDelegate {
    @IBOutlet var textView: UITextView!

    override func viewDidLoad() {
        let aText = NSMutableAttributedString(string: "Hello google")
        aText.addAttribute(.link, 
                           value: "https://google.com", 
                           range: NSRange(location: 6, length: 6))

        textView.isSelectable=true
        textView.isScrollEnabled = false
        textView.isEditable = false
        textView.dataDetectorTypes = UIDataDetectorTypes.Link
        textView.attributedText = aText
    }

    func textView(_ textView: UITextView, shouldInteractWith URL: URL, 
                  in characterRange: NSRange, 
                  interaction: UITextItemInteraction) -> Bool {
        UIApplication.shared.open(URL)
        return false
    }
}

auto height

With auto layout, the UITextView can automatically grow when content bigger then current size.

tv.textContainer.lineBreakMode = .byWordWrapping
tv.isScrollEnabled = false // important for automatic height

When the UITextView is in a table cell, you will also want to change the cell's height. To do this, you need to detect a change in the number of lines and reload the cell.

If you want to automatically resize when the user enters text, use the UITableView update API.

// MARK: - MyCellDelegate
extension MyViewController: MyCellDelegate {
    
    func requestRefresh(indexPath: IndexPath?, newValue: String?) {
        guard let indexPath = indexPath else { return }
       
        srcItems[indexPath.row].value = newValue
        myTableView.reloadRows(at: [indexPath], with: .automatic)
        // myTableView.beginUpdates()
        // myTableView.endUpdates()
        // 
    }  
}

private var numberOfLines: Int = 1
private var isChangingValue = false
private var indexPath: IndexPath? = nil // row associated with this cell
 
extension MyCell: UITextViewDelegate { 
    func textViewDidChange(_ textView: UITextView) {
        if isChangingValue { return }
        isChangingValue = true
        
        let oldNumberOfLines = numberOfLines
        numberOfLines = textView.countOfLines()
        
        if numberOfLines != oldNumberOfLines {
            delegate?.requestRefresh(indexPath: indexPath, 
                                     newValue: textView.text)
        
            if textView.isFirstResponder {
                DispatchQueue.main.async {
                    textView.becomeFirstResponder()
                    textView.selectedRange = NSMakeRange(textView.text.count,
                                                         textView.text.count)
                    self.isChangingValue = false
                }
            } else {
                isChangingValue = false
            }
            
        } else {
            isChangingValue = false
        }                              
    }
}

extension UITextView { 
    func countOfLines () -> Int {
        let fixedWidth = frame.size.width
        let sizeConstraint = CGSize(width: fixedWidth, 
                                    height: CGFloat.greatestFiniteMagnitude)
        let newSize = sizeThatFits(sizeConstraint)
        let r = newSize.height / font!.lineHeight
        return Int(r)
    }
}

text padding

textContainerInset property allows to set text padding for UITextView. Default value is (8, 0, 8, 0).

// set padding
textView.textContainerInset = UIEdgeInsets(top: 8, left: 10, bottom: 8, right: 10)

For a label and text field you need to create subclasses.

TextFieldWithPadding: UITextField {
    
    var padding = UIEdgeInsets(top: 8, left: 8, bottom: 8, right: 8);
    
    // Paddging for place holder
    override func placeholderRectForBounds(bounds: CGRect) -> CGRect {
       return UIEdgeInsetsInsetRect(bounds, padding)
    }
    
    // Padding for text
    override func textRectForBounds(bounds: CGRect) -> CGRect {
       return UIEdgeInsetsInsetRect(bounds, padding)
    }
    
    // Padding for text in editting mode
    override func editingRectForBounds(bounds: CGRect) -> CGRect {
       return UIEdgeInsetsInsetRect(bounds, padding)
    }    
}

// if necessary mark inset fields as @IBInspectable
open class PaddingLabel: UILabel {
    
  open var topInset: CGFloat = 5.0
  open var bottomInset: CGFloat = 5.0
  open var leftInset: CGFloat = 7.0
  open var rightInset: CGFloat = 7.0
    
    open override func drawText(in rect: CGRect) {
        let insets = UIEdgeInsets(top: topInset, left: leftInset, bottom: bottomInset, right: rightInset)
        super.drawText(in: rect.inset(by: insets))
    }
    
    open override var intrinsicContentSize: CGSize {
        let size = super.intrinsicContentSize
        return CGSize(width: size.width + leftInset + rightInset,
                      height: size.height + topInset + bottomInset)
    }
    
    open override var bounds: CGRect {
        didSet {
          //  preferredMaxLayoutWidth = bounds.width - (leftInset + rightInset)
        }
    }
}