selectable_text.dart 22.9 KB
Newer Older
Ian Hickson's avatar
Ian Hickson committed
1
// Copyright 2014 The Flutter Authors. All rights reserved.
2 3 4 5 6 7 8 9 10 11 12 13
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import 'package:flutter/cupertino.dart';
import 'package:flutter/rendering.dart';
import 'package:flutter/services.dart';
import 'package:flutter/widgets.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/gestures.dart';

import 'feedback.dart';
import 'text_selection.dart';
14
import 'text_selection_theme.dart';
15 16 17 18 19 20 21 22 23 24 25
import 'theme.dart';

/// An eyeballed value that moves the cursor slightly left of where it is
/// rendered for text on Android so its 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 iOSHorizontalOffset = -2;

class _TextSpanEditingController extends TextEditingController {
26
  _TextSpanEditingController({required TextSpan textSpan}):
27 28 29 30 31 32 33
    assert(textSpan != null),
    _textSpan = textSpan,
    super(text: textSpan.toPlainText());

  final TextSpan _textSpan;

  @override
34
  TextSpan buildTextSpan({TextStyle? style ,bool? withComposing}) {
35
    // This does not care about composing.
36 37 38 39 40 41 42
    return TextSpan(
      style: style,
      children: <TextSpan>[_textSpan],
    );
  }

  @override
43
  set text(String? newText) {
44 45
    // This should never be reached.
    throw UnimplementedError();
46 47 48 49 50
  }
}

class _SelectableTextSelectionGestureDetectorBuilder extends TextSelectionGestureDetectorBuilder {
  _SelectableTextSelectionGestureDetectorBuilder({
51
    required _SelectableTextState state,
52
  }) : _state = state,
53
       super(delegate: state);
54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

  final _SelectableTextState _state;

  @override
  void onForcePressStart(ForcePressDetails details) {
    super.onForcePressStart(details);
    if (delegate.selectionEnabled && shouldShowSelectionToolbar) {
      editableText.showToolbar();
    }
  }

  @override
  void onForcePressEnd(ForcePressDetails details) {
    // Not required.
  }

  @override
  void onSingleLongTapMoveUpdate(LongPressMoveUpdateDetails details) {
    if (delegate.selectionEnabled) {
73 74 75 76 77
      renderEditable.selectWordsInRange(
        from: details.globalPosition - details.offsetFromOrigin,
        to: details.globalPosition,
        cause: SelectionChangedCause.longPress,
      );
78 79 80 81 82 83 84
    }
  }

  @override
  void onSingleTapUp(TapUpDetails details) {
    editableText.hideToolbar();
    if (delegate.selectionEnabled) {
85
      switch (Theme.of(_state.context).platform) {
86
        case TargetPlatform.iOS:
87
        case TargetPlatform.macOS:
88 89 90 91
          renderEditable.selectWordEdge(cause: SelectionChangedCause.tap);
          break;
        case TargetPlatform.android:
        case TargetPlatform.fuchsia:
92 93
        case TargetPlatform.linux:
        case TargetPlatform.windows:
94 95 96 97 98
          renderEditable.selectPosition(cause: SelectionChangedCause.tap);
          break;
      }
    }
    if (_state.widget.onTap != null)
99
      _state.widget.onTap!();
100 101 102 103 104
  }

  @override
  void onSingleLongTapStart(LongPressStartDetails details) {
    if (delegate.selectionEnabled) {
105 106
      renderEditable.selectWord(cause: SelectionChangedCause.longPress);
      Feedback.forLongPress(_state.context);
107 108 109 110 111 112 113 114 115 116
    }
  }
}

/// A run of selectable text with a single style.
///
/// The [SelectableText] widget displays a string of text with a single style.
/// The string might break across multiple lines or might all be displayed on
/// the same line depending on the layout constraints.
///
117 118
/// {@youtube 560 315 https://www.youtube.com/watch?v=ZSU3ZXOs6hc}
///
119 120 121 122 123 124 125
/// The [style] argument is optional. When omitted, the text will use the style
/// from the closest enclosing [DefaultTextStyle]. If the given style's
/// [TextStyle.inherit] property is true (the default), the given style will
/// be merged with the closest enclosing [DefaultTextStyle]. This merging
/// behavior is useful, for example, to make the text bold while using the
/// default font family and size.
///
126
/// {@tool snippet}
127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
///
/// ```dart
/// SelectableText(
///   'Hello! How are you?',
///   textAlign: TextAlign.center,
///   style: TextStyle(fontWeight: FontWeight.bold),
/// )
/// ```
/// {@end-tool}
///
/// Using the [SelectableText.rich] constructor, the [SelectableText] widget can
/// display a paragraph with differently styled [TextSpan]s. The sample
/// that follows displays "Hello beautiful world" with different styles
/// for each word.
///
142
/// {@tool snippet}
143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
///
/// ```dart
/// const SelectableText.rich(
///   TextSpan(
///     text: 'Hello', // default text style
///     children: <TextSpan>[
///       TextSpan(text: ' beautiful ', style: TextStyle(fontStyle: FontStyle.italic)),
///       TextSpan(text: 'world', style: TextStyle(fontWeight: FontWeight.bold)),
///     ],
///   ),
/// )
/// ```
/// {@end-tool}
///
/// ## Interactivity
///
/// To make [SelectableText] react to touch events, use callback [onTap] to achieve
/// the desired behavior.
///
/// See also:
///
///  * [Text], which is the non selectable version of this widget.
///  * [TextField], which is the editable version of this widget.
class SelectableText extends StatefulWidget {
  /// Creates a selectable text widget.
  ///
  /// If the [style] argument is null, the text will use the style from the
  /// closest enclosing [DefaultTextStyle].
  ///
172 173 174 175

  /// The [showCursor], [autofocus], [dragStartBehavior], and [data] parameters
  /// must not be null. If specified, the [maxLines] argument must be greater
  /// than zero.
176
  const SelectableText(
177
    String this.data, {
178
    Key? key,
179 180 181 182 183
    this.focusNode,
    this.style,
    this.strutStyle,
    this.textAlign,
    this.textDirection,
184
    this.textScaleFactor,
185 186
    this.showCursor = false,
    this.autofocus = false,
187
    ToolbarOptions? toolbarOptions,
188
    this.minLines,
189 190
    this.maxLines,
    this.cursorWidth = 2.0,
191
    this.cursorHeight,
192 193 194 195
    this.cursorRadius,
    this.cursorColor,
    this.dragStartBehavior = DragStartBehavior.start,
    this.enableInteractiveSelection = true,
196
    this.selectionControls,
197 198
    this.onTap,
    this.scrollPhysics,
199
    this.textHeightBehavior,
200
    this.textWidthBasis,
201
    this.onSelectionChanged,
202 203 204 205
  }) :  assert(showCursor != null),
        assert(autofocus != null),
        assert(dragStartBehavior != null),
        assert(maxLines == null || maxLines > 0),
206 207 208 209 210
        assert(minLines == null || minLines > 0),
        assert(
          (maxLines == null) || (minLines == null) || (maxLines >= minLines),
          'minLines can\'t be greater than maxLines',
        ),
211 212 213 214 215
        assert(
          data != null,
          'A non-null String must be provided to a SelectableText widget.',
        ),
        textSpan = null,
216 217 218 219 220
        toolbarOptions = toolbarOptions ??
          const ToolbarOptions(
            selectAll: true,
            copy: true,
          ),
221 222 223 224 225 226
        super(key: key);

  /// Creates a selectable text widget with a [TextSpan].
  ///
  /// The [textSpan] parameter must not be null and only contain [TextSpan] in
  /// [textSpan.children]. Other type of [InlineSpan] is not allowed.
227 228
  ///
  /// The [autofocus] and [dragStartBehavior] arguments must not be null.
229
  const SelectableText.rich(
230
    TextSpan this.textSpan, {
231
    Key? key,
232 233 234 235 236
    this.focusNode,
    this.style,
    this.strutStyle,
    this.textAlign,
    this.textDirection,
237
    this.textScaleFactor,
238 239
    this.showCursor = false,
    this.autofocus = false,
240
    ToolbarOptions? toolbarOptions,
241
    this.minLines,
242 243
    this.maxLines,
    this.cursorWidth = 2.0,
244
    this.cursorHeight,
245 246 247 248
    this.cursorRadius,
    this.cursorColor,
    this.dragStartBehavior = DragStartBehavior.start,
    this.enableInteractiveSelection = true,
249
    this.selectionControls,
250 251
    this.onTap,
    this.scrollPhysics,
252
    this.textHeightBehavior,
253
    this.textWidthBasis,
254
    this.onSelectionChanged,
255 256 257 258
  }) :  assert(showCursor != null),
    assert(autofocus != null),
    assert(dragStartBehavior != null),
    assert(maxLines == null || maxLines > 0),
259 260 261 262 263
    assert(minLines == null || minLines > 0),
    assert(
      (maxLines == null) || (minLines == null) || (maxLines >= minLines),
      'minLines can\'t be greater than maxLines',
    ),
264 265 266 267 268
    assert(
      textSpan != null,
      'A non-null TextSpan must be provided to a SelectableText.rich widget.',
    ),
    data = null,
269 270 271 272 273
    toolbarOptions = toolbarOptions ??
      const ToolbarOptions(
        selectAll: true,
        copy: true,
      ),
274 275 276 277 278
    super(key: key);

  /// The text to display.
  ///
  /// This will be null if a [textSpan] is provided instead.
279
  final String? data;
280 281 282 283

  /// The text to display as a [TextSpan].
  ///
  /// This will be null if [data] is provided instead.
284
  final TextSpan? textSpan;
285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309

  /// Defines the focus for this widget.
  ///
  /// Text is only selectable when widget is focused.
  ///
  /// The [focusNode] is a long-lived object that's typically managed by a
  /// [StatefulWidget] parent. See [FocusNode] for more information.
  ///
  /// To give the focus to this widget, provide a [focusNode] and then
  /// use the current [FocusScope] to request the focus:
  ///
  /// ```dart
  /// FocusScope.of(context).requestFocus(myFocusNode);
  /// ```
  ///
  /// This happens automatically when the widget is tapped.
  ///
  /// To be notified when the widget gains or loses the focus, add a listener
  /// to the [focusNode]:
  ///
  /// ```dart
  /// focusNode.addListener(() { print(myFocusNode.hasFocus); });
  /// ```
  ///
  /// If null, this widget will create its own [FocusNode].
310
  final FocusNode? focusNode;
311 312 313 314

  /// The style to use for the text.
  ///
  /// If null, defaults [DefaultTextStyle] of context.
315
  final TextStyle? style;
316 317

  /// {@macro flutter.widgets.editableText.strutStyle}
318
  final StrutStyle? strutStyle;
319 320

  /// {@macro flutter.widgets.editableText.textAlign}
321
  final TextAlign? textAlign;
322 323

  /// {@macro flutter.widgets.editableText.textDirection}
324
  final TextDirection? textDirection;
325

326
  /// {@macro flutter.widgets.editableText.textScaleFactor}
327
  final double? textScaleFactor;
328

329 330 331
  /// {@macro flutter.widgets.editableText.autofocus}
  final bool autofocus;

332
  /// {@macro flutter.widgets.editableText.minLines}
333
  final int? minLines;
334

335
  /// {@macro flutter.widgets.editableText.maxLines}
336
  final int? maxLines;
337 338 339 340 341 342 343

  /// {@macro flutter.widgets.editableText.showCursor}
  final bool showCursor;

  /// {@macro flutter.widgets.editableText.cursorWidth}
  final double cursorWidth;

344
  /// {@macro flutter.widgets.editableText.cursorHeight}
345
  final double? cursorHeight;
346

347
  /// {@macro flutter.widgets.editableText.cursorRadius}
348
  final Radius? cursorRadius;
349 350 351 352

  /// The color to use when painting the cursor.
  ///
  /// Defaults to the theme's `cursorColor` when null.
353
  final Color? cursorColor;
354 355 356 357

  /// {@macro flutter.widgets.editableText.enableInteractiveSelection}
  final bool enableInteractiveSelection;

358 359 360
  /// {@macro flutter.widgets.editableText.selectionControls}
  final TextSelectionControls? selectionControls;

361 362 363
  /// {@macro flutter.widgets.scrollable.dragStartBehavior}
  final DragStartBehavior dragStartBehavior;

364 365 366 367 368 369 370
  /// Configuration of toolbar options.
  ///
  /// Paste and cut will be disabled regardless.
  ///
  /// If not set, select all and copy will be enabled by default.
  final ToolbarOptions toolbarOptions;

371 372
  /// {@macro flutter.widgets.editableText.selectionEnabled}
  bool get selectionEnabled => enableInteractiveSelection;
373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388

  /// Called when the user taps on this selectable text.
  ///
  /// The selectable text builds a [GestureDetector] to handle input events like tap,
  /// to trigger focus requests, to move the caret, adjust the selection, etc.
  /// Handling some of those events by wrapping the selectable text with a competing
  /// GestureDetector is problematic.
  ///
  /// To unconditionally handle taps, without interfering with the selectable text's
  /// internal gesture detector, provide this callback.
  ///
  /// To be notified when the text field gains or loses the focus, provide a
  /// [focusNode] and add a listener to that.
  ///
  /// To listen to arbitrary pointer events without competing with the
  /// selectable text's internal gesture detector, use a [Listener].
389
  final GestureTapCallback? onTap;
390

Dan Field's avatar
Dan Field committed
391
  /// {@macro flutter.widgets.editableText.scrollPhysics}
392
  final ScrollPhysics? scrollPhysics;
393

394
  /// {@macro flutter.dart:ui.textHeightBehavior}
395
  final TextHeightBehavior? textHeightBehavior;
396

397
  /// {@macro flutter.painting.textPainter.textWidthBasis}
398
  final TextWidthBasis? textWidthBasis;
399

400
  /// {@macro flutter.widgets.editableText.onSelectionChanged}
401
  final SelectionChangedCallback? onSelectionChanged;
402

403 404 405 406 407 408 409 410 411 412 413
  @override
  _SelectableTextState createState() => _SelectableTextState();

  @override
  void debugFillProperties(DiagnosticPropertiesBuilder properties) {
    super.debugFillProperties(properties);
    properties.add(DiagnosticsProperty<String>('data', data, defaultValue: null));
    properties.add(DiagnosticsProperty<FocusNode>('focusNode', focusNode, defaultValue: null));
    properties.add(DiagnosticsProperty<TextStyle>('style', style, defaultValue: null));
    properties.add(DiagnosticsProperty<bool>('autofocus', autofocus, defaultValue: false));
    properties.add(DiagnosticsProperty<bool>('showCursor', showCursor, defaultValue: false));
414
    properties.add(IntProperty('minLines', minLines, defaultValue: null));
415 416 417
    properties.add(IntProperty('maxLines', maxLines, defaultValue: null));
    properties.add(EnumProperty<TextAlign>('textAlign', textAlign, defaultValue: null));
    properties.add(EnumProperty<TextDirection>('textDirection', textDirection, defaultValue: null));
418
    properties.add(DoubleProperty('textScaleFactor', textScaleFactor, defaultValue: null));
419
    properties.add(DoubleProperty('cursorWidth', cursorWidth, defaultValue: 2.0));
420
    properties.add(DoubleProperty('cursorHeight', cursorHeight, defaultValue: null));
421 422 423
    properties.add(DiagnosticsProperty<Radius>('cursorRadius', cursorRadius, defaultValue: null));
    properties.add(DiagnosticsProperty<Color>('cursorColor', cursorColor, defaultValue: null));
    properties.add(FlagProperty('selectionEnabled', value: selectionEnabled, defaultValue: true, ifFalse: 'selection disabled'));
424
    properties.add(DiagnosticsProperty<TextSelectionControls>('selectionControls', selectionControls, defaultValue: null));
425
    properties.add(DiagnosticsProperty<ScrollPhysics>('scrollPhysics', scrollPhysics, defaultValue: null));
426
    properties.add(DiagnosticsProperty<TextHeightBehavior>('textHeightBehavior', textHeightBehavior, defaultValue: null));
427 428 429 430
  }
}

class _SelectableTextState extends State<SelectableText> with AutomaticKeepAliveClientMixin implements TextSelectionGestureDetectorBuilderDelegate {
431
  EditableTextState? get _editableText => editableTextKey.currentState;
432

433
  late _TextSpanEditingController _controller;
434

435
  FocusNode? _focusNode;
436 437 438 439
  FocusNode get _effectiveFocusNode => widget.focusNode ?? (_focusNode ??= FocusNode());

  bool _showSelectionHandles = false;

440
  late _SelectableTextSelectionGestureDetectorBuilder _selectionGestureDetectorBuilder;
441 442 443

  // API for TextSelectionGestureDetectorBuilderDelegate.
  @override
444
  late bool forcePressEnabled;
445 446 447 448 449 450 451 452 453 454 455 456 457 458 459

  @override
  final GlobalKey<EditableTextState> editableTextKey = GlobalKey<EditableTextState>();

  @override
  bool get selectionEnabled => widget.selectionEnabled;
  // End of API for TextSelectionGestureDetectorBuilderDelegate.

  @override
  void initState() {
    super.initState();
    _selectionGestureDetectorBuilder = _SelectableTextSelectionGestureDetectorBuilder(state: this);
    _controller = _TextSpanEditingController(
        textSpan: widget.textSpan ?? TextSpan(text: widget.data)
    );
460
    _controller.addListener(_onControllerChanged);
461 462 463 464 465 466
  }

  @override
  void didUpdateWidget(SelectableText oldWidget) {
    super.didUpdateWidget(oldWidget);
    if (widget.data != oldWidget.data || widget.textSpan != oldWidget.textSpan) {
467
      _controller.removeListener(_onControllerChanged);
468 469 470
      _controller = _TextSpanEditingController(
          textSpan: widget.textSpan ?? TextSpan(text: widget.data)
      );
471
      _controller.addListener(_onControllerChanged);
472 473
    }
    if (_effectiveFocusNode.hasFocus && _controller.selection.isCollapsed) {
474
      _showSelectionHandles = false;
475 476
    } else {
      _showSelectionHandles = true;
477 478 479 480 481 482
    }
  }

  @override
  void dispose() {
    _focusNode?.dispose();
483
    _controller.removeListener(_onControllerChanged);
484 485 486
    super.dispose();
  }

487 488 489 490 491 492 493 494 495 496 497
  void _onControllerChanged() {
    final bool showSelectionHandles = !_effectiveFocusNode.hasFocus
      || !_controller.selection.isCollapsed;
    if (showSelectionHandles == _showSelectionHandles) {
      return;
    }
    setState(() {
      _showSelectionHandles = showSelectionHandles;
    });
  }

498
  void _handleSelectionChanged(TextSelection selection, SelectionChangedCause? cause) {
499 500 501 502 503 504 505
    final bool willShowSelectionHandles = _shouldShowSelectionHandles(cause);
    if (willShowSelectionHandles != _showSelectionHandles) {
      setState(() {
        _showSelectionHandles = willShowSelectionHandles;
      });
    }

506
    if (widget.onSelectionChanged != null) {
507
      widget.onSelectionChanged!(selection, cause);
508 509
    }

510
    switch (Theme.of(context).platform) {
511
      case TargetPlatform.iOS:
512
      case TargetPlatform.macOS:
513 514 515 516 517 518
        if (cause == SelectionChangedCause.longPress) {
          _editableText?.bringIntoView(selection.base);
        }
        return;
      case TargetPlatform.android:
      case TargetPlatform.fuchsia:
519 520
      case TargetPlatform.linux:
      case TargetPlatform.windows:
521 522 523 524 525 526 527
      // Do nothing.
    }
  }

  /// Toggle the toolbar when a selection handle is tapped.
  void _handleSelectionHandleTapped() {
    if (_controller.selection.isCollapsed) {
528
      _editableText!.toggleToolbar();
529 530 531
    }
  }

532
  bool _shouldShowSelectionHandles(SelectionChangedCause? cause) {
533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564
    // 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;

    if (_controller.selection.isCollapsed)
      return false;

    if (cause == SelectionChangedCause.keyboard)
      return false;

    if (cause == SelectionChangedCause.longPress)
      return true;

    if (_controller.text.isNotEmpty)
      return true;

    return false;
  }

  @override
  bool get wantKeepAlive => true;

  @override
  Widget build(BuildContext context) {
    super.build(context); // See AutomaticKeepAliveClientMixin.
    assert(() {
      return _controller._textSpan.visitChildren((InlineSpan span) => span.runtimeType == TextSpan);
    }(), 'SelectableText only supports TextSpan; Other type of InlineSpan is not allowed');
    assert(debugCheckHasMediaQuery(context));
    assert(debugCheckHasDirectionality(context));
    assert(
565 566
      !(widget.style != null && widget.style!.inherit == false &&
          (widget.style!.fontSize == null || widget.style!.textBaseline == null)),
567 568 569
      'inherit false style must supply fontSize and textBaseline',
    );

570
    final ThemeData theme = Theme.of(context);
571
    final TextSelectionThemeData selectionTheme = TextSelectionTheme.of(context);
572 573
    final FocusNode focusNode = _effectiveFocusNode;

574
    TextSelectionControls? textSelectionControls =  widget.selectionControls;
575 576
    final bool paintCursorAboveText;
    final bool cursorOpacityAnimates;
577 578
    Offset? cursorOffset;
    Color? cursorColor = widget.cursorColor;
579
    final Color selectionColor;
580
    Radius? cursorRadius = widget.cursorRadius;
581

582
    switch (theme.platform) {
583
      case TargetPlatform.iOS:
584
      case TargetPlatform.macOS:
585
        final CupertinoThemeData cupertinoTheme = CupertinoTheme.of(context);
586
        forcePressEnabled = true;
587
        textSelectionControls ??= cupertinoTextSelectionControls;
588 589
        paintCursorAboveText = true;
        cursorOpacityAnimates = true;
590 591
        cursorColor ??= selectionTheme.cursorColor ?? cupertinoTheme.primaryColor;
        selectionColor = selectionTheme.selectionColor ?? cupertinoTheme.primaryColor.withOpacity(0.40);
592
        cursorRadius ??= const Radius.circular(2.0);
593
        cursorOffset = Offset(iOSHorizontalOffset / MediaQuery.of(context).devicePixelRatio, 0);
594 595 596 597
        break;

      case TargetPlatform.android:
      case TargetPlatform.fuchsia:
598 599
      case TargetPlatform.linux:
      case TargetPlatform.windows:
600
        forcePressEnabled = false;
601
        textSelectionControls ??= materialTextSelectionControls;
602 603
        paintCursorAboveText = false;
        cursorOpacityAnimates = false;
604 605
        cursorColor ??= selectionTheme.cursorColor ?? theme.colorScheme.primary;
        selectionColor = selectionTheme.selectionColor ?? theme.colorScheme.primary.withOpacity(0.40);
606 607 608 609
        break;
    }

    final DefaultTextStyle defaultTextStyle = DefaultTextStyle.of(context);
610 611
    TextStyle? effectiveTextStyle = widget.style;
    if (effectiveTextStyle == null || effectiveTextStyle.inherit)
612 613 614 615 616 617 618 619 620
      effectiveTextStyle = defaultTextStyle.style.merge(widget.style);
    if (MediaQuery.boldTextOverride(context))
      effectiveTextStyle = effectiveTextStyle.merge(const TextStyle(fontWeight: FontWeight.bold));
    final Widget child = RepaintBoundary(
      child: EditableText(
        key: editableTextKey,
        style: effectiveTextStyle,
        readOnly: true,
        textWidthBasis: widget.textWidthBasis ?? defaultTextStyle.textWidthBasis,
621
        textHeightBehavior: widget.textHeightBehavior ?? defaultTextStyle.textHeightBehavior,
622 623 624 625
        showSelectionHandles: _showSelectionHandles,
        showCursor: widget.showCursor,
        controller: _controller,
        focusNode: focusNode,
626
        strutStyle: widget.strutStyle ?? const StrutStyle(),
627 628
        textAlign: widget.textAlign ?? defaultTextStyle.textAlign ?? TextAlign.start,
        textDirection: widget.textDirection,
629
        textScaleFactor: widget.textScaleFactor,
630 631
        autofocus: widget.autofocus,
        forceLine: false,
632
        toolbarOptions: widget.toolbarOptions,
633
        minLines: widget.minLines,
634
        maxLines: widget.maxLines ?? defaultTextStyle.maxLines,
635
        selectionColor: selectionColor,
636 637 638 639 640
        selectionControls: widget.selectionEnabled ? textSelectionControls : null,
        onSelectionChanged: _handleSelectionChanged,
        onSelectionHandleTapped: _handleSelectionHandleTapped,
        rendererIgnoresPointer: true,
        cursorWidth: widget.cursorWidth,
641
        cursorHeight: widget.cursorHeight,
642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669
        cursorRadius: cursorRadius,
        cursorColor: cursorColor,
        cursorOpacityAnimates: cursorOpacityAnimates,
        cursorOffset: cursorOffset,
        paintCursorAboveText: paintCursorAboveText,
        backgroundCursorColor: CupertinoColors.inactiveGray,
        enableInteractiveSelection: widget.enableInteractiveSelection,
        dragStartBehavior: widget.dragStartBehavior,
        scrollPhysics: widget.scrollPhysics,
      ),
    );

    return Semantics(
      onTap: () {
        if (!_controller.selection.isValid)
          _controller.selection = TextSelection.collapsed(offset: _controller.text.length);
        _effectiveFocusNode.requestFocus();
      },
      onLongPress: () {
        _effectiveFocusNode.requestFocus();
      },
      child: _selectionGestureDetectorBuilder.buildGestureDetector(
        behavior: HitTestBehavior.translucent,
        child: child,
      ),
    );
  }
}