RenderEditable.getBoxesForSelection gets selection width for longest line width #180311

import 'package:flutter/material.dart';
import 'package:flutter/rendering.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'RenderEditable Bug Demo',
      theme: ThemeData(
        colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
        useMaterial3: true,
      ),
      home: const MyHomePage(title: 'RenderEditable Bug Demo'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  const MyHomePage({super.key, required this.title});

  final String title;

  @override
  State<MyHomePage> createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  final GlobalKey customPaintKey = GlobalKey();
  final ScrollController scrollController = ScrollController();
  final TextEditingController controller = TextEditingController();
  final List<TextSelection> errorLines = [const TextSelection(baseOffset: 39, extentOffset: 51)]; // "Highlight me" position
  ErrorLinesPainter? painter;
  @override
  void initState() {
    controller.text = '''
Some long lines of text should go here
Highlight me
Doesn't matter
''';
    painter = ErrorLinesPainter(
      customPaintKey,
      const TextStyle(),
      controller,
    );
    painter!.lineErrorPositions = errorLines;
    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        backgroundColor: Theme.of(context).colorScheme.inversePrimary,
        title: Text(widget.title),
      ),
      body: DumbVisitor<EditableTextState>(
        onFound: (ets) {
          painter?.setupEditableTextState(ets);
        },
        child: CustomPaint(
          key: customPaintKey,
          foregroundPainter: painter,
          child: TextField(
            controller: controller,
            maxLines: null,
            expands: true,
            readOnly: true,
            decoration: const InputDecoration(
              border: OutlineInputBorder(),
            ),
          ),
        ),
      ),
    );
  }
}

class ErrorLinesPainter extends CustomPainter {
  ErrorLinesPainter(this.customPaintKey, this.textStyle, Listenable listenable) : super(repaint: listenable);
  GlobalKey customPaintKey;
  RenderEditable? re;

  final TextStyle textStyle;

  List<TextSelection> lineErrorPositions = [];

  @override
  void paint(Canvas canvas, Size size) {
    if (re case RenderEditable re) {
      final ancestor = customPaintKey.currentContext!.findRenderObject();
      final offset = re.localToGlobal(Offset.zero, ancestor: ancestor);
      for (final e in lineErrorPositions) {
        final boxes = re.getBoxesForSelection(e);
        if (boxes.isNotEmpty) {
          final firstBox = boxes.first.toRect();
          final lastBox = boxes.last.toRect();
          canvas.drawLine(
              Offset(firstBox.left + offset.dx, firstBox.bottom + offset.dy),
              Offset(lastBox.right + offset.dx, firstBox.bottom + offset.dy),
              Paint()
                ..strokeWidth = 2
                ..style = PaintingStyle.stroke
                ..filterQuality = FilterQuality.low
                ..strokeCap = StrokeCap.round
                ..color = Colors.red.shade500);
        }
      }
    }
  }

  @override
  bool shouldRepaint(ErrorLinesPainter oldDelegate) => false;

  void setupEditableTextState(EditableTextState ets) {
    re = ets.renderEditable;
  }
}

class DumbVisitor<T> extends StatelessWidget {
  const DumbVisitor({
    super.key,
    required this.onFound,
    required this.child,
  });

  final void Function(T object) onFound;
  final Widget child;

  @override
  Widget build(BuildContext context) => child;

  @override
  StatelessElement createElement() => _DumbVisitorElement<T>(this, onFound);
}

class _DumbVisitorElement<T> extends StatelessElement {
  _DumbVisitorElement(super.widget, this.onFound);

  final void Function(T object) onFound;
  Element? oldElement;

  @override
  Element? updateChild(Element? child, Widget? newWidget, Object? newSlot) {
    final element = super.updateChild(child, newWidget, newSlot);
    if (oldElement != element) {
      oldElement = element;
      element?.visitChildren(_visitor);
    }
    return element;
  }

  void _visitor(Element child) {
    if (child is StatefulElement && child.state is T) {
      onFound(child.state as T);
    } else if (child.renderObject is T) {
      onFound(child.renderObject as T);
    }
    child.visitChildren(_visitor);
  }
}