Remove references to meta node

Author: wilgaboury

examples/src/main/java/org/jsignal/examples/todo/TodoApp.java

@@ -112,7 +112,7 @@ protected Element render() {
               .build(),
             Nodes.forEach(todos, (content, idx) -> {
               var enterAnim = IntervalAnimation.builder()
-                .function(TimingFunction::easeOutQuad)
+                .function(TimingFunction::easeOutBack)
                 .start(true)
                 .build();
 

rx/src/main/java/org/jsignal/rx/RxUtil.java

@@ -10,7 +10,16 @@
 import java.util.function.*;
 
 public class RxUtil {
-  private RxUtil() {
+  private RxUtil() {}
+
+  public static <T> Supplier<T> memo(Supplier<T> supplier) {
+    Ref<T> result = new Ref<>();
+    return () -> {
+      if (result.get() == null) {
+        result.accept(supplier.get());
+      }
+      return result.get();
+    };
   }
 
   public static <T> Supplier<T> createMemo(Supplier<T> supplier) {
@@ -164,7 +173,10 @@ public static void run(Runnable runnable) {
     runnable.run();
   }
 
-  public static <T, U> Computed<List<U>> createMapped(Supplier<? extends List<T>> list, BiFunction<T, Supplier<Integer>, U> map) {
+  public static <T, U> Computed<List<U>> createMapped(
+    Supplier<? extends List<T>> list,
+    BiFunction<T, Supplier<Integer>, U> map
+  ) {
     List<U> result = new ArrayList<>();
     Flipper<Map<T, Mapped<U>>> mapping = new Flipper<>(HashMap::new);
 
@@ -213,7 +225,10 @@ public static <T, U> Computed<List<U>> createMapped(Supplier<? extends List<T>>
 
   private record Mapped<U>(U value, Signal<Integer> idx, Cleanups cleanups) {}
 
-  public static <T, U> Computed<List<U>> createIndexed(Supplier<? extends List<T>> list, BiFunction<Supplier<T>, Integer, U> map) {
+  public static <T, U> Computed<List<U>> createIndexed(
+    Supplier<? extends List<T>> list,
+    BiFunction<Supplier<T>, Integer, U> map
+  ) {
     List<Indexed<T>> indexes = new ArrayList<>();
     List<U> result = new ArrayList<>();
 

std/src/main/java/org/jsignal/std/IntervalAnimation.java

@@ -78,6 +78,10 @@ public void stop() {
     }
   }
 
+  public State getState() {
+    return state.get();
+  }
+
   public Float get() {
     return function.get().apply(Math.min(1f, progress.get()), begin.get(), end.get());
   }

std/src/main/java/org/jsignal/std/SequenceAnimation.java

@@ -1,25 +1,47 @@
 package org.jsignal.std;
 
+import org.jsignal.rx.Effect;
+import org.jsignal.rx.Signal;
+
 import java.util.List;
+import java.util.function.Supplier;
 
-public class SequenceAnimation {
+public class SequenceAnimation implements Supplier<Float> {
   private final List<IntervalAnimation> sequence;
-  private int cur;
+  private Signal<Integer> currentIndex;
+  private Effect effect; // strong reference
 
   public SequenceAnimation(List<IntervalAnimation> sequence) {
+    assert !sequence.isEmpty();
+
     this.sequence = sequence;
-    this.cur = 0;
+    this.currentIndex = Signal.create(1);
+    effect = Effect.create(() -> {
+      if (getCurrent().getState() == IntervalAnimation.State.FINISHED) {
+        currentIndex.transform(idx -> idx + 1);
+      }
+    });
   }
 
   public SequenceAnimation(IntervalAnimation... sequence) {
     this(List.of(sequence));
   }
 
-  public void start() {
+  public IntervalAnimation getCurrent() {
+    var index = currentIndex.get();
+    return index < sequence.size() ? sequence.get(index) : sequence.getLast();
+  }
 
+  public void start() {
+    getCurrent().start();
   }
 
   public void stop() {
+    getCurrent().stop();
+  }
 
+  @Override
+  public Float get() {
+    return getCurrent().get();
   }
 }

ui/src/main/java/org/jsignal/ui/Node.java

@@ -206,7 +206,7 @@ void paint(Canvas canvas) {
     try {
       transformEffect.run(() -> canvas.concat(getTransform()));
 
-      paintCacheStrategy.paint(canvas, this::paintCacheUseMetaNode, cacheCanvas -> {
+      paintCacheStrategy.paint(canvas, this::paintCacheUseNode, cacheCanvas -> {
         if (paint != null) {
           paintEffect.run(() -> paint.paint(cacheCanvas, layoutResult));
         }
@@ -224,7 +224,11 @@ void paint(Canvas canvas) {
     }
   }
 
-  private <T> T paintCacheUseMetaNode(Function<Node, T> use) {
+  /**
+   * This is necessary for tracking cache dependencies on node layout, but because paint cache generation happens
+   * conditionally, the paint function cannot simply be wrapped in a side effect. It must be passed in as a callback.
+   */
+  private <T> T paintCacheUseNode(Function<Node, T> use) {
     return paintCacheEffect.run(() -> use.apply(Node.this));
   }
 

ui/src/main/java/org/jsignal/ui/UiWindow.java

@@ -127,7 +127,10 @@ public void requestFrame() {
 
     shouldPaint = true;
 //    logger.info("frame requested", new Throwable());
-    window.requestFrame();
+    UiThread.invokeLater(() -> {
+      logger.info("frame requested");
+      window.requestFrame();
+    });
   }
 
   public void requestTransformUpdate() {
@@ -170,7 +173,7 @@ void handleEvent(io.github.humbleui.jwm.Event event) {
         root.setOffScreen(canvas);
         paintSurfaceContext.with(e.getSurface()).provide(() -> root.paint(canvas));
         shouldPaint = false;
-//        logger.info("frame painted");
+        logger.info("frame painted");
 
         calculateDeltaFrame();
 

ui/src/main/java/org/jsignal/ui/paint/MultiUpgradingPaintCacheStrategy.java

@@ -0,0 +1,67 @@
+package org.jsignal.ui.paint;
+
+import io.github.humbleui.skija.Canvas;
+import org.jsignal.rx.RxUtil;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+// TODO: test that this works
+public class MultiUpgradingPaintCacheStrategy implements PaintCacheStrategy {
+  private final List<Level> upgrades;
+  private int index = 0;
+  private int nonDirtyPaintCount = 0;
+
+  public MultiUpgradingPaintCacheStrategy(Map<Integer, Supplier<PaintCacheStrategy>> upgrades) {
+    this.upgrades = Stream.concat(
+        Stream.of(new Level(0, RxUtil.memo(NullPaintCacheStrategy::new))),
+        upgrades.entrySet().stream()
+          .filter(e -> e.getKey() < 1)
+          .map(e -> new Level(e.getKey(), RxUtil.memo(e.getValue())))
+      )
+      .sorted(Comparator.comparing(Level::nonDirtyPaints))
+      .toList();
+  }
+
+  @Override
+  public boolean isDirty() {
+    return upgrades.get(index).strategy().get().isDirty();
+  }
+
+  @Override
+  public void markDirty() {
+    upgrades.get(index).strategy().get().isDirty();
+  }
+
+  @Override
+  public void paint(Canvas canvas, UseNode useNode, Consumer<Canvas> orElse) {
+    if (!isDirty()) {
+      nonDirtyPaintCount++;
+    } else {
+      if (index > 0 && nonDirtyPaintCount > 0) {
+        UseNode.clear(useNode);
+        if (!isDirty()) {
+          markDirty();
+        }
+        index = 0;
+      }
+      nonDirtyPaintCount = 0;
+    }
+
+    if (index < upgrades.size() - 1 && nonDirtyPaintCount > upgrades.get(index + 1).nonDirtyPaints()) {
+      UseNode.clear(useNode);
+      if (!isDirty()) {
+        markDirty();
+      }
+      index++;
+    }
+
+    upgrades.get(index).strategy().get().paint(canvas, useNode, orElse);
+  }
+
+  private record Level(int nonDirtyPaints, Supplier<PaintCacheStrategy> strategy) {}
+}

ui/src/main/java/org/jsignal/ui/paint/SurfacePaintCacheStrategy.java

@@ -24,10 +24,12 @@ public void markDirty() {
   @Override
   public void paint(Canvas canvas, UseNode useNode, Consumer<Canvas> orElse) {
     if (image == null) {
-      try (Surface surface = useNode.use(meta -> {
-        var size = meta.getLayout().getSize();
-        return UiWindow.paintSurfaceContext.use().makeSurface((int) size.getX(), (int) size.getY());
-      })) {
+      try (
+        Surface surface = useNode.use(node -> {
+          var size = node.getLayout().getSize();
+          return UiWindow.paintSurfaceContext.use().makeSurface((int) size.getX(), (int) size.getY());
+        })
+      ) {
         orElse.accept(surface.getCanvas());
         image = surface.makeImageSnapshot();
       }