TextField class

A Material Design text field.

A text field lets the user enter text, either with hardware keyboard or with an onscreen keyboard.

The text field calls the onChanged callback whenever the user changes the text in the field. If the user indicates that they are done typing in the field (e.g., by pressing a button on the soft keyboard), the text field calls the onSubmitted callback.

To control the text that is displayed in the text field, use the controller. For example, to set the initial value of the text field, use a controller that already contains some text. The controller can also control the selection and composing region (and to observe changes to the text, selection, and composing region).

By default, a text field has a decoration that draws a divider below the text field. You can use the decoration property to control the decoration, for example by adding a label or an icon. If you set the decoration property to null, the decoration will be removed entirely, including the extra padding introduced by the decoration to save space for the labels.

If decoration is non-null (which is the default), the text field requires one of its ancestors to be a Material widget.

To integrate the TextField into a Form with other FormField widgets, consider using TextFormField.

When the widget has focus, it will prevent itself from disposing via its underlying EditableText's AutomaticKeepAliveClientMixin.wantKeepAlive in order to avoid losing the selection. Removing the focus will allow it to be disposed.

Remember to call TextEditingController.dispose on the TextEditingController when it is no longer needed. This will ensure we discard any resources used by the object.

If this field is part of a scrolling container that lazily constructs its children, like a ListView or a CustomScrollView, then a controller should be specified. The controller's lifetime should be managed by a stateful widget ancestor of the scrolling container.

Obscured Input

Reading values

A common way to read a value from a TextField is to use the onSubmitted callback. This callback is applied to the text field's current value when the user finishes editing.

Lifecycle

Upon completion of editing, like pressing the "done" button on the keyboard, two actions take place:

1st: Editing is finalized. The default behavior of this step includes an invocation of onChanged. That default behavior can be overridden. See onEditingComplete for details.

2nd: onSubmitted is invoked with the user's input value.

onSubmitted can be used to manually move focus to another input widget when a user finishes with the currently focused input widget.

When the widget has focus, it will prevent itself from disposing via AutomaticKeepAliveClientMixin.wantKeepAlive in order to avoid losing the selection. Removing the focus will allow it to be disposed.

For most applications the onSubmitted callback will be sufficient for reacting to user input.

The onEditingComplete callback also runs when the user finishes editing. It's different from onSubmitted because it has a default value which updates the text controller and yields the keyboard focus. Applications that require different behavior can override the default onEditingComplete callback.

Keep in mind you can also always read the current string from a TextField's TextEditingController using TextEditingController.text.

Handling emojis and other complex characters

It's important to always use characters when dealing with user input text that may contain complex characters. This will ensure that extended grapheme clusters and surrogate pairs are treated as single characters, as they appear to the user.

For example, when finding the length of some user input, use string.characters.length. Do NOT use string.length or even string.runes.length. For the complex character "👨‍👩‍👦", this appears to the user as a single character, and string.characters.length intuitively returns 1. On the other hand, string.length returns 8, and string.runes.length returns 5!

In the live Dartpad example above, try typing the emoji 👨‍👩‍👦 into the field and submitting. Because the example code measures the length with value.characters.length, the emoji is correctly counted as a single character.

Keep the caret visible when focused

When focused, this widget will make attempts to keep the text area and its caret (even when showCursor is false) visible, on these occasions:

• When the user focuses this text field and it is not readOnly.
• When the user changes the selection of the text field, or changes the text when the text field is not readOnly.
• When the virtual keyboard pops up.

Troubleshooting Common Accessibility Issues

Customizing User Input Accessibility Announcements

To customize user input accessibility announcements triggered by text changes, use SemanticsService.announce to make the desired accessibility announcement.

On iOS, the on-screen keyboard may announce the most recent input incorrectly when a TextInputFormatter inserts a thousands separator to a currency value text field. The following example demonstrates how to suppress the default accessibility announcements by always announcing the content of the text field as a US currency value (the \$ inserts a dollar sign, the $newText interpolates the newText variable):

onChanged: (String newText) {
  if (newText.isNotEmpty) {
    SemanticsService.announce('\$$newText', Directionality.of(context));
  }
}

Scrolling Considerations

If this TextField is not a descendant of Scaffold and is being used within a Scrollable or nested Scrollables, consider placing a ScrollNotificationObserver above the root Scrollable that contains this TextField to ensure proper scroll coordination for TextField and its components like TextSelectionOverlay.

See also:

• TextFormField, which integrates with the Form widget.
• InputDecorator, which shows the labels and other visual elements that surround the actual text editing widget.
• EditableText, which is the raw text editing control at the heart of a TextField. The EditableText widget is rarely used directly unless you are implementing an entirely different design language, such as Cupertino.
• material.io/design/components/text-fields.html
• Cookbook: Create and style a text field
• Cookbook: Handle changes to a text field
• Cookbook: Retrieve the value of a text field
• Cookbook: Focus and text fields