paint method

@override String paint()

Implementation

@override
String paint() {
  if (children.isEmpty) return '';
  final span = TuiTrace.begin(
    'RenderColumn.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.height.toInt();
  final maxCross = size.width.toInt();
  final childHeights = children
      .map((c) => c.size.height.toInt())
      .toList(growable: false);
  final childWidths = children
      .map((c) => c.size.width.toInt())
      .toList(growable: false);

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

  if (totalFlex > 0) {
    var nonFlexHeight = 0;
    for (var i = 0; i < adjusted.length; i++) {
      if (flexData[i].flex <= 0) nonFlexHeight += adjustedHeights[i];
    }
    final gapTotal = gap * (adjusted.length - 1);
    final available = math.max(0, maxMain - nonFlexHeight - 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 currentHeight = adjustedHeights[i];
      if (currentHeight > target) {
        block = Layout.truncateHeight(block, target);
      }
      adjusted[i] = Layout.place(
        width: childWidths[i],
        height: target,
        horizontal: HorizontalAlign.left,
        vertical: VerticalAlign.top,
        content: block,
      );
      adjustedHeights[i] = target;
    }
  }

  final aligned = <String>[];
  final hAlign = switch (crossAxisAlignment) {
    RenderCrossAxisAlignment.start => HorizontalAlign.left,
    RenderCrossAxisAlignment.center => HorizontalAlign.center,
    RenderCrossAxisAlignment.end => HorizontalAlign.right,
    RenderCrossAxisAlignment.stretch => HorizontalAlign.left,
  };

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

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

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