paint method

@override String paint()

Implementation

@override
String paint() {
  if (children.isEmpty) return '';
  final span = TuiTrace.begin(
    'RenderRow.paint',
    tag: TraceTag.paint,
    extra: 'children=${children.length}',
  );
  _pruneChildPaintCache();
  final blocks = children.map(_paintChild).toList(growable: false);
  final flexData = children.map(_flexDataFor).toList(growable: false);
  final maxMain = size.width.toInt();
  final maxCross = size.height.toInt();
  final childWidths = children
      .map((c) => c.size.width.toInt())
      .toList(growable: false);
  final childHeights = children
      .map((c) => c.size.height.toInt())
      .toList(growable: false);

  final totalFlex = flexData.fold<int>(0, (sum, f) => sum + f.flex);
  final adjusted = List<String>.of(blocks, growable: false);
  final adjustedWidths = List<int>.of(childWidths, growable: false);

  if (totalFlex > 0) {
    var nonFlexWidth = 0;
    for (var i = 0; i < adjusted.length; i++) {
      if (flexData[i].flex <= 0) nonFlexWidth += adjustedWidths[i];
    }
    final gapTotal = gap * (adjusted.length - 1);
    final available = math.max(0, maxMain - nonFlexWidth - gapTotal);

    for (var i = 0; i < adjusted.length; i++) {
      final data = flexData[i];
      if (data.flex <= 0 || data.fit == RenderFlexFit.loose) continue;

      final target = (available * data.flex) ~/ totalFlex;
      var block = adjusted[i];
      final currentWidth = adjustedWidths[i];
      if (currentWidth > target) {
        block = Layout.truncateLines(block, target, ellipsis: '');
      }
      adjusted[i] = Layout.place(
        width: target,
        height: childHeights[i],
        horizontal: HorizontalAlign.left,
        vertical: VerticalAlign.top,
        content: block,
      );
      adjustedWidths[i] = target;
    }
  }

  final aligned = <String>[];
  final vAlign = switch (crossAxisAlignment) {
    RenderCrossAxisAlignment.start => VerticalAlign.top,
    RenderCrossAxisAlignment.center => VerticalAlign.center,
    RenderCrossAxisAlignment.end => VerticalAlign.bottom,
    RenderCrossAxisAlignment.stretch => VerticalAlign.top,
  };

  for (var i = 0; i < adjusted.length; i++) {
    final block = adjusted[i];
    final childWidth = adjustedWidths[i];
    final childHeight = childHeights[i];
    if (vAlign == VerticalAlign.top && childHeight == maxCross) {
      aligned.add(block);
    } else {
      aligned.add(
        Layout.place(
          width: childWidth,
          height: maxCross,
          horizontal: HorizontalAlign.left,
          vertical: vAlign,
          content: block,
        ),
      );
    }
  }

  final totalMain =
      adjustedWidths.fold<int>(0, (sum, w) => sum + w) +
      gap * (children.length - 1);
  final extra = math.max(0, maxMain - totalMain);
  final spacing = _computeSpacing(
    children.length,
    gap,
    extra,
    mainAxisAlignment,
  );

  final result = Layout.place(
    width: maxMain,
    height: maxCross,
    horizontal: HorizontalAlign.left,
    vertical: VerticalAlign.top,
    content: _joinHorizontalWithSpacing(aligned, spacing),
  );
  span.end(extra: 'size=${size.width.toInt()}x${size.height.toInt()}');
  return result;
}