e4f86d11fe8a
thumbs.rs
//! The slide thumbnail pane (Normal view): numbered thumbnails grouped by section, selection,
//! drag-to-reorder, and the slide context menu.
use std::collections::HashSet;
use deckcraft_engine::Target;
use deckcraft_model::SlideId;
use egui::{Align2, Color32, CornerRadius, Rect, Role, Sense, Stroke, Ui, WidgetInfo, pos2, vec2};
use serde_json::json;
use crate::SlideApp;
use crate::theme::{self, Tokens};
/// A slide drag in the thumbnail pane or the Slide Sorter.
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct SlideDrag {
/// The presentation the drag started in; it is dropped, not applied, anywhere else.
pub uid: u64,
/// The dragged slides, in deck order.
pub ids: Vec<SlideId>,
/// The gap under the pointer: 0 is before the first slide, the slide count after the last.
pub slot: usize,
}
/// Starts dragging slide `i`: the whole slide selection when `i` is part of it, else `i` alone,
/// which then becomes the selection, as in PowerPoint.
pub(crate) fn start_slide_drag(app: &mut SlideApp, i: usize) {
let Some(st) = app.session.active() else { return };
let Some(id) = st.doc.slides.get(i).map(|s| s.id) else { return };
let selected: HashSet<SlideId> = st.selection.slides.iter().copied().collect();
let ids: Vec<SlideId> =
if selected.contains(&id) { st.doc.slides.iter().map(|s| s.id).filter(|x| selected.contains(x)).collect() } else { vec![id] };
let uid = st.uid;
if !selected.contains(&id) {
let _ = app.run("slide.go", json!({"index": i}));
}
app.thumb_drag = Some(SlideDrag { uid, ids, slot: i });
}
/// Whether a slide drag is under way in the active presentation. `button` is whether the
/// primary button is held or was released this frame. A drag begun in another presentation, or
/// one whose release this view never saw (the view changed under it), is discarded, so it never
/// moves slides on some later, unrelated release.
pub(crate) fn slide_drag_live(app: &mut SlideApp, button: bool) -> bool {
let uid = app.session.active().map(|st| st.uid);
if !button || app.thumb_drag.as_ref().is_some_and(|d| Some(d.uid) != uid) {
app.thumb_drag = None;
}
app.thumb_drag.is_some()
}
/// Whether the primary button is held or was released this frame: a slide drag is still alive.
pub(crate) fn drag_button(ui: &Ui) -> bool {
ui.input(|i| i.pointer.primary_down() || i.pointer.any_released())
}
/// `slide.move`'s `to` for slides at `moving` (ascending indices) dropped at gap `slot`: the gap
/// counted without them. `None` when the drop leaves the deck as it is.
pub(crate) fn slides_move_dest(moving: &[usize], slot: usize) -> Option<usize> {
let first = *moving.first()?;
let dest = slot.saturating_sub(moving.iter().filter(|&&i| i < slot).count());
let one_run = moving.iter().enumerate().all(|(k, &i)| first.checked_add(k) == Some(i));
if one_run && dest == first { None } else { Some(dest) }
}
/// Ends the slide drag: one `slide.move` (one undo step) for all the dragged slides, unless the
/// drop leaves them where they are, the drag began in another presentation, or one of them is gone.
pub(crate) fn drop_slide_drag(app: &mut SlideApp) {
let Some(drag) = app.thumb_drag.take() else { return };
let Some(st) = app.session.active().filter(|st| st.uid == drag.uid) else { return };
let dragged: HashSet<SlideId> = drag.ids.iter().copied().collect();
let moving: Vec<usize> = st.doc.slides.iter().enumerate().filter(|(_, s)| dragged.contains(&s.id)).map(|(i, _)| i).collect();
if moving.len() != dragged.len() {
return;
}
if let Some(to) = slides_move_dest(&moving, drag.slot) {
let ids: Vec<u32> = drag.ids.iter().map(|id| id.0).collect();
let _ = app.run("slide.move", json!({"ids": ids, "to": to}));
}
}
/// Render the slide thumbnail pane, including section headers, selection, and scroll state.
pub fn show(app: &mut SlideApp, ui: &mut Ui) {
let t = Tokens::get(ui.ctx());
let in_master = app.session.active().is_some_and(|d| d.selection.target != Target::Slides);
// Handout Master view has one page and no thumbnails, as in PowerPoint.
if app.session.active().is_some_and(|d| d.selection.target.is_page_master()) {
return;
}
let panel = egui::Panel::left("thumbs")
.resizable(true)
.default_size(app.ui.thumbs_width)
.size_range(150.0..=420.0)
.frame(egui::Frame::NONE.fill(t.chrome))
.show(ui, |ui| {
app.ui.thumbs_width = ui.available_width();
if in_master {
master_list(app, ui);
return;
}
let out = egui::ScrollArea::vertical().auto_shrink([false, false]).show(ui, |ui| {
ui.add_space(8.0);
list(app, ui);
ui.add_space(20.0);
});
// Where the pane is scrolled to, for the control channel and tests (#917).
app.ui.thumbs_scroll = out.state.clamped_offset().y;
});
// Focus follows the last press: inside the pane keeps it, anywhere else (canvas, ribbon) drops it.
if let Some(pos) = ui.input(|i| if i.pointer.primary_pressed() { i.pointer.interact_pos() } else { None }) {
app.slides_focused = panel.response.rect.contains(pos);
}
}
/// Slide index -> the first section starting there, built once instead of searched per slide.
fn section_starts(doc: &deckcraft_model::Presentation) -> std::collections::HashMap<usize, usize> {
let mut index_of = std::collections::HashMap::new();
for (i, s) in doc.slides.iter().enumerate() {
index_of.entry(s.id).or_insert(i);
}
let mut starts = std::collections::HashMap::new();
for (si, s) in doc.sections.iter().enumerate() {
if let Some(&i) = s.slides.first().and_then(|id| index_of.get(id)) {
starts.entry(i).or_insert(si);
}
}
starts
}
/// Render the scrollable thumbnail list, scrolling the current slide into view when it changes.
fn list(app: &mut SlideApp, ui: &mut Ui) {
let t = Tokens::get(ui.ctx());
let Some(st) = app.session.active() else { return };
let doc = st.doc.clone();
let cur = st.selection.slide;
let multi = st.selection.slides.clone();
let width = ui.available_width();
let tw = (width - 40.0).max(60.0);
let th = tw * (doc.slide_size.height / doc.slide_size.width.max(1.0)) as f32;
// Scroll the current slide into view when it changes, so arrow-key navigation follows
// along in the pane (#917). The scroll itself is minimal, only when the thumbnail leaves
// the view, as in PowerPoint, so the user's own scrolling stands; the first frame only
// records the slide.
let scroll_key = ui.scope_id().with("thumb_scrolled_to");
let slide_changed = ui.data_mut(|d| {
let last: Option<usize> = d.get_temp(scroll_key);
d.insert_temp(scroll_key, cur);
last.is_some_and(|last| last != cur)
});
let ppp = ui.ctx().pixels_per_point();
let mut budget = 3u32;
let mut rects = vec![];
let section_starts = section_starts(&doc);
let mut need_more = false;
for i in 0..doc.slides.len() {
if let Some(si) = section_starts.get(&i)
&& let Some(sec) = doc.sections.get(*si)
{
ui.add_space(4.0);
let (r, resp) = ui.allocate_exact_size(vec2(width, 22.0), Sense::click());
let p = ui.painter();
crate::widgets::chevron(p, pos2(r.min.x + 14.0, r.center().y), 3.0, t.text_dim);
p.text(
pos2(r.min.x + 24.0, r.center().y),
Align2::LEFT_CENTER,
format!("{} ({})", sec.name, sec.slides.len()),
theme::font(12.0),
t.text_dim,
);
resp.context_menu(|ui| {
if ui.button("Rename Section…").clicked() {
let mut d = crate::dialogs::Dialog::new("renameSection");
d.params = json!({"index": si, "name": sec.name});
app.dialog = Some(d);
ui.close();
}
if ui.button("Remove Section").clicked() {
let _ = app.run("section.remove", json!({"index": si}));
ui.close();
}
if ui.button("Remove Section & Slides").clicked() {
let _ = app.run("section.remove", json!({"index": si, "slides": true}));
ui.close();
}
if ui.button("Move Section Up").clicked() {
let _ = app.run("section.move", json!({"index": si, "to": si.saturating_sub(1)}));
ui.close();
}
if ui.button("Move Section Down").clicked() {
let _ = app.run("section.move", json!({"index": si, "to": si + 1}));
ui.close();
}
});
}
let (row, resp) = ui.allocate_exact_size(vec2(width, th + 16.0), Sense::click_and_drag());
let label = format!("Slide {}", i + 1);
resp.widget_info(|| WidgetInfo::labeled(Role::Button, true, &label));
let img = crate::textures::device_pixel_rect(Rect::from_min_size(pos2(row.min.x + 30.0, row.min.y + 6.0), vec2(tw, th)), ppp);
rects.push((i, row));
let p = ui.painter();
let id = doc.slides.get(i).map(|s| s.id);
let selected = i == cur || id.is_some_and(|id| multi.contains(&id));
let hidden = doc.slides.get(i).is_some_and(|s| s.hidden);
p.text(
pos2(row.min.x + 14.0, img.min.y + 2.0),
Align2::CENTER_TOP,
format!("{}", i + 1),
theme::font(12.0),
if selected { t.text } else { t.text_dim },
);
if hidden {
p.line_segment([pos2(row.min.x + 8.0, img.min.y + 18.0), pos2(row.min.x + 20.0, img.min.y + 6.0)], Stroke::new(1.0, t.text_dim));
}
let has_anim = doc.slides.get(i).is_some_and(|s| !s.animations.is_empty() || s.transition.as_ref().is_some_and(|tr| tr.kind != "none"));
if has_anim {
p.text(pos2(row.min.x + 14.0, img.min.y + 20.0), Align2::CENTER_TOP, "★", theme::font(10.0), t.text_faint);
}
let wpx = (img.width() * ppp).round() as u32;
// Only rows in view (plus a little margin) ask for a thumbnail: with every row asking, a
// deck bigger than the thumbnail cache evicts its own thumbnails and never settles (#969).
let near = ui.clip_rect().expand2(vec2(0.0, 2.0 * row.height())).intersects(row);
let tex = if near { app.textures.thumb(ui.ctx(), &doc, i, wpx, app.ui.grayscale, &mut budget) } else { None };
match tex {
Some(tex) => {
p.image(
tex.id(),
img,
Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)),
if hidden { Color32::from_white_alpha(140) } else { Color32::WHITE },
);
}
None => {
p.rect_filled(img, CornerRadius::ZERO, Color32::WHITE);
need_more |= near;
}
}
if selected {
p.rect_stroke(img.expand(2.0), CornerRadius::same(4), Stroke::new(3.0, t.accent), egui::StrokeKind::Outside);
} else {
p.rect_stroke(
img,
CornerRadius::ZERO,
Stroke::new(if resp.hovered() { 2.0 } else { 1.0 }, if resp.hovered() { t.text_faint } else { t.border }),
egui::StrokeKind::Outside,
);
}
if resp.clicked() {
let (shift, cmd) = ui.input(|i| (i.modifiers.shift, i.modifiers.command));
if let Some(id) = id {
if shift {
// Shift: the slides between the current one and this one. Ctrl+Shift keeps what is selected.
let _ = app.run("slide.selectRange", json!({"to": i, "add": cmd}));
} else if cmd {
let _ = app.run("slide.selectSlides", json!({"ids": [id.0], "add": true}));
} else {
let _ = app.run("slide.go", json!({"index": i}));
}
}
}
if resp.double_clicked() {
app.start_show(i, false);
}
if resp.drag_started() {
start_slide_drag(app, i);
}
resp.context_menu(|ui| slide_menu(app, ui, i));
}
if need_more {
ui.ctx().request_repaint();
}
// Scroll the current slide's thumbnail into view when the slide changes (#917).
if slide_changed && let Some((_, row_rect)) = rects.iter().find(|(i, _)| *i == cur) {
ui.scroll_to_rect(*row_rect, None);
}
// Drag reorder: insertion line.
if slide_drag_live(app, drag_button(ui)) {
if let Some(pp) = ui.input(|i| i.pointer.interact_pos()) {
let mut to = doc.slides.len();
for (i, r) in &rects {
if pp.y < r.center().y {
to = *i;
break;
}
}
if let Some(d) = app.thumb_drag.as_mut() {
d.slot = to;
}
let y = rects.iter().find(|(i, _)| *i == to).map(|(_, r)| r.min.y + 2.0).or_else(|| rects.last().map(|(_, r)| r.max.y)).unwrap_or(0.0);
ui.painter().line_segment([pos2(26.0, y), pos2(width, y)], Stroke::new(2.0, t.accent));
}
if ui.input(|i| i.pointer.any_released()) {
drop_slide_drag(app);
}
}
// Click on empty space below: new slide prompt.
let (r, resp) = ui.allocate_exact_size(vec2(width, 40.0), Sense::click());
if resp.hovered() {
ui.painter().text(r.center(), Align2::CENTER_CENTER, "+ New Slide", theme::font(12.0), t.text_faint);
}
if resp.clicked() {
let _ = app.run("slide.new", json!({}));
}
}
pub fn slide_menu(app: &mut SlideApp, ui: &mut Ui, i: usize) {
if app.session.active().is_some_and(|d| d.selection.slide != i && !d.selection.slides.iter().any(|id| d.doc.slide_index(*id) == Some(i))) {
let _ = app.run("slide.go", json!({"index": i}));
}
for (l, id, p) in [
("Cut", "edit.cut", json!({"scope": "slides"})),
("Copy", "edit.copy", json!({"scope": "slides"})),
("Paste", "edit.paste", json!({"scope": "slides"})),
] {
if ui.button(l).clicked() {
let _ = app.run(id, p);
ui.close();
}
}
ui.separator();
if ui.button("New Slide").clicked() {
let _ = app.run("slide.new", json!({}));
ui.close();
}
if ui.button("Duplicate Slide").clicked() {
let _ = app.run("slide.duplicate", json!({}));
ui.close();
}
if ui.button("Delete Slide").clicked() {
let _ = app.run("slide.delete", json!({}));
ui.close();
}
ui.separator();
if ui.button("Add Section").clicked() {
let _ = app.run("section.add", json!({"at": i}));
ui.close();
}
ui.menu_button("Layout", |ui| {
let layouts: Vec<(String, u32)> = app
.session
.active()
.and_then(|d| d.doc.masters.first().map(|m| m.layouts.iter().map(|l| (l.name.clone(), l.id.0)).collect()))
.unwrap_or_default();
for (n, id) in layouts {
if ui.button(n).clicked() {
let _ = app.run("slide.layout", json!({"layout": id}));
ui.close();
}
}
});
if ui.button("Reset Slide").clicked() {
let _ = app.run("slide.reset", json!({}));
ui.close();
}
if ui.button("Format Background…").clicked() {
let _ = app.run("view.pane", json!({"pane": "background"}));
ui.close();
}
let hidden = app.session.active().and_then(|d| d.doc.slides.get(i).map(|s| s.hidden)).unwrap_or(false);
if ui.button(if hidden { "Show Slide" } else { "Hide Slide" }).clicked() {
let _ = app.run("slide.hide", json!({"index": i}));
ui.close();
}
}
fn master_list(app: &mut SlideApp, ui: &mut Ui) {
let t = Tokens::get(ui.ctx());
let Some(st) = app.session.active() else { return };
let doc = st.doc.clone();
let target = st.selection.target;
egui::ScrollArea::vertical().auto_shrink([false, false]).show(ui, |ui| {
ui.add_space(8.0);
let width = ui.available_width();
for (mi, m) in doc.masters.iter().enumerate() {
let items: Vec<Option<usize>> = std::iter::once(None).chain((0..m.layouts.len()).map(Some)).collect();
for li in items {
let indent = if li.is_some() { 30.0 } else { 14.0 };
let tw = (width - indent - 14.0).max(40.0) * if li.is_some() { 0.8 } else { 1.0 };
let th = tw * (doc.slide_size.height / doc.slide_size.width.max(1.0)) as f32;
let (row, resp) = ui.allocate_exact_size(vec2(width, th + 12.0), Sense::click());
let ppp = ui.ctx().pixels_per_point();
let img = crate::textures::device_pixel_rect(Rect::from_min_size(pos2(row.min.x + indent, row.min.y + 4.0), vec2(tw, th)), ppp);
let wpx = ((img.width() * ppp).round() as u32).max(1);
let px = crate::textures::fit_size(
(wpx, (wpx as f64 * doc.slide_size.height / doc.slide_size.width.max(1.0)).clamp(1.0, 1e9) as u32),
crate::textures::max_side(ui.ctx()),
);
let pic = deckcraft_render::render_layout(
&doc,
mi,
li,
&deckcraft_render::RenderOpts {
scale: px.0 as f64 / doc.slide_size.width.max(1.0),
edit: true,
size: Some(px),
..Default::default()
},
);
let tex = crate::textures::upload_editor(ui.ctx(), format!("ml-{mi}-{li:?}"), crate::textures::to_color_image(&pic, false));
ui.painter().image(tex.id(), img, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
let selected = match (target, li) {
(Target::Master { master }, None) => master == mi,
(Target::Layout { master, layout }, Some(l)) => master == mi && layout == l,
_ => false,
};
ui.painter().rect_stroke(
img.expand(if selected { 2.0 } else { 0.0 }),
CornerRadius::same(2),
Stroke::new(if selected { 3.0 } else { 1.0 }, if selected { t.accent } else { t.border }),
egui::StrokeKind::Outside,
);
let name = match li {
Some(l) => m.layouts.get(l).map(|x| x.name.clone()).unwrap_or_default(),
None => format!("{} Slide Master", m.name),
};
let resp = resp.on_hover_text(name);
if resp.clicked() {
let p = match li {
Some(l) => json!({"master": mi, "layout": l}),
None => json!({"master": mi}),
};
let _ = app.run("view.slideMaster", p);
}
}
}
});
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used)]
use egui_kittest::Harness;
use egui_kittest::kittest::Queryable;
use super::*;
use crate::Services;
use deckcraft_engine::Session;
fn harness() -> Harness<'static, SlideApp> {
let mut h = Harness::builder().with_size(egui::vec2(1200.0, 800.0)).build_ui_state(
|ui, app: &mut SlideApp| {
app.logic(ui.ctx());
app.ui(ui);
},
SlideApp::new(Session::with_new(), Services::default()),
);
h.run_steps(3);
h
}
#[test]
fn section_starts_map_each_first_slide_to_its_first_section() {
let mut s = Session::with_new();
for _ in 0..3 {
s.execute("slide.new", &json!({})).unwrap();
}
let mut doc = (*s.active().unwrap().doc).clone();
let ids: Vec<_> = doc.slides.iter().map(|sl| sl.id).collect();
doc.sections = vec![
deckcraft_model::Section { name: "a".into(), slides: vec![ids[0], ids[1]] },
deckcraft_model::Section { name: "dup".into(), slides: vec![ids[0]] },
deckcraft_model::Section { name: "c".into(), slides: vec![ids[2]] },
deckcraft_model::Section { name: "empty".into(), slides: vec![] },
];
let starts = section_starts(&doc);
assert_eq!(starts.get(&0), Some(&0), "the first section starting at a slide wins");
assert_eq!(starts.get(&2), Some(&2));
assert_eq!(starts.len(), 2);
}
/// Vertical scroll offset of the thumbnail pane, as recorded each frame by `show`.
fn thumbs_scroll(h: &Harness<'_, SlideApp>) -> f32 {
h.state().ui.thumbs_scroll
}
/// #917: navigating to a slide below the fold scrolls the pane to reveal it; a neighbour
/// that is already on screen does not move the pane.
#[test]
fn navigating_slides_keeps_the_current_thumbnail_visible() {
let mut h = harness();
for _ in 0..30 {
h.state_mut().session.execute("slide.new", &json!({})).unwrap();
}
// slide.new selects each new slide; back to the first so the pane starts at the top.
h.state_mut().session.execute("slide.go", &json!({"index": 0})).unwrap();
h.run_steps(3);
let last = h.state().session.active().unwrap().doc.slides.len() - 1;
assert_eq!(thumbs_scroll(&h), 0.0, "the pane starts at the top");
// Jump to the last slide: the pane follows and reveals it.
h.state_mut().session.execute("slide.go", &json!({"index": last})).unwrap();
h.run_steps(120); // the scroll eases in over several frames
let jumped = thumbs_scroll(&h);
assert!(jumped > 100.0, "the pane scrolled to the last slide, offset {jumped}");
// One slide up was already on screen after that scroll: the pane holds still.
h.state_mut().session.execute("slide.go", &json!({"index": last - 1})).unwrap();
h.run_steps(120);
let held = thumbs_scroll(&h);
assert!((held - jumped).abs() < 1.0, "no re-scroll for a visible slide: {jumped} -> {held}");
}
/// A tall window, so every thumbnail of a small deck is on screen.
fn tall_harness(slides: usize) -> (Harness<'static, SlideApp>, Vec<u32>) {
let mut s = Session::with_new();
while s.doc().unwrap().doc.slides.len() < slides {
s.execute("slide.new", &json!({})).unwrap();
}
let mut h = Harness::builder().with_size(egui::vec2(1200.0, 1600.0)).with_step_dt(1.0 / 60.0).build_ui_state(
|ui, app: &mut SlideApp| {
app.logic(ui.ctx());
app.ui(ui);
},
SlideApp::new(s, Services::default()),
);
h.run_steps(3);
let ids = order(&h);
(h, ids)
}
fn order(h: &Harness<'_, SlideApp>) -> Vec<u32> {
h.state().session.active().unwrap().doc.slides.iter().map(|s| s.id.0).collect()
}
#[test]
fn slides_move_dest_counts_without_the_moved_slides() {
// One slide: the gaps on either side of it leave it where it is.
assert_eq!(slides_move_dest(&[1], 1), None);
assert_eq!(slides_move_dest(&[1], 2), None);
assert_eq!(slides_move_dest(&[1], 0), Some(0));
assert_eq!(slides_move_dest(&[1], 4), Some(3));
// A run: any gap inside or around it is a no-op.
for slot in 2..=5 {
assert_eq!(slides_move_dest(&[2, 3, 4], slot), None, "slot {slot}");
}
assert_eq!(slides_move_dest(&[2, 3, 4], 0), Some(0));
assert_eq!(slides_move_dest(&[2, 3, 4], 6), Some(3));
// Scattered slides always gather, even at a gap between them.
assert_eq!(slides_move_dest(&[0, 2], 1), Some(0));
assert_eq!(slides_move_dest(&[0, 2], 0), Some(0));
assert_eq!(slides_move_dest(&[1, 3], 5), Some(3));
assert_eq!(slides_move_dest(&[], 3), None);
assert_eq!(slides_move_dest(&[usize::MAX], usize::MAX), None);
}
#[test]
fn dragging_selected_thumbnails_moves_them_together() {
let (mut h, ids) = tall_harness(4);
h.state_mut().run("slide.selectSlides", json!({"ids": [ids[0], ids[2]]})).unwrap();
h.run_steps(2);
let (first, last) = (h.get_by_label("Slide 1").rect(), h.get_by_label("Slide 4").rect());
// Below the middle of the last thumbnail: the gap after it.
crate::sorter::ui_tests::drag(&mut h, first.center(), egui::pos2(last.center().x, last.bottom() - 4.0));
assert_eq!(order(&h), [ids[1], ids[3], ids[0], ids[2]]);
let sel: Vec<u32> = h.state().session.active().unwrap().selection.slides.iter().map(|s| s.0).collect();
assert_eq!(sel, [ids[0], ids[2]], "the moved slides stay selected");
h.state_mut().run("edit.undo", json!({})).unwrap();
assert_eq!(order(&h), ids, "one undo puts both back");
}
#[test]
fn dragging_an_unselected_thumbnail_moves_only_it() {
let (mut h, ids) = tall_harness(4);
h.state_mut().run("slide.selectSlides", json!({"ids": [ids[0], ids[2]]})).unwrap();
h.run_steps(2);
let (second, first) = (h.get_by_label("Slide 2").rect(), h.get_by_label("Slide 1").rect());
crate::sorter::ui_tests::drag(&mut h, second.center(), egui::pos2(first.center().x, first.top() + 4.0));
assert_eq!(order(&h), [ids[1], ids[0], ids[2], ids[3]]);
let sel: Vec<u32> = h.state().session.active().unwrap().selection.slides.iter().map(|s| s.0).collect();
assert_eq!(sel, [ids[1]]);
}
/// A drag whose release no view saw (a double-click in the Slide Sorter opens Normal view
/// mid-gesture) is dropped, not left to move slides on the next unrelated release.
#[test]
fn a_slide_drag_without_a_held_button_is_dropped() {
let (mut h, ids) = tall_harness(3);
let app = h.state_mut();
app.run("slide.selectSlides", json!({"ids": [ids[0], ids[1]]})).unwrap();
start_slide_drag(app, 0);
if let Some(d) = app.thumb_drag.as_mut() {
d.slot = 3;
}
h.run_steps(2);
assert!(h.state().thumb_drag.is_none(), "no button held: the drag is over");
let last = h.get_by_label("Slide 3").rect();
h.hover_at(last.center());
h.run_steps(1);
h.event(egui::Event::PointerButton {
pos: last.center(),
button: egui::PointerButton::Primary,
pressed: false,
modifiers: egui::Modifiers::NONE,
});
h.run_steps(2);
assert_eq!(order(&h), ids, "a later release moves nothing");
}
/// A drag begun in one presentation never moves slides in another (switching mid-drag).
#[test]
fn a_slide_drag_does_not_follow_into_another_presentation() {
let (mut h, ids) = tall_harness(3);
let app = h.state_mut();
app.run("slide.selectSlides", json!({"ids": [ids[0], ids[1]]})).unwrap();
start_slide_drag(app, 0);
let drag = app.thumb_drag.clone().unwrap();
assert_eq!(drag.ids.iter().map(|s| s.0).collect::<Vec<_>>(), [ids[0], ids[1]]);
app.thumb_drag = Some(SlideDrag { slot: 3, ..drag.clone() });
app.run("file.new", json!({})).unwrap();
while app.session.active().unwrap().doc.slides.len() < 3 {
app.run("slide.new", json!({})).unwrap();
}
let other = app.session.active().unwrap().doc.slides.iter().map(|s| s.id.0).collect::<Vec<_>>();
assert!(!slide_drag_live(app, true), "the drag belongs to the first presentation");
app.thumb_drag = Some(SlideDrag { slot: 3, ..drag });
drop_slide_drag(app);
assert!(app.thumb_drag.is_none());
assert_eq!(app.session.active().unwrap().doc.slides.iter().map(|s| s.id.0).collect::<Vec<_>>(), other);
app.session.set_active(0);
assert_eq!(order(&h), ids, "and the first presentation is untouched");
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.