ElyShow: a slide size the kernel did not take stops showing (S-09)

apps/ely-show/src/deck.rs

@@ -220,6 +220,7 @@ impl Deck {
         }
         (tab.extra.reading, tab.extra.read) = (true, Some(seen));
         let landed = tab.extra.transition_landed(view.read(cx));
+        let sized = tab.extra.size_landed(view.read(cx));
         let doc = tab.doc.clone();
         ely_lok::read_off(
             &self.core.worker,
@@ -296,12 +297,6 @@ impl Deck {
                         {
                             tab.extra.stale = tab.extra.thumbs.keys().cloned().collect();
                         }
-                        let read = crate::design::mm100(size);
-                        if tab.extra.size_asked.is_some_and(|(w, h)| {
-                            (w - read.0).abs() <= 50 && (h - read.1).abs() <= 50
-                        }) {
-                            tab.extra.size_asked = None;
-                        }
                         (tab.extra.slides, tab.extra.design) = (slides, Some(design));
                         tab.extra.objects = Some(objects);
                         (tab.extra.notes, tab.extra.remarks) = (Some(notes), remarks);
@@ -309,6 +304,7 @@ impl Deck {
                         tab.extra.settle_transition(landed);
                         tab.extra.reads += 1;
                         tab.extra.size = size;
+                        tab.extra.settle_size(sized);
                         tab.extra.failed.clear();
                         deck.paint_next(id, cx);
                         deck.read_fonts(id, cx);

apps/ely-show/src/design.rs

@@ -59,9 +59,18 @@ impl Deck {
             log::info!("show: the slides already measure {w} x {h}");
             return;
         }
-        tab.extra.size_asked = Some((w, h));
-        let (w, h) = (w.to_string(), h.to_string());
-        self.design_command("slide.size", &[&w, &h, "true"], cx);
+        let (id, view) = (tab.id, tab.view.clone());
+        let before = view.read(cx).sent();
+        tab.extra.size_asked = Some(((w, h), before + 1));
+        let (sw, sh) = (w.to_string(), h.to_string());
+        self.run_in(Some(id), "slide.size", &[&sw, &sh, "true"], cx);
+        // Refused before sending: run_in said so already.
+        if view.read(cx).sent() == before
+            && let Some(tab) = self.tab_mut(id)
+        {
+            tab.extra.size_asked = None;
+        }
+        self.force_reread(id, cx);
     }
 
     /// Enters or leaves the master view.

apps/ely-show/src/extra.rs

@@ -37,8 +37,8 @@ pub struct Extra {
     pub size: (i64, i64),
     /// Undo and redo lists at the last read.
     pub history: Option<(Vec<Step>, Vec<Step>)>,
-    /// A size sent, in 1/100 mm, until read back.
-    pub size_asked: Option<(i64, i64)>,
+    /// A size sent (1/100 mm) and its input, until read.
+    pub size_asked: Option<((i64, i64), u64)>,
     /// A transition sent for a slide, until read back.
     pub transition_asked: Option<(String, ely_lok::show::Transition, u64)>,
     /// Pictures by slide name; stale ones show until repainted.
@@ -60,6 +60,22 @@ impl Extra {
     /// The size to show, in 1/100 mm: asked, else read.
     pub fn shown_size(&self) -> (i64, i64) {
         self.size_asked
-            .unwrap_or_else(|| crate::design::mm100(self.size))
+            .map_or_else(|| crate::design::mm100(self.size), |(size, _)| size)
+    }
+
+    /// The size input that landed before this read began.
+    pub fn size_landed(&self, view: &ely_lok::LokView) -> Option<u64> {
+        let (_, seq) = self.size_asked?;
+        view.reached(seq).then_some(seq)
+    }
+
+    /// Forgets the asked size once read back, taken or refused.
+    pub fn settle_size(&mut self, landed: Option<u64>) {
+        let read = crate::design::mm100(self.size);
+        if self.size_asked.is_some_and(|((w, h), seq)| {
+            landed == Some(seq) || (w - read.0).abs() <= 50 && (h - read.1).abs() <= 50
+        }) {
+            self.size_asked = None;
+        }
     }
 }

apps/ely-show/src/tests/slides.rs

@@ -417,3 +417,47 @@ fn a_check_row_does_not_jump_among_masters() {
     });
     assert!(cx.update(|app| deck.read(app).dialog.is_some()), "the check stays open");
 }
+
+#[test]
+fn a_refused_size_does_not_stay_shown() {
+    let dir = tempfile::tempdir().expect("a temp dir");
+    let mut cx = TestAppContext::single();
+    let Some(deck) = blank(&mut cx, dir.path()) else {
+        eprintln!("SKIP: no LOK build");
+        return;
+    };
+    let before = cx.update(|app| deck.read(app).active_tab().expect("a tab").extra.size);
+    update(&mut cx, &deck, |deck, cx| deck.resize((-500, -500), cx));
+    settle(&cx, |app| {
+        deck.read(app).active_tab().is_some_and(|tab| tab.extra.size_asked.is_none())
+    });
+    let extra = cx.update(|app| {
+        let tab = deck.read(app).active_tab().expect("a tab");
+        (tab.extra.size, tab.extra.shown_size())
+    });
+    assert_eq!(extra.0, before, "the kernel kept its size");
+    assert_eq!(extra.1, crate::design::mm100(before), "the fields show it");
+}
+
+#[test]
+fn a_size_the_kernel_does_not_take_clears_after_its_read() {
+    let dir = tempfile::tempdir().expect("a temp dir");
+    let mut cx = TestAppContext::single();
+    let Some(deck) = blank(&mut cx, dir.path()) else {
+        eprintln!("SKIP: no LOK build");
+        return;
+    };
+    update(&mut cx, &deck, |deck, cx| {
+        deck.resize((30_000, 19_050), cx);
+        // As if the kernel refused: it keeps another size.
+        let id = deck.core.active.expect("a tab");
+        let tab = deck.tab_mut(id).expect("a tab");
+        let (_, seq) = tab.extra.size_asked.expect("asked");
+        tab.extra.size_asked = Some(((40_000, 19_050), seq));
+    });
+    settle(&cx, |app| {
+        deck.read(app).active_tab().is_some_and(|tab| tab.extra.size_asked.is_none())
+    });
+    let read = cx.update(|app| crate::design::mm100(deck.read(app).active_tab().expect("a tab").extra.size));
+    assert!((read.0 - 30_000).abs() <= 50, "the kernel's own size shows: {read:?}");
+}