render method

@override void render(Canvas canvas, Graph graph, Paint paint)

Implementation

@override
void render(Canvas canvas, Graph graph, Paint paint) {
  var trianglePaint = Paint()
    ..color = paint.color
    ..style = PaintingStyle.fill;

  graph.edges.forEach((edge) {
    final source = edge.source;

    var x = source.x;
    var y = source.y;

    var destination = edge.destination;

    var x1 = destination.x;
    var y1 = destination.y;
    path.reset();

    var clippedLine = <double>[];

    Paint? edgeTrianglePaint;
    if (edge.paint != null) {
      edgeTrianglePaint = Paint()
        ..color = edge.paint?.color ?? paint.color
        ..style = PaintingStyle.fill;
    }

    var currentPaint = edge.paint ?? paint
      ..style = PaintingStyle.stroke;

    if (edgeData.containsKey(edge) && edgeData[edge]!.bendPoints.isNotEmpty) {
      // draw bend points
      var bendPoints = edgeData[edge]!.bendPoints;
      final size = bendPoints.length;

      if (nodeData[source]!.isReversed) {
        clippedLine = clipLine(bendPoints[2], bendPoints[3], bendPoints[0], bendPoints[1], destination);
      } else {
        clippedLine = clipLine(
            bendPoints[size - 4], bendPoints[size - 3], bendPoints[size - 2], bendPoints[size - 1], destination);
      }

      final triangleCentroid = drawTriangle(
          canvas, edgeTrianglePaint ?? trianglePaint, clippedLine[0], clippedLine[1], clippedLine[2], clippedLine[3]);

      path.reset();
      path.moveTo(bendPoints[0], bendPoints[1]);

      final bendPointsWithoutDuplication = <Offset>[];

      for (var i = 0; i < bendPoints.length; i += 2) {
        final isLastPoint = i == bendPoints.length - 2;

        final x = bendPoints[i];
        final y = bendPoints[i + 1];
        final x2 = isLastPoint ? -1 : bendPoints[i + 2];
        final y2 = isLastPoint ? -1 : bendPoints[i + 3];
        if (x == x2 && y == y2) {
          // Skip when two consecutive points are identical
          // because drawing a line between would be redundant in this case.
          continue;
        }
        bendPointsWithoutDuplication.add(Offset(x, y));
      }

      if (bendPointShape is MaxCurvedBendPointShape) {
        _drawMaxCurvedBendPointsEdge(bendPointsWithoutDuplication);
      } else if (bendPointShape is CurvedBendPointShape) {
        final shape = bendPointShape as CurvedBendPointShape;
        _drawCurvedBendPointsEdge(bendPointsWithoutDuplication, shape.curveLength);
      } else {
        _drawSharpBendPointsEdge(bendPointsWithoutDuplication);
      }

      path.lineTo(triangleCentroid[0], triangleCentroid[1]);
      canvas.drawPath(path, currentPaint);
    } else {
      final startX = x + source.width / 2;
      final startY = y + source.height / 2;
      final stopX = x1 + destination.width / 2;
      final stopY = y1 + destination.height / 2;

      clippedLine = clipLine(startX, startY, stopX, stopY, destination);

      final triangleCentroid = drawTriangle(
          canvas, edgeTrianglePaint ?? trianglePaint, clippedLine[0], clippedLine[1], clippedLine[2], clippedLine[3]);

      canvas.drawLine(
          Offset(clippedLine[0], clippedLine[1]), Offset(triangleCentroid[0], triangleCentroid[1]), currentPaint);
    }
  });
}