macOS9 min read

Mastering NSTextField for Elegant macOS Text Input

NSTextField is a fundamental UI control for macOS apps, enabling users to view and edit text. This article explores its core functionalities, from basic setup to advanced delegate methods, formatting, and accessibility, empowering you to create sophisticated text input experiences.

Introduction to NSTextField

NSTextField is a cornerstone of macOS user interfaces, providing a flexible way to display static text or allow users to input and edit text. Unlike SwiftUI's TextField, NSTextField offers a rich set of AppKit-specific features and deep integration with the macOS environment. Whether you're building a simple form or a complex text editor, understanding NSTextField is crucial for any macOS developer. This guide will take you from the basics to advanced customization, ensuring you can leverage its full potential.

NSTextField is a subclass of NSControl and NSView, meaning it inherits capabilities for handling user interaction and drawing on the screen. It can operate in two primary modes: as a display-only label or as an editable text input field. Its versatility makes it suitable for a wide range of tasks, from showing user names to accepting complex commands.

Basic Setup and Configuration

Setting up a basic NSTextField is straightforward, whether you do it programmatically or using Interface Builder. For programmatic setup, you typically initialize an instance, set its frame, and add it to a view. You can then configure properties like its text, font, alignment, and whether it's editable.

Programmatic Setup

Creating an NSTextField programmatically gives you full control. Here's how you can create an editable text field:

swift

import AppKit

class ViewController: NSViewController {

    let usernameField = NSTextField()
    let passwordField = NSSecureTextField()

    override func viewDidLoad() {
        super.viewDidLoad()
        setupTextFields()
    }

    func setupTextFields() {
        // Username Field setup
        usernameField.placeholderString = "Enter username"
        usernameField.isBezeled = true
        usernameField.isEditable = true
        usernameField.translatesAutoresizingMaskIntoConstraints = false
        usernameField.target = self
        usernameField.action = #selector(textFieldAction(_:))
        view.addSubview(usernameField)

        // Password Field setup (NSSecureTextField is a specialized NSTextField)
        passwordField.placeholderString = "Enter password"
        passwordField.isBezeled = true
        passwordField.isEditable = true
        passwordField.translatesAutoresizingMaskIntoConstraints = false
        passwordField.target = self
        passwordField.action = #selector(textFieldAction(_:))
        view.addSubview(passwordField)

        // Layout constraints
        NSLayoutConstraint.activate([
            usernameField.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            usernameField.centerYAnchor.constraint(equalTo: view.centerYAnchor, constant: -30),
            usernameField.widthAnchor.constraint(equalToConstant: 200),

            passwordField.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            passwordField.topAnchor.constraint(equalTo: usernameField.bottomAnchor, constant: 10),
            passwordField.widthAnchor.constraint(equalToConstant: 200)
        ])

        // Set initial text
        usernameField.stringValue = "john.doe"
    }

    @objc func textFieldAction(_ sender: NSTextField) {
        print("Text field \(sender == usernameField ? "username" : "password") committed: \(sender.stringValue)")
        // You might want to process the input here, e.g., trigger a login attempt
    }
}

This code demonstrates setting up two text fields, one of which is an NSSecureTextField for password input, and configuring their basic properties and layout. It also sets a target-action pattern for handling text submission.

Key Properties and Attributes

stringValue: The text content of the field. For formatted text, use attributedStringValue.
placeholderString: Text displayed when the field is empty.
isEditable: A boolean indicating if the user can modify the text.
isSelectable: A boolean indicating if the user can select text (even if not editable).
isBordered: Renders a border around the field.
isBezeled: Renders a bezeled border, typical for text input fields.
alignment: Controls the text alignment (.left, .center, .right).
font: Sets the NSFont for the text.
textColor: Sets the NSColor for the text.
backgroundColor: Sets the for the background (only applies if is true).

Availability: macOS 10.0+ for NSTextField basics.

swift

import AppKit

class MyTextFieldController: NSViewController {

    lazy var myTextField: NSTextField = {
        let textField = NSTextField(frame: .zero)
        textField.placeholderString = "Type here..."
        textField.isEditable = true
        textField.isSelectable = true
        textField.isBordered = false // Don't draw a standard border
        textField.isBezeled = true   // Draw a typical text input bezel
        textField.font = NSFont.systemFont(ofSize: 16)
        textField.textColor = .labelColor
        textField.backgroundColor = .windowBackgroundColor
        textField.alignment = .left
        textField.translatesAutoresizingMaskIntoConstraints = false
        return textField
    }()

    override func viewDidLoad() {
        super.viewDidLoad()
        setupTextField()
    }

    private func setupTextField() {
        view.addSubview(myTextField)
        NSLayoutConstraint.activate([
            myTextField.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            myTextField.centerYAnchor.constraint(equalTo: view.centerYAnchor),
            myTextField.widthAnchor.constraint(equalToConstant: 300),
            myTextField.heightAnchor.constraint(equalToConstant: 30)
        ])

        // Set initial value
        myTextField.stringValue = "Hello, NSTextField!"
        
        // Make it respond to target-action (e.g., when pressing Enter)
        myTextField.target = self
        myTextField.action = #selector(textFieldDidCommit(_:))
    }

    @objc func textFieldDidCommit(_ sender: NSTextField) {
        print("User committed text: \(sender.stringValue)")
        // You can programmatically resign first responder to dismiss the keyboard focus
        sender.window?.makeFirstResponder(nil)
    }
}

Handling Events with NSTextFieldDelegate

For more fine-grained control over text input, you'll use NSTextFieldDelegate. This protocol provides methods to respond to changes in the text, validate input, and control cursor behavior. To use it, your view controller or a dedicated delegate object must conform to NSTextFieldDelegate and be assigned to the text field's delegate property.

Key Delegate Methods

controlTextDidBeginEditing(_:): Called when the text field becomes the first responder (user starts editing).
controlTextDidChange(_:): Called whenever the text content changes, character by character. This is useful for live validation or search suggestions.
controlTextDidEndEditing(_:): Called when the text field resigns first responder (user finishes editing, e.g., by pressing Tab or Enter, or clicking outside).
control(_:isValidObject:): For NSComboBox and NSSearchField, but can be useful in custom scenarios for validation.
control(_:textShouldBeginEditing:): Asks the delegate if editing should begin.
control(_:textShouldEndEditing:): Asks the delegate if editing should end.
control(_:didFailToFormatString:errorDescription:): Informs the delegate that a string failed to format.

Let's implement a delegate to enforce character limits and perform basic validation:

swift

import AppKit

class DelegatedTextFieldController: NSViewController, NSTextFieldDelegate {

    let limitedTextField = NSTextField()
    let emailTextField = NSTextField()
    let statusLabel = NSTextField(labelWithString: "")

    override func viewDidLoad() {
        super.viewDidLoad()
        setupTextFields()
    }

    func setupTextFields() {
        view.addSubview(limitedTextField)
        view.addSubview(emailTextField)
        view.addSubview(statusLabel)

        limitedTextField.placeholderString = "Max 10 chars"
        limitedTextField.isEditable = true
        limitedTextField.delegate = self // Assign delegate
        limitedTextField.translatesAutoresizingMaskIntoConstraints = false

        emailTextField.placeholderString = "Enter email (validated)"
        emailTextField.isEditable = true
        emailTextField.delegate = self // Assign delegate
        emailTextField.translatesAutoresizingMaskIntoConstraints = false

        statusLabel.textColor = .labelColor
        statusLabel.translatesAutoresizingMaskIntoConstraints = false

        NSLayoutConstraint.activate([
            limitedTextField.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            limitedTextField.topAnchor.constraint(equalTo: view.topAnchor, constant: 50),
            limitedTextField.widthAnchor.constraint(equalToConstant: 200),

            emailTextField.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            emailTextField.topAnchor.constraint(equalTo: limitedTextField.bottomAnchor, constant: 20),
            emailTextField.widthAnchor.constraint(equalToConstant: 200),

            statusLabel.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            statusLabel.topAnchor.constraint(equalTo: emailTextField.bottomAnchor, constant: 20),
            statusLabel.widthAnchor.constraint(equalToConstant: 300)
        ])
    }

    // MARK: - NSTextFieldDelegate

    func controlTextDidBeginEditing(_ obj: Notification) {
        if let textField = obj.object as? NSTextField {
            print("Did begin editing: \(textField.placeholderString ?? "")")
        }
        statusLabel.stringValue = "Editing..."
    }

    func controlTextDidChange(_ obj: Notification) {
        if let textField = obj.object as? NSTextField {
            if textField == limitedTextField {
                // Enforce character limit
                if textField.stringValue.count > 10 {
                    textField.stringValue = String(textField.stringValue.prefix(10))
                    statusLabel.stringValue = "Max 10 characters reached!"
                } else {
                    statusLabel.stringValue = "Characters left: \(10 - textField.stringValue.count)"
                }
            } else if textField == emailTextField {
                // Basic email validation feedback
                let isValid = isValidEmail(textField.stringValue)
                statusLabel.stringValue = isValid ? "Valid email" : "Invalid email format"
                statusLabel.textColor = isValid ? .systemGreen : .systemRed
            }
        }
    }

    func controlTextDidEndEditing(_ obj: Notification) {
        if let textField = obj.object as? NSTextField {
            print("Did end editing: \(textField.placeholderString ?? "") - Value: \(textField.stringValue)")
        }
        statusLabel.stringValue = "" // Clear status or show final validation
        statusLabel.textColor = .labelColor // Reset color
    }

    // Simple email validation regex
    private func isValidEmail(_ email: String) -> Bool {
        let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\\\.com"
        let emailPredicate = NSPredicate(format: "SELF MATCHES %@", emailRegex)
        return emailPredicate.evaluate(with: email)
    }
}

This example showcases how NSTextFieldDelegate methods can be used to implement character limits, provide real-time validation feedback, and react to the lifecycle of text editing. Remember that NSPredicate for email validation is a simple example; for robust validation, consider more comprehensive libraries or patterns.

Availability: macOS 10.0+.

Formatting and Data Binding

NSTextField integrates well with NSFormatter for powerful data formatting and validation. Formatters can convert raw input into a desired output format and prevent invalid input from being entered. For instance, you can use NSNumberFormatter for numeric input or NSDateFormatter for date input. You can assign a formatter directly to an NSTextField using its formatter property.

swift

import AppKit

class FormatterViewController: NSViewController {

    let numberInput = NSTextField()
    let currencyOutput = NSTextField(labelWithString: "")
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupViews()
    }

    func setupViews() {
        view.addSubview(numberInput)
        view.addSubview(currencyOutput)

        // MARK: - Number Formatter Example
        let numberFormatter = NumberFormatter()
        numberFormatter.numberStyle = .currency
        numberFormatter.locale = Locale.current // Use current locale for currency symbol
        numberFormatter.usesGroupingSeparator = true
        numberFormatter.minimumFractionDigits = 2
        numberFormatter.maximumFractionDigits = 2
        
        numberInput.placeholderString = "Enter amount"
        numberInput.isEditable = true
        numberInput.formatter = numberFormatter // Assign the formatter
        numberInput.translatesAutoresizingMaskIntoConstraints = false
        numberInput.target = self
        numberInput.action = #selector(formatTextAction(_:))

        currencyOutput.font = NSFont.monospacedSystemFont(ofSize: 18, weight: .regular)
        currencyOutput.backgroundColor = .systemYellow.withAlphaComponent(0.2)
        currencyOutput.isBezeled = true
        currencyOutput.translatesAutoresizingMaskIntoConstraints = false

        NSLayoutConstraint.activate([
            numberInput.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            numberInput.topAnchor.constraint(equalTo: view.topAnchor, constant: 50),
            numberInput.widthAnchor.constraint(equalToConstant: 200),

            currencyOutput.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            currencyOutput.topAnchor.constraint(equalTo: numberInput.bottomAnchor, constant: 20),
            currencyOutput.widthAnchor.constraint(equalToConstant: 200),
            currencyOutput.heightAnchor.constraint(equalToConstant: 30)
        ])
        
        // Initial display for output
        currencyOutput.stringValue = numberFormatter.string(for: 0.0) ?? "$0.00"
    }

    @objc func formatTextAction(_ sender: NSTextField) {
        // The formatter already ensures valid numbers for 'stringValue'
        // When you retrieve 'objectValue', it's already a Number (or nil)
        if let number = sender.objectValue as? NSNumber {
            print("Raw number value: \(number)")
            currencyOutput.stringValue = sender.formatter?.string(for: number) ?? "Invalid Input"
        } else {
            currencyOutput.stringValue = "Invalid Input"
        }
    }
}

In this example, numberInput.formatter handles both displaying and parsing the number according to the currency style. When the user types, the formatter tries to interpret the input. If NSTextField is in editing mode, the formatter's stringForObjectValue: is used to display the value; when editing ends or the value is retrieved, getObjectValue:forString:errorDescription: is called to convert the string back to an object (like NSNumber).

Bidirectional Data Binding with Bindings

NSTextField also supports Cocoa Bindings, a powerful mechanism for connecting UI elements to data models without writing explicit glue code. You can bind properties like value, placeholderString, isEditable, and isHidden to properties of an NSObject subclass using Key-Value Coding (KVC).

Availability: macOS 10.0+ (NSFormatter), macOS 10.3+ (Bindings).

While Bindings offer a lot of power, they can sometimes make debugging complex UI flows challenging. For modern Swift projects, property observers (didSet, willSet) or reactive frameworks like Combine are often preferred for managing data flow, especially when bridging to SwiftUI views.

Accessibility and Best Practices

Ensuring your NSTextField implementations are accessible is crucial for all users. Apple's AppKit provides robust accessibility features, and NSTextField automatically leverages many of them. However, you can enhance accessibility further:

Labels: Always associate a static NSTextField (or NSBox with a title) as a label for an editable NSTextField. VoiceOver users rely on these labels to understand the purpose of input fields. You can programmatically set accessibilityTitle or accessibilityInputLabels.
Placeholder Text: Use meaningful placeholderString values to hint at expected input, but don't rely solely on them for accessibility, as they disappear when editing begins.
Tooltips: Provide toolTip text for complex fields to offer additional guidance.
Validation Feedback: Clearly communicate validation errors to the user, not just visually but also through accessibility APIs. This might involve setting accessibility alerts or updating an accessibility status region.
Keyboard Navigation: NSTextField handles standard keyboard navigation (Tab, Shift-Tab) automatically for focus management. Ensure the tab order of your UI is logical.
Semantic Meaning: For secure input, always use NSSecureTextField. For search fields, use NSSearchField (a subclass of NSTextField) which provides a built-in search icon and cancel button.

Consider the user experience from an accessibility standpoint from the beginning of your design process. Making your NSTextField controls clear, navigable, and informative benefits everyone. Adhering to these best practices will lead to more robust, user-friendly, and maintainable macOS applications.

Transitioning to SwiftUI Text Input

While NSTextField remains fundamental for AppKit-based applications, modern macOS development increasingly uses SwiftUI. SwiftUI's TextField and TextEditor offer a declarative approach to text input, often simplifying development for new projects. However, NSTextField's deep customization and direct access to AppKit features (like NSTextView for richer text editing or very specific cursor behaviors) might still be necessary for complex legacy applications or when bridging to AppKit views within SwiftUI using NSViewRepresentable.

swift

import SwiftUI
import AppKit

// A basic NSViewRepresentable for NSTextField
struct AppKitTextField: NSViewRepresentable {
    @Binding var text: String
    var placeholder: String = ""
    var isSecure: Bool = false
    var onCommit: (() -> Void)? = nil

    func makeNSView(context: Context) -> NSTextField {
        let textField = isSecure ? NSSecureTextField() : NSTextField()
        textField.delegate = context.coordinator
        textField.isBezeled = true
        textField.isEditable = true
        textField.font = NSFont.preferredFont(forTextStyle: .body)
        // Important: NSTextField doesn't automatically resign first responder on Enter in some contexts
        // Implement target-action to ensure onCommit is called when user presses Enter
        textField.target = context.coordinator
        textField.action = #selector(Coordinator.textFieldAction(_:))
        return textField
    }

    func updateNSView(_ nsView: NSTextField, context: Context) {
        nsView.placeholderString = placeholder
        // Only update stringValue if it's different to prevent cursor jump
        if nsView.stringValue != text {
            nsView.stringValue = text
        }
    }

    func makeCoordinator() -> Coordinator {
        Coordinator(self)
    }

    class Coordinator: NSObject, NSTextFieldDelegate {
        var parent: AppKitTextField

        init(_ parent: AppKitTextField) {
            self.parent = parent
        }

        func controlTextDidChange(_ obj: Notification) {
            if let textField = obj.object as? NSTextField {
                parent.text = textField.stringValue
            }
        }
        
        @objc func textFieldAction(_ sender: NSTextField) {
            print("NSTextField Commit in SwiftUI Wrapper: \(sender.stringValue)")
            parent.onCommit?()
            // Optionally, resign first responder here if you want to dismiss focus on Enter
            sender.window?.makeFirstResponder(nil)
        }

        // You can implement other delegate methods here like controlTextDidEndEditing
    }
}

struct ContentView: View {
    @State private var username: String = ""
    @State private var password: String = ""
    @State private var statusMessage: String = "Tap to edit"

    var body: some View {
        VStack(spacing: 15) {
            Text("Custom NSTextField in SwiftUI")
                .font(.title2)

            HStack {
                Text("Username:")
                    .frame(width: 80, alignment: .leading)
                AppKitTextField(text: $username, placeholder: "Your username") {
                    statusMessage = "Username committed: \(username)"
                }
                .frame(width: 200, height: 25)
            }

            HStack {
                Text("Password:")
                    .frame(width: 80, alignment: .leading)
                AppKitTextField(text: $password, placeholder: "Your password", isSecure: true) {
                    statusMessage = "Password committed (hidden)"
                }
                .frame(width: 200, height: 25)
            }

            Text(statusMessage)
                .font(.caption)
                .foregroundColor(.gray)
                .padding()
        }
        .padding()
        .frame(minWidth: 400, minHeight: 250)
    }
}

// To preview in Xcode, you can add:
// #Preview {
//    ContentView()
// }

This AppKitTextField NSViewRepresentable provides a bridge to use NSTextField within a SwiftUI view hierarchy, allowing you to access its specific behaviors while leveraging SwiftUI's declarative power. This pattern is useful for gradually migrating or integrating AppKit-specific features into SwiftUI projects.

Availability: macOS 10.15+ (SwiftUI), macOS 10.0+ (NSTextField).

NSTextField is 'Just' a Text Box

Becoming a stronger iOS Engineer

THE MYTH or PROBLEM: NSTextField is 'Just' a Text Box

Many developers, especially those new to macOS, view NSTextField as a simple, black-box text input. They might not realize its depth, its powerful delegate methods, or its integration with NSFormatter for complex validation and display.

swift

textField.stringValue = "Some text" // Basic usage, missing delegates & formatters

WHAT HAPPENS INTERNALLY? OR THE NSTextField LIFECYCLE

NSTextField heavily relies on internal text handling via its field editor (an NSTextView) and communicates changes via its delegate and target-action patterns.

NSTextField

NSControl

NSTexthFieldCell

NSTextView (Field Editor)

NSTextFieldDelegate

NSFormatter

1. User Clicks (Begin Editing)

NSTextField becomes the first responder. It instantiates or reuses an internal `NSTextView` (the "field editor") and passes control to it. `controlTextDidBeginEditing` is called via delegate.

2. User Types (Text Changes)

The field editor (`NSTextView`) handles key presses and updates its text storage. `controlTextDidChange` is repeatedly called via delegate, allowing real-time intervention/validation.

3. User Submits (End Editing/Action)

User presses Enter or Tab, or clicks outside. The field editor resigns first responder. If a formatter is present, it's asked to validate/format the string. `controlTextDidEndEditing` is called. If Enter was pressed, the target-action method is triggered.

4. Display Update

The `NSTextField`'s `stringValue` (or `attributedStringValue`) is updated. If a formatter is set, it might be used to format the displayed text for non-editing mode.

Visualized execution hierarchy.

Powerful Guarantees

Automatic Accessibility

NSTextField provides robust default accessibility, including VoiceOver support for reading content and labels, and basic keyboard navigation.

Input Handling Consistency

Handles standard input methods, including special characters, key permutations, and adheres to system-wide text input settings.

Formatter Integration

Ensures consistent data formatting and validation on input and output through `NSFormatter`, automatically handling number, date, and custom types.

REAL PRODUCTION EXAMPLE: Live Search Filtering

A common issue is inefficiently filtering an `NSTableView` or `NSCollectionView` with `NSTextField` input. Polling on `controlTextDidEndEditing` causes lag, but excessively calling `reloadData` on `controlTextDidChange` can be CPU-intensive for large datasets.

Impact / Results

Smooth, responsive filtering

Reduced CPU usage

Improved user experience

THE FIX: Debounced Live Filtering

swift

import AppKit

class LiveSearchViewController: NSViewController, NSTextFieldDelegate {

    let searchField = NSTextField()
    var searchCancellable: Cancellable? // For Combine-based debouncing

    override func viewDidLoad() {
        super.viewDidLoad()
        setupSearchField()
    }

    func setupSearchField() {
        searchField.placeholderString = "Search items..."
        searchField.isEditable = true
        searchField.delegate = self
        searchField.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(searchField)

        NSLayoutConstraint.activate([
            searchField.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            searchField.topAnchor.constraint(equalTo: view.topAnchor, constant: 20),
            searchField.widthAnchor.constraint(equalToConstant: 250)
        ])
        
        // MARK: - Combine Debouncing Example
        // Requires Combine framework (macOS 10.15+)
        // This part needs a custom publisher for NSTextField or a way to bridge.
        // For simplicity, imagine 'searchField.textPublisher' exists.
        
        /*
        searchCancellable = NotificationCenter.default.publisher(for: NSTextField.textDidChangeNotification, object: searchField)
            .compactMap { ($0.object as? NSTextField)?.stringValue }
            .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
            .removeDuplicates()
            .sink { [weak self] searchText in
                self?.performSearch(with: searchText)
            }
        */
    }

    func controlTextDidChange(_ obj: Notification) {
        // Without Combine, you'd implement manual debouncing with Timer
        NSObject.cancelPreviousPerformRequests(withTarget: self, selector: #selector(debouncedPerformSearch), object: nil)
        self.perform(#selector(debouncedPerformSearch), with: nil, afterDelay: 0.3)
    }

    @objc func debouncedPerformSearch() {
        performSearch(with: searchField.stringValue)
    }

    private func performSearch(with searchText: String) {
        print("Performing search for: \"\(searchText)\"")
        // This is where you would filter your data source and reload your table/collection view.
        // e.g., myTableView.filter(searchText) and myTableView.reloadData()
    }
}
// (Note: `Cancellable` and `textPublisher` are conceptual here for demonstration.
// A real Combine implementation would use a `PassthroughSubject` wrapped with `NSTextFieldDelegate`.)

INTERVIEW PERSPECTIVE

Common Question

“Describe how you'd handle complex input validation and formatting for an `NSTextField`.”

Strong Answer

A strong answer would emphasize using `NSTextFieldDelegate` for real-time character-by-character validation (`controlTextDidChange`) and `NSFormatter` for robust input sanitization and complex data type conversion (e.g., numbers, dates, custom types). It would also mention providing clear user feedback for invalid input, accessibility considerations, and potentially combining these with debouncing for performance if connected to live search features.

Interviewers Expect you to understand:

NSTextFieldDelegate (controlTextDidChange)
NSFormatter (NSNumberFormatter, NSDateFormatter, custom)
User feedback and error handling
Accessibility

KEY TAKEAWAY

NSTextField is more than a simple text box; master its delegate, formatter, and target-action patterns to build truly responsive, validated, and accessible macOS text input experiences, even when leveraging SwiftUI.

Common Interview Questions

What is the difference between `NSTextField` and `NSSecureTextField`?

`NSTextField` is a general-purpose text input field. `NSSecureTextField` is a subclass of `NSTextField` specifically designed for entering sensitive information like passwords, where it automatically obscures the input characters (e.g., with bullets) and disables features like copy-pasting the full text for security reasons.

How do I make an `NSTextField` multi-line?

`NSTextField` is primarily designed for single-line input. For multi-line text input and display, you should use `NSTextView`. You can embed an `NSTextView` within an `NSScrollView` to provide scrolling capabilities. `NSTextView` offers rich text editing features, text storage management, and more.

How can I prevent certain characters from being entered into an `NSTextField`?

You can achieve this by implementing the `NSTextFieldDelegate` method `controlTextDidChange(_:)`. Inside this method, you can inspect the `stringValue` of the text field and filter out unwanted characters, updating `textField.stringValue` with the sanitized version. Alternatively, for more robust validation and formatting, especially for numbers or dates, use an `NSFormatter`.

When should I use `NSTextField` over SwiftUI's `TextField` in a macOS app?

Use `NSTextField` when you are building a purely AppKit-based application, need very specific AppKit-only behaviors (like deep integration with `NSTextView` or advanced `NSFormatter` setups), or when you're working on a legacy project. For new projects or when you want a more modern, declarative UI, SwiftUI's `TextField` is generally preferred, potentially with `NSViewRepresentable` if you need to bridge `NSTextField` functionality.

How do `NSTextField`'s target-action and delegate patterns differ?

The target-action pattern (`target` and `action`) is typically used for simple events like the user pressing Enter (committing the text). The `NSTextFieldDelegate` protocol provides a much richer set of callbacks for granular control, such as when editing begins, when the text changes character by character, or when editing ends, allowing for active validation and interaction management.

#NSTextField#macOS#AppKit#text input#Swift