BadNote/lib/editor/canvas/ink_painters.dart

// lib/editor/canvas/ink_painters.dart
//
// CustomPainters for the ink layers. Strokes are stored in normalized page
// coordinates; both painters receive the on-screen page [Size] and scale
// points into pixels at paint time. perfect_freehand produces the outline.

import 'package:flutter/material.dart';
import 'package:perfect_freehand/perfect_freehand.dart' as pf;

import '../engine/stroke_geometry.dart' show kDefaultPenThinning;
import 'pen_stroke.dart';

/// Builds a filled outline [Path] for one stroke (already scaled to pixels).
///
/// [pageSize] maps normalized coords to pixels. [isComplete] should be false
/// for the in-progress live stroke so freehand tapers correctly. [thinning] is
/// the pressure→width response (shared default [kDefaultPenThinning]); the
/// SAME value drives the export path so screen and PDF never diverge.
Path buildStrokePath(
  PenStroke stroke,
  Size pageSize, {
  required bool isComplete,
  double thinning = kDefaultPenThinning,
}) {
  final pixelWidth = stroke.width * pageSize.width;

  final hasRealPressure = stroke.points.any((p) => p.pressure != null);
  final isHighlighter = stroke.kind == PenStrokeKind.highlighter;

  final pfPoints = stroke.points
      .map(
        (p) => pf.PointVector(
          p.x * pageSize.width,
          p.y * pageSize.height,
          p.pressure ?? 0.5,
        ),
      )
      .toList();

  final outline = pf.getStroke(
    pfPoints,
    options: pf.StrokeOptions(
      size: pixelWidth,
      // Highlighter keeps a constant width (no thinning); pen uses the
      // configurable [thinning] so real Surface-Pen pressure changes width.
      thinning: isHighlighter ? 0.0 : thinning,
      smoothing: 0.5,
      streamline: 0.5,
      // Real stylus pressure → don't simulate; no pressure → let freehand fake
      // it based on velocity. (perfect_freehand 2.x honors REAL pressure when
      // simulatePressure is false — 1.0.4 ignored it, which made width
      // unresponsive to pen force.)
      simulatePressure: !hasRealPressure && !isHighlighter,
      isComplete: isComplete,
    ),
  );

  final path = Path();
  if (outline.isEmpty) return path;
  path.moveTo(outline.first.dx, outline.first.dy);
  for (var i = 1; i < outline.length; i++) {
    path.lineTo(outline[i].dx, outline[i].dy);
  }
  path.close();
  return path;
}

/// Paints all committed strokes for the page. Repaints only when the stroke
/// list identity or page size changes (kept behind a RepaintBoundary).
class StaticInkPainter extends CustomPainter {
  StaticInkPainter({
    required this.strokes,
    required this.pageSize,
    this.thinning = kDefaultPenThinning,
  });

  final List<PenStroke> strokes;
  final Size pageSize;

  /// Pressure→width response shared with the live/export paths.
  final double thinning;

  @override
  void paint(Canvas canvas, Size size) {
    for (final stroke in strokes) {
      final path =
          buildStrokePath(stroke, pageSize, isComplete: true, thinning: thinning);
      if (path.getBounds().isEmpty) continue;
      canvas.drawPath(
        path,
        Paint()
          ..color = Color(stroke.color)
          ..style = PaintingStyle.fill
          ..isAntiAlias = true,
      );
    }
  }

  @override
  bool shouldRepaint(StaticInkPainter old) =>
      !identical(old.strokes, strokes) ||
      old.strokes.length != strokes.length ||
      old.pageSize != pageSize ||
      old.thinning != thinning;
}

/// Paints just the in-progress stroke (the live layer), kept behind its own
/// RepaintBoundary so committed strokes don't repaint on every move.
class LiveInkPainter extends CustomPainter {
  LiveInkPainter({
    required this.stroke,
    required this.pageSize,
    this.thinning = kDefaultPenThinning,
  });

  /// Current in-progress stroke, or null when nothing is being drawn.
  final PenStroke? stroke;
  final Size pageSize;

  /// Pressure→width response shared with the static/export paths.
  final double thinning;

  @override
  void paint(Canvas canvas, Size size) {
    final s = stroke;
    if (s == null || s.points.isEmpty) return;
    final path =
        buildStrokePath(s, pageSize, isComplete: false, thinning: thinning);
    if (path.getBounds().isEmpty) return;
    canvas.drawPath(
      path,
      Paint()
        ..color = Color(s.color)
        ..style = PaintingStyle.fill
        ..isAntiAlias = true,
    );
  }

  @override
  bool shouldRepaint(LiveInkPainter old) =>
      !identical(old.stroke, stroke) ||
      old.pageSize != pageSize ||
      old.thinning != thinning;
}