paint method Null safety

  1. @override
void paint(
  1. PaintingContext context,
  2. Offset offset
)
override

Paint this render object into the given context at the given offset.

Subclasses should override this method to provide a visual appearance for themselves. The render object's local coordinate system is axis-aligned with the coordinate system of the context's canvas and the render object's local origin (i.e, x=0 and y=0) is placed at the given offset in the context's canvas.

Do not call this function directly. If you wish to paint yourself, call markNeedsPaint instead to schedule a call to this function. If you wish to paint one of your children, call PaintingContext.paintChild on the given context.

When painting one of your children (via a paint child function on the given context), the current canvas held by the context might change because draw operations before and after painting children might need to be recorded on separate compositing layers.

Implementation

@override
void paint(PaintingContext context, Offset offset) {
  // Ideally we could compute the min/max intrinsic width/height with a
  // non-destructive operation. However, currently, computing these values
  // will destroy state inside the painter. If that happens, we need to get
  // back the correct state by calling _layout again.
  //
  // TODO(abarth): Make computing the min/max intrinsic width/height a
  //  non-destructive operation.
  //
  // If you remove this call, make sure that changing the textAlign still
  // works properly.
  _layoutTextWithConstraints(constraints);

  assert(() {
    if (debugRepaintTextRainbowEnabled) {
      final Paint paint = Paint()
        ..color = debugCurrentRepaintColor.toColor();
      context.canvas.drawRect(offset & size, paint);
    }
    return true;
  }());

  if (_needsClipping) {
    final Rect bounds = offset & size;
    if (_overflowShader != null) {
      // This layer limits what the shader below blends with to be just the
      // text (as opposed to the text and its background).
      context.canvas.saveLayer(bounds, Paint());
    } else {
      context.canvas.save();
    }
    context.canvas.clipRect(bounds);
  }
  _textPainter.paint(context.canvas, offset);

  RenderBox? child = firstChild;
  int childIndex = 0;
  // childIndex might be out of index of placeholder boxes. This can happen
  // if engine truncates children due to ellipsis. Sadly, we would not know
  // it until we finish layout, and RenderObject is in immutable state at
  // this point.
  while (child != null && childIndex < _textPainter.inlinePlaceholderBoxes!.length) {
    final TextParentData textParentData = child.parentData! as TextParentData;

    final double scale = textParentData.scale!;
    context.pushTransform(
      needsCompositing,
      offset + textParentData.offset,
      Matrix4.diagonal3Values(scale, scale, scale),
      (PaintingContext context, Offset offset) {
        context.paintChild(
          child!,
          offset,
        );
      },
    );
    child = childAfter(child);
    childIndex += 1;
  }
  if (_needsClipping) {
    if (_overflowShader != null) {
      context.canvas.translate(offset.dx, offset.dy);
      final Paint paint = Paint()
        ..blendMode = BlendMode.modulate
        ..shader = _overflowShader;
      context.canvas.drawRect(Offset.zero & size, paint);
    }
    context.canvas.restore();
  }
  if (_lastSelectableFragments != null) {
    for (final _SelectableFragment fragment in _lastSelectableFragments!) {
      fragment.paint(context, offset);
    }
  }
  super.paint(context, offset);
}