flet-charts 0.85.0.dev2__tar.gz → 0.85.0.dev4__tar.gz

{flet_charts-0.85.0.dev2/src/flet_charts.egg-info → flet_charts-0.85.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flet-charts
-Version: 0.85.0.dev2
+Version: 0.85.0.dev4
 Summary: Interactive chart controls for Flet apps.
 Author-email: Flet contributors <hello@flet.dev>
 License-Expression: Apache-2.0
@@ -11,7 +11,7 @@ Project-URL: Issues, https://github.com/flet-dev/flet/issues
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: flet==0.85.0.dev2
+Requires-Dist: flet==0.85.0.dev4
 Dynamic: license-file
 
 # flet-charts

{flet_charts-0.85.0.dev2 → flet_charts-0.85.0.dev4}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "flet-charts"
-version = "0.85.0.dev2"
+version = "0.85.0.dev4"
 description = "Interactive chart controls for Flet apps."
 readme = "README.md"
 authors = [{ name = "Flet contributors", email = "hello@flet.dev" }]
 license = "Apache-2.0"
 requires-python = ">=3.10"
 dependencies = [
-    "flet==0.85.0.dev2",
+    "flet==0.85.0.dev4",
 ]
 
 [project.urls]

{flet_charts-0.85.0.dev2 → flet_charts-0.85.0.dev4}/src/flet_charts/__init__.py

@@ -33,6 +33,10 @@ from flet_charts.matplotlib_chart import (
     MatplotlibChartMessageEvent,
     MatplotlibChartToolbarButtonsUpdateEvent,
 )
+from flet_charts.matplotlib_chart_canvas import (
+    MatplotlibChartCanvas,
+    MatplotlibChartCanvasResizeEvent,
+)
 from flet_charts.matplotlib_chart_with_toolbar import MatplotlibChartWithToolbar
 from flet_charts.pie_chart import PieChart, PieChartEvent
 from flet_charts.pie_chart_section import PieChartSection
@@ -95,6 +99,8 @@ __all__ = [
     "LineChartEventSpot",
     "LineChartTooltip",
     "MatplotlibChart",
+    "MatplotlibChartCanvas",
+    "MatplotlibChartCanvasResizeEvent",
     "MatplotlibChartMessageEvent",
     "MatplotlibChartToolbarButtonsUpdateEvent",
     "MatplotlibChartWithToolbar",

{flet_charts-0.85.0.dev2 → flet_charts-0.85.0.dev4}/src/flet_charts/line_chart.py

@@ -59,6 +59,10 @@ class LineChartEvent(ft.Event["LineChart"]):
     spots: list[LineChartEventSpot]
     """
     Spots on which the event occurred.
+
+    Note:
+        This list is empty when the event does not target a concrete point, for
+        example when the pointer hovers over or taps empty chart space.
     """
 
 

{flet_charts-0.85.0.dev2 → flet_charts-0.85.0.dev4}/src/flet_charts/matplotlib_chart.py

@@ -5,7 +5,10 @@ from io import BytesIO
 from typing import Any, Optional
 
 import flet as ft
-import flet.canvas as fc
+from flet_charts.matplotlib_chart_canvas import (
+    MatplotlibChartCanvas,
+    MatplotlibChartCanvasResizeEvent,
+)
 
 _MATPLOTLIB_IMPORT_ERROR: Optional[ImportError] = None
 
@@ -124,13 +127,21 @@ class MatplotlibChart(ft.GestureDetector):
         logger.debug(f"DPR: {self.__dpr}")
         self.__image_mode = "full"
 
-        self.canvas = fc.Canvas(
-            # resize_interval=10,
+        self.mpl_canvas = MatplotlibChartCanvas(
             on_resize=self._on_canvas_resize,
             expand=True,
         )
+        # Rubberband (zoom selection) overlay drawn on top of the chart image.
+        self._rubberband = ft.Container(
+            visible=False,
+            border=ft.Border.all(1, ft.Colors.with_opacity(0.6, ft.Colors.GREY)),
+        )
+        self._stack = ft.Stack(
+            controls=[self.mpl_canvas, self._rubberband],
+            expand=True,
+        )
         self.keyboard_listener = ft.KeyboardListener(
-            self.canvas,
+            self._stack,
             autofocus=True,
             on_key_down=self._on_key_down,
             on_key_up=self._on_key_up,
@@ -419,23 +430,18 @@ class MatplotlibChart(ft.GestureDetector):
 
         while True:
             is_binary, content = await self._receive_queue.get()
+
             if is_binary:
+                assert isinstance(content, (bytes, bytearray))
                 logger.debug(f"receive_binary({len(content)})")
+                # Hand the frame to the client widget — full PNG replaces the
+                # backbuffer, diff PNG composites onto it. Awaiting naturally
+                # rate-limits this loop to the client's processing speed and
+                # yields the asyncio loop for incoming events.
                 if self.__image_mode == "full":
-                    await self.canvas.clear_capture()
-
-                self.canvas.shapes = [
-                    fc.Image(
-                        src=content,
-                        x=0,
-                        y=0,
-                        width=self.figure.bbox.size[0] / self.__dpr,
-                        height=self.figure.bbox.size[1] / self.__dpr,
-                    )
-                ]
-                ft.context.disable_auto_update()
-                self.canvas.update()
-                await self.canvas.capture()
+                    await self.mpl_canvas.apply_full(bytes(content))
+                else:
+                    await self.mpl_canvas.apply_diff(bytes(content))
                 self.img_count += 1
                 self._waiting = False
             else:
@@ -449,8 +455,6 @@ class MatplotlibChart(ft.GestureDetector):
                     self._waiting = True
                     self.send_message({"type": "draw"})
                 elif content["type"] == "rubberband":
-                    if len(self.canvas.shapes) == 2:
-                        self.canvas.shapes.pop()
                     if (
                         content["x0"] != -1
                         and content["y0"] != -1
@@ -461,18 +465,14 @@ class MatplotlibChart(ft.GestureDetector):
                         y0 = self._height - content["y0"] / self.__dpr
                         x1 = content["x1"] / self.__dpr
                         y1 = self._height - content["y1"] / self.__dpr
-                        self.canvas.shapes.append(
-                            fc.Rect(
-                                x=x0,
-                                y=y0,
-                                width=x1 - x0,
-                                height=y1 - y0,
-                                paint=ft.Paint(
-                                    stroke_width=1, style=ft.PaintingStyle.STROKE
-                                ),
-                            )
-                        )
-                    self.canvas.update()
+                        self._rubberband.left = min(x0, x1)
+                        self._rubberband.top = min(y0, y1)
+                        self._rubberband.width = abs(x1 - x0)
+                        self._rubberband.height = abs(y1 - y0)
+                        self._rubberband.visible = True
+                    else:
+                        self._rubberband.visible = False
+                    self._rubberband.update()
                 elif content["type"] == "resize":
                     self.send_message({"type": "refresh"})
                 elif content["type"] == "message":
@@ -508,7 +508,7 @@ class MatplotlibChart(ft.GestureDetector):
             lambda: self._receive_queue.put_nowait((True, blob))
         )
 
-    async def _on_canvas_resize(self, e: fc.CanvasResizeEvent):
+    async def _on_canvas_resize(self, e: MatplotlibChartCanvasResizeEvent):
         """
         Handle canvas resize and initialize backend session on first resize.
 

flet_charts-0.85.0.dev4/src/flet_charts/matplotlib_chart_canvas.py

@@ -0,0 +1,72 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+import flet as ft
+
+__all__ = ["MatplotlibChartCanvas", "MatplotlibChartCanvasResizeEvent"]
+
+
+@dataclass
+class MatplotlibChartCanvasResizeEvent(ft.Event["MatplotlibChartCanvas"]):
+    """
+    Event emitted when the canvas reports a new rendered size.
+    """
+
+    width: float = field(metadata={"data_field": "w"})
+    """New width of the canvas in logical pixels."""
+
+    height: float = field(metadata={"data_field": "h"})
+    """New height of the canvas in logical pixels."""
+
+
+@ft.control("MatplotlibChartCanvas")
+class MatplotlibChartCanvas(ft.LayoutControl):
+    """
+    Display widget for matplotlib WebAgg-style image streams.
+
+    Receives full and incremental "diff" PNG frames and composites them in
+    CPU memory, holding at most one decoded image for display at a time.
+    Avoids the per-frame `Picture.toImage` allocations that the generic
+    `flet.canvas.Canvas` capture path uses, which on Flutter web
+    (CanvasKit/WASM) accumulate and aren't promptly reclaimed by the JS GC
+    during animation, causing browser memory growth.
+    """
+
+    resize_interval: ft.Number = 10
+    """
+    Sampling interval in milliseconds for `on_resize` event.
+    """
+
+    on_resize: Optional[ft.EventHandler[MatplotlibChartCanvasResizeEvent]] = None
+    """
+    Called when the size of this canvas has changed.
+    """
+
+    async def apply_full(self, image_bytes: bytes) -> None:
+        """
+        Replace the current displayed image with a full PNG frame.
+
+        Args:
+            image_bytes: PNG bytes of the complete frame.
+        """
+        await self._invoke_method("apply_full", arguments={"bytes": image_bytes})
+
+    async def apply_diff(self, image_bytes: bytes) -> None:
+        """
+        Composite an incremental "diff" PNG frame onto the current image.
+
+        Pixels with non-zero alpha replace the corresponding pixels in the
+        existing backbuffer; transparent pixels leave the backbuffer
+        unchanged. If no backbuffer exists yet, the diff is treated as a
+        full frame.
+
+        Args:
+            image_bytes: PNG bytes of the diff frame.
+        """
+        await self._invoke_method("apply_diff", arguments={"bytes": image_bytes})
+
+    async def clear(self) -> None:
+        """
+        Clear the displayed image and discard the backbuffer.
+        """
+        await self._invoke_method("clear")

{flet_charts-0.85.0.dev2 → flet_charts-0.85.0.dev4/src/flet_charts.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flet-charts
-Version: 0.85.0.dev2
+Version: 0.85.0.dev4
 Summary: Interactive chart controls for Flet apps.
 Author-email: Flet contributors <hello@flet.dev>
 License-Expression: Apache-2.0
@@ -11,7 +11,7 @@ Project-URL: Issues, https://github.com/flet-dev/flet/issues
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: flet==0.85.0.dev2
+Requires-Dist: flet==0.85.0.dev4
 Dynamic: license-file
 
 # flet-charts

{flet_charts-0.85.0.dev2 → flet_charts-0.85.0.dev4}/src/flet_charts.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ src/flet_charts/line_chart.py
 src/flet_charts/line_chart_data.py
 src/flet_charts/line_chart_data_point.py
 src/flet_charts/matplotlib_chart.py
+src/flet_charts/matplotlib_chart_canvas.py
 src/flet_charts/matplotlib_chart_with_toolbar.py
 src/flet_charts/pie_chart.py
 src/flet_charts/pie_chart_section.py
@@ -34,6 +35,7 @@ src/flutter/flet_charts/lib/src/bar_chart.dart
 src/flutter/flet_charts/lib/src/candlestick_chart.dart
 src/flutter/flet_charts/lib/src/extension.dart
 src/flutter/flet_charts/lib/src/line_chart.dart
+src/flutter/flet_charts/lib/src/matplotlib_chart_canvas.dart
 src/flutter/flet_charts/lib/src/pie_chart.dart
 src/flutter/flet_charts/lib/src/radar_chart.dart
 src/flutter/flet_charts/lib/src/scatter_chart.dart

flet_charts-0.85.0.dev4/src/flet_charts.egg-info/requires.txt

@@ -0,0 +1 @@
+flet==0.85.0.dev4

{flet_charts-0.85.0.dev2 → flet_charts-0.85.0.dev4}/src/flutter/flet_charts/lib/src/extension.dart

@@ -4,6 +4,7 @@ import 'package:flutter/material.dart';
 import 'bar_chart.dart';
 import 'candlestick_chart.dart';
 import 'line_chart.dart';
+import 'matplotlib_chart_canvas.dart';
 import 'radar_chart.dart';
 import 'pie_chart.dart';
 import 'scatter_chart.dart';
@@ -18,6 +19,8 @@ class Extension extends FletExtension {
         return CandlestickChartControl(key: key, control: control);
       case "LineChart":
         return LineChartControl(key: key, control: control);
+      case "MatplotlibChartCanvas":
+        return MatplotlibChartCanvasControl(key: key, control: control);
       case "RadarChart":
         return RadarChartControl(key: key, control: control);
       case "PieChart":

flet_charts-0.85.0.dev4/src/flutter/flet_charts/lib/src/matplotlib_chart_canvas.dart

@@ -0,0 +1,457 @@
+import 'dart:async';
+import 'dart:typed_data';
+import 'dart:ui' as ui;
+
+import 'package:flet/flet.dart';
+import 'package:flutter/foundation.dart' show kIsWeb;
+import 'package:flutter/material.dart';
+
+/// Display widget for matplotlib WebAgg-style image streams.
+///
+/// Two rendering strategies, picked at runtime by platform:
+///
+/// - **GPU + flatten** (native): keeps an `_backdrop` plus a list of pending
+///   diff `ui.Image`s, paints all of them per frame, and bakes them into a
+///   fresh backdrop via `Picture.toImage` every [_GpuMatplotlibChartCanvasState._flattenInterval]
+///   diffs. Fast (no GPU↔CPU readback) and memory-stable on native runtimes
+///   where Dart GC is aggressive enough to reclaim layer-held SkImage refs.
+///
+/// - **CPU composite** (web): decodes each PNG to RGBA bytes, composites
+///   onto a single backbuffer in Dart, and uploads ONE fresh `ui.Image` per
+///   frame. Slower per frame, but holds at most one `ui.Image` at a time so
+///   layer-ref accumulation stays bounded under Flutter web (CanvasKit/WASM)
+///   where Dart GC doesn't promptly reclaim native SkImage refs.
+class MatplotlibChartCanvasControl extends StatefulWidget {
+  final Control control;
+
+  MatplotlibChartCanvasControl({Key? key, required this.control})
+      : super(key: key ?? ValueKey("control_${control.id}"));
+
+  @override
+  // ignore: no_logic_in_create_state
+  State<MatplotlibChartCanvasControl> createState() => kIsWeb
+      ? _CpuMatplotlibChartCanvasState()
+      : _GpuMatplotlibChartCanvasState();
+}
+
+// ---------------------------------------------------------------------------
+// Shared helpers
+// ---------------------------------------------------------------------------
+
+Uint8List _extractBytes(dynamic args) {
+  final v = args is Map ? args["bytes"] : args;
+  if (v is Uint8List) return v;
+  if (v is ByteData) {
+    return v.buffer.asUint8List(v.offsetInBytes, v.lengthInBytes);
+  }
+  if (v is List<int>) return Uint8List.fromList(v);
+  if (v is List && v.every((e) => e is int)) {
+    return Uint8List.fromList(v.cast<int>());
+  }
+  throw ArgumentError("Expected bytes for image data, got ${v.runtimeType}");
+}
+
+abstract class _MatplotlibChartCanvasStateBase
+    extends State<MatplotlibChartCanvasControl> {
+  // Serialize concurrent apply_full / apply_diff calls so backdrop mutations
+  // happen in arrival order.
+  Future<void>? _applyChain;
+
+  Size _lastSize = Size.zero;
+  int _lastResize = DateTime.now().millisecondsSinceEpoch;
+
+  @override
+  void initState() {
+    super.initState();
+    widget.control.addInvokeMethodListener(_invokeMethod);
+  }
+
+  @override
+  void dispose() {
+    widget.control.removeInvokeMethodListener(_invokeMethod);
+    disposeResources();
+    super.dispose();
+  }
+
+  /// Subclass hook — release any held `ui.Image`s / backbuffers.
+  void disposeResources();
+
+  Future<void> applyFull(Uint8List bytes);
+  Future<void> applyDiff(Uint8List bytes);
+  Future<void> clearAll();
+  CustomPainter buildPainter();
+
+  Future<dynamic> _invokeMethod(String name, dynamic args) async {
+    switch (name) {
+      case "apply_full":
+        await _enqueue(() => applyFull(_extractBytes(args)));
+        return;
+      case "apply_diff":
+        await _enqueue(() => applyDiff(_extractBytes(args)));
+        return;
+      case "clear":
+        await _enqueue(clearAll);
+        return;
+      default:
+        throw Exception("Unknown MatplotlibChartCanvas method: $name");
+    }
+  }
+
+  Future<void> _enqueue(Future<void> Function() task) {
+    final prev = _applyChain ?? Future.value();
+    final next = prev.then((_) => task());
+    _applyChain = next.catchError((_) {});
+    return next;
+  }
+
+  void _maybeReportResize(Size size) {
+    final resizeInterval = widget.control.getInt("resize_interval", 10)!;
+    final now = DateTime.now().millisecondsSinceEpoch;
+    if ((now - _lastResize > resizeInterval && _lastSize != size) ||
+        _lastSize.isEmpty) {
+      _lastSize = size;
+      _lastResize = now;
+      widget.control
+          .triggerEvent("resize", {"w": size.width, "h": size.height});
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return LayoutBuilder(
+      builder: (context, constraints) {
+        WidgetsBinding.instance.addPostFrameCallback((_) {
+          if (!mounted) return;
+          _maybeReportResize(constraints.biggest);
+        });
+        return CustomPaint(
+          size: constraints.biggest,
+          painter: buildPainter(),
+        );
+      },
+    );
+  }
+}
+
+/// Decodes PNG bytes to a [ui.Image], staying GPU-resident.
+Future<ui.Image?> _decodeImage(Uint8List bytes) async {
+  if (bytes.isEmpty) {
+    debugPrint("MatplotlibChartCanvas: skipping empty image bytes");
+    return null;
+  }
+  // Defensive copy; Safari's WASM runtime can free underlying buffers across
+  // async boundaries and trigger "EncodingError: Loading error.".
+  final owned = Uint8List.fromList(bytes);
+  ui.Codec? codec;
+  try {
+    codec = await ui.instantiateImageCodec(owned, allowUpscaling: false);
+    final frame = await codec.getNextFrame();
+    return frame.image;
+  } catch (e) {
+    debugPrint(
+        "MatplotlibChartCanvas: decode failed (${owned.length} bytes): $e");
+    rethrow;
+  } finally {
+    codec?.dispose();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// GPU + flatten strategy (native runtimes)
+// ---------------------------------------------------------------------------
+
+class _GpuMatplotlibChartCanvasState
+    extends _MatplotlibChartCanvasStateBase {
+  // Number of diffs to accumulate before flattening into a fresh backdrop.
+  // Larger = fewer Picture.toImage calls; smaller = lower transient memory.
+  static const int _flattenInterval = 10;
+
+  ui.Image? _backdrop;
+  final List<ui.Image> _diffs = [];
+
+  @override
+  void disposeResources() {
+    _backdrop?.dispose();
+    _backdrop = null;
+    for (final img in _diffs) {
+      img.dispose();
+    }
+    _diffs.clear();
+  }
+
+  @override
+  Future<void> applyFull(Uint8List bytes) async {
+    final image = await _decodeImage(bytes);
+    if (image == null) return;
+    _replaceBackdrop(image);
+    _disposeDiffs();
+    if (mounted) setState(() {});
+  }
+
+  @override
+  Future<void> applyDiff(Uint8List bytes) async {
+    if (_backdrop == null) {
+      // No baseline yet — first frame must be a full.
+      await applyFull(bytes);
+      return;
+    }
+    final image = await _decodeImage(bytes);
+    if (image == null) return;
+    _diffs.add(image);
+    if (_diffs.length >= _flattenInterval) {
+      await _flatten();
+    }
+    if (mounted) setState(() {});
+  }
+
+  @override
+  Future<void> clearAll() async {
+    _replaceBackdrop(null);
+    _disposeDiffs();
+    if (mounted) setState(() {});
+  }
+
+  /// Bakes [_backdrop] + pending [_diffs] into a single new backdrop via
+  /// `Picture.toImage`, replaces [_backdrop], and drops the diffs.
+  Future<void> _flatten() async {
+    final backdrop = _backdrop;
+    if (backdrop == null || _diffs.isEmpty) return;
+
+    final w = backdrop.width;
+    final h = backdrop.height;
+
+    final recorder = ui.PictureRecorder();
+    final canvas = Canvas(recorder);
+    final paint = Paint();
+    canvas.drawImage(backdrop, Offset.zero, paint);
+    for (final diff in _diffs) {
+      canvas.drawImage(diff, Offset.zero, paint);
+    }
+
+    final picture = recorder.endRecording();
+    final ui.Image newBackdrop;
+    try {
+      newBackdrop = await picture.toImage(w, h);
+    } finally {
+      picture.dispose();
+    }
+
+    _replaceBackdrop(newBackdrop);
+    _disposeDiffs();
+  }
+
+  void _replaceBackdrop(ui.Image? image) {
+    final old = _backdrop;
+    _backdrop = image;
+    if (old != null) {
+      WidgetsBinding.instance.addPostFrameCallback((_) {
+        old.dispose();
+      });
+    }
+  }
+
+  void _disposeDiffs() {
+    if (_diffs.isEmpty) return;
+    final old = List<ui.Image>.of(_diffs);
+    _diffs.clear();
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      for (final img in old) {
+        img.dispose();
+      }
+    });
+  }
+
+  @override
+  CustomPainter buildPainter() => _GpuMatplotlibImagePainter(
+        backdrop: _backdrop,
+        diffs: List<ui.Image>.unmodifiable(_diffs),
+      );
+}
+
+class _GpuMatplotlibImagePainter extends CustomPainter {
+  final ui.Image? backdrop;
+  final List<ui.Image> diffs;
+
+  const _GpuMatplotlibImagePainter({
+    required this.backdrop,
+    required this.diffs,
+  });
+
+  @override
+  void paint(Canvas canvas, Size size) {
+    final bg = backdrop;
+    if (bg == null) return;
+    final dst = Rect.fromLTWH(0, 0, size.width, size.height);
+    final paint = Paint();
+    final bgSrc =
+        Rect.fromLTWH(0, 0, bg.width.toDouble(), bg.height.toDouble());
+    canvas.drawImageRect(bg, bgSrc, dst, paint);
+    for (final diff in diffs) {
+      final src =
+          Rect.fromLTWH(0, 0, diff.width.toDouble(), diff.height.toDouble());
+      canvas.drawImageRect(diff, src, dst, paint);
+    }
+  }
+
+  @override
+  bool shouldRepaint(_GpuMatplotlibImagePainter old) {
+    return backdrop != old.backdrop || diffs.length != old.diffs.length;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// CPU composite strategy (web — CanvasKit/WASM)
+// ---------------------------------------------------------------------------
+
+class _CpuMatplotlibChartCanvasState
+    extends _MatplotlibChartCanvasStateBase {
+  ui.Image? _displayImage;
+  Uint8List? _backbuffer;
+  int _bbWidth = 0;
+  int _bbHeight = 0;
+
+  @override
+  void disposeResources() {
+    _displayImage?.dispose();
+    _displayImage = null;
+    _backbuffer = null;
+  }
+
+  @override
+  Future<void> applyFull(Uint8List bytes) async {
+    final decoded = await _decodeRgba(bytes);
+    if (decoded == null) return;
+
+    _backbuffer = decoded.bytes;
+    _bbWidth = decoded.width;
+    _bbHeight = decoded.height;
+
+    final image = await _makeImage(decoded.bytes, decoded.width, decoded.height);
+    _swapDisplay(image);
+  }
+
+  @override
+  Future<void> applyDiff(Uint8List bytes) async {
+    if (_backbuffer == null) {
+      // No baseline yet — treat as full.
+      await applyFull(bytes);
+      return;
+    }
+
+    final decoded = await _decodeRgba(bytes);
+    if (decoded == null) return;
+
+    // Promote to a full replace if the frame size changed.
+    if (decoded.width != _bbWidth ||
+        decoded.height != _bbHeight ||
+        decoded.bytes.length != _backbuffer!.length) {
+      _backbuffer = decoded.bytes;
+      _bbWidth = decoded.width;
+      _bbHeight = decoded.height;
+      final image =
+          await _makeImage(decoded.bytes, decoded.width, decoded.height);
+      _swapDisplay(image);
+      return;
+    }
+
+    // Composite: matplotlib's diff PNG has alpha=0 for unchanged pixels.
+    // Where alpha != 0, copy the new pixel into the backbuffer.
+    final bb = _backbuffer!.buffer.asUint32List();
+    final df = decoded.bytes.buffer.asUint32List();
+    for (int i = 0; i < df.length; i++) {
+      // RGBA8888 on little-endian: alpha is the highest byte (0xFF000000).
+      if ((df[i] & 0xFF000000) != 0) {
+        bb[i] = df[i];
+      }
+    }
+
+    final image = await _makeImage(_backbuffer!, _bbWidth, _bbHeight);
+    _swapDisplay(image);
+  }
+
+  @override
+  Future<void> clearAll() async {
+    final old = _displayImage;
+    _displayImage = null;
+    _backbuffer = null;
+    _bbWidth = 0;
+    _bbHeight = 0;
+    if (old != null) {
+      WidgetsBinding.instance.addPostFrameCallback((_) {
+        old.dispose();
+      });
+    }
+    if (mounted) setState(() {});
+  }
+
+  Future<_DecodedRgba?> _decodeRgba(Uint8List bytes) async {
+    final img = await _decodeImage(bytes);
+    if (img == null) return null;
+    try {
+      final byteData =
+          await img.toByteData(format: ui.ImageByteFormat.rawRgba);
+      if (byteData == null) return null;
+      return _DecodedRgba(
+        bytes: byteData.buffer.asUint8List(),
+        width: img.width,
+        height: img.height,
+      );
+    } finally {
+      img.dispose();
+    }
+  }
+
+  Future<ui.Image> _makeImage(Uint8List rgba, int width, int height) {
+    final completer = Completer<ui.Image>();
+    ui.decodeImageFromPixels(
+      rgba,
+      width,
+      height,
+      ui.PixelFormat.rgba8888,
+      completer.complete,
+    );
+    return completer.future;
+  }
+
+  void _swapDisplay(ui.Image newImage) {
+    final old = _displayImage;
+    _displayImage = newImage;
+    if (mounted) setState(() {});
+    if (old != null) {
+      WidgetsBinding.instance.addPostFrameCallback((_) {
+        old.dispose();
+      });
+    }
+  }
+
+  @override
+  CustomPainter buildPainter() =>
+      _CpuMatplotlibImagePainter(image: _displayImage);
+}
+
+class _DecodedRgba {
+  final Uint8List bytes;
+  final int width;
+  final int height;
+  _DecodedRgba(
+      {required this.bytes, required this.width, required this.height});
+}
+
+class _CpuMatplotlibImagePainter extends CustomPainter {
+  final ui.Image? image;
+
+  const _CpuMatplotlibImagePainter({required this.image});
+
+  @override
+  void paint(Canvas canvas, Size size) {
+    final img = image;
+    if (img == null) return;
+    final src =
+        Rect.fromLTWH(0, 0, img.width.toDouble(), img.height.toDouble());
+    final dst = Rect.fromLTWH(0, 0, size.width, size.height);
+    canvas.drawImageRect(img, src, dst, Paint());
+  }
+
+  @override
+  bool shouldRepaint(_CpuMatplotlibImagePainter old) => old.image != image;
+}

{flet_charts-0.85.0.dev2 → flet_charts-0.85.0.dev4}/src/flutter/flet_charts/lib/src/utils/line_chart.dart

@@ -25,7 +25,7 @@ class LineChartEventData extends Equatable {
 
   Map<String, dynamic> toMap() => <String, dynamic>{
         'type': eventType,
-        'spots': barSpots,
+        'spots': barSpots.map((spot) => spot.toMap()).toList(),
       };
 
   @override

flet_charts-0.85.0.dev2/src/flet_charts.egg-info/requires.txt

@@ -1 +0,0 @@
-flet==0.85.0.dev2