Import TXT and Markdown notes into presentation sidecars

This commit is contained in:
Dandaedre 2026-11-20 07:56:33 +01:00
parent 75bb3cb44b
commit 00d69dafed
15 changed files with 757 additions and 12 deletions

2
Cargo.lock generated
View File

@ -2221,7 +2221,7 @@ dependencies = [
[[package]]
name = "pdf-presenter"
version = "0.1.52"
version = "0.1.53"
dependencies = [
"bytemuck",
"chrono",

View File

@ -4,7 +4,7 @@ default-members = ["crates/pdf-presenter"]
resolver = "3"
[workspace.package]
version = "0.1.52"
version = "0.1.53"
edition = "2024"
license = "MIT"
repository = "https://proxy.dandaedre.com/gitea/idle-org/pdf-presenter"

View File

@ -49,8 +49,8 @@ are not yet available. Test your display setup before using it for a live event.
4. **Present.** Use arrows or Space to advance. Type a slide number and press Enter
to jump. All slides opens a thumbnail browser; B blanks or restores the output.
Opening a document shows the presentation by default. After changing displays,
use **Show presentation** to restore output. Hide the bars for more space; move the
Opening a document shows the presentation by default. Changing displays or fullscreen
preserves whether you have shown or blanked the output. Hide the bars for more space; move the
pointer near an edge or right-click to recover them.
Prepared slides are cached for reuse. The presenter shows loading progress, RAM use
@ -58,6 +58,44 @@ and an ETA when available; decks larger than the RAM budget use a rolling buffer
Notes can come from the PDF or picture-folder sidecars. Themes and English/French
controls are available in Menu.
## Import your notes
Open your presentation, then choose **Menu → Import notes…**, or drop a `.txt` or
`.md` file onto the presenter window. Review the import and choose **Import and save
notes**. This creates or updates `presentation.notes.toml` beside `presentation.pdf`
(or `Slides.notes.toml` beside a picture folder named `Slides`). Your original notes
file and slides stay untouched. Double-click the notes pane to edit a slide later.
**TXT:** separate slides with a line containing two or more hyphens:
```text
Welcome everyone.
-------
Explain the results.
-------
Thank the audience.
```
**Markdown:** start each slide with a top-level `#` title. Titles are separators;
only their body becomes the slide's notes:
```markdown
# Introduction
Welcome everyone.
# Results
Explain the results.
# Conclusion
Thank the audience.
```
Sections map to slides **in order, starting at slide 1**; titles do not select slide
numbers. Fewer sections preserve the remaining slides' notes; too many sections
reject the import without writing. Empty sections clear a slide's notes. TXT files
need no final separator (a final separator creates an empty section). Use UTF-8.
Markdown `##` subheadings and headings inside fenced code stay in the note;
nonblank text before the first `#` title is rejected. Notes display as plain text.
[Format details and limits →](docs/interfaces/presentation-notes.md#importing-txt-and-markdown)
[**Read the user guide →**](docs/user-guide.md)
---

View File

@ -39,6 +39,19 @@ pub fn tr<'a>(ctx: &egui::Context, text: &'a str) -> &'a str {
return text;
}
match text {
"Cancel" => "Annuler",
"Preview (first 3 slides)" => "Aperçu (3 premières diapositives)",
"Import notes…" => "Importer des notes…",
"Import notes" => "Importer des notes",
"Processing notes…" => "Traitement des notes…",
"Slides to update" => "Diapositives à modifier",
"Sections replace notes starting at slide 1. Remaining slides keep their notes." => {
"Les sections remplacent les notes à partir de la diapositive 1. Les suivantes conservent leurs notes."
}
"Update existing notes file" => "Mettre à jour le fichier de notes existant",
"Create notes file" => "Créer le fichier de notes",
"Empty note" => "Note vide",
"Import and save notes" => "Importer et enregistrer les notes",
"File chooser already open" => "Sélecteur de fichiers déjà ouvert",
"Page background" => "Fond de page",
"Fit padding color" => "Couleur des marges",

View File

@ -599,7 +599,7 @@ impl App {
}
// Notes editing must never turn typing or Escape into presentation commands.
// Unsaved text is only discarded through the explicit editor control.
if role == Role::Presenter && s.notes_editor.is_some() {
if role == Role::Presenter && (s.notes_editor.is_some() || s.notes_import.is_some()) {
return;
}
if modifiers.ctrl || modifiers.alt || modifiers.command || consumed {
@ -671,7 +671,7 @@ impl App {
repaint |= !actions.is_empty();
for action in actions {
#[cfg(target_os = "windows")]
if matches!(action, Action::Pick(_)) && !s.dialog_busy {
if matches!(action, Action::Pick(_) | Action::PickNotes) && !s.dialog_busy {
use winit::raw_window_handle::{HasWindowHandle, RawWindowHandle};
s.dialog_owner = self
.windows
@ -1016,8 +1016,14 @@ impl ApplicationHandler for App {
}
}
WindowEvent::DroppedFile(path) => {
if let Some(s) = &mut self.studio {
s.execute(Action::Open(path));
if role == Role::Presenter
&& let Some(s) = &mut self.studio
{
s.execute(if crate::notes::is_import(&path) {
Action::ImportNotes(path)
} else {
Action::Open(path)
});
}
}
WindowEvent::KeyboardInput { event, .. }

View File

@ -194,3 +194,164 @@ pub fn save(
notes: info.notes,
})
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ImportPreview {
pub path: PathBuf,
pub revision: Option<String>,
pub sections: Vec<String>,
pub total: usize,
}
/// Recognize imports without filesystem access on the input thread.
pub fn is_import(path: &Path) -> bool {
path.extension()
.and_then(|s| s.to_str())
.is_some_and(|s| s.eq_ignore_ascii_case("txt") || s.eq_ignore_ascii_case("md"))
}
/// Plain UTF-8 notes; Markdown headings delimit slides, not rendered formatting.
pub fn parse_import(text: &str, markdown: bool) -> Result<Vec<String>, String> {
if text.len() > MAX_TEXT {
return Err("Imported notes exceed 8 MiB".into());
}
let text = text
.strip_prefix('\u{feff}')
.unwrap_or(text)
.replace("\r\n", "\n");
let mut sections = Vec::new();
let mut lines = Vec::new();
let mut heading_seen = false;
let mut fence: Option<(u8, usize)> = None;
for line in text.lines() {
let trimmed = line.trim();
let mut heading = false;
if markdown {
let start = line.trim_start_matches(' ');
let indent = line.len() - start.len();
let marker = start.as_bytes().first().copied();
let run = start.bytes().take_while(|b| Some(*b) == marker).count();
if let Some((ch, len)) = fence {
if indent <= 3 && marker == Some(ch) && run >= len && start[run..].trim().is_empty()
{
fence = None;
}
} else if indent <= 3 && matches!(marker, Some(b'`' | b'~')) && run >= 3 {
fence = Some((marker.unwrap(), run));
} else if indent <= 3 {
heading = start == "#"
|| start
.strip_prefix('#')
.is_some_and(|tail| tail.starts_with([' ', '\t']));
}
}
let separator = !markdown && trimmed.len() >= 2 && trimmed.bytes().all(|b| b == b'-');
if heading || separator {
if markdown && !heading_seen {
if lines.iter().any(|line: &&str| !line.trim().is_empty()) {
return Err(
"Markdown notes must begin with a # slide title (blank lines are allowed)."
.into(),
);
}
heading_seen = true;
} else {
sections.push(lines.join("\n").trim_matches('\n').to_owned());
}
lines.clear();
} else {
lines.push(line);
}
if sections.len() >= 10000 {
return Err("Imported notes exceed 10000 slides".into());
}
}
if markdown && !heading_seen {
return Err("Markdown notes need # slide titles.".into());
}
sections.push(lines.join("\n").trim_matches('\n').to_owned());
if sections.iter().any(|s| s.len() > MAX_NOTE) {
return Err("An imported note exceeds 256 KiB".into());
}
Ok(sections)
}
pub fn preview_import(
source: &Path,
cache: PathBuf,
source_sha: &str,
import: &Path,
) -> Result<ImportPreview, String> {
if !is_import(import) {
return Err("Choose a .txt or .md notes file.".into());
}
let input = read_limited(import, MAX_TEXT as u64)?;
let text = std::str::from_utf8(&input).map_err(|_| "Notes imports must be UTF-8 text.")?;
let markdown = import
.extension()
.is_some_and(|e| e.eq_ignore_ascii_case("md"));
let sections = parse_import(text, markdown)?;
let (info, existing) = document(source, cache, source_sha)?;
if sections.len() > info.notes.len() {
return Err(format!(
"{} note sections, but only {} slides. Nothing was changed.",
sections.len(),
info.notes.len()
));
}
Ok(ImportPreview {
path: sidecar_path(&info.path),
revision: existing.map(|(_, b)| revision(&b)),
sections,
total: info.notes.len(),
})
}
pub fn apply_import(
source: &Path,
cache: PathBuf,
source_sha: &str,
preview: ImportPreview,
) -> Result<Snapshot, String> {
let (mut info, existing) = document(source, cache, source_sha)?;
let path = sidecar_path(&info.path);
if path != preview.path
|| info.notes.len() != preview.total
|| preview.sections.len() > info.notes.len()
{
return Err("Presentation changed. Import the notes again.".into());
}
let previous = existing.as_ref().map(|(_, b)| b);
if previous.map(|b| revision(b)) != preview.revision {
return Err("Notes changed on disk. Import again to review the latest notes.".into());
}
for (note, imported) in info.notes.iter_mut().zip(preview.sections) {
*note = imported;
}
if info.notes.iter().map(String::len).sum::<usize>() > MAX_TEXT {
return Err("Combined notes exceed 8 MiB; nothing was saved.".into());
}
let mut file = NotesFile {
version: 1,
notes: BTreeMap::new(),
};
if let Some((existing, _)) = &existing {
file.notes.clone_from(&existing.notes);
}
file.notes.extend(
keys(&info.path, &info.names)
.into_iter()
.zip(info.notes.iter().cloned()),
);
let bytes = bytes(&file)?;
let temp = temporary(&path, &bytes)?;
if read(&path)?.as_ref().map(|(_, b)| b) != previous {
return Err("Notes changed while importing; nothing was saved.".into());
}
if previous.is_some() {
temp.persist(&path).map_err(|e| e.to_string())?;
} else {
temp.persist_noclobber(&path).map_err(|e| e.to_string())?;
}
Ok(Snapshot {
path,
revision: revision(&bytes),
notes: info.notes,
})
}

View File

@ -1290,8 +1290,54 @@ pub fn presenter(ui: &mut Ui, s: &mut Studio, native: &mut UiState) {
});
s.displays_open &= open;
}
notes_import_ui(&ctx, s);
notes_editor_ui(&ctx, s);
}
fn notes_import_ui(ctx: &Context, s: &mut Studio) {
let Some(import) = &s.notes_import else {
return;
};
let mut apply = false;
let mut close = false;
egui::Window::new(tr(ctx, "Import notes"))
.id(egui::Id::new("notes-import"))
.collapsible(false).resizable(true)
.default_size(Vec2::new(560., 360.).min(ctx.content_rect().size() - Vec2::splat(48.)))
.max_size(ctx.content_rect().size() - Vec2::splat(32.))
.show(ctx, |ui| {
if import.busy {
ui.horizontal(|ui| { ui.spinner(); ui.label(tr(ctx, "Processing notes…")); });
}
egui::ScrollArea::vertical().max_height((ui.available_height() - 45.).max(60.)).show(ui, |ui| {
if let Some(preview) = &import.preview {
ui.label(format!("{}: {} / {}", tr(ctx, "Slides to update"), preview.sections.len(), preview.total));
ui.label(tr(ctx, "Sections replace notes starting at slide 1. Remaining slides keep their notes."));
ui.label(tr(ctx, if preview.revision.is_some() { "Update existing notes file" } else { "Create notes file" }));
ui.label(preview.path.display().to_string());
ui.separator();
ui.strong(tr(ctx, "Preview (first 3 slides)"));
for (index, note) in preview.sections.iter().enumerate().take(3) {
ui.strong(format!("{} {}", tr(ctx, "Slide"), index + 1));
let mut excerpt: String = note.chars().take(500).collect();
if excerpt.len() < note.len() { excerpt.push('…'); }
ui.label(if note.is_empty() { tr(ctx, "Empty note") } else { &excerpt });
}
}
if let Some(error) = &import.error { ui.colored_label(ui.visuals().error_fg_color, error); }
});
ui.separator();
ui.horizontal(|ui| {
apply = ui.add_enabled(!import.busy && import.preview.is_some() && import.error.is_none(), egui::Button::new(tr(ctx, "Import and save notes"))).clicked();
close = ui.add_enabled(!import.busy, egui::Button::new(tr(ctx, "Cancel"))).clicked();
});
});
if apply {
s.actions.push(Action::ApplyNotesImport);
}
if close {
s.notes_import = None;
}
}
fn notes_editor_ui(ctx: &Context, s: &mut Studio) {
let Some(editor) = &mut s.notes_editor else {
return;
@ -1720,6 +1766,21 @@ fn menu(ui: &mut Ui, s: &mut Studio) {
if s.dialog_busy {
ui.label(tr(&locale, "File chooser already open"));
}
ui.add_enabled_ui(
!s.dialog_busy
&& !s.loading
&& s.deck.is_some()
&& s.notes_editor.is_none()
&& s.notes_import.is_none(),
|ui| {
button(
ui,
tr(&locale, "Import notes…"),
Action::PickNotes,
&mut s.actions,
);
},
);
ui.separator();
button(
ui,

View File

@ -21,6 +21,9 @@ pub struct Monitor {
pub enum Action {
Open(PathBuf),
Pick(bool),
PickNotes,
ImportNotes(PathBuf),
ApplyNotesImport,
Go(usize),
Blank,
SaveProject,
@ -41,6 +44,11 @@ pub enum Action {
ReloadNotes,
SaveNotes,
}
pub struct NotesImport {
pub preview: Option<crate::notes::ImportPreview>,
pub busy: bool,
pub error: Option<String>,
}
pub struct NotesEditor {
pub page: usize,
pub text: String,
@ -84,6 +92,7 @@ pub struct Studio {
pub evicted_frames: usize,
pub loading: bool,
pub notes_loading: bool,
pub notes_import: Option<NotesImport>,
pub notes_editor: Option<NotesEditor>,
notes_io: Bridge,
notes_edited: bool,
@ -180,6 +189,7 @@ impl Studio {
evicted_frames: 0,
loading: false,
notes_loading: false,
notes_import: None,
notes_editor: None,
notes_io: Bridge::with_program(Duration::from_secs(30), worker_program.clone()),
notes_edited: false,
@ -299,9 +309,9 @@ impl Studio {
pub fn execute(&mut self, action: Action) {
match action {
Action::Open(path) => {
if self.notes_editor.is_some() {
if self.notes_editor.is_some() || self.notes_import.is_some() || self.dialog_busy {
self.status =
"Close the notes editor before opening another presentation.".into();
"Close the notes editor/import or file chooser before opening another presentation.".into();
return;
}
if self.fg_busy {
@ -314,6 +324,75 @@ impl Studio {
self.pending_open = Some(path);
self.status = "Opening document in an isolated worker…".into();
}
Action::PickNotes => {
if !self.dialog_busy
&& !self.loading
&& self.deck.is_some()
&& self.notes_editor.is_none()
&& self.notes_import.is_none()
{
self.dialog_busy = self.dialog.submit(
self.generation,
1,
Request::PickNotes {
owner: self.dialog_owner,
},
);
self.status = "Choose a TXT or Markdown notes file.".into();
}
}
Action::ImportNotes(import) => {
if self.loading
|| self.notes_editor.is_some()
|| self.notes_import.is_some()
|| self.dialog_busy
{
self.status = "Close the notes editor/import or file chooser and wait for the presentation to load.".into();
return;
}
let Some(deck) = &self.deck else {
self.status = "Open a presentation before importing notes.".into();
return;
};
if self.notes_io.submit(
self.generation,
2,
Request::PreviewNotesImport {
path: deck.path.clone(),
cache: self.cache_path.clone(),
source_sha: deck.sha256.clone(),
import,
},
) {
self.notes_import = Some(NotesImport {
preview: None,
busy: true,
error: None,
});
self.jump.clear();
self.status = "Reading notes for import…".into();
}
}
Action::ApplyNotesImport => {
if let (Some(deck), Some(import)) = (&self.deck, &mut self.notes_import)
&& !import.busy
&& import.error.is_none()
&& let Some(preview) = &import.preview
&& self.notes_io.submit(
self.generation,
3,
Request::ApplyNotesImport {
path: deck.path.clone(),
cache: self.cache_path.clone(),
source_sha: deck.sha256.clone(),
preview: preview.clone(),
},
)
{
import.busy = true;
self.status = "Saving imported notes…".into();
}
}
Action::Pick(folder) => {
if !self.dialog_busy {
self.dialog_busy = self.dialog.submit(
@ -462,6 +541,10 @@ impl Studio {
}
Action::Refresh => self.dirty_routes = true,
Action::Exit => {
if self.notes_import.as_ref().is_some_and(|i| i.busy) {
self.status = "Wait for notes import to finish before closing.".into();
return;
}
if self
.notes_editor
.as_ref()
@ -476,7 +559,11 @@ impl Studio {
if matches!(command, Action::EditNotes) && self.notes_editor.is_some() {
return;
}
if self.loading || self.notes_editor.as_ref().is_some_and(|e| e.busy) {
if self.loading
|| self.notes_import.is_some()
|| self.dialog_busy
|| self.notes_editor.as_ref().is_some_and(|e| e.busy)
{
return;
}
if let Some(deck) = &self.deck {
@ -588,6 +675,34 @@ impl Studio {
if completion.generation != self.generation {
continue;
}
if completion.tag >= 2 {
if let Some(import) = &mut self.notes_import {
import.busy = false;
match completion.result {
Ok(packet) => {
import.error = packet.reply.error;
if let Some(preview) = packet.reply.notes_import {
import.preview = Some(preview);
self.status = "Review the notes import before saving.".into();
}
if let Some(snapshot) = packet.reply.notes {
if let Some(deck) = &mut self.deck {
deck.notes = snapshot.notes;
}
self.notes_edited = true;
self.status =
format!("Notes imported: {}", snapshot.path.display());
self.notes_import = None;
}
}
Err(error) => import.error = Some(error),
}
if let Some(error) = self.notes_import.as_ref().and_then(|i| i.error.as_ref()) {
self.status = format!("Notes import: {error}");
}
}
continue;
}
if let Some(editor) = &mut self.notes_editor {
editor.busy = false;
match completion.result {
@ -668,7 +783,13 @@ impl Studio {
match c.result {
Ok(p) => {
if let Some(path) = p.reply.picked {
self.execute(Action::Open(path));
if c.tag == 1 {
if c.generation == self.generation {
self.execute(Action::ImportNotes(path));
}
} else {
self.execute(Action::Open(path));
}
}
if let Some(e) = p.reply.error {
self.status = e;

View File

@ -34,6 +34,21 @@ pub enum Request {
path: PathBuf,
cache: PathBuf,
},
PreviewNotesImport {
path: PathBuf,
cache: PathBuf,
source_sha: String,
import: PathBuf,
},
ApplyNotesImport {
path: PathBuf,
cache: PathBuf,
source_sha: String,
preview: crate::notes::ImportPreview,
},
PickNotes {
owner: Option<isize>,
},
PrepareNotes {
path: PathBuf,
cache: PathBuf,
@ -74,6 +89,7 @@ pub struct Reply {
pub frame: Option<FrameInfo>,
pub settings: Option<Settings>,
pub notes: Option<crate::notes::Snapshot>,
pub notes_import: Option<crate::notes::ImportPreview>,
pub picked: Option<PathBuf>,
pub bytes: usize,
pub edge: Option<u32>,
@ -203,6 +219,37 @@ pub fn run() -> Result<(), String> {
Request::Notes { path, cache } => {
reply.info = Some(document::Document::open(&path, cache)?.info);
}
Request::PreviewNotesImport {
path,
cache,
source_sha,
import,
} => {
reply.notes_import = Some(crate::notes::preview_import(
&path,
cache,
&source_sha,
&import,
)?);
}
Request::ApplyNotesImport {
path,
cache,
source_sha,
preview,
} => {
reply.notes = Some(crate::notes::apply_import(
&path,
cache,
&source_sha,
preview,
)?);
}
Request::PickNotes { owner } => {
reply.picked = picker_dialog(owner)?
.add_filter("Notes (TXT, Markdown)", &["txt", "md"])
.pick_file();
}
Request::PrepareNotes {
path,
cache,

View File

@ -279,3 +279,160 @@ fn partial_sidecar_cannot_exceed_combined_notes_limit_with_fallback_text() {
.contains("Combined notes")
);
}
#[test]
fn text_and_markdown_import_sections_and_limits() {
assert_eq!(
notes::parse_import("\u{feff}First\r\n ------- \r\nSecond\n--\n--\n", false).unwrap(),
vec!["First", "Second", "", ""]
);
assert_eq!(
notes::parse_import("one\n-\ninline -- text", false).unwrap(),
vec!["one\n-\ninline -- text"]
);
assert_eq!(notes::parse_import("\n# Opening\nHello é漢字\n\n## Keep this heading\n```md\n# Not a slide\n```\n# Next\n~~~\n# Also code\n~~~\n# Empty\n", true).unwrap(), vec!["Hello é漢字\n\n## Keep this heading\n```md\n# Not a slide\n```", "~~~\n# Also code\n~~~", ""]);
assert!(notes::parse_import("No headings", true).is_err());
assert!(notes::parse_import("Lost preamble\n# Title\nNote", true).is_err());
assert!(notes::parse_import(&"x".repeat(notes::MAX_NOTE + 1), false).is_err());
assert!(notes::parse_import(&"x".repeat(8 * 1024 * 1024 + 1), false).is_err());
assert!(notes::parse_import(&"--\n".repeat(10000), false).is_err());
assert!(notes::is_import(std::path::Path::new("NOTES.MD")));
assert!(!notes::is_import(std::path::Path::new("talk.pdf")));
}
#[test]
fn import_preview_is_read_only_and_apply_preserves_remaining_and_unknown_notes() {
let temp = tempfile::tempdir().unwrap();
let source = temp.path().join("talk.pdf");
common::pdf(&source);
let original = std::fs::read(&source).unwrap();
let cache = temp.path().join("cache");
let sha = Document::open(&source, cache.clone()).unwrap().info.sha256;
let input = temp.path().join("speaker.TXT");
std::fs::write(&input, "Imported é\n-------\nSecond").unwrap();
let preview = notes::preview_import(&source, cache.clone(), &sha, &input).unwrap();
assert!(!preview.path.exists());
let result = notes::apply_import(&source, cache.clone(), &sha, preview).unwrap();
assert_eq!(result.notes, vec!["Imported é", "Second"]);
std::fs::write(
&result.path,
"version=1\n[notes]\n'1'='Old'\n'2'='Keep'\n'99'='Unknown'",
)
.unwrap();
std::fs::write(&input, "First only").unwrap();
let preview = notes::preview_import(&source, cache.clone(), &sha, &input).unwrap();
let saved = notes::apply_import(&source, cache.clone(), &sha, preview).unwrap();
assert_eq!(saved.notes, vec!["First only", "Keep"]);
assert!(
std::fs::read_to_string(&result.path)
.unwrap()
.contains("Unknown")
);
assert_eq!(
Document::open(&source, cache).unwrap().info.notes,
saved.notes
);
assert_eq!(std::fs::read(source).unwrap(), original);
assert_eq!(std::fs::read_to_string(input).unwrap(), "First only");
}
#[test]
fn import_errors_and_conflicts_leave_files_untouched() {
let temp = tempfile::tempdir().unwrap();
let source = temp.path().join("talk.pdf");
common::pdf(&source);
let cache = temp.path().join("cache");
let sha = Document::open(&source, cache.clone()).unwrap().info.sha256;
let input = temp.path().join("notes.md");
std::fs::write(&input, "# One\nFirst\n# Two\nSecond\n# Three\nExtra").unwrap();
assert!(notes::preview_import(&source, cache.clone(), &sha, &input).is_err());
assert!(!notes::sidecar_path(&source).exists());
std::fs::write(&input, [0xff, 0xfe]).unwrap();
assert!(notes::preview_import(&source, cache.clone(), &sha, &input).is_err());
std::fs::write(&input, "# One\nFirst").unwrap();
let preview = notes::preview_import(&source, cache.clone(), &sha, &input).unwrap();
let external = "version=1\n[notes]\n'1'='External'";
std::fs::write(&preview.path, external).unwrap();
assert!(notes::apply_import(&source, cache.clone(), &sha, preview).is_err());
let preview = notes::preview_import(&source, cache.clone(), &sha, &input).unwrap();
std::fs::remove_file(&preview.path).unwrap();
assert!(notes::apply_import(&source, cache.clone(), &sha, preview).is_err());
assert!(!notes::sidecar_path(&source).exists());
std::fs::write(notes::sidecar_path(&source), "invalid TOML").unwrap();
assert!(notes::preview_import(&source, cache, &sha, &input).is_err());
assert_eq!(
std::fs::read_to_string(notes::sidecar_path(&source)).unwrap(),
"invalid TOML"
);
}
#[test]
fn folder_import_uses_natural_slide_order() {
let temp = tempfile::tempdir().unwrap();
let source = temp.path().join("Slides");
std::fs::create_dir(&source).unwrap();
common::image(&source.join("slide10.png"), [0, 0, 0, 255]);
common::image(&source.join("slide2.png"), [0, 0, 0, 255]);
let cache = temp.path().join("cache");
let sha = Document::open(&source, cache.clone()).unwrap().info.sha256;
let input = temp.path().join("notes.md");
std::fs::write(&input, "# Title is not a filename\nFirst\n# Slide\nSecond").unwrap();
let preview = notes::preview_import(&source, cache.clone(), &sha, &input).unwrap();
let saved = notes::apply_import(&source, cache, &sha, preview).unwrap();
let file: toml::Value = toml::from_str(&std::fs::read_to_string(saved.path).unwrap()).unwrap();
assert_eq!(file["notes"]["slide2.png"].as_str(), Some("First"));
assert_eq!(file["notes"]["slide10.png"].as_str(), Some("Second"));
}
#[test]
fn worker_import_review_save_and_failure_keep_presentation_running() {
let temp = tempfile::tempdir().unwrap();
let source = temp.path().join("talk.pdf");
common::pdf(&source);
let cache = temp.path().join("cache");
let info = Document::open(&source, cache.clone()).unwrap().info;
let input = temp.path().join("notes.txt");
std::fs::write(&input, "Imported").unwrap();
let mut s = Studio::with_program(true, None, env!("CARGO_BIN_EXE_pdf-presenter").into());
s.cache_path = cache;
s.initialized = true;
s.execute(Action::ImportNotes(input.clone()));
assert!(s.status.contains("Open a presentation"));
s.deck = Some(info);
s.blanked = false;
s.execute(Action::ImportNotes(input.clone()));
s.execute(Action::Exit);
assert!(!s.close_requested);
s.execute(Action::EditNotes);
assert!(s.notes_editor.is_none());
fn finish(s: &mut Studio) {
let deadline = Instant::now() + Duration::from_secs(10);
while s.notes_import.as_ref().is_some_and(|i| i.busy) {
s.poll();
assert!(Instant::now() < deadline, "notes import stalled");
std::thread::sleep(Duration::from_millis(2));
}
}
finish(&mut s);
assert!(s.notes_import.as_ref().unwrap().error.is_none());
assert!(!notes::sidecar_path(&source).exists());
s.execute(Action::Open(source.clone()));
assert!(!s.loading);
s.execute(Action::ApplyNotesImport);
finish(&mut s);
assert!(s.notes_import.is_none());
assert_eq!(s.deck.as_ref().unwrap().notes[0], "Imported");
assert!(!s.blanked);
s.execute(Action::ImportNotes(input));
finish(&mut s);
std::fs::write(
notes::sidecar_path(&source),
"version=1\n[notes]\n'1'='External'",
)
.unwrap();
s.execute(Action::ApplyNotesImport);
finish(&mut s);
assert!(s.notes_import.as_ref().unwrap().error.is_some());
assert_eq!(s.deck.as_ref().unwrap().notes[0], "Imported");
assert!(!s.blanked);
}

View File

@ -1067,3 +1067,70 @@ fn double_click_notes_opens_editor_and_editor_keeps_unsaved_draft() {
}
assert!(s.actions.iter().any(|a| matches!(a, Action::SaveNotes)));
}
#[test]
fn notes_import_review_requires_explicit_save_and_cancel_discards_preview() {
fn label_pos(shape: &egui::Shape, label: &str) -> Option<Pos2> {
match shape {
egui::Shape::Text(t) if t.galley.text() == label => Some(t.pos + t.galley.size() * 0.5),
egui::Shape::Vec(shapes) => shapes.iter().find_map(|s| label_pos(s, label)),
_ => None,
}
}
for (button, apply) in [("Import and save notes", true), ("Cancel", false)] {
let ctx = Context::default();
let mut s = studio();
let original = s.deck.as_ref().unwrap().notes.clone();
s.notes_import = Some(pdf_presenter::studio::NotesImport {
busy: false,
error: None,
preview: Some(pdf_presenter::notes::ImportPreview {
path: "demo.notes.toml".into(),
revision: Some("revision".into()),
sections: vec!["New first note".into(), "".into()],
total: 30,
}),
});
let mut state = UiState::default();
let mut time = 0.;
let mut render = |s: &mut Studio, events| {
time += 0.04;
let mut raw = input(Vec2::new(900., 700.));
raw.time = Some(time);
raw.events = events;
ctx.run_ui(raw, |ui| presenter_ui::presenter(ui, s, &mut state))
};
for _ in 0..3 {
render(&mut s, vec![]);
}
let output = render(&mut s, vec![]);
let pos = output
.shapes
.iter()
.find_map(|s| label_pos(&s.shape, button))
.unwrap();
assert_eq!(s.deck.as_ref().unwrap().notes, original);
for pressed in [true, false] {
render(
&mut s,
vec![
egui::Event::PointerMoved(pos),
egui::Event::PointerButton {
pos,
button: egui::PointerButton::Primary,
pressed,
modifiers: egui::Modifiers::NONE,
},
],
);
}
assert_eq!(
s.actions
.iter()
.any(|a| matches!(a, Action::ApplyNotesImport)),
apply
);
assert_eq!(s.notes_import.is_some(), apply);
assert_eq!(s.deck.as_ref().unwrap().notes, original);
}
}

View File

@ -2,6 +2,15 @@
## Unreleased
### 0.1.53
- Import UTF-8 TXT notes separated by hyphen lines or Markdown notes separated by
level-one headings, via Menu or presenter drag-and-drop. Review before converting
to a complete presentation notes sidecar; preserve remaining notes/source files,
detect external conflicts and keep processing off the presentation thread.
Document examples and mapping in the README. Linux regression coverage includes
parsers, worker flow, natural ordering, atomic saves and conflict handling.
### 0.1.52
- Load presentation-named notes sidecars before falling back to PDF/folder notes.

View File

@ -58,3 +58,46 @@ sent to presentation outputs or persisted in global/project layout settings.
See [example](examples/presentation.notes.toml), `tests/notes.rs`, the pointer
interaction tests in `tests/presenter_ui.rs`, and the private worker protocol.
## Importing TXT and Markdown
Implemented in 0.1.53, with no change to the version-1 TOML representation. A loaded
presentation accepts `.txt` and `.md` files (case-insensitive extensions) through
Menu → Import notes or drag-and-drop onto the presenter. Import review is read-only;
only **Import and save notes** writes the named sidecar. Cancel writes nothing.
- Input is UTF-8, up to 8 MiB; an initial BOM is removed and CRLF becomes LF.
- TXT splits at a line whose trimmed content is only two or more ASCII hyphens.
Consecutive separators preserve empty sections, as do leading/trailing separators.
No separators means one slide's notes. A trailing newline is not a separator.
- Markdown splits at ATX level-one headings (`#` followed by space/tab, or `#`
alone), with up to three leading spaces. The title is omitted. Level-two and
deeper headings remain literal text. Backtick/tilde fences of at least three
markers protect headings inside them; closing fences use the same marker and
at least the opening length. A document without a heading, or with nonblank
preamble before the first heading, is rejected. Setext headings are unsupported.
- Blank newline characters at the beginning/end of each section are removed;
internal newlines, indentation and Markdown body text are retained, displayed
literally. This is section parsing, not Markdown rendering.
- Sections replace slides sequentially from slide 1, using natural filename order
for folders. Titles never match filenames or page numbers. Empty sections clear
notes. Missing trailing sections retain current sidecar/extracted notes. Excess
sections fail without writing. Limits remain 10000 sections and 256 KiB per note.
- Saving materializes all slides' effective notes and preserves unknown existing
page keys. Combined notes and serialized-file limits still apply. Existing TOML
comments/formatting are regenerated. The source notes import is never modified.
Preview holds parsed sections in memory, the destination, slide count and optional
existing-sidecar SHA. Apply revalidates the source identity and sidecar revision;
external creation, edits or deletion since review cause a conflict. Atomic replace
and no-clobber creation use the same guarantees/limitations as the editor above.
Malformed existing sidecars are never overwritten. Errors appear in the import
window; cancel and import again after resolving the cause. The first three sections
are excerpted in the review; all sections are validated before writing.
Parsing, extraction and writes run in the supervised notes worker, never on the
input/render thread. Presentation navigation and output continue independently.
Keyboard presentation shortcuts are suspended while the import window is open.
Opening another presentation/editing notes is held until the import closes; normal
exit is held during an active import job. No notes payload reaches output windows.

View File

@ -123,3 +123,16 @@ and `revision` is the notes file SHA-256 observed when editing began. A successf
order. Errors use the existing error field. The presenter ignores stale-generation
completions and late background extraction after an editor snapshot has been accepted.
The current page draft survives save failure. None of this payload enters output IPC.
## Notes import in 0.1.53
`PickNotes {owner}` uses the existing owned, supervised file chooser with TXT/MD
filters. `PreviewNotesImport {path, cache, source_sha, import}` returns
`Reply.notes_import {path, revision, sections, total}`: destination sidecar path,
optional existing-file SHA, parsed strings and total slide count. It writes nothing.
`ApplyNotesImport {path, cache, source_sha, preview}` revalidates identity/revision,
merges notes and writes atomically, returning the existing `Reply.notes` snapshot.
Both notes jobs use the dedicated 30-second bridge, bounded JSON messages and source
generations. Notes picker results carry the source generation too. These messages
are private same-executable presenter/worker traffic, never output-host traffic.

View File

@ -308,3 +308,12 @@ Save errors keep your draft visible. If another program changed the notes file,
copy your draft before choosing **Reload (discard edits)**; the editor won't
silently replace a detected external edit. Notes files require a writable source
folder. They travel alongside the presentation, independently of saved layouts.
### Import notes from text or Markdown
With a presentation open, choose **Menu → Import notes…** or drop a `.txt`/`.md`
file onto the presenter. Review the destination and slide count, then choose
**Import and save notes** to create/update the presentation's `.notes.toml` file.
Cancel leaves files unchanged. See the [README examples](../README.md#import-your-notes)
and [format contract](interfaces/presentation-notes.md#importing-txt-and-markdown).