R6.12, R6.13: the LOK worker has no Dock icon; Show turns slides

R6.12: on macOS the worker sets LibreOffice's own NSApplication to the
accessory policy before the kit starts, so it never shows in the Dock.

R6.13: when the whole slide fits, the wheel and Up/Down (nothing
selected, no text editing) turn slides in the ElyShow editor.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

apps/ely-show/src/deck.rs

@@ -95,7 +95,11 @@ impl Host for Deck {
             && !tab.extra.fitted
         {
             tab.extra.fitted = true;
-            view.update(cx, |view, cx| view.fit_page(cx));
+            view.update(cx, |view, cx| {
+                view.fit_page(cx);
+                view.turn_parts();
+            });
+            cx.subscribe(view, move |deck, view, turn: &ely_lok::Turn, cx| deck.turn(id, &view, turn.0, cx)).detach();
         }
         // Pictures follow the kernel's light or dark scheme.
         let dark = view.read(cx).dark();
@@ -263,7 +267,12 @@ impl Deck {
                     Ok(((slides, at), (design, objects, notes, remarks, (motion, media)), size, history)) => {
                         tab.extra.read_at = Some(at);
                         log::info!("show: tab {id} has {} parts", slides.list.len());
-                        view.update(cx, |view, _| view.set_part(slides.current));
+                        // A queued turn outranks a read made before it.
+                        view.update(cx, |view, _| {
+                            if view.settled() {
+                                view.set_part(slides.current)
+                            }
+                        });
                         let names: HashSet<&String> =
                             slides.list.iter().map(|slide| &slide.name).collect();
                         tab.extra.keep_pictures(&names);

apps/ely-show/src/slides.rs

@@ -9,10 +9,11 @@ use ely_gpui_component::{
 };
 use ely_office::prelude::*;
 use gpui::{
-    Action, App, Context, Div, InteractiveElement as _, IntoElement, Menu, MenuItem,
+    Action, App, Context, Div, Entity, InteractiveElement as _, IntoElement, Menu, MenuItem,
     ParentElement as _, Render, RenderImage, Role, StatefulInteractiveElement as _, Styled as _,
     WeakEntity, Window, actions, div, img, prelude::FluentBuilder as _, px,
 };
+use ely_lok::LokView;
 use image::{Frame, ImageBuffer, Rgba};
 
 use crate::deck::Deck;
@@ -98,6 +99,19 @@ impl Deck {
         self.run_active(id, &[], cx);
     }
 
+    /// Shows the slide `step` away, as the strip would.
+    pub(crate) fn turn(&mut self, id: u64, view: &Entity<LokView>, step: i32, cx: &mut Context<Self>) {
+        let Some(count) = self.tab(id).map(|tab| tab.extra.slides.list.len()).filter(|count| *count > 0) else {
+            return;
+        };
+        // From the part asked last, so quick turns add up.
+        let shown = view.read(cx).part();
+        let part = (shown as i64 + i64::from(step)).clamp(0, count as i64 - 1) as usize;
+        if part != shown {
+            view.update(cx, |view, _| view.show_part(part));
+        }
+    }
+
     /// Paints the next missing or stale slide picture.
     pub fn paint_next(&mut self, id: u64, cx: &mut Context<Self>) {
         let Some(tab) = self.tab(id) else {

apps/ely-show/src/tests.rs

@@ -19,6 +19,7 @@ mod play_time;
 mod review;
 mod slides;
 mod strip;
+mod turn;
 
 /// An unrendered Deck over a fresh worker, if LOK exists.
 pub(super) fn deck(cx: &mut TestAppContext, dir: &Path) -> Option<Entity<Deck>> {

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

@@ -0,0 +1,62 @@
+use ely_lok::LokView;
+use ely_office::prelude::*;
+use gpui::{Entity, ScrollDelta, ScrollWheelEvent, TestAppContext, VisualTestContext, point};
+
+use super::objects::blank;
+use super::{counts, quiet, settle, update};
+use crate::deck::Deck;
+
+/// The slide canvas alone in a window.
+struct Host(Entity<LokView>);
+
+impl gpui::Render for Host {
+    fn render(&mut self, _: &mut gpui::Window, _: &mut gpui::Context<Self>) -> impl gpui::IntoElement {
+        use gpui::{ParentElement as _, Styled as _};
+        gpui::div().size_full().child(self.0.clone())
+    }
+}
+
+/// The current slide once every turn landed.
+fn current(shown: &mut VisualTestContext, deck: &Entity<Deck>) -> usize {
+    quiet(shown, deck);
+    shown.update(|_, app| deck.read(app).active_tab().map(|tab| tab.extra.slides.current).expect("a tab"))
+}
+
+fn wheel(shown: &mut VisualTestContext, lines: f32) {
+    let middle = shown.update(|window, _| window.viewport_size()).center();
+    let delta = ScrollDelta::Lines(point(0.0, lines));
+    shown.simulate_event(ScrollWheelEvent { position: middle.into(), delta, ..Default::default() });
+}
+
+#[test]
+fn the_wheel_and_up_down_turn_slides() {
+    let dir = tempfile::tempdir().expect("a temp dir");
+    let mut cx = TestAppContext::single();
+    let Some(deck) = blank(&mut cx, dir.path()) else {
+        return eprintln!("SKIP: no LOK build");
+    };
+    for n in 2..=3 {
+        update(&mut cx, &deck, |deck, cx| deck.object_command("slide.insert", &[], cx));
+        settle(&cx, |app| counts(app, &deck).0 == n);
+    }
+    let view = cx.update(|app| deck.read(app).active_tab().expect("a tab").view.clone());
+    cx.update(|app| view.update(app, |view, _| view.show_part(0)));
+    let window = cx.add_window(|_, _| Host(view.clone()));
+    let mut shown = VisualTestContext::from_window(window.into(), &cx);
+    shown.run_until_parked();
+    assert_eq!(current(&mut shown, &deck), 0);
+    wheel(&mut shown, -1.0);
+    assert_eq!(current(&mut shown, &deck), 1, "the wheel turns down");
+    shown.update(|window, app| {
+        let focus = view.read(app).focus_handle().clone();
+        window.focus(&focus, app)
+    });
+    shown.simulate_keystrokes("down");
+    assert_eq!(current(&mut shown, &deck), 2, "Down turns");
+    shown.simulate_keystrokes("down");
+    assert_eq!(current(&mut shown, &deck), 2, "the last slide stays");
+    shown.simulate_keystrokes("up");
+    assert_eq!(current(&mut shown, &deck), 1, "Up turns back");
+    wheel(&mut shown, 1.0);
+    assert_eq!(current(&mut shown, &deck), 0, "the wheel turns up");
+}