227abf351e
Draw on slides while presenting, kept as a layer fully separate from the Marp content so the deck stays pure, portable Marp. Presenter tools (D pen, T highlighter, E eraser, X laser, C clear, Esc puts the tool away) with a small floating colour/tool bar shown only when a tool is active. Strokes use coordinates normalized to the 16:9 slide so they render identically on the laptop and the beamer; in dual-screen mode the ink and the laser are mirrored live to the audience window. Persistence (decoupled from the .md): - In memory the layer is keyed by Slide.id (stable within a session). - On disk it lives in a sidecar <name>.ink.json next to the deck and as a separate entry inside the .ocideck package; the markdown is untouched. - Because slide ids are regenerated on load, the sidecar anchors strokes by order + a content fingerprint, re-attaching them after reordering and dropping them when a slide's content changed. - Deck.annotations carries the layer in memory but is never serialized to markdown; deckProvider.setAnnotations keeps it out of undo/redo. flutter analyze is clean, all tests pass (incl. new stroke/codec tests), and the macOS debug build compiles. Drawing and live beamer sync still need verification on real hardware. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
72 lines
2.2 KiB
Dart
72 lines
2.2 KiB
Dart
import 'dart:ui';
|
|
|
|
/// Annotation tools available while presenting. Drawings live in a layer that
|
|
/// is fully separate from the Marp content — they are never written to the
|
|
/// markdown.
|
|
enum InkTool { laser, pen, highlighter, eraser }
|
|
|
|
/// A single freehand stroke on the annotation layer.
|
|
///
|
|
/// Coordinates are normalized (0..1) within the 16:9 slide rectangle and the
|
|
/// width is a fraction of the slide width, so a stroke renders identically on
|
|
/// the laptop preview and the beamer regardless of resolution or letterboxing.
|
|
class InkStroke {
|
|
final InkTool tool;
|
|
final int color; // ARGB
|
|
final double width; // fraction of the slide width
|
|
final List<Offset> points; // normalized 0..1
|
|
|
|
const InkStroke({
|
|
required this.tool,
|
|
required this.color,
|
|
required this.width,
|
|
required this.points,
|
|
});
|
|
|
|
InkStroke copyWith({List<Offset>? points}) => InkStroke(
|
|
tool: tool,
|
|
color: color,
|
|
width: width,
|
|
points: points ?? this.points,
|
|
);
|
|
|
|
/// Compact JSON: points are flattened to [x0, y0, x1, y1, …].
|
|
Map<String, dynamic> toJson() => {
|
|
'tool': tool.name,
|
|
'color': color,
|
|
'width': width,
|
|
'points': [
|
|
for (final p in points) ...[
|
|
_round(p.dx),
|
|
_round(p.dy),
|
|
],
|
|
],
|
|
};
|
|
|
|
static double _round(double v) => (v * 10000).roundToDouble() / 10000;
|
|
|
|
factory InkStroke.fromJson(Map<String, dynamic> json) {
|
|
final raw = (json['points'] as List?)?.cast<num>() ?? const [];
|
|
final pts = <Offset>[];
|
|
for (var i = 0; i + 1 < raw.length; i += 2) {
|
|
pts.add(Offset(raw[i].toDouble(), raw[i + 1].toDouble()));
|
|
}
|
|
return InkStroke(
|
|
tool: InkTool.values.firstWhere(
|
|
(t) => t.name == json['tool'],
|
|
orElse: () => InkTool.pen,
|
|
),
|
|
color: (json['color'] as num?)?.toInt() ?? 0xFFEF4444,
|
|
width: (json['width'] as num?)?.toDouble() ?? 0.004,
|
|
points: pts,
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Encode/decode a per-slide map of strokes keyed by slide id.
|
|
List<Map<String, dynamic>> encodeStrokes(List<InkStroke> strokes) =>
|
|
[for (final s in strokes) s.toJson()];
|
|
|
|
List<InkStroke> decodeStrokes(List<dynamic> raw) => [
|
|
for (final e in raw) InkStroke.fromJson(Map<String, dynamic>.from(e as Map)),
|
|
];
|