// Copyright 2014 The Flutter Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. import 'dart:ui' as ui show BoxHeightStyle, BoxWidthStyle; import 'package:flutter/foundation.dart' show defaultTargetPlatform; import 'package:flutter/gestures.dart'; import 'package:flutter/rendering.dart'; import 'package:flutter/services.dart'; import 'package:flutter/widgets.dart'; import 'colors.dart'; import 'desktop_text_selection.dart'; import 'icons.dart'; import 'text_selection.dart'; import 'theme.dart'; export 'package:flutter/services.dart' show TextInputType, TextInputAction, TextCapitalization, SmartQuotesType, SmartDashesType; const TextStyle _kDefaultPlaceholderStyle = TextStyle( fontWeight: FontWeight.w400, color: CupertinoColors.placeholderText, ); // Value inspected from Xcode 11 & iOS 13.0 Simulator. const BorderSide _kDefaultRoundedBorderSide = BorderSide( color: CupertinoDynamicColor.withBrightness( color: Color(0x33000000), darkColor: Color(0x33FFFFFF), ), style: BorderStyle.solid, width: 0.0, ); const Border _kDefaultRoundedBorder = Border( top: _kDefaultRoundedBorderSide, bottom: _kDefaultRoundedBorderSide, left: _kDefaultRoundedBorderSide, right: _kDefaultRoundedBorderSide, ); const BoxDecoration _kDefaultRoundedBorderDecoration = BoxDecoration( color: CupertinoDynamicColor.withBrightness( color: CupertinoColors.white, darkColor: CupertinoColors.black, ), border: _kDefaultRoundedBorder, borderRadius: BorderRadius.all(Radius.circular(5.0)), ); const Color _kDisabledBackground = CupertinoDynamicColor.withBrightness( color: Color(0xFFFAFAFA), darkColor: Color(0xFF050505), ); // Value inspected from Xcode 12 & iOS 14.0 Simulator. // Note it may not be consistent with https://developer.apple.com/design/resources/. const CupertinoDynamicColor _kClearButtonColor = CupertinoDynamicColor.withBrightness( color: Color(0x33000000), darkColor: Color(0x33FFFFFF), ); // An eyeballed value that moves the cursor slightly left of where it is // rendered for text on Android so it's positioning more accurately matches the // native iOS text cursor positioning. // // This value is in device pixels, not logical pixels as is typically used // throughout the codebase. const int _iOSHorizontalCursorOffsetPixels = -2; /// Visibility of text field overlays based on the state of the current text entry. /// /// Used to toggle the visibility behavior of the optional decorating widgets /// surrounding the [EditableText] such as the clear text button. enum OverlayVisibilityMode { /// Overlay will never appear regardless of the text entry state. never, /// Overlay will only appear when the current text entry is not empty. /// /// This includes prefilled text that the user did not type in manually. But /// does not include text in placeholders. editing, /// Overlay will only appear when the current text entry is empty. /// /// This also includes not having prefilled text that the user did not type /// in manually. Texts in placeholders are ignored. notEditing, /// Always show the overlay regardless of the text entry state. always, } class _CupertinoTextFieldSelectionGestureDetectorBuilder extends TextSelectionGestureDetectorBuilder { _CupertinoTextFieldSelectionGestureDetectorBuilder({ required _CupertinoTextFieldState state, }) : _state = state, super(delegate: state); final _CupertinoTextFieldState _state; @override void onSingleTapUp(TapUpDetails details) { editableText.hideToolbar(); // Because TextSelectionGestureDetector listens to taps that happen on // widgets in front of it, tapping the clear button will also trigger // this handler. If the clear button widget recognizes the up event, // then do not handle it. if (_state._clearGlobalKey.currentContext != null) { final RenderBox renderBox = _state._clearGlobalKey.currentContext!.findRenderObject()! as RenderBox; final Offset localOffset = renderBox.globalToLocal(details.globalPosition); if (renderBox.hitTest(BoxHitTestResult(), position: localOffset)) { return; } } super.onSingleTapUp(details); _state._requestKeyboard(); _state.widget.onTap?.call(); } @override void onDragSelectionEnd(DragEndDetails details) { _state._requestKeyboard(); } } /// An iOS-style text field. /// /// A text field lets the user enter text, either with a hardware keyboard or with /// an onscreen keyboard. /// /// This widget corresponds to both a `UITextField` and an editable `UITextView` /// on iOS. /// /// 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. /// /// {@macro flutter.widgets.EditableText.onChanged} /// /// 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 such as: /// /// {@tool snippet} /// /// ```dart /// class MyPrefilledText extends StatefulWidget { /// const MyPrefilledText({Key? key}) : super(key: key); /// /// @override /// _MyPrefilledTextState createState() => _MyPrefilledTextState(); /// } /// /// class _MyPrefilledTextState extends State<MyPrefilledText> { /// late TextEditingController _textController; /// /// @override /// void initState() { /// super.initState(); /// _textController = TextEditingController(text: 'initial text'); /// } /// /// @override /// Widget build(BuildContext context) { /// return CupertinoTextField(controller: _textController); /// } /// } /// ``` /// {@end-tool} /// /// The [controller] can also control the selection and composing region (and to /// observe changes to the text, selection, and composing region). /// /// The text field has an overridable [decoration] that, by default, draws a /// rounded rectangle border around the text field. If you set the [decoration] /// property to null, the decoration will be removed entirely. /// /// Remember to call [TextEditingController.dispose] when it is no longer /// needed. This will ensure we discard any resources used by the object. /// /// {@macro flutter.widgets.editableText.showCaretOnScreen} /// /// See also: /// /// * <https://developer.apple.com/documentation/uikit/uitextfield> /// * [TextField], an alternative text field widget that follows the Material /// Design UI conventions. /// * [EditableText], which is the raw text editing control at the heart of a /// [TextField]. /// * Learn how to use a [TextEditingController] in one of our [cookbook recipes](https://flutter.dev/docs/cookbook/forms/text-field-changes#2-use-a-texteditingcontroller). class CupertinoTextField extends StatefulWidget { /// Creates an iOS-style text field. /// /// To provide a prefilled text entry, pass in a [TextEditingController] with /// an initial value to the [controller] parameter. /// /// To provide a hint placeholder text that appears when the text entry is /// empty, pass a [String] to the [placeholder] parameter. /// /// The [maxLines] property can be set to null to remove the restriction on /// the number of lines. In this mode, the intrinsic height of the widget will /// grow as the number of lines of text grows. By default, it is `1`, meaning /// this is a single-line text field and will scroll horizontally when /// overflown. [maxLines] must not be zero. /// /// The text cursor is not shown if [showCursor] is false or if [showCursor] /// is null (the default) and [readOnly] is true. /// /// If specified, the [maxLength] property must be greater than zero. /// /// The [selectionHeightStyle] and [selectionWidthStyle] properties allow /// changing the shape of the selection highlighting. These properties default /// to [ui.BoxHeightStyle.tight] and [ui.BoxWidthStyle.tight] respectively and /// must not be null. /// /// The [autocorrect], [autofocus], [clearButtonMode], [dragStartBehavior], /// [expands], [maxLengthEnforced], [obscureText], [prefixMode], [readOnly], /// [scrollPadding], [suffixMode], [textAlign], [selectionHeightStyle], /// [selectionWidthStyle], and [enableSuggestions] properties must not be null. /// /// See also: /// /// * [minLines], which is the minimum number of lines to occupy when the /// content spans fewer lines. /// * [expands], to allow the widget to size itself to its parent's height. /// * [maxLength], which discusses the precise meaning of "number of /// characters" and how it may differ from the intuitive meaning. const CupertinoTextField({ Key? key, this.controller, this.focusNode, this.decoration = _kDefaultRoundedBorderDecoration, this.padding = const EdgeInsets.all(6.0), this.placeholder, this.placeholderStyle = const TextStyle( fontWeight: FontWeight.w400, color: CupertinoColors.placeholderText, ), this.prefix, this.prefixMode = OverlayVisibilityMode.always, this.suffix, this.suffixMode = OverlayVisibilityMode.always, this.clearButtonMode = OverlayVisibilityMode.never, TextInputType? keyboardType, this.textInputAction, this.textCapitalization = TextCapitalization.none, this.style, this.strutStyle, this.textAlign = TextAlign.start, this.textAlignVertical, this.readOnly = false, ToolbarOptions? toolbarOptions, this.showCursor, this.autofocus = false, this.obscuringCharacter = '•', this.obscureText = false, this.autocorrect = true, SmartDashesType? smartDashesType, SmartQuotesType? smartQuotesType, this.enableSuggestions = true, this.maxLines = 1, this.minLines, this.expands = false, this.maxLength, @Deprecated( 'Use maxLengthEnforcement parameter which provides more specific ' 'behavior related to the maxLength limit. ' 'This feature was deprecated after v1.25.0-5.0.pre.', ) this.maxLengthEnforced = true, this.maxLengthEnforcement, this.onChanged, this.onEditingComplete, this.onSubmitted, this.inputFormatters, this.enabled, this.cursorWidth = 2.0, this.cursorHeight, this.cursorRadius = const Radius.circular(2.0), this.cursorColor, this.selectionHeightStyle = ui.BoxHeightStyle.tight, this.selectionWidthStyle = ui.BoxWidthStyle.tight, this.keyboardAppearance, this.scrollPadding = const EdgeInsets.all(20.0), this.dragStartBehavior = DragStartBehavior.start, this.enableInteractiveSelection = true, this.selectionControls, this.onTap, this.scrollController, this.scrollPhysics, this.autofillHints, this.restorationId, }) : assert(textAlign != null), assert(readOnly != null), assert(autofocus != null), assert(obscuringCharacter != null && obscuringCharacter.length == 1), assert(obscureText != null), assert(autocorrect != null), smartDashesType = smartDashesType ?? (obscureText ? SmartDashesType.disabled : SmartDashesType.enabled), smartQuotesType = smartQuotesType ?? (obscureText ? SmartQuotesType.disabled : SmartQuotesType.enabled), assert(enableSuggestions != null), assert(maxLengthEnforced != null), assert( maxLengthEnforced || maxLengthEnforcement == null, 'maxLengthEnforced is deprecated, use only maxLengthEnforcement', ), assert(scrollPadding != null), assert(dragStartBehavior != null), assert(selectionHeightStyle != null), assert(selectionWidthStyle != null), assert(maxLines == null || maxLines > 0), assert(minLines == null || minLines > 0), assert( (maxLines == null) || (minLines == null) || (maxLines >= minLines), "minLines can't be greater than maxLines", ), assert(expands != null), assert( !expands || (maxLines == null && minLines == null), 'minLines and maxLines must be null when expands is true.', ), assert(!obscureText || maxLines == 1, 'Obscured fields cannot be multiline.'), assert(maxLength == null || maxLength > 0), assert(clearButtonMode != null), assert(prefixMode != null), assert(suffixMode != null), // Assert the following instead of setting it directly to avoid surprising the user by silently changing the value they set. assert(!identical(textInputAction, TextInputAction.newline) || maxLines == 1 || !identical(keyboardType, TextInputType.text), 'Use keyboardType TextInputType.multiline when using TextInputAction.newline on a multiline TextField.'), keyboardType = keyboardType ?? (maxLines == 1 ? TextInputType.text : TextInputType.multiline), toolbarOptions = toolbarOptions ?? (obscureText ? const ToolbarOptions( selectAll: true, paste: true, ) : const ToolbarOptions( copy: true, cut: true, selectAll: true, paste: true, )), super(key: key); /// Creates a borderless iOS-style text field. /// /// To provide a prefilled text entry, pass in a [TextEditingController] with /// an initial value to the [controller] parameter. /// /// To provide a hint placeholder text that appears when the text entry is /// empty, pass a [String] to the [placeholder] parameter. /// /// The [maxLines] property can be set to null to remove the restriction on /// the number of lines. In this mode, the intrinsic height of the widget will /// grow as the number of lines of text grows. By default, it is `1`, meaning /// this is a single-line text field and will scroll horizontally when /// overflown. [maxLines] must not be zero. /// /// The text cursor is not shown if [showCursor] is false or if [showCursor] /// is null (the default) and [readOnly] is true. /// /// If specified, the [maxLength] property must be greater than zero. /// /// The [selectionHeightStyle] and [selectionWidthStyle] properties allow /// changing the shape of the selection highlighting. These properties default /// to [ui.BoxHeightStyle.tight] and [ui.BoxWidthStyle.tight] respectively and /// must not be null. /// /// The [autocorrect], [autofocus], [clearButtonMode], [dragStartBehavior], /// [expands], [maxLengthEnforced], [obscureText], [prefixMode], [readOnly], /// [scrollPadding], [suffixMode], [textAlign], [selectionHeightStyle], /// [selectionWidthStyle], and [enableSuggestions] properties must not be null. /// /// See also: /// /// * [minLines], which is the minimum number of lines to occupy when the /// content spans fewer lines. /// * [expands], to allow the widget to size itself to its parent's height. /// * [maxLength], which discusses the precise meaning of "number of /// characters" and how it may differ from the intuitive meaning. const CupertinoTextField.borderless({ Key? key, this.controller, this.focusNode, this.decoration, this.padding = const EdgeInsets.all(6.0), this.placeholder, this.placeholderStyle = _kDefaultPlaceholderStyle, this.prefix, this.prefixMode = OverlayVisibilityMode.always, this.suffix, this.suffixMode = OverlayVisibilityMode.always, this.clearButtonMode = OverlayVisibilityMode.never, TextInputType? keyboardType, this.textInputAction, this.textCapitalization = TextCapitalization.none, this.style, this.strutStyle, this.textAlign = TextAlign.start, this.textAlignVertical, this.readOnly = false, ToolbarOptions? toolbarOptions, this.showCursor, this.autofocus = false, this.obscuringCharacter = '•', this.obscureText = false, this.autocorrect = true, SmartDashesType? smartDashesType, SmartQuotesType? smartQuotesType, this.enableSuggestions = true, this.maxLines = 1, this.minLines, this.expands = false, this.maxLength, @Deprecated( 'Use maxLengthEnforcement parameter which provides more specific ' 'behavior related to the maxLength limit. ' 'This feature was deprecated after v1.25.0-5.0.pre.', ) this.maxLengthEnforced = true, this.maxLengthEnforcement, this.onChanged, this.onEditingComplete, this.onSubmitted, this.inputFormatters, this.enabled, this.cursorWidth = 2.0, this.cursorHeight, this.cursorRadius = const Radius.circular(2.0), this.cursorColor, this.selectionHeightStyle = ui.BoxHeightStyle.tight, this.selectionWidthStyle = ui.BoxWidthStyle.tight, this.keyboardAppearance, this.scrollPadding = const EdgeInsets.all(20.0), this.dragStartBehavior = DragStartBehavior.start, this.enableInteractiveSelection = true, this.selectionControls, this.onTap, this.scrollController, this.scrollPhysics, this.autofillHints, this.restorationId, }) : assert(textAlign != null), assert(readOnly != null), assert(autofocus != null), assert(obscuringCharacter != null && obscuringCharacter.length == 1), assert(obscureText != null), assert(autocorrect != null), smartDashesType = smartDashesType ?? (obscureText ? SmartDashesType.disabled : SmartDashesType.enabled), smartQuotesType = smartQuotesType ?? (obscureText ? SmartQuotesType.disabled : SmartQuotesType.enabled), assert(enableSuggestions != null), assert(maxLengthEnforced != null), assert( maxLengthEnforced || maxLengthEnforcement == null, 'maxLengthEnforced is deprecated, use only maxLengthEnforcement', ), assert(scrollPadding != null), assert(dragStartBehavior != null), assert(selectionHeightStyle != null), assert(selectionWidthStyle != null), assert(maxLines == null || maxLines > 0), assert(minLines == null || minLines > 0), assert( (maxLines == null) || (minLines == null) || (maxLines >= minLines), "minLines can't be greater than maxLines", ), assert(expands != null), assert( !expands || (maxLines == null && minLines == null), 'minLines and maxLines must be null when expands is true.', ), assert(!obscureText || maxLines == 1, 'Obscured fields cannot be multiline.'), assert(maxLength == null || maxLength > 0), assert(clearButtonMode != null), assert(prefixMode != null), assert(suffixMode != null), // Assert the following instead of setting it directly to avoid surprising the user by silently changing the value they set. assert(!identical(textInputAction, TextInputAction.newline) || maxLines == 1 || !identical(keyboardType, TextInputType.text), 'Use keyboardType TextInputType.multiline when using TextInputAction.newline on a multiline TextField.'), keyboardType = keyboardType ?? (maxLines == 1 ? TextInputType.text : TextInputType.multiline), toolbarOptions = toolbarOptions ?? (obscureText ? const ToolbarOptions( selectAll: true, paste: true, ) : const ToolbarOptions( copy: true, cut: true, selectAll: true, paste: true, )), super(key: key); /// Controls the text being edited. /// /// If null, this widget will create its own [TextEditingController]. final TextEditingController? controller; /// {@macro flutter.widgets.Focus.focusNode} final FocusNode? focusNode; /// Controls the [BoxDecoration] of the box behind the text input. /// /// Defaults to having a rounded rectangle grey border and can be null to have /// no box decoration. final BoxDecoration? decoration; /// Padding around the text entry area between the [prefix] and [suffix] /// or the clear button when [clearButtonMode] is not never. /// /// Defaults to a padding of 6 pixels on all sides and can be null. final EdgeInsetsGeometry padding; /// A lighter colored placeholder hint that appears on the first line of the /// text field when the text entry is empty. /// /// Defaults to having no placeholder text. /// /// The text style of the placeholder text matches that of the text field's /// main text entry except a lighter font weight and a grey font color. final String? placeholder; /// The style to use for the placeholder text. /// /// The [placeholderStyle] is merged with the [style] [TextStyle] when applied /// to the [placeholder] text. To avoid merging with [style], specify /// [TextStyle.inherit] as false. /// /// Defaults to the [style] property with w300 font weight and grey color. /// /// If specifically set to null, placeholder's style will be the same as [style]. final TextStyle? placeholderStyle; /// An optional [Widget] to display before the text. final Widget? prefix; /// Controls the visibility of the [prefix] widget based on the state of /// text entry when the [prefix] argument is not null. /// /// Defaults to [OverlayVisibilityMode.always] and cannot be null. /// /// Has no effect when [prefix] is null. final OverlayVisibilityMode prefixMode; /// An optional [Widget] to display after the text. final Widget? suffix; /// Controls the visibility of the [suffix] widget based on the state of /// text entry when the [suffix] argument is not null. /// /// Defaults to [OverlayVisibilityMode.always] and cannot be null. /// /// Has no effect when [suffix] is null. final OverlayVisibilityMode suffixMode; /// Show an iOS-style clear button to clear the current text entry. /// /// Can be made to appear depending on various text states of the /// [TextEditingController]. /// /// Will only appear if no [suffix] widget is appearing. /// /// Defaults to never appearing and cannot be null. final OverlayVisibilityMode clearButtonMode; /// {@macro flutter.widgets.editableText.keyboardType} final TextInputType keyboardType; /// The type of action button to use for the keyboard. /// /// Defaults to [TextInputAction.newline] if [keyboardType] is /// [TextInputType.multiline] and [TextInputAction.done] otherwise. final TextInputAction? textInputAction; /// {@macro flutter.widgets.editableText.textCapitalization} final TextCapitalization textCapitalization; /// The style to use for the text being edited. /// /// Also serves as a base for the [placeholder] text's style. /// /// Defaults to the standard iOS font style from [CupertinoTheme] if null. final TextStyle? style; /// {@macro flutter.widgets.editableText.strutStyle} final StrutStyle? strutStyle; /// {@macro flutter.widgets.editableText.textAlign} final TextAlign textAlign; /// Configuration of toolbar options. /// /// If not set, select all and paste will default to be enabled. Copy and cut /// will be disabled if [obscureText] is true. If [readOnly] is true, /// paste and cut will be disabled regardless. final ToolbarOptions toolbarOptions; /// {@macro flutter.material.InputDecorator.textAlignVertical} final TextAlignVertical? textAlignVertical; /// {@macro flutter.widgets.editableText.readOnly} final bool readOnly; /// {@macro flutter.widgets.editableText.showCursor} final bool? showCursor; /// {@macro flutter.widgets.editableText.autofocus} final bool autofocus; /// {@macro flutter.widgets.editableText.obscuringCharacter} final String obscuringCharacter; /// {@macro flutter.widgets.editableText.obscureText} final bool obscureText; /// {@macro flutter.widgets.editableText.autocorrect} final bool autocorrect; /// {@macro flutter.services.TextInputConfiguration.smartDashesType} final SmartDashesType smartDashesType; /// {@macro flutter.services.TextInputConfiguration.smartQuotesType} final SmartQuotesType smartQuotesType; /// {@macro flutter.services.TextInputConfiguration.enableSuggestions} final bool enableSuggestions; /// {@macro flutter.widgets.editableText.maxLines} final int? maxLines; /// {@macro flutter.widgets.editableText.minLines} final int? minLines; /// {@macro flutter.widgets.editableText.expands} final bool expands; /// The maximum number of characters (Unicode scalar values) to allow in the /// text field. /// /// After [maxLength] characters have been input, additional input /// is ignored, unless [maxLengthEnforcement] is set to /// [MaxLengthEnforcement.none]. /// /// The TextField enforces the length with a /// [LengthLimitingTextInputFormatter], which is evaluated after the supplied /// [inputFormatters], if any. /// /// This value must be either null or greater than zero. If set to null /// (the default), there is no limit to the number of characters allowed. /// /// Whitespace characters (e.g. newline, space, tab) are included in the /// character count. /// /// {@macro flutter.services.lengthLimitingTextInputFormatter.maxLength} final int? maxLength; /// If [maxLength] is set, [maxLengthEnforced] indicates whether or not to /// enforce the limit. /// /// If true, prevents the field from allowing more than [maxLength] /// characters. @Deprecated( 'Use maxLengthEnforcement parameter which provides more specific ' 'behavior related to the maxLength limit. ' 'This feature was deprecated after v1.25.0-5.0.pre.', ) final bool maxLengthEnforced; /// Determines how the [maxLength] limit should be enforced. /// /// If [MaxLengthEnforcement.none] is set, additional input beyond [maxLength] /// will not be enforced by the limit. /// /// {@macro flutter.services.textFormatter.effectiveMaxLengthEnforcement} /// /// {@macro flutter.services.textFormatter.maxLengthEnforcement} final MaxLengthEnforcement? maxLengthEnforcement; /// {@macro flutter.widgets.editableText.onChanged} final ValueChanged<String>? onChanged; /// {@macro flutter.widgets.editableText.onEditingComplete} final VoidCallback? onEditingComplete; /// {@macro flutter.widgets.editableText.onSubmitted} /// /// See also: /// /// * [TextInputAction.next] and [TextInputAction.previous], which /// automatically shift the focus to the next/previous focusable item when /// the user is done editing. final ValueChanged<String>? onSubmitted; /// {@macro flutter.widgets.editableText.inputFormatters} final List<TextInputFormatter>? inputFormatters; /// Disables the text field when false. /// /// Text fields in disabled states have a light grey background and don't /// respond to touch events including the [prefix], [suffix] and the clear /// button. final bool? enabled; /// {@macro flutter.widgets.editableText.cursorWidth} final double cursorWidth; /// {@macro flutter.widgets.editableText.cursorHeight} final double? cursorHeight; /// {@macro flutter.widgets.editableText.cursorRadius} final Radius cursorRadius; /// The color to use when painting the cursor. /// /// Defaults to the [CupertinoThemeData.primaryColor] of the ambient theme, /// which itself defaults to [CupertinoColors.activeBlue] in the light theme /// and [CupertinoColors.activeOrange] in the dark theme. final Color? cursorColor; /// Controls how tall the selection highlight boxes are computed to be. /// /// See [ui.BoxHeightStyle] for details on available styles. final ui.BoxHeightStyle selectionHeightStyle; /// Controls how wide the selection highlight boxes are computed to be. /// /// See [ui.BoxWidthStyle] for details on available styles. final ui.BoxWidthStyle selectionWidthStyle; /// The appearance of the keyboard. /// /// This setting is only honored on iOS devices. /// /// If null, defaults to [Brightness.light]. final Brightness? keyboardAppearance; /// {@macro flutter.widgets.editableText.scrollPadding} final EdgeInsets scrollPadding; /// {@macro flutter.widgets.editableText.enableInteractiveSelection} final bool enableInteractiveSelection; /// {@macro flutter.widgets.editableText.selectionControls} final TextSelectionControls? selectionControls; /// {@macro flutter.widgets.scrollable.dragStartBehavior} final DragStartBehavior dragStartBehavior; /// {@macro flutter.widgets.editableText.scrollController} final ScrollController? scrollController; /// {@macro flutter.widgets.editableText.scrollPhysics} final ScrollPhysics? scrollPhysics; /// {@macro flutter.widgets.editableText.selectionEnabled} bool get selectionEnabled => enableInteractiveSelection; /// {@macro flutter.material.textfield.onTap} final GestureTapCallback? onTap; /// {@macro flutter.widgets.editableText.autofillHints} /// {@macro flutter.services.AutofillConfiguration.autofillHints} final Iterable<String>? autofillHints; /// {@macro flutter.material.textfield.restorationId} final String? restorationId; @override _CupertinoTextFieldState createState() => _CupertinoTextFieldState(); @override void debugFillProperties(DiagnosticPropertiesBuilder properties) { super.debugFillProperties(properties); properties.add(DiagnosticsProperty<TextEditingController>('controller', controller, defaultValue: null)); properties.add(DiagnosticsProperty<FocusNode>('focusNode', focusNode, defaultValue: null)); properties.add(DiagnosticsProperty<BoxDecoration>('decoration', decoration)); properties.add(DiagnosticsProperty<EdgeInsetsGeometry>('padding', padding)); properties.add(StringProperty('placeholder', placeholder)); properties.add(DiagnosticsProperty<TextStyle>('placeholderStyle', placeholderStyle)); properties.add(DiagnosticsProperty<OverlayVisibilityMode>('prefix', prefix == null ? null : prefixMode)); properties.add(DiagnosticsProperty<OverlayVisibilityMode>('suffix', suffix == null ? null : suffixMode)); properties.add(DiagnosticsProperty<OverlayVisibilityMode>('clearButtonMode', clearButtonMode)); properties.add(DiagnosticsProperty<TextInputType>('keyboardType', keyboardType, defaultValue: TextInputType.text)); properties.add(DiagnosticsProperty<TextStyle>('style', style, defaultValue: null)); properties.add(DiagnosticsProperty<bool>('autofocus', autofocus, defaultValue: false)); properties.add(DiagnosticsProperty<String>('obscuringCharacter', obscuringCharacter, defaultValue: '•')); properties.add(DiagnosticsProperty<bool>('obscureText', obscureText, defaultValue: false)); properties.add(DiagnosticsProperty<bool>('autocorrect', autocorrect, defaultValue: true)); properties.add(EnumProperty<SmartDashesType>('smartDashesType', smartDashesType, defaultValue: obscureText ? SmartDashesType.disabled : SmartDashesType.enabled)); properties.add(EnumProperty<SmartQuotesType>('smartQuotesType', smartQuotesType, defaultValue: obscureText ? SmartQuotesType.disabled : SmartQuotesType.enabled)); properties.add(DiagnosticsProperty<bool>('enableSuggestions', enableSuggestions, defaultValue: true)); properties.add(IntProperty('maxLines', maxLines, defaultValue: 1)); properties.add(IntProperty('minLines', minLines, defaultValue: null)); properties.add(DiagnosticsProperty<bool>('expands', expands, defaultValue: false)); properties.add(IntProperty('maxLength', maxLength, defaultValue: null)); properties.add(FlagProperty('maxLengthEnforced', value: maxLengthEnforced, ifTrue: 'max length enforced')); properties.add(EnumProperty<MaxLengthEnforcement>('maxLengthEnforcement', maxLengthEnforcement, defaultValue: null)); properties.add(DoubleProperty('cursorWidth', cursorWidth, defaultValue: 2.0)); properties.add(DoubleProperty('cursorHeight', cursorHeight, defaultValue: null)); properties.add(DiagnosticsProperty<Radius>('cursorRadius', cursorRadius, defaultValue: null)); properties.add(createCupertinoColorProperty('cursorColor', cursorColor, defaultValue: null)); properties.add(FlagProperty('selectionEnabled', value: selectionEnabled, defaultValue: true, ifFalse: 'selection disabled')); properties.add(DiagnosticsProperty<TextSelectionControls>('selectionControls', selectionControls, defaultValue: null)); properties.add(DiagnosticsProperty<ScrollController>('scrollController', scrollController, defaultValue: null)); properties.add(DiagnosticsProperty<ScrollPhysics>('scrollPhysics', scrollPhysics, defaultValue: null)); properties.add(EnumProperty<TextAlign>('textAlign', textAlign, defaultValue: TextAlign.start)); properties.add(DiagnosticsProperty<TextAlignVertical>('textAlignVertical', textAlignVertical, defaultValue: null)); } } class _CupertinoTextFieldState extends State<CupertinoTextField> with RestorationMixin, AutomaticKeepAliveClientMixin<CupertinoTextField> implements TextSelectionGestureDetectorBuilderDelegate { final GlobalKey _clearGlobalKey = GlobalKey(); RestorableTextEditingController? _controller; TextEditingController get _effectiveController => widget.controller ?? _controller!.value; FocusNode? _focusNode; FocusNode get _effectiveFocusNode => widget.focusNode ?? (_focusNode ??= FocusNode()); MaxLengthEnforcement get _effectiveMaxLengthEnforcement => widget.maxLengthEnforcement ?? LengthLimitingTextInputFormatter.getDefaultMaxLengthEnforcement(); bool _showSelectionHandles = false; late _CupertinoTextFieldSelectionGestureDetectorBuilder _selectionGestureDetectorBuilder; // API for TextSelectionGestureDetectorBuilderDelegate. @override bool get forcePressEnabled => true; @override final GlobalKey<EditableTextState> editableTextKey = GlobalKey<EditableTextState>(); @override bool get selectionEnabled => widget.selectionEnabled; // End of API for TextSelectionGestureDetectorBuilderDelegate. @override void initState() { super.initState(); _selectionGestureDetectorBuilder = _CupertinoTextFieldSelectionGestureDetectorBuilder(state: this); if (widget.controller == null) { _createLocalController(); } _effectiveFocusNode.canRequestFocus = widget.enabled ?? true; } @override void didUpdateWidget(CupertinoTextField oldWidget) { super.didUpdateWidget(oldWidget); if (widget.controller == null && oldWidget.controller != null) { _createLocalController(oldWidget.controller!.value); } else if (widget.controller != null && oldWidget.controller == null) { unregisterFromRestoration(_controller!); _controller!.dispose(); _controller = null; } _effectiveFocusNode.canRequestFocus = widget.enabled ?? true; } @override void restoreState(RestorationBucket? oldBucket, bool initialRestore) { if (_controller != null) { _registerController(); } } void _registerController() { assert(_controller != null); registerForRestoration(_controller!, 'controller'); _controller!.value.addListener(updateKeepAlive); } void _createLocalController([TextEditingValue? value]) { assert(_controller == null); _controller = value == null ? RestorableTextEditingController() : RestorableTextEditingController.fromValue(value); if (!restorePending) { _registerController(); } } @override String? get restorationId => widget.restorationId; @override void dispose() { _focusNode?.dispose(); _controller?.dispose(); super.dispose(); } EditableTextState get _editableText => editableTextKey.currentState!; void _requestKeyboard() { _editableText.requestKeyboard(); } bool _shouldShowSelectionHandles(SelectionChangedCause? cause) { // When the text field is activated by something that doesn't trigger the // selection overlay, we shouldn't show the handles either. if (!_selectionGestureDetectorBuilder.shouldShowSelectionToolbar) return false; // On iOS, we don't show handles when the selection is collapsed. if (_effectiveController.selection.isCollapsed) return false; if (cause == SelectionChangedCause.keyboard) return false; if (_effectiveController.text.isNotEmpty) return true; return false; } void _handleSelectionChanged(TextSelection selection, SelectionChangedCause? cause) { if (cause == SelectionChangedCause.longPress) { _editableText.bringIntoView(selection.base); } final bool willShowSelectionHandles = _shouldShowSelectionHandles(cause); if (willShowSelectionHandles != _showSelectionHandles) { setState(() { _showSelectionHandles = willShowSelectionHandles; }); } } @override bool get wantKeepAlive => _controller?.value.text.isNotEmpty == true; bool _shouldShowAttachment({ required OverlayVisibilityMode attachment, required bool hasText, }) { switch (attachment) { case OverlayVisibilityMode.never: return false; case OverlayVisibilityMode.always: return true; case OverlayVisibilityMode.editing: return hasText; case OverlayVisibilityMode.notEditing: return !hasText; } } bool _showPrefixWidget(TextEditingValue text) { return widget.prefix != null && _shouldShowAttachment( attachment: widget.prefixMode, hasText: text.text.isNotEmpty, ); } bool _showSuffixWidget(TextEditingValue text) { return widget.suffix != null && _shouldShowAttachment( attachment: widget.suffixMode, hasText: text.text.isNotEmpty, ); } bool _showClearButton(TextEditingValue text) { return _shouldShowAttachment( attachment: widget.clearButtonMode, hasText: text.text.isNotEmpty, ); } // True if any surrounding decoration widgets will be shown. bool get _hasDecoration { return widget.placeholder != null || widget.clearButtonMode != OverlayVisibilityMode.never || widget.prefix != null || widget.suffix != null; } // Provide default behavior if widget.textAlignVertical is not set. // CupertinoTextField has top alignment by default, unless it has decoration // like a prefix or suffix, in which case it's aligned to the center. TextAlignVertical get _textAlignVertical { if (widget.textAlignVertical != null) { return widget.textAlignVertical!; } return _hasDecoration ? TextAlignVertical.center : TextAlignVertical.top; } Widget _addTextDependentAttachments(Widget editableText, TextStyle textStyle, TextStyle placeholderStyle) { assert(editableText != null); assert(textStyle != null); assert(placeholderStyle != null); // If there are no surrounding widgets, just return the core editable text // part. if (!_hasDecoration) { return editableText; } // Otherwise, listen to the current state of the text entry. return ValueListenableBuilder<TextEditingValue>( valueListenable: _effectiveController, child: editableText, builder: (BuildContext context, TextEditingValue? text, Widget? child) { return Row(children: <Widget>[ // Insert a prefix at the front if the prefix visibility mode matches // the current text state. if (_showPrefixWidget(text!)) widget.prefix!, // In the middle part, stack the placeholder on top of the main EditableText // if needed. Expanded( child: Stack( children: <Widget>[ if (widget.placeholder != null && text.text.isEmpty) SizedBox( width: double.infinity, child: Padding( padding: widget.padding, child: Text( widget.placeholder!, maxLines: widget.maxLines, overflow: TextOverflow.ellipsis, style: placeholderStyle, textAlign: widget.textAlign, ), ), ), child!, ], ), ), // First add the explicit suffix if the suffix visibility mode matches. if (_showSuffixWidget(text)) widget.suffix! // Otherwise, try to show a clear button if its visibility mode matches. else if (_showClearButton(text)) GestureDetector( key: _clearGlobalKey, onTap: widget.enabled ?? true ? () { // Special handle onChanged for ClearButton // Also call onChanged when the clear button is tapped. final bool textChanged = _effectiveController.text.isNotEmpty; _effectiveController.clear(); if (widget.onChanged != null && textChanged) widget.onChanged!(_effectiveController.text); } : null, child: Padding( padding: const EdgeInsets.symmetric(horizontal: 6.0), child: Icon( CupertinoIcons.clear_thick_circled, size: 18.0, color: CupertinoDynamicColor.resolve(_kClearButtonColor, context), ), ), ), ]); }, ); } @override Widget build(BuildContext context) { super.build(context); // See AutomaticKeepAliveClientMixin. assert(debugCheckHasDirectionality(context)); final TextEditingController controller = _effectiveController; TextSelectionControls? textSelectionControls = widget.selectionControls; VoidCallback? handleDidGainAccessibilityFocus; switch (defaultTargetPlatform) { case TargetPlatform.iOS: case TargetPlatform.android: case TargetPlatform.fuchsia: case TargetPlatform.linux: case TargetPlatform.windows: textSelectionControls ??= cupertinoTextSelectionControls; break; case TargetPlatform.macOS: textSelectionControls ??= cupertinoDesktopTextSelectionControls; handleDidGainAccessibilityFocus = () { // macOS automatically activated the TextField when it receives // accessibility focus. if (!_effectiveFocusNode.hasFocus && _effectiveFocusNode.canRequestFocus) { _effectiveFocusNode.requestFocus(); } }; break; } final bool enabled = widget.enabled ?? true; final Offset cursorOffset = Offset(_iOSHorizontalCursorOffsetPixels / MediaQuery.of(context).devicePixelRatio, 0); final List<TextInputFormatter> formatters = <TextInputFormatter>[ ...?widget.inputFormatters, if (widget.maxLength != null && widget.maxLengthEnforced) LengthLimitingTextInputFormatter( widget.maxLength, maxLengthEnforcement: _effectiveMaxLengthEnforcement, ), ]; final CupertinoThemeData themeData = CupertinoTheme.of(context); final TextStyle? resolvedStyle = widget.style?.copyWith( color: CupertinoDynamicColor.maybeResolve(widget.style?.color, context), backgroundColor: CupertinoDynamicColor.maybeResolve(widget.style?.backgroundColor, context), ); final TextStyle textStyle = themeData.textTheme.textStyle.merge(resolvedStyle); final TextStyle? resolvedPlaceholderStyle = widget.placeholderStyle?.copyWith( color: CupertinoDynamicColor.maybeResolve(widget.placeholderStyle?.color, context), backgroundColor: CupertinoDynamicColor.maybeResolve(widget.placeholderStyle?.backgroundColor, context), ); final TextStyle placeholderStyle = textStyle.merge(resolvedPlaceholderStyle); final Brightness keyboardAppearance = widget.keyboardAppearance ?? CupertinoTheme.brightnessOf(context); final Color cursorColor = CupertinoDynamicColor.maybeResolve(widget.cursorColor, context) ?? themeData.primaryColor; final Color disabledColor = CupertinoDynamicColor.resolve(_kDisabledBackground, context); final Color? decorationColor = CupertinoDynamicColor.maybeResolve(widget.decoration?.color, context); final BoxBorder? border = widget.decoration?.border; Border? resolvedBorder = border as Border?; if (border is Border) { BorderSide resolveBorderSide(BorderSide side) { return side == BorderSide.none ? side : side.copyWith(color: CupertinoDynamicColor.resolve(side.color, context)); } resolvedBorder = border == null || border.runtimeType != Border ? border : Border( top: resolveBorderSide(border.top), left: resolveBorderSide(border.left), bottom: resolveBorderSide(border.bottom), right: resolveBorderSide(border.right), ); } final BoxDecoration? effectiveDecoration = widget.decoration?.copyWith( border: resolvedBorder, color: enabled ? decorationColor : disabledColor, ); final Color selectionColor = CupertinoTheme.of(context).primaryColor.withOpacity(0.2); final Widget paddedEditable = Padding( padding: widget.padding, child: RepaintBoundary( child: UnmanagedRestorationScope( bucket: bucket, child: EditableText( key: editableTextKey, controller: controller, readOnly: widget.readOnly, toolbarOptions: widget.toolbarOptions, showCursor: widget.showCursor, showSelectionHandles: _showSelectionHandles, focusNode: _effectiveFocusNode, keyboardType: widget.keyboardType, textInputAction: widget.textInputAction, textCapitalization: widget.textCapitalization, style: textStyle, strutStyle: widget.strutStyle, textAlign: widget.textAlign, autofocus: widget.autofocus, obscuringCharacter: widget.obscuringCharacter, obscureText: widget.obscureText, autocorrect: widget.autocorrect, smartDashesType: widget.smartDashesType, smartQuotesType: widget.smartQuotesType, enableSuggestions: widget.enableSuggestions, maxLines: widget.maxLines, minLines: widget.minLines, expands: widget.expands, selectionColor: selectionColor, selectionControls: widget.selectionEnabled ? textSelectionControls : null, onChanged: widget.onChanged, onSelectionChanged: _handleSelectionChanged, onEditingComplete: widget.onEditingComplete, onSubmitted: widget.onSubmitted, inputFormatters: formatters, rendererIgnoresPointer: true, cursorWidth: widget.cursorWidth, cursorHeight: widget.cursorHeight, cursorRadius: widget.cursorRadius, cursorColor: cursorColor, cursorOpacityAnimates: true, cursorOffset: cursorOffset, paintCursorAboveText: true, autocorrectionTextRectColor: selectionColor, backgroundCursorColor: CupertinoDynamicColor.resolve(CupertinoColors.inactiveGray, context), selectionHeightStyle: widget.selectionHeightStyle, selectionWidthStyle: widget.selectionWidthStyle, scrollPadding: widget.scrollPadding, keyboardAppearance: keyboardAppearance, dragStartBehavior: widget.dragStartBehavior, scrollController: widget.scrollController, scrollPhysics: widget.scrollPhysics, enableInteractiveSelection: widget.enableInteractiveSelection, autofillHints: widget.autofillHints, restorationId: 'editable', ), ), ), ); return Semantics( enabled: enabled, onTap: !enabled || widget.readOnly ? null : () { if (!controller.selection.isValid) { controller.selection = TextSelection.collapsed(offset: controller.text.length); } _requestKeyboard(); }, onDidGainAccessibilityFocus: handleDidGainAccessibilityFocus, child: IgnorePointer( ignoring: !enabled, child: Container( decoration: effectiveDecoration, color: !enabled && effectiveDecoration == null ? disabledColor : null, child: _selectionGestureDetectorBuilder.buildGestureDetector( behavior: HitTestBehavior.translucent, child: Align( alignment: Alignment(-1.0, _textAlignVertical.y), widthFactor: 1.0, heightFactor: 1.0, child: _addTextDependentAttachments(paddedEditable, textStyle, placeholderStyle), ), ), ), ), ); } }