diff --git a/Cargo.lock b/Cargo.lock index 12a7ac2..c64a2b4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -95,6 +95,15 @@ dependencies = [ "libc", ] +[[package]] +name = "arbitrary" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3bc62ac97cc33321f50863d514c3bc38a453947a8f9e781137e47c7401020aed" +dependencies = [ + "derive_arbitrary", +] + [[package]] name = "arrayref" version = "0.3.9" @@ -670,7 +679,7 @@ dependencies = [ [[package]] name = "deckstride" -version = "0.1.100" +version = "0.1.101" dependencies = [ "bytemuck", "chrono", @@ -697,6 +706,18 @@ dependencies = [ "winit", "winresource", "x11-dl", + "zip", +] + +[[package]] +name = "derive_arbitrary" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b034bd7d5f032402a2479444dcc6f74e36a03f31854d41680fb240ef682a1ac" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.10", ] [[package]] @@ -4319,6 +4340,21 @@ dependencies = [ "syn 3.0.10", ] +[[package]] +name = "zip" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1dcb24d0152526ae49b9b96c1dcf71850ca1e0b882e4e28ed898a93c41334744" +dependencies = [ + "arbitrary", + "crc32fast", + "crossbeam-utils", + "flate2", + "indexmap", + "memchr", + "zopfli", +] + [[package]] name = "zlib-rs" version = "0.6.8" @@ -4331,6 +4367,18 @@ version = "1.0.23" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" +[[package]] +name = "zopfli" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aaf7fc5d30c28483d93805c4a5e12b05bbb52407fa67c5f8bd552374cd01fb11" +dependencies = [ + "bumpalo", + "crc32fast", + "log", + "simd-adler32", +] + [[package]] name = "zune-core" version = "0.5.3" diff --git a/Cargo.toml b/Cargo.toml index f3e0208..1ad6373 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,7 +4,7 @@ default-members = ["crates/deckstride"] resolver = "3" [workspace.package] -version = "0.1.100" +version = "0.1.101" edition = "2024" license = "MIT" repository = "https://proxy.dandaedre.com/gitea/idle-org/deckstride" diff --git a/README.md b/README.md index 4d70d76..406ec32 100644 --- a/README.md +++ b/README.md @@ -45,7 +45,7 @@ slow document operation does not have to freeze navigation. | **Notes that belong to the presentation** | Read notes from a sidecar or the PDF, import TXT/Markdown, and double-click the notes pane to edit the current slide. Notes automatically fit the available space. | | **Presentation-aware desktop behavior** | Deckstride asks supported operating systems to keep the display awake and reports whether protection is active. Closing Presenter also closes its Slides windows. | | **Portable by design** | The release binaries include the PDF renderer and application dependencies. Keep the extracted folder anywhere convenient; no Rust or separate PDF software is required. | -| **Themes and languages** | Choose from 20 built-in palettes and English, French, Spanish, Japanese, Simplified Chinese, German or Brazilian Portuguese. System language detection stays offline. | +| **Themes and languages** | Choose from 20 built-in palettes and seven interface languages, or import bounded offline language/theme packs. | On Windows, multi-screen output, per-screen layouts, zoom, tools, and unplugging then reconnecting displays have been tested in extended use. Linux and macOS use the same @@ -142,6 +142,19 @@ Useful controls: [Notes file formats →](docs/interfaces/presentation-notes.md) · [Preparation, cache and RAM behavior →](docs/user-guide.md#preparation-processed-slides-and-ram) +## Add languages and themes + +Open **Preferences → General → Appearance** and choose **Import language pack…** +or **Import theme pack…**. Imported choices appear in the existing Language and +Theme selectors without restarting Deckstride. Packs stay offline and contain data +only. + +Editable examples and ready-to-import ZIPs: + +- [Language pack example](docs/packs/deckstride-language-pack.zip) +- [Theme pack example](docs/packs/deckstride-theme-pack.zip) +- [Pack format and limits](docs/packs/README.md) + ## Open source Deckstride is independent open-source software under the [MIT license](LICENSE). diff --git a/crates/deckstride/Cargo.toml b/crates/deckstride/Cargo.toml index 4c57273..fb8b6bd 100644 --- a/crates/deckstride/Cargo.toml +++ b/crates/deckstride/Cargo.toml @@ -27,6 +27,7 @@ hayro = "=0.9.0" chrono = "0.4" rfd = "=0.15.4" sysinfo = { version = "=0.37.2", default-features = false, features = ["system"] } +zip = { version = "2", default-features = false, features = ["deflate"] } [target.'cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))'.dependencies] keepawake = "=0.6.1" diff --git a/crates/deckstride/src/lib.rs b/crates/deckstride/src/lib.rs index b0922c4..5e13381 100644 --- a/crates/deckstride/src/lib.rs +++ b/crates/deckstride/src/lib.rs @@ -82,6 +82,8 @@ pub mod studio; /// Presenter interface language. pub mod localization; +/// Bounded runtime language and theme packs. +pub mod packs; /// Standalone presenter palettes. pub mod theme; diff --git a/crates/deckstride/src/localization.rs b/crates/deckstride/src/localization.rs index a2a6941..6ee908f 100644 --- a/crates/deckstride/src/localization.rs +++ b/crates/deckstride/src/localization.rs @@ -64,6 +64,12 @@ enum ResolvedLanguage { PtBr, } +#[derive(Clone, Debug, PartialEq, Eq)] +struct ActiveLanguage { + builtin: ResolvedLanguage, + pack: Option, +} + fn language_id() -> egui::Id { egui::Id::new("deckstride-language") } @@ -100,19 +106,31 @@ fn system_language() -> ResolvedLanguage { } pub fn apply(ctx: &egui::Context, language: &Language) { + apply_selected(ctx, language, None); +} + +pub fn apply_selected(ctx: &egui::Context, language: &Language, pack: Option<&str>) { let resolved = language.resolved(); - let previous = ctx.data(|data| data.get_temp::(language_id())); - if previous == Some(resolved) { + let active = ActiveLanguage { + builtin: resolved, + pack: pack.map(str::to_owned), + }; + let previous = ctx.data(|data| data.get_temp::(language_id())); + if previous.as_ref() == Some(&active) { return; } - if matches!(resolved, ResolvedLanguage::Ja | ResolvedLanguage::ZhCn) { + if pack.is_none() && matches!(resolved, ResolvedLanguage::Ja | ResolvedLanguage::ZhCn) { ctx.set_fonts(cjk_fonts(resolved)); - } else if previous - .is_some_and(|language| matches!(language, ResolvedLanguage::Ja | ResolvedLanguage::ZhCn)) - { + } else if previous.is_some_and(|language| { + language.pack.is_none() + && matches!( + language.builtin, + ResolvedLanguage::Ja | ResolvedLanguage::ZhCn + ) + }) { ctx.set_fonts(egui::FontDefinitions::default()); } - ctx.data_mut(|data| data.insert_temp(language_id(), resolved)); + ctx.data_mut(|data| data.insert_temp(language_id(), active)); } fn cjk_fonts(language: ResolvedLanguage) -> egui::FontDefinitions { @@ -136,10 +154,18 @@ fn cjk_fonts(language: ResolvedLanguage) -> egui::FontDefinitions { } pub fn tr<'a>(ctx: &egui::Context, text: &'a str) -> &'a str { - match ctx - .data(|data| data.get_temp::(language_id())) - .unwrap_or(ResolvedLanguage::En) + let active = ctx + .data(|data| data.get_temp::(language_id())) + .unwrap_or(ActiveLanguage { + builtin: ResolvedLanguage::En, + pack: None, + }); + if let Some(locale) = active.pack + && let Some(translated) = crate::packs::translation(&locale, text) { + return translated; + } + match active.builtin { ResolvedLanguage::En => text, ResolvedLanguage::Fr => fr(text), ResolvedLanguage::Es => es(text), @@ -152,7 +178,8 @@ pub fn tr<'a>(ctx: &egui::Context, text: &'a str) -> &'a str { pub fn display_revert_countdown(ctx: &egui::Context, seconds: u64) -> String { match ctx - .data(|data| data.get_temp::(language_id())) + .data(|data| data.get_temp::(language_id())) + .map(|active| active.builtin) .unwrap_or(ResolvedLanguage::En) { ResolvedLanguage::Fr => { diff --git a/crates/deckstride/src/native.rs b/crates/deckstride/src/native.rs index 24ca24e..b2b0dcb 100644 --- a/crates/deckstride/src/native.rs +++ b/crates/deckstride/src/native.rs @@ -194,7 +194,9 @@ struct NativeWindow { zoom_slow: bool, presentation_base: Option, applied_theme: Option, + applied_theme_pack: Option>, applied_language: Option, + applied_language_pack: Option>, #[cfg(target_os = "linux")] browser_parent: Option, } @@ -256,7 +258,9 @@ impl NativeWindow { zoom_slow: false, presentation_base: None, applied_theme: None, + applied_theme_pack: None, applied_language: None, + applied_language_pack: None, #[cfg(target_os = "linux")] browser_parent: None, }) @@ -340,13 +344,27 @@ impl NativeWindow { return Err("Display exceeds 40 megapixels".into()); } if let Some(s) = studio.as_ref() { - if self.applied_theme != Some(s.settings.theme) { - s.settings.theme.apply(&self.ctx); + if self.applied_theme != Some(s.settings.theme) + || self.applied_theme_pack.as_ref() != Some(&s.settings.theme_pack) + { + crate::theme::apply_selected( + &self.ctx, + s.settings.theme, + s.settings.theme_pack.as_deref(), + ); self.applied_theme = Some(s.settings.theme); + self.applied_theme_pack = Some(s.settings.theme_pack.clone()); } - if self.applied_language != Some(s.settings.language) { - crate::localization::apply(&self.ctx, &s.settings.language); + if self.applied_language != Some(s.settings.language) + || self.applied_language_pack.as_ref() != Some(&s.settings.language_pack) + { + crate::localization::apply_selected( + &self.ctx, + &s.settings.language, + s.settings.language_pack.as_deref(), + ); self.applied_language = Some(s.settings.language); + self.applied_language_pack = Some(s.settings.language_pack.clone()); } } let input = self.input.take_egui_input(&self.window); @@ -1171,7 +1189,11 @@ impl App { #[cfg(target_os = "windows")] if matches!( action, - Action::Pick(_) | Action::PickNotes | Action::PickBlankPicture + Action::Pick(_) + | Action::PickNotes + | Action::PickBlankPicture + | Action::PickLanguagePack + | Action::PickThemePack ) && !s.dialog_busy { use winit::raw_window_handle::{HasWindowHandle, RawWindowHandle}; diff --git a/crates/deckstride/src/packs.rs b/crates/deckstride/src/packs.rs new file mode 100644 index 0000000..641f283 --- /dev/null +++ b/crates/deckstride/src/packs.rs @@ -0,0 +1,698 @@ +//! Bounded, data-only language and theme packs compatible with Canvas Pilot manifests. +use crate::theme::Palette; +use egui::Color32; +use serde::Deserialize; +use sha2::{Digest, Sha256}; +use std::{ + collections::{BTreeMap, BTreeSet}, + io::Read, + path::{Path, PathBuf}, + sync::{LazyLock, RwLock}, +}; + +const MAX_ARCHIVE: u64 = 2 * 1024 * 1024; +const MAX_EXPANDED: u64 = 4 * 1024 * 1024; +const MAX_PACKS: usize = 32; + +#[derive(Clone, Debug, Deserialize)] +#[serde(deny_unknown_fields)] +struct LanguageManifest { + version: u32, + id: String, + revision: u64, + languages: Vec, +} + +#[derive(Clone, Debug, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct LanguageDescription { + pub locale: String, + pub name: String, + pub native_name: String, +} + +#[derive(Clone, Debug)] +pub struct InstalledLanguagePack { + pub id: String, + pub revision: u64, + pub languages: Vec, +} + +#[derive(Clone)] +struct LanguagePack { + manifest: LanguageManifest, + catalogs: BTreeMap>, + path: PathBuf, + fingerprint: [u8; 32], +} + +#[derive(Clone, Debug, Deserialize)] +#[serde(deny_unknown_fields)] +struct ThemeManifest { + version: u32, + id: String, + revision: u64, + themes: Vec, + #[serde(default)] + notices: String, +} + +#[derive(Clone, Debug, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct ThemeDescription { + pub id: String, + pub name: String, + pub light: bool, + colors: ThemeColors, +} + +#[derive(Clone, Debug, Deserialize)] +#[serde(deny_unknown_fields)] +struct ThemeColors { + canvas: String, + banner: String, + grid: String, + layer: String, + bg: String, + panel: String, + field: String, + line: String, + text: String, + muted: String, + cyan: String, + amber: String, + purple: String, + pattern: [String; 2], +} + +#[derive(Clone, Debug)] +pub struct InstalledThemePack { + pub id: String, + pub revision: u64, + pub themes: Vec, + pub notices: String, +} + +#[derive(Clone)] +struct ThemePack { + manifest: ThemeManifest, + path: PathBuf, + fingerprint: [u8; 32], +} + +static LANGUAGE_PACKS: LazyLock>> = + LazyLock::new(|| RwLock::new(Vec::new())); +static THEME_PACKS: LazyLock>> = LazyLock::new(|| RwLock::new(Vec::new())); +#[derive(Default)] +struct InternPool { + values: BTreeMap, + bytes: usize, +} +static INTERNED: LazyLock> = LazyLock::new(Default::default); + +pub fn valid_id(id: &str) -> bool { + !id.is_empty() + && id.len() <= 63 + && id + .bytes() + .all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit() || byte == b'-') + && !id.starts_with('-') + && !id.ends_with('-') +} + +pub fn valid_theme_choice(id: &str) -> bool { + id.split_once('/') + .is_some_and(|(pack, theme)| valid_id(pack) && valid_id(theme)) +} + +fn bounded_read(path: &Path) -> Result, String> { + let mut bytes = Vec::new(); + std::fs::File::open(path) + .map_err(|error| error.to_string())? + .take(MAX_ARCHIVE + 1) + .read_to_end(&mut bytes) + .map_err(|error| error.to_string())?; + if bytes.len() as u64 > MAX_ARCHIVE { + return Err("Pack exceeds 2 MiB".into()); + } + Ok(bytes) +} + +fn fingerprint(bytes: &[u8]) -> [u8; 32] { + Sha256::digest(bytes).into() +} + +fn intern(text: String) -> Result<&'static str, String> { + let mut pool = INTERNED.write().unwrap(); + if let Some(value) = pool.values.get(&text) { + return Ok(value); + } + if pool.bytes.saturating_add(text.len()) > 32 * 1024 * 1024 { + return Err( + "Runtime language-pack text limit reached; restart before importing more".into(), + ); + } + let leaked = Box::leak(text.clone().into_boxed_str()); + pool.bytes += text.len(); + pool.values.insert(text, leaked); + Ok(leaked) +} + +fn parse_language(bytes: &[u8], path: PathBuf) -> Result { + if bytes.len() as u64 > MAX_ARCHIVE { + return Err("Language pack exceeds 2 MiB".into()); + } + let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes)).map_err(|e| e.to_string())?; + if zip.is_empty() || zip.len() > 17 { + return Err("Expected manifest.json and at most 16 catalogs".into()); + } + let mut entries = BTreeMap::new(); + let mut expanded = 0_u64; + for index in 0..zip.len() { + let mut entry = zip.by_index(index).map_err(|e| e.to_string())?; + let name = entry.name().to_owned(); + if name.contains(['/', '\\']) + || !name.ends_with(".json") + || entry.is_dir() + || entry + .unix_mode() + .is_some_and(|mode| mode & 0o170000 == 0o120000) + { + return Err("Pack entries must be regular JSON files at the ZIP root".into()); + } + let mut data = Vec::new(); + (&mut entry) + .take(MAX_EXPANDED.saturating_sub(expanded) + 1) + .read_to_end(&mut data) + .map_err(|e| e.to_string())?; + expanded += data.len() as u64; + if expanded > MAX_EXPANDED { + return Err("Expanded language pack exceeds 4 MiB".into()); + } + if entries.insert(name, data).is_some() { + return Err("Duplicate ZIP entry".into()); + } + } + let manifest: LanguageManifest = serde_json::from_slice( + &entries + .remove("manifest.json") + .ok_or("Missing manifest.json")?, + ) + .map_err(|e| e.to_string())?; + if manifest.version != 2 + || manifest.revision == 0 + || !valid_id(&manifest.id) + || manifest.languages.is_empty() + || manifest.languages.len() > 16 + { + return Err("Invalid language-pack manifest or unsupported version".into()); + } + let builtins = ["system", "en", "fr", "es", "ja", "zh-cn", "de", "pt-br"]; + let mut locales = BTreeSet::new(); + let mut catalogs = BTreeMap::new(); + for language in &manifest.languages { + if !valid_id(&language.locale) + || builtins.contains(&language.locale.as_str()) + || !locales.insert(language.locale.clone()) + { + return Err("Invalid, duplicate, or built-in locale identifier".into()); + } + for name in [&language.name, &language.native_name] { + if name.trim().is_empty() || name.len() > 160 || name.chars().any(char::is_control) { + return Err("Invalid language display name".into()); + } + } + let messages: BTreeMap = serde_json::from_slice( + &entries + .remove(&format!("{}.json", language.locale)) + .ok_or("Missing language catalog")?, + ) + .map_err(|e| e.to_string())?; + if messages.is_empty() || messages.len() > 4096 { + return Err("Language catalog is empty or too large".into()); + } + let mut checked = BTreeMap::new(); + for (key, value) in messages { + if key.trim().is_empty() + || key.len() > 16_384 + || key.chars().any(char::is_control) + || value.trim().is_empty() + || value.len() > 16_384 + || value + .chars() + .any(|c| c.is_control() && c != '\n' && c != '\t') + { + return Err("Invalid translation key or text".into()); + } + checked.insert(key, intern(value)?); + } + catalogs.insert(language.locale.clone(), checked); + } + if !entries.is_empty() { + return Err("Unexpected files in language pack".into()); + } + Ok(LanguagePack { + manifest, + catalogs, + path, + fingerprint: fingerprint(bytes), + }) +} + +fn color(text: &str) -> Result { + if text.len() != 7 + || !text.starts_with('#') + || !text[1..].bytes().all(|byte| byte.is_ascii_hexdigit()) + { + return Err(format!("Expected opaque #RRGGBB color: {text}")); + } + let value = u32::from_str_radix(&text[1..], 16).map_err(|e| e.to_string())?; + Ok(Color32::from_rgb( + (value >> 16) as u8, + (value >> 8) as u8, + value as u8, + )) +} + +impl ThemeColors { + fn palette(&self) -> Result { + Ok(Palette { + canvas: color(&self.canvas)?, + banner: color(&self.banner)?, + grid: color(&self.grid)?, + layer: color(&self.layer)?, + bg: color(&self.bg)?, + panel: color(&self.panel)?, + field: color(&self.field)?, + line: color(&self.line)?, + text: color(&self.text)?, + muted: color(&self.muted)?, + cyan: color(&self.cyan)?, + amber: color(&self.amber)?, + purple: color(&self.purple)?, + pattern: [color(&self.pattern[0])?, color(&self.pattern[1])?], + }) + } +} + +fn parse_theme(bytes: &[u8], path: PathBuf) -> Result { + if bytes.len() as u64 > MAX_ARCHIVE { + return Err("Theme pack exceeds 2 MiB".into()); + } + let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes)).map_err(|e| e.to_string())?; + if zip.len() != 1 { + return Err("Expected only manifest.json in the theme pack".into()); + } + let mut entry = zip.by_index(0).map_err(|e| e.to_string())?; + if entry.name() != "manifest.json" + || entry.is_dir() + || entry + .unix_mode() + .is_some_and(|mode| mode & 0o170000 == 0o120000) + { + return Err("Expected a regular manifest.json at the ZIP root".into()); + } + let mut data = Vec::new(); + (&mut entry) + .take(MAX_EXPANDED + 1) + .read_to_end(&mut data) + .map_err(|e| e.to_string())?; + if data.len() as u64 > MAX_EXPANDED { + return Err("Expanded theme pack exceeds 4 MiB".into()); + } + let manifest: ThemeManifest = serde_json::from_slice(&data).map_err(|e| e.to_string())?; + if manifest.version != 1 + || manifest.revision == 0 + || !valid_id(&manifest.id) + || manifest.themes.is_empty() + || manifest.themes.len() > 16 + || manifest.notices.len() > 65_536 + || manifest + .notices + .chars() + .any(|c| c.is_control() && !matches!(c, '\n' | '\r' | '\t')) + { + return Err("Invalid theme-pack manifest or unsupported version".into()); + } + let mut ids = BTreeSet::new(); + for theme in &manifest.themes { + if !valid_id(&theme.id) + || !ids.insert(theme.id.clone()) + || theme.name.trim().is_empty() + || theme.name.len() > 160 + || theme.name.chars().any(char::is_control) + { + return Err("Invalid or duplicate theme identifier/name".into()); + } + theme.colors.palette()?; + } + Ok(ThemePack { + manifest, + path, + fingerprint: fingerprint(bytes), + }) +} + +fn zip_paths(directory: &Path) -> Result, String> { + let entries = match std::fs::read_dir(directory) { + Ok(entries) => entries, + Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(Vec::new()), + Err(error) => return Err(error.to_string()), + }; + let mut paths: Vec<_> = entries + .filter_map(Result::ok) + .map(|entry| entry.path()) + .filter(|path| path.extension().is_some_and(|extension| extension == "zip")) + .collect(); + paths.sort(); + if paths.len() > MAX_PACKS { + return Err("Too many packs (maximum 32)".into()); + } + Ok(paths) +} + +pub fn load(root: &Path) -> Vec { + let mut errors = Vec::new(); + let mut languages = Vec::new(); + match zip_paths(&root.join("language-packs")) { + Ok(paths) => { + for path in paths { + match bounded_read(&path).and_then(|bytes| parse_language(&bytes, path.clone())) { + Ok(pack) + if !languages.iter().any(|old: &LanguagePack| { + old.manifest.id == pack.manifest.id + || old.manifest.languages.iter().any(|old_language| { + pack.manifest + .languages + .iter() + .any(|new| new.locale == old_language.locale) + }) + }) => + { + languages.push(pack) + } + Ok(_) => errors.push(format!("{}: duplicate pack or locale", path.display())), + Err(error) => errors.push(format!("{}: {error}", path.display())), + } + } + } + Err(error) => errors.push(error), + } + let mut themes = Vec::new(); + match zip_paths(&root.join("theme-packs")) { + Ok(paths) => { + for path in paths { + match bounded_read(&path).and_then(|bytes| parse_theme(&bytes, path.clone())) { + Ok(pack) + if !themes + .iter() + .any(|old: &ThemePack| old.manifest.id == pack.manifest.id) => + { + themes.push(pack) + } + Ok(_) => errors.push(format!("{}: duplicate pack identifier", path.display())), + Err(error) => errors.push(format!("{}: {error}", path.display())), + } + } + } + Err(error) => errors.push(error), + } + *LANGUAGE_PACKS.write().unwrap() = languages; + *THEME_PACKS.write().unwrap() = themes; + errors +} + +fn install_bytes( + directory: &Path, + id: &str, + revision: u64, + previous: Option<(PathBuf, u64, [u8; 32])>, + bytes: &[u8], +) -> Result { + let destination = previous + .as_ref() + .map(|(path, _, _)| path.clone()) + .unwrap_or_else(|| directory.join(format!("{id}.zip"))); + if let Some((_, old_revision, _)) = &previous + && revision <= *old_revision + { + return Err(format!( + "Installed revision {old_revision} is not older than revision {revision}" + )); + } + if previous.is_none() && destination.exists() { + return Err("Pack destination already exists; remove or rename it before importing".into()); + } + if let Some((_, _, expected)) = previous + && fingerprint(&bounded_read(&destination)?) != expected + { + return Err("Installed pack changed on disk; restart before updating it".into()); + } + if !destination.exists() && zip_paths(directory).is_ok_and(|paths| paths.len() >= MAX_PACKS) { + return Err("Too many packs (maximum 32)".into()); + } + crate::settings::atomic_write(&destination, bytes)?; + Ok(destination) +} + +pub fn install_language(root: &Path, source: &Path) -> Result { + let bytes = bounded_read(source)?; + let parsed = parse_language(&bytes, PathBuf::new())?; + let installed = LANGUAGE_PACKS.read().unwrap().clone(); + for old in &installed { + if old.manifest.id != parsed.manifest.id + && old.manifest.languages.iter().any(|old_language| { + parsed + .manifest + .languages + .iter() + .any(|new| new.locale == old_language.locale) + }) + { + return Err(format!( + "Locale belongs to installed pack {}", + old.manifest.id + )); + } + } + let previous = installed + .iter() + .find(|pack| pack.manifest.id == parsed.manifest.id) + .map(|pack| (pack.path.clone(), pack.manifest.revision, pack.fingerprint)); + let directory = root.join("language-packs"); + let path = install_bytes( + &directory, + &parsed.manifest.id, + parsed.manifest.revision, + previous, + &bytes, + )?; + let id = parsed.manifest.id.clone(); + let parsed = parse_language(&bytes, path)?; + let mut packs = LANGUAGE_PACKS.write().unwrap(); + packs.retain(|pack| pack.manifest.id != id); + packs.push(parsed); + packs.sort_by(|a, b| a.manifest.id.cmp(&b.manifest.id)); + Ok(id) +} + +pub fn install_theme(root: &Path, source: &Path) -> Result { + let bytes = bounded_read(source)?; + let parsed = parse_theme(&bytes, PathBuf::new())?; + let installed = THEME_PACKS.read().unwrap().clone(); + let previous = installed + .iter() + .find(|pack| pack.manifest.id == parsed.manifest.id) + .map(|pack| (pack.path.clone(), pack.manifest.revision, pack.fingerprint)); + let directory = root.join("theme-packs"); + let path = install_bytes( + &directory, + &parsed.manifest.id, + parsed.manifest.revision, + previous, + &bytes, + )?; + let id = parsed.manifest.id.clone(); + let parsed = parse_theme(&bytes, path)?; + let mut packs = THEME_PACKS.write().unwrap(); + packs.retain(|pack| pack.manifest.id != id); + packs.push(parsed); + packs.sort_by(|a, b| a.manifest.id.cmp(&b.manifest.id)); + Ok(id) +} + +pub fn language_packs() -> Vec { + LANGUAGE_PACKS + .read() + .unwrap() + .iter() + .map(|pack| InstalledLanguagePack { + id: pack.manifest.id.clone(), + revision: pack.manifest.revision, + languages: pack.manifest.languages.clone(), + }) + .collect() +} + +pub fn theme_packs() -> Vec { + THEME_PACKS + .read() + .unwrap() + .iter() + .map(|pack| InstalledThemePack { + id: pack.manifest.id.clone(), + revision: pack.manifest.revision, + themes: pack.manifest.themes.clone(), + notices: pack.manifest.notices.clone(), + }) + .collect() +} + +pub fn translation(locale: &str, source: &str) -> Option<&'static str> { + LANGUAGE_PACKS + .read() + .unwrap() + .iter() + .find_map(|pack| pack.catalogs.get(locale)?.get(source).copied()) +} + +pub fn language_name(locale: &str) -> Option { + LANGUAGE_PACKS.read().unwrap().iter().find_map(|pack| { + pack.manifest + .languages + .iter() + .find(|language| language.locale == locale) + .map(|language| format!("{} — {}", language.native_name, language.name)) + }) +} + +pub fn theme_choices() -> Vec<(String, String)> { + THEME_PACKS + .read() + .unwrap() + .iter() + .flat_map(|pack| { + pack.manifest.themes.iter().map(|theme| { + ( + format!("{}/{}", pack.manifest.id, theme.id), + theme.name.clone(), + ) + }) + }) + .collect() +} + +pub fn packed_theme(choice: &str) -> Option<(Palette, bool, String)> { + let (pack_id, theme_id) = choice.split_once('/')?; + THEME_PACKS.read().unwrap().iter().find_map(|pack| { + if pack.manifest.id != pack_id { + return None; + } + let theme = pack + .manifest + .themes + .iter() + .find(|theme| theme.id == theme_id)?; + Some(( + theme.colors.palette().ok()?, + theme.light, + theme.name.clone(), + )) + }) +} + +pub fn pack_root(settings_path: &Path) -> Result<&Path, String> { + settings_path + .parent() + .ok_or("Settings directory unavailable".into()) +} + +#[cfg(test)] +mod tests { + use super::*; + use std::io::Write; + + fn archive(files: &[(&str, &[u8])]) -> Vec { + let mut writer = zip::ZipWriter::new(std::io::Cursor::new(Vec::new())); + for (name, bytes) in files { + writer + .start_file(*name, zip::write::SimpleFileOptions::default()) + .unwrap(); + writer.write_all(bytes).unwrap(); + } + writer.finish().unwrap().into_inner() + } + + #[test] + fn example_packs_install_load_and_resolve() { + let temp = tempfile::tempdir().unwrap(); + let language = temp.path().join("language.zip"); + let theme = temp.path().join("theme.zip"); + std::fs::write( + &language, + include_bytes!("../../../docs/packs/deckstride-language-pack.zip"), + ) + .unwrap(); + std::fs::write( + &theme, + include_bytes!("../../../docs/packs/deckstride-theme-pack.zip"), + ) + .unwrap(); + assert_eq!( + install_language(temp.path(), &language).unwrap(), + "example-language" + ); + assert_eq!(translation("eo-example", "Close"), Some("Fermi")); + assert_eq!(install_theme(temp.path(), &theme).unwrap(), "example-theme"); + assert!(packed_theme("example-theme/night").is_some()); + assert!(load(temp.path()).is_empty()); + assert_eq!(language_packs()[0].revision, 1); + assert_eq!(theme_packs()[0].revision, 1); + let ctx = egui::Context::default(); + crate::localization::apply_selected( + &ctx, + &crate::localization::Language::En, + Some("eo-example"), + ); + assert_eq!(crate::localization::tr(&ctx, "Close"), "Fermi"); + crate::theme::apply_selected( + &ctx, + crate::theme::Theme::Midra, + Some("example-theme/night"), + ); + assert_eq!( + ctx.global_style().visuals.panel_fill, + color("#101820").unwrap() + ); + let mut manifest: serde_json::Value = serde_json::from_str(include_str!( + "../../../docs/packs/language-example/manifest.json" + )) + .unwrap(); + manifest["revision"] = 2.into(); + let updated = archive(&[ + ("manifest.json", &serde_json::to_vec(&manifest).unwrap()), + ( + "eo-example.json", + include_bytes!("../../../docs/packs/language-example/eo-example.json"), + ), + ]); + std::fs::write( + temp.path().join("language-packs/example-language.zip"), + b"changed", + ) + .unwrap(); + std::fs::write(&language, updated).unwrap(); + assert!( + install_language(temp.path(), &language) + .unwrap_err() + .contains("changed on disk") + ); + } + + #[test] + fn malformed_and_traversing_archives_are_rejected() { + let bad = archive(&[("../manifest.json", b"{}")]); + assert!(parse_language(&bad, PathBuf::new()).is_err()); + assert!(parse_theme(&bad, PathBuf::new()).is_err()); + } +} diff --git a/crates/deckstride/src/presenter_ui.rs b/crates/deckstride/src/presenter_ui.rs index 7a5ae96..3a2370d 100644 --- a/crates/deckstride/src/presenter_ui.rs +++ b/crates/deckstride/src/presenter_ui.rs @@ -2415,31 +2415,133 @@ fn appearance_preferences(ui: &mut Ui, s: &mut Studio) { .show(ui, |ui| { ui.label(tr(&locale, "Theme")); egui::ComboBox::from_id_salt("preferences-theme") - .selected_text(s.settings.theme.name()) + .selected_text(match s.settings.theme_pack.as_deref() { + Some(choice) => crate::packs::packed_theme(choice) + .map_or_else(|| format!("{choice} (unavailable)"), |(_, _, name)| name), + None => s.settings.theme.name().to_owned(), + }) .show_ui(ui, |ui| { for theme in crate::theme::Theme::ALL { - changed |= ui - .selectable_value(&mut s.settings.theme, theme, theme.name()) - .changed(); + if ui + .selectable_label( + s.settings.theme_pack.is_none() && s.settings.theme == theme, + theme.name(), + ) + .clicked() + { + s.settings.theme = theme; + s.settings.theme_pack = None; + changed = true; + } + } + let packed = crate::packs::theme_choices(); + if !packed.is_empty() { + ui.separator(); + } + for (choice, name) in packed { + if ui + .selectable_label( + s.settings.theme_pack.as_deref() == Some(choice.as_str()), + name, + ) + .clicked() + { + s.settings.theme_pack = Some(choice); + changed = true; + } } }); ui.end_row(); ui.label(tr(&locale, "Language")); egui::ComboBox::from_id_salt("preferences-language") - .selected_text(s.settings.language.name()) + .selected_text(match s.settings.language_pack.as_deref() { + Some(locale) => crate::packs::language_name(locale) + .unwrap_or_else(|| format!("{locale} (unavailable)")), + None => s.settings.language.name().to_owned(), + }) .show_ui(ui, |ui| { for language in crate::localization::Language::ALL { - changed |= ui - .selectable_value( - &mut s.settings.language, - language, + if ui + .selectable_label( + s.settings.language_pack.is_none() + && s.settings.language == language, language.name(), ) - .changed(); + .clicked() + { + s.settings.language = language; + s.settings.language_pack = None; + changed = true; + } + } + let packed: Vec<_> = crate::packs::language_packs() + .into_iter() + .flat_map(|pack| pack.languages) + .collect(); + if !packed.is_empty() { + ui.separator(); + } + for language in packed { + let name = format!("{} — {}", language.native_name, language.name); + if ui + .selectable_label( + s.settings.language_pack.as_deref() + == Some(language.locale.as_str()), + name, + ) + .clicked() + { + s.settings.language_pack = Some(language.locale); + changed = true; + } } }); ui.end_row(); }); + ui.horizontal_wrapped(|ui| { + if ui + .add_enabled( + s.initialized && !s.dialog_busy, + egui::Button::new(tr(&locale, "Import language pack…")), + ) + .clicked() + { + s.actions.push(Action::PickLanguagePack); + } + if ui + .add_enabled( + s.initialized && !s.dialog_busy, + egui::Button::new(tr(&locale, "Import theme pack…")), + ) + .clicked() + { + s.actions.push(Action::PickThemePack); + } + }); + let language_packs = crate::packs::language_packs(); + let theme_packs = crate::packs::theme_packs(); + if !language_packs.is_empty() || !theme_packs.is_empty() { + egui::CollapsingHeader::new(tr(&locale, "Installed packs")) + .id_salt("installed-appearance-packs") + .show(ui, |ui| { + for pack in language_packs { + ui.label(format!( + "{} · r{} · {} language(s)", + pack.id, + pack.revision, + pack.languages.len() + )); + } + for pack in theme_packs { + ui.label(format!( + "{} · r{} · {} theme(s)", + pack.id, + pack.revision, + pack.themes.len() + )); + } + }); + } ui.separator(); for (label, color) in [ ( @@ -2463,6 +2565,16 @@ fn appearance_preferences(ui: &mut Ui, s: &mut Studio) { if changed { s.new_output = true; s.save_preferences(); + crate::theme::apply_selected( + &locale, + s.settings.theme, + s.settings.theme_pack.as_deref(), + ); + crate::localization::apply_selected( + &locale, + &s.settings.language, + s.settings.language_pack.as_deref(), + ); ui.ctx().request_repaint(); } }); diff --git a/crates/deckstride/src/settings.rs b/crates/deckstride/src/settings.rs index 3c3da1f..bac788a 100644 --- a/crates/deckstride/src/settings.rs +++ b/crates/deckstride/src/settings.rs @@ -286,7 +286,9 @@ pub struct Settings { pub zoom_enabled: bool, pub zoom_keep_fitted_area: bool, pub theme: crate::theme::Theme, + pub theme_pack: Option, pub language: crate::localization::Language, + pub language_pack: Option, } /// Choose a per-process decoded-frame budget from available physical RAM. /// Prefer 15%, with a soft 512 MiB floor that never exceeds 20% (except the @@ -337,7 +339,9 @@ impl Default for Settings { zoom_enabled: false, zoom_keep_fitted_area: false, theme: Default::default(), + theme_pack: None, language: Default::default(), + language_pack: None, } } } @@ -346,6 +350,17 @@ impl Settings { if self.version != 1 { return Err(format!("Unsupported settings version {}", self.version)); } + if self + .theme_pack + .as_deref() + .is_some_and(|choice| !crate::packs::valid_theme_choice(choice)) + || self + .language_pack + .as_deref() + .is_some_and(|locale| !crate::packs::valid_id(locale)) + { + return Err("Invalid language or theme pack choice".into()); + } self.disk_cache.validate()?; if !(64..=16384).contains(&self.buffer_mib) { return Err("RAM buffer must be 64–16384 MiB per process".into()); diff --git a/crates/deckstride/src/studio.rs b/crates/deckstride/src/studio.rs index 2014fe3..6852e79 100644 --- a/crates/deckstride/src/studio.rs +++ b/crates/deckstride/src/studio.rs @@ -23,6 +23,8 @@ pub enum Action { Pick(bool), PickNotes, PickBlankPicture, + PickLanguagePack, + PickThemePack, SetBlankPicture(PathBuf), ClearBlankPicture, #[cfg(target_os = "windows")] @@ -221,6 +223,14 @@ impl Studio { settings_path = dir.path().join("settings.toml"); cache_path = dir.path().join("cache"); } + let pack_errors = if smoke { + Vec::new() + } else { + settings_path + .parent() + .map(crate::packs::load) + .unwrap_or_else(|| vec!["Settings directory unavailable for packs".into()]) + }; let io = Bridge::with_program(Duration::from_secs(10), worker_program.clone()); io.submit(0, 0, Request::LoadSettings(settings_path.clone())); Self { @@ -247,7 +257,14 @@ impl Studio { blank_picture: None, blank_busy: false, blank_loader: Bridge::with_program(Duration::from_secs(15), worker_program.clone()), - status: "Ready — open a PDF or picture folder, or drop it here.".into(), + status: if pack_errors.is_empty() { + "Ready — open a PDF or picture folder, or drop it here.".into() + } else { + format!( + "Some language/theme packs were skipped: {}", + pack_errors.join("; ") + ) + }, awake_status: "Sleep protection starting…".into(), generation: 0, frames: HashMap::new(), @@ -631,6 +648,25 @@ impl Studio { self.status = "Choose a TXT or Markdown notes file.".into(); } } + pack_action @ (Action::PickLanguagePack | Action::PickThemePack) => { + if self.initialized && !self.dialog_busy { + let language = matches!(pack_action, Action::PickLanguagePack); + self.dialog_busy = self.dialog.submit( + 0, + if language { 3 } else { 4 }, + Request::PickPack { + language, + owner: self.dialog_owner, + }, + ); + self.status = if language { + "Choose a Deckstride language-pack ZIP." + } else { + "Choose a Deckstride theme-pack ZIP." + } + .into(); + } + } Action::ImportNotes(import) => { if self.loading || self.notes_editor.is_some() @@ -1313,6 +1349,19 @@ impl Studio { if let Some(path) = p.reply.picked { if c.tag == 2 { self.execute(Action::SetBlankPicture(path)); + } else if c.tag == 3 || c.tag == 4 { + let result = + crate::packs::pack_root(&self.settings_path).and_then(|root| { + if c.tag == 3 { + crate::packs::install_language(root, &path) + .map(|id| format!("Installed language pack {id}.")) + } else { + crate::packs::install_theme(root, &path) + .map(|id| format!("Installed theme pack {id}.")) + } + }); + self.status = result + .unwrap_or_else(|error| format!("Could not install pack: {error}")); } else if c.tag == 1 { if c.generation == self.generation { self.execute(Action::ImportNotes(path)); diff --git a/crates/deckstride/src/theme.rs b/crates/deckstride/src/theme.rs index 90de9aa..3006ef3 100644 --- a/crates/deckstride/src/theme.rs +++ b/crates/deckstride/src/theme.rs @@ -53,6 +53,12 @@ pub struct Palette { pub purple: Color32, } +#[derive(Clone, Debug, PartialEq, Eq)] +enum AppliedTheme { + Builtin(Theme), + Pack(String), +} + impl Theme { pub const ALL: [Self; 20] = [ Self::Midra, @@ -276,54 +282,78 @@ impl Theme { } } pub fn apply(&self, ctx: &egui::Context) { - let applied = egui::Id::new("deckstride-theme"); - if ctx.data(|data| data.get_temp::(applied)) == Some(*self) { - return; - } - let p = self.palette(); - let mut v = if self.is_light() { - egui::Visuals::light() - } else { - egui::Visuals::dark() - }; - v.override_text_color = Some(p.text); - v.panel_fill = p.bg; - v.window_fill = p.panel; - v.extreme_bg_color = p.field; - v.faint_bg_color = p.bg; - v.hyperlink_color = p.cyan; - v.warn_fg_color = p.amber; - v.error_fg_color = if self.is_light() { - Color32::from_rgb(165, 30, 40) - } else { - Color32::LIGHT_RED - }; - v.window_stroke = egui::Stroke::new(1_f32, p.line); - v.selection.bg_fill = p.purple; - v.selection.stroke.color = p.text; - for (w, fill) in [ - (&mut v.widgets.noninteractive, p.panel), - (&mut v.widgets.inactive, p.field), - (&mut v.widgets.hovered, p.panel.lerp_to_gamma(p.text, 0.08)), - (&mut v.widgets.active, p.purple), - (&mut v.widgets.open, p.panel), - ] { - w.bg_fill = fill; - w.weak_bg_fill = fill; - w.bg_stroke = egui::Stroke::new( - if *self == Self::HighContrast { - 2_f32 - } else { - 1_f32 - }, - p.line, - ); - w.fg_stroke = egui::Stroke::new(1_f32, p.text); - } - ctx.set_visuals(v); - ctx.data_mut(|data| data.insert_temp(applied, *self)); + apply_palette( + ctx, + AppliedTheme::Builtin(*self), + self.palette(), + self.is_light(), + *self == Self::HighContrast, + ); } } + +pub fn apply_selected(ctx: &egui::Context, builtin: Theme, packed: Option<&str>) { + if let Some(choice) = packed + && let Some((palette, light, _)) = crate::packs::packed_theme(choice) + { + apply_palette( + ctx, + AppliedTheme::Pack(choice.to_owned()), + palette, + light, + false, + ); + } else { + builtin.apply(ctx); + } +} + +fn apply_palette( + ctx: &egui::Context, + choice: AppliedTheme, + p: Palette, + light: bool, + high_contrast: bool, +) { + let applied = egui::Id::new("deckstride-theme"); + if ctx.data(|data| data.get_temp::(applied)) == Some(choice.clone()) { + return; + } + let mut v = if light { + egui::Visuals::light() + } else { + egui::Visuals::dark() + }; + v.override_text_color = Some(p.text); + v.panel_fill = p.bg; + v.window_fill = p.panel; + v.extreme_bg_color = p.field; + v.faint_bg_color = p.bg; + v.hyperlink_color = p.cyan; + v.warn_fg_color = p.amber; + v.error_fg_color = if light { + Color32::from_rgb(165, 30, 40) + } else { + Color32::LIGHT_RED + }; + v.window_stroke = egui::Stroke::new(1_f32, p.line); + v.selection.bg_fill = p.purple; + v.selection.stroke.color = p.text; + for (w, fill) in [ + (&mut v.widgets.noninteractive, p.panel), + (&mut v.widgets.inactive, p.field), + (&mut v.widgets.hovered, p.panel.lerp_to_gamma(p.text, 0.08)), + (&mut v.widgets.active, p.purple), + (&mut v.widgets.open, p.panel), + ] { + w.bg_fill = fill; + w.weak_bg_fill = fill; + w.bg_stroke = egui::Stroke::new(if high_contrast { 2_f32 } else { 1_f32 }, p.line); + w.fg_stroke = egui::Stroke::new(1_f32, p.text); + } + ctx.set_visuals(v); + ctx.data_mut(|data| data.insert_temp(applied, choice)); +} fn sotv_palette(colors: [u32; 8], light: bool) -> Palette { let [bg, panel, field, layer, text, subtle, accent, line] = colors.map(|hex| Color32::from_rgb((hex >> 16) as u8, (hex >> 8) as u8, hex as u8)); diff --git a/crates/deckstride/src/worker.rs b/crates/deckstride/src/worker.rs index e998bda..03c39eb 100644 --- a/crates/deckstride/src/worker.rs +++ b/crates/deckstride/src/worker.rs @@ -56,6 +56,10 @@ pub enum Request { PickNotes { owner: Option, }, + PickPack { + language: bool, + owner: Option, + }, PrepareNotes { path: PathBuf, cache: PathBuf, @@ -277,6 +281,23 @@ pub fn run() -> Result<(), String> { .add_filter("Notes (TXT, Markdown)", &["txt", "md"]) .pick_file(); } + Request::PickPack { language, owner } => { + reply.picked = picker_dialog(owner)? + .set_title(if language { + "Import language pack" + } else { + "Import theme pack" + }) + .add_filter( + if language { + "Language pack" + } else { + "Theme pack" + }, + &["zip"], + ) + .pick_file(); + } Request::PrepareNotes { path, cache, diff --git a/crates/deckstride/tests/settings.rs b/crates/deckstride/tests/settings.rs index 63aac70..4cde3b8 100644 --- a/crates/deckstride/tests/settings.rs +++ b/crates/deckstride/tests/settings.rs @@ -24,7 +24,9 @@ fn settings_roundtrip_preserves_project_overrides_and_hidden_bars() { settings.buffer_mib = 2048; settings.auto_show = false; settings.theme = deckstride::theme::Theme::CorporateLight; + settings.theme_pack = Some("example-theme/night".into()); settings.language = deckstride::localization::Language::Fr; + settings.language_pack = Some("eo-example".into()); let mut project = Layout::default(); project.previous.show = true; // Explicit opt-in survives saving and loading. project.current.show = false; @@ -46,7 +48,9 @@ fn settings_roundtrip_preserves_project_overrides_and_hidden_bars() { assert_eq!(loaded.buffer_mib, 2048); assert!(!loaded.auto_show); assert_eq!(loaded.theme, settings.theme); + assert_eq!(loaded.theme_pack, settings.theme_pack); assert_eq!(loaded.language, settings.language); + assert_eq!(loaded.language_pack, settings.language_pack); let bytes = std::fs::read(&path).unwrap(); settings.version = 2; assert!(settings::write(&path, &settings).is_err()); diff --git a/docs/changelog.md b/docs/changelog.md index b186c16..e5838ea 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -2,6 +2,13 @@ ## Unreleased +### 0.1.101 + +- Import bounded, data-only language and theme ZIP packs from Preferences. Packs use + Canvas Pilot-compatible manifests, persist beside settings, load offline at startup + and appear in the existing selectors without restarting. +- Add editable example packs, ready-to-import ZIPs and pack-format documentation. + ### 0.1.100 - Keep the Preferences window size stable while the pointer moves by removing a diff --git a/docs/packs/README.md b/docs/packs/README.md new file mode 100644 index 0000000..cd64f32 --- /dev/null +++ b/docs/packs/README.md @@ -0,0 +1,29 @@ +# Deckstride language and theme packs + +Install either example from **Preferences → General → Appearance**. Packs remain +ZIP files and are copied into Deckstride's configuration directory; they contain +data only and are never extracted or executed. + +## Language pack + +`deckstride-language-pack.zip` uses the same version-2 manifest shape as Canvas +Pilot: `manifest.json` and one root `.json` per language. Catalog keys are +Deckstride's exact visible English source strings, and missing keys fall back to +English. A pack may contain 1–16 languages. Pack/locale IDs use lowercase ASCII +letters, digits and hyphens. Increase the positive `revision` to publish an update. + +Limits: 2 MiB ZIP, 4 MiB expanded data, 32 installed packs, 4,096 messages per +catalog, and no paths, directories, symlinks or unexpected files. + +## Theme pack + +`deckstride-theme-pack.zip` is a Canvas Pilot format-1 theme pack containing one +root `manifest.json`. It can contain 1–16 complete themes. Colors are opaque +`#RRGGBB` values using the shared Canvas Pilot roles. `light` selects egui's light +or dark base behavior. Keep license and attribution text in `notices`. + +Limits: 2 MiB ZIP, 4 MiB manifest, 32 installed packs, and no executable content. + +Higher revisions replace an installed pack with the same ID. Equal or older +revisions are rejected, preventing accidental downgrades. Invalid packs are skipped +at startup and reported in the Presenter status line. diff --git a/docs/packs/deckstride-language-pack.zip b/docs/packs/deckstride-language-pack.zip new file mode 100644 index 0000000..9be0035 Binary files /dev/null and b/docs/packs/deckstride-language-pack.zip differ diff --git a/docs/packs/deckstride-theme-pack.zip b/docs/packs/deckstride-theme-pack.zip new file mode 100644 index 0000000..dd1480b Binary files /dev/null and b/docs/packs/deckstride-theme-pack.zip differ diff --git a/docs/packs/language-example/eo-example.json b/docs/packs/language-example/eo-example.json new file mode 100644 index 0000000..800bc83 --- /dev/null +++ b/docs/packs/language-example/eo-example.json @@ -0,0 +1,16 @@ +{ + "Preferences": "Agordoj", + "General": "Ĝenerala", + "Performance": "Rendimento", + "Storage": "Konservejo", + "Theme": "Etoso", + "Language": "Lingvo", + "Close": "Fermi", + "Menu": "Menuo", + "Presenter": "Prezentanto", + "Slides": "Lumbildoj", + "Previous": "Antaŭa", + "Next": "Sekva", + "Show slides": "Montri lumbildojn", + "Blank slides": "Kaŝi lumbildojn" +} diff --git a/docs/packs/language-example/manifest.json b/docs/packs/language-example/manifest.json new file mode 100644 index 0000000..f57ab8e --- /dev/null +++ b/docs/packs/language-example/manifest.json @@ -0,0 +1,12 @@ +{ + "version": 2, + "id": "example-language", + "revision": 1, + "languages": [ + { + "locale": "eo-example", + "name": "Example Esperanto", + "native_name": "Ekzempla Esperanto" + } + ] +} diff --git a/docs/packs/theme-example/manifest.json b/docs/packs/theme-example/manifest.json new file mode 100644 index 0000000..5b1b563 --- /dev/null +++ b/docs/packs/theme-example/manifest.json @@ -0,0 +1,29 @@ +{ + "version": 1, + "id": "example-theme", + "revision": 1, + "themes": [ + { + "id": "night", + "name": "Example Night", + "light": false, + "colors": { + "canvas": "#15202b", + "banner": "#203040", + "grid": "#3e5870", + "layer": "#26394a", + "pattern": ["#24384a", "#182634"], + "bg": "#101820", + "panel": "#192733", + "field": "#0d151c", + "line": "#42627d", + "text": "#eef7ff", + "muted": "#aec7d9", + "cyan": "#65d9ef", + "amber": "#f0c674", + "purple": "#554b9a" + } + } + ], + "notices": "Original example palette for Deckstride. CC0-1.0; attribution is not required." +} diff --git a/docs/user-guide.md b/docs/user-guide.md index 7ebdb8f..70ad82f 100644 --- a/docs/user-guide.md +++ b/docs/user-guide.md @@ -17,7 +17,7 @@ folder in a permanent location and run `python3 install-linux-launcher.py` there Python is only needed for this optional installer; no administrator privileges are required. -On Windows, use **Menu → Preferences… → Set as default PDF app…** to register the +On Windows, use **Menu → Preferences… → General → Set as default PDF app…** to register the portable executable for the current user. Windows opens Default Apps for the required confirmation. Once Deckstride is selected for `.pdf`, Explorer uses the icon embedded in `deckstride.exe` for PDF files. Keep @@ -27,7 +27,7 @@ To update, close Deckstride, download and extract the new portable release, and run its executable. Settings and saved layouts live in your user configuration directory, outside the extracted folder. If you installed the Linux launcher, rerun its installer from the new location so it points to the updated binary. -**Menu → Preferences… → Storage and preparation** shows the full path of the +**Menu → Preferences… → Storage** shows the full path of the currently running executable, so you can find its portable folder when updating or removing the application. @@ -222,7 +222,7 @@ fit; separate copies for every smaller resolution would waste RAM. The current renderer limit is 4096 pixels per side, shown in the Preferences window. Resolution changes start a new preparation pass with a new buffer identity. -Processed frames are kept in the application's persistent cache; **Menu → Preferences… → Storage and preparation** shows its +Processed frames are kept in the application's persistent cache; **Menu → Preferences… → Storage** shows its location. Reopening with unchanged source contents, resolution and renderer reuses those frames without PDF rasterization or image decoding. It still verifies source identity/checksums and reads frames into RAM: a restart cannot literally take zero @@ -243,7 +243,7 @@ Navigation then performs no application slide-file reads, PDF rendering or image decoding. Raster composition still happens, and the OS can page memory under pressure. The entire deck stays resident when it fits the configured RAM budget. -**Menu → Preferences… → Memory and cache** controls the decoded-slide allowance for **each process**, default +**Menu → Preferences… → Performance** controls the decoded-slide allowance for **each process**, default 15% of available RAM, with a soft 512 MiB minimum that yields when it would exceed 20% of available RAM. The adjustable range is 64–16384 MiB. Saved budgets are preserved; the automatic default is chosen when no budget has been saved. Presenter and output can each consume @@ -300,18 +300,26 @@ The numbered screen rectangles in **Displays** reflect each monitor’s pixel as ratio, so portrait, standard and ultrawide displays are easier to distinguish. They represent proportions, not physical screen size. -Menu → Appearance → Theme offers the same 20 built-in palettes as Canvas Pilot, -including light, dark and High Contrast. Menu → Appearance → Language offers System, -English, French, Spanish, Japanese, Simplified Chinese, German and Brazilian +**Preferences → General → Appearance** offers the same 20 built-in palettes as +Canvas Pilot, including light, dark and High Contrast. Its Language selector offers +System, English, French, Spanish, Japanese, Simplified Chinese, German and Brazilian Portuguese. System uses the native OS locale when it matches one of these choices and otherwise falls back to English. Traditional Chinese is not silently treated as Simplified Chinese. Choices are saved globally and apply to all presenter/browser windows; slides are never recolored. -Translations are built into the executable and need no runtime file reads. Japanese -and Chinese use the bundled Noto Sans CJK font, loaded only when one of those languages -is active. Theme styles and language fonts are rebuilt only when their selection -changes. Detailed worker and operating-system diagnostics remain verbatim. +Choose **Import language pack…** or **Import theme pack…** in the same section to +install a bounded ZIP. Installed languages and themes join the selectors immediately +and load offline on later starts. Higher revisions update a pack; equal or older +revisions are rejected. The ZIP is copied beside settings and is never extracted or +executed. The [pack guide](packs/README.md) includes editable sources and +ready-to-import examples. + +Built-in translations need no runtime file reads; imported catalogs are read once at +startup and retained in memory. Japanese and Chinese use the bundled Noto Sans CJK +font, loaded only when one of those built-in languages is active. Theme styles and +language fonts are rebuilt only when their selection changes. Detailed worker and +operating-system diagnostics remain verbatim. All slides opens a windowed browser above fullscreen windows and requests focus. Opening it again restores/focuses the existing browser. Its Close button dismisses it; Escape requests application quit confirmation. @@ -467,7 +475,7 @@ output. It cannot predict compositor/hardware delays or guarantee a frame rate. ### Disk cache cleanup -In **Menu → Preferences… → Memory and cache**, set the maximum total size in MiB and +In **Menu → Preferences… → Performance**, set the maximum total size in MiB and lifetime in days since rendering (defaults: 10 GiB and 30 days). Automatic cleanup runs once at startup, after initial document loading and slide preparation complete, deleting expired files and then the oldest files to meet the size target. Changing limits takes effect at the next startup; manual expunge remains @@ -477,7 +485,7 @@ background. Active decks are protected and may temporarily exceed either limit. The cleanup report shows removed and remaining data; deleted slides regenerate when reopened. Source documents and presenter notes are preserved. -Choose **Menu → Preferences… → Blank Slides image → Choose picture…** to replace the +Choose **Menu → Preferences… → General → Blank Slides image → Choose picture…** to replace the black blanking screen with your own picture on every Slides screen. The app saves a copy, fits the whole image against black, and remembers it across restarts. The original may then be moved or removed. Use **Use solid black** to reset.