Compare commits

..

6 Commits

Author SHA1 Message Date
Dandaedre bf8c57c344 Prepare Deckstride 0.1.101 release
Gitea/Deckstride/pipeline/head This commit looks good Details
2026-11-21 16:18:55 +01:00
Dandaedre 00c8ed0697 Add importable language and theme packs 2026-11-21 16:11:51 +01:00
Dandaedre 3ca73d86cd Keep preferences window size stable
Gitea/Deckstride/pipeline/head This commit looks good Details
2026-11-21 15:35:07 +01:00
Dandaedre d41b8ab614 Organize preferences into tabs
Gitea/Deckstride/pipeline/head This commit looks good Details
2026-11-21 15:28:20 +01:00
Dandaedre aad895bc61 Shorten presenter menu 2026-11-21 15:23:45 +01:00
Dandaedre 2f98df4674 Configure releases for Gitea and GitHub 2026-11-21 15:11:56 +01:00
27 changed files with 1907 additions and 328 deletions

50
Cargo.lock generated
View File

@ -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.96"
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"

View File

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

View File

@ -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).

View File

@ -65,6 +65,12 @@ Source: https://github.com/nical/android_system_properties
LICENSE-APACHE: text 216486f29671a426
LICENSE-MIT: text 80f275e90d799911
arbitrary 1.5.0
License expression: MIT OR Apache-2.0
Source: https://github.com/rust-fuzz/arbitrary/
LICENSE-APACHE: text a60eea8175145316
LICENSE-MIT: text 15656cc11a8331f2
arrayref 0.3.9
License expression: BSD-2-Clause
Source: https://github.com/droundy/arrayref
@ -401,6 +407,12 @@ License expression: MIT
Source: https://github.com/TedDriggs/darling
LICENSE: text 8ea93490d74a5a1b
derive_arbitrary 1.5.0
License expression: MIT OR Apache-2.0
Source: https://github.com/rust-fuzz/arbitrary
LICENSE-APACHE: text a60eea8175145316
LICENSE-MIT: text 15656cc11a8331f2
derive_builder 0.20.2
License expression: MIT OR Apache-2.0
Source: https://github.com/colin-kiegel/rust-derive-builder
@ -2463,6 +2475,11 @@ License expression: Unicode-3.0
Source: https://github.com/unicode-org/icu4x
LICENSE: text f367c1b8e1aa2624
zip 2.6.1
License expression: MIT
Source: https://github.com/zip-rs/zip2.git
LICENSE: text 04dc52136d82400b
zlib-rs 0.6.8
License expression: Zlib
Source: https://github.com/trifectatechfoundation/zlib-rs
@ -2473,6 +2490,11 @@ License expression: MIT
Source: https://github.com/dtolnay/zmij
LICENSE-MIT: text 23f18e03dc49df91
zopfli 0.8.4
License expression: Apache-2.0
Source: https://github.com/zopfli-rs/zopfli
COPYING: text 018b1cb87efdf7a0
zune-core 0.5.3
License expression: MIT OR Apache-2.0 OR Zlib
Source: https://github.com/etemesi254/zune-image
@ -2504,6 +2526,210 @@ Source: https://github.com/z-galaxy/zbus/
LICENSE TEXTS
=== 018b1cb87efdf7a0 ===
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2011 Google Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
=== 01c266bced4a434d ===
This project is dual-licensed under the Unlicense and MIT licenses.
@ -2821,6 +3047,32 @@ SOFTWARE.
=== 04dc52136d82400b ===
The MIT License (MIT)
Copyright (c) 2014 Mathijs van de Nes
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Some files in the "tests/data" subdirectory of this repository are under other
licences; see files named LICENSE.*.txt for details.
=== 04ea4849dba9dcae ===
Apache License
Version 2.0, January 2004
@ -3697,6 +3949,36 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
=== 15656cc11a8331f2 ===
MIT License
Copyright (c) 2019 Manish Goregaokar
Permission is hereby granted, free of charge, to any
person obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the
Software without restriction, including without
limitation the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software
is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice
shall be included in all copies or substantial portions
of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
=== 1847e0e0698142ed ===
MIT License

View File

@ -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"

View File

@ -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;

View File

@ -64,6 +64,12 @@ enum ResolvedLanguage {
PtBr,
}
#[derive(Clone, Debug, PartialEq, Eq)]
struct ActiveLanguage {
builtin: ResolvedLanguage,
pack: Option<String>,
}
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::<ResolvedLanguage>(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::<ActiveLanguage>(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::<ResolvedLanguage>(language_id()))
.unwrap_or(ResolvedLanguage::En)
let active = ctx
.data(|data| data.get_temp::<ActiveLanguage>(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::<ResolvedLanguage>(language_id()))
.data(|data| data.get_temp::<ActiveLanguage>(language_id()))
.map(|active| active.builtin)
.unwrap_or(ResolvedLanguage::En)
{
ResolvedLanguage::Fr => {

View File

@ -194,7 +194,9 @@ struct NativeWindow {
zoom_slow: bool,
presentation_base: Option<PresentationBase>,
applied_theme: Option<crate::theme::Theme>,
applied_theme_pack: Option<Option<String>>,
applied_language: Option<crate::localization::Language>,
applied_language_pack: Option<Option<String>>,
#[cfg(target_os = "linux")]
browser_parent: Option<WindowId>,
}
@ -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};

View File

@ -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<LanguageDescription>,
}
#[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<LanguageDescription>,
}
#[derive(Clone)]
struct LanguagePack {
manifest: LanguageManifest,
catalogs: BTreeMap<String, BTreeMap<String, &'static str>>,
path: PathBuf,
fingerprint: [u8; 32],
}
#[derive(Clone, Debug, Deserialize)]
#[serde(deny_unknown_fields)]
struct ThemeManifest {
version: u32,
id: String,
revision: u64,
themes: Vec<ThemeDescription>,
#[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<ThemeDescription>,
pub notices: String,
}
#[derive(Clone)]
struct ThemePack {
manifest: ThemeManifest,
path: PathBuf,
fingerprint: [u8; 32],
}
static LANGUAGE_PACKS: LazyLock<RwLock<Vec<LanguagePack>>> =
LazyLock::new(|| RwLock::new(Vec::new()));
static THEME_PACKS: LazyLock<RwLock<Vec<ThemePack>>> = LazyLock::new(|| RwLock::new(Vec::new()));
#[derive(Default)]
struct InternPool {
values: BTreeMap<String, &'static str>,
bytes: usize,
}
static INTERNED: LazyLock<RwLock<InternPool>> = 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<Vec<u8>, 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<LanguagePack, String> {
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<String, String> = 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<Color32, String> {
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<Palette, String> {
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<ThemePack, String> {
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<Vec<PathBuf>, 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<String> {
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<PathBuf, String> {
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<String, String> {
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<String, String> {
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<InstalledLanguagePack> {
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<InstalledThemePack> {
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<String> {
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<u8> {
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());
}
}

View File

@ -1267,8 +1267,7 @@ fn presenter_view(
.show(|ui| {
egui::ScrollArea::vertical()
.max_height(
(screen.bottom() - trigger.rect.bottom() - 16.)
.clamp(80., 720.),
(screen.bottom() - trigger.rect.bottom() - 16.).max(80.),
)
.show(ui, |ui| menu(ui, s, &mut view.preferences_open));
});
@ -2406,6 +2405,331 @@ pub fn browser(ui: &mut Ui, s: &mut Studio, native: &mut UiState) {
quit_confirmation(ui.ctx(), s);
}
fn appearance_preferences(ui: &mut Ui, s: &mut Studio) {
let locale = ui.ctx().clone();
layout_section(ui, tr(&locale, "Appearance"), |ui| {
let mut changed = false;
egui::Grid::new("preferences-appearance-grid")
.num_columns(2)
.spacing(Vec2::new(12., 8.))
.show(ui, |ui| {
ui.label(tr(&locale, "Theme"));
egui::ComboBox::from_id_salt("preferences-theme")
.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 {
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(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 {
if ui
.selectable_label(
s.settings.language_pack.is_none()
&& s.settings.language == language,
language.name(),
)
.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 [
(
"Page background",
&mut s.settings.slide_colors.page_background,
),
(
"Fit padding color",
&mut s.settings.slide_colors.fit_padding,
),
] {
ui.horizontal(|ui| {
ui.label(tr(&locale, label));
changed |= ui.color_edit_button_srgb(color).changed();
});
}
ui.small(tr(
&locale,
"Page background fills transparency; fit padding fills space around the slide.",
));
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();
}
});
}
#[derive(Clone, Copy, Default, PartialEq, Eq)]
enum PreferencesTab {
#[default]
General,
Performance,
Storage,
}
fn general_preferences(ui: &mut Ui, s: &mut Studio) {
let locale = ui.ctx().clone();
appearance_preferences(ui, s);
ui.add_space(8.);
layout_section(ui, tr(&locale, "Blank Slides image"), |ui| {
ui.label(if s.settings.blank_picture {
tr(&locale, "Custom picture selected")
} else {
tr(&locale, "Solid black")
});
ui.horizontal_wrapped(|ui| {
if ui
.add_enabled(
s.initialized && !s.dialog_busy && !s.blank_busy,
egui::Button::new(tr(&locale, "Choose picture…")),
)
.clicked()
{
s.actions.push(Action::PickBlankPicture);
}
if ui
.add_enabled(
s.initialized && !s.dialog_busy && (s.settings.blank_picture || s.blank_busy),
egui::Button::new(tr(&locale, "Use solid black")),
)
.clicked()
{
s.actions.push(Action::ClearBlankPicture);
}
if s.blank_busy {
ui.spinner();
}
});
ui.small(tr(
&locale,
"A copy is saved and fitted to all Slides screens against a black background.",
));
});
#[cfg(target_os = "windows")]
{
ui.add_space(8.);
layout_section(ui, tr(&locale, "Default PDF application"), |ui| {
ui.label(tr(
&locale,
"Register Deckstride and its icon for PDF files in your Windows account.",
));
if ui.button(tr(&locale, "Set as default PDF app…")).clicked() {
s.actions.push(Action::RegisterPdfAssociation);
}
ui.small(tr(
&locale,
"Windows will open Default Apps; select Deckstride for .pdf to confirm.",
));
});
}
}
fn performance_preferences(ui: &mut Ui, s: &mut Studio) {
let locale = ui.ctx().clone();
layout_section(ui, tr(&locale, "Memory and cache"), |ui| {
ui.label(tr(
&locale,
"RAM budget per process (presenter + output each use this allowance):",
));
if ui
.add(egui::Slider::new(&mut s.settings.buffer_mib, 64..=16384).text("MiB"))
.changed()
{
s.remember_buffer_budget();
}
ui.small(tr(
&locale,
"Raise only within available RAM; OS paging can cause delays. Screen rendering is capped at 4096 px.",
));
ui.separator();
let mut changed = false;
ui.horizontal_wrapped(|ui| {
ui.label(tr(&locale, "Maximum total size (MiB)"));
changed |= ui
.add(
egui::DragValue::new(&mut s.settings.disk_cache.max_mib)
.range(64..=1048576)
.speed(64),
)
.changed();
});
ui.horizontal_wrapped(|ui| {
ui.label(tr(&locale, "Expire after (days since rendering)"));
changed |= ui
.add(egui::DragValue::new(&mut s.settings.disk_cache.max_days).range(1..=3650))
.changed();
});
if changed {
s.remember_cache_policy();
}
ui.small(tr(
&locale,
"Oldest files are removed first. Active decks are protected and may exceed the limit. Automatic cleanup runs once at startup, after loading and preparation finish.",
));
if ui
.add_enabled(
!s.cache_busy && !s.loading && s.initialized,
egui::Button::new(tr(&locale, "Expunge unused cache now")),
)
.clicked()
{
s.clean_cache(true);
}
if s.cache_busy {
ui.spinner();
}
ui.small(&s.cache_status);
});
}
fn storage_preferences(ui: &mut Ui, s: &Studio) {
let locale = ui.ctx().clone();
layout_section(ui, tr(&locale, "Storage and preparation"), |ui| {
ui.label(s.preparation_status());
ui.separator();
ui.label(egui::RichText::new(tr(&locale, "Application executable")).strong());
let executable = s.executable_path().display().to_string();
ui.add(
egui::Label::new(egui::RichText::new(&executable).monospace())
.selectable(true)
.wrap(),
)
.on_hover_text(&executable);
ui.small(tr(
&locale,
"This is the running portable executable. Use its containing folder to find or remove the application.",
));
ui.separator();
ui.label(format!(
"{}: {}",
tr(&locale, "Processed slides"),
s.cache_path.display()
));
ui.label(format!("Configuration: {}", s.settings_path.display()));
});
}
fn preferences_window(ctx: &egui::Context, s: &mut Studio, open: &mut bool) {
let locale = ctx.clone();
let mut window_open = true;
@ -2416,168 +2740,38 @@ fn preferences_window(ctx: &egui::Context, s: &mut Studio, open: &mut bool) {
.open(&mut window_open)
.collapsible(false)
.resizable(true)
.default_size(Vec2::new(620., 640.).min(screen - Vec2::splat(32.)))
.default_size(Vec2::new(620., 760.).min(screen - Vec2::splat(32.)))
.min_size(Vec2::new(360., 320.))
.max_size((screen - Vec2::splat(24.)).max(Vec2::splat(1.)))
.show(ctx, |ui| {
ui.spacing_mut().item_spacing = Vec2::new(8., 8.);
let scroll_height = (ui.available_height() - 52.).max(180.);
let tab_id = egui::Id::new("preferences-tab");
let mut tab = ctx
.data(|data| data.get_temp::<PreferencesTab>(tab_id))
.unwrap_or_default();
ui.horizontal(|ui| {
ui.selectable_value(&mut tab, PreferencesTab::General, tr(&locale, "General"));
ui.selectable_value(
&mut tab,
PreferencesTab::Performance,
tr(&locale, "Performance"),
);
ui.selectable_value(&mut tab, PreferencesTab::Storage, tr(&locale, "Storage"));
});
ctx.data_mut(|data| data.insert_temp(tab_id, tab));
ui.separator();
// Reserve the close row, separator and both surrounding item gaps. If
// this is short by even one gap, the body asks the resizable window to
// grow again on every repaint.
let scroll_height = (ui.available_height() - 60.).max(180.);
egui::ScrollArea::vertical()
.id_salt("preferences-scroll")
.id_salt(("preferences-scroll", tab as u8))
.auto_shrink([false, false])
.max_height(scroll_height)
.show(ui, |ui| {
layout_section(
ui,
tr(&locale, "Blank Slides image"),
|ui| {
ui.label(if s.settings.blank_picture {
tr(&locale, "Custom picture selected")
} else {
tr(&locale, "Solid black")
});
ui.horizontal_wrapped(|ui| {
if ui
.add_enabled(
s.initialized && !s.dialog_busy && !s.blank_busy,
egui::Button::new(tr(&locale, "Choose picture…")),
)
.clicked()
{
s.actions.push(Action::PickBlankPicture);
}
if ui
.add_enabled(
s.initialized
&& !s.dialog_busy
&& (s.settings.blank_picture || s.blank_busy),
egui::Button::new(tr(&locale, "Use solid black")),
)
.clicked()
{
s.actions.push(Action::ClearBlankPicture);
}
if s.blank_busy {
ui.spinner();
}
});
ui.small(tr(
&locale,
"A copy is saved and fitted to all Slides screens against a black background.",
));
},
);
#[cfg(target_os = "windows")]
{
ui.add_space(8.);
layout_section(
ui,
tr(&locale, "Default PDF application"),
|ui| {
ui.label(tr(
&locale,
"Register Deckstride and its icon for PDF files in your Windows account.",
));
if ui
.button(tr(&locale, "Set as default PDF app…"))
.clicked()
{
s.actions.push(Action::RegisterPdfAssociation);
}
ui.small(tr(
&locale,
"Windows will open Default Apps; select Deckstride for .pdf to confirm.",
));
},
);
}
ui.add_space(8.);
layout_section(ui, tr(&locale, "Memory and cache"), |ui| {
ui.label(tr(
&locale,
"RAM budget per process (presenter + output each use this allowance):",
));
if ui
.add(
egui::Slider::new(&mut s.settings.buffer_mib, 64..=16384)
.text("MiB"),
)
.changed()
{
s.remember_buffer_budget();
}
ui.small(tr(
&locale,
"Raise only within available RAM; OS paging can cause delays. Screen rendering is capped at 4096 px.",
));
ui.separator();
let mut changed = false;
ui.horizontal_wrapped(|ui| {
ui.label(tr(&locale, "Maximum total size (MiB)"));
changed |= ui
.add(
egui::DragValue::new(&mut s.settings.disk_cache.max_mib)
.range(64..=1048576)
.speed(64),
)
.changed();
});
ui.horizontal_wrapped(|ui| {
ui.label(tr(&locale, "Expire after (days since rendering)"));
changed |= ui
.add(
egui::DragValue::new(&mut s.settings.disk_cache.max_days)
.range(1..=3650),
)
.changed();
});
if changed {
s.remember_cache_policy();
}
ui.small(tr(
&locale,
"Oldest files are removed first. Active decks are protected and may exceed the limit. Automatic cleanup runs once at startup, after loading and preparation finish.",
));
if ui
.add_enabled(
!s.cache_busy && !s.loading && s.initialized,
egui::Button::new(tr(&locale, "Expunge unused cache now")),
)
.clicked()
{
s.clean_cache(true);
}
if s.cache_busy {
ui.spinner();
}
ui.small(&s.cache_status);
});
ui.add_space(8.);
layout_section(ui, tr(&locale, "Storage and preparation"), |ui| {
ui.label(s.preparation_status());
ui.separator();
ui.label(
egui::RichText::new(tr(&locale, "Application executable")).strong(),
);
let executable = s.executable_path().display().to_string();
ui.add(
egui::Label::new(egui::RichText::new(&executable).monospace())
.selectable(true)
.wrap(),
)
.on_hover_text(&executable);
ui.small(tr(
&locale,
"This is the running portable executable. Use its containing folder to find or remove the application.",
));
ui.separator();
ui.label(format!(
"{}: {}",
tr(&locale, "Processed slides"),
s.cache_path.display()
));
ui.label(format!("Configuration: {}", s.settings_path.display()));
});
.show(ui, |ui| match tab {
PreferencesTab::General => general_preferences(ui, s),
PreferencesTab::Performance => performance_preferences(ui, s),
PreferencesTab::Storage => storage_preferences(ui, s),
});
ui.separator();
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
@ -2626,12 +2820,6 @@ fn menu(ui: &mut Ui, s: &mut Studio, preferences_open: &mut bool) {
},
);
ui.separator();
button(
ui,
tr(&locale, "All slides"),
Action::OpenBrowser,
&mut s.actions,
);
ui.menu_button(tr(&locale, "Autoplay"), |ui| {
ui.set_min_width(250.);
let mut changed = ui
@ -2661,67 +2849,6 @@ fn menu(ui: &mut Ui, s: &mut Studio, preferences_open: &mut bool) {
ui.ctx().request_repaint();
}
});
ui.menu_button(tr(&locale, "Appearance"), |ui| {
ui.with_layout(egui::Layout::top_down(egui::Align::Min), |ui| {
ui.set_min_width(250.);
let mut changed = false;
ui.label(
egui::RichText::new(tr(&locale, "Theme"))
.small()
.strong()
.color(ui.visuals().weak_text_color()),
);
ui.menu_button(s.settings.theme.name(), |ui| {
for theme in crate::theme::Theme::ALL {
let name = theme.name();
changed |= ui
.selectable_value(&mut s.settings.theme, theme, name)
.changed();
}
});
ui.add_space(6.);
ui.separator();
ui.add_space(4.);
ui.label(
egui::RichText::new(tr(&locale, "Language"))
.small()
.strong()
.color(ui.visuals().weak_text_color()),
);
ui.menu_button(s.settings.language.name(), |ui| {
for language in crate::localization::Language::ALL {
changed |= ui
.selectable_value(&mut s.settings.language, language, language.name())
.changed();
}
});
ui.separator();
for (label, color) in [
(
"Page background",
&mut s.settings.slide_colors.page_background,
),
(
"Fit padding color",
&mut s.settings.slide_colors.fit_padding,
),
] {
ui.horizontal(|ui| {
ui.label(tr(&locale, label));
changed |= ui.color_edit_button_srgb(color).changed();
});
}
ui.small(tr(
&locale,
"Page background fills transparency; fit padding fills space around the slide.",
));
if changed {
s.new_output = true;
s.save_preferences();
ui.ctx().request_repaint();
}
});
});
ui.separator();
ui.label(
egui::RichText::new(tr(&locale, "Quick settings"))

View File

@ -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<String>,
pub language: crate::localization::Language,
pub language_pack: Option<String>,
}
/// 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());

View File

@ -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));

View File

@ -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::<Self>(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::<AppliedTheme>(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));

View File

@ -56,6 +56,10 @@ pub enum Request {
PickNotes {
owner: Option<isize>,
},
PickPack {
language: bool,
owner: Option<isize>,
},
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,

View File

@ -505,6 +505,16 @@ fn quick_settings_and_preferences_window_remain_interactive() {
}
};
click(&mut s, "Menu");
click(&mut s, "Quit");
assert!(
s.actions
.iter()
.any(|action| matches!(action, Action::Exit)),
"Quit should be directly reachable without scrolling at 1080p"
);
assert!(!s.menu_open);
s.actions.clear();
click(&mut s, "Menu");
click(&mut s, "Autoplay");
click(&mut s, "Play automatically");
assert!(s.settings.autoplay_enabled);
@ -514,22 +524,16 @@ fn quick_settings_and_preferences_window_remain_interactive() {
assert!(s.menu_open);
click(&mut s, "Menu");
click(&mut s, "Menu");
click(&mut s, "Appearance");
click(&mut s, "Preferences…");
assert!(s.preferences_open);
assert!(!s.menu_open);
click(&mut s, "Midra Dark");
assert!(
s.menu_open,
"Opening a theme selector must keep its parents open"
);
click(&mut s, "High Contrast");
assert_eq!(s.settings.theme, deckstride::theme::Theme::HighContrast);
assert!(s.menu_open);
click(&mut s, "English");
click(&mut s, "System language");
assert_eq!(
s.settings.language,
deckstride::localization::Language::System
);
assert!(s.menu_open);
assert!(s.preferences_open);
click(&mut s, "Close");
assert!(!s.preferences_open);
click(&mut s, "Menu");
let zoom_enabled = s.settings.zoom_enabled;
click(&mut s, "Enable page zoom");
assert_eq!(s.settings.zoom_enabled, !zoom_enabled);
@ -545,6 +549,7 @@ fn quick_settings_and_preferences_window_remain_interactive() {
click(&mut s, "Preferences…");
assert!(s.preferences_open);
assert!(!s.menu_open);
click(&mut s, "Performance");
click(&mut s, "Expunge unused cache now");
assert!(s.cache_busy, "The Preferences window must submit cleanup");
assert!(s.preferences_open);
@ -926,11 +931,17 @@ fn browser_thumbnails_fill_resized_window_without_stretching_tiles() {
#[test]
fn floating_windows_can_grow_and_shrink_after_content_is_drawn() {
for id in ["layout-window", "displays-window", "slide-preview"] {
for id in [
"layout-window",
"displays-window",
"preferences-window",
"slide-preview",
] {
let ctx = Context::default();
let mut s = studio();
s.layout_open = id == "layout-window";
s.displays_open = id == "displays-window";
s.preferences_open = id == "preferences-window";
if id == "slide-preview" {
s.browser_preview = Some((s.generation, 0));
}
@ -950,6 +961,22 @@ fn floating_windows_can_grow_and_shrink_after_content_is_drawn() {
frame(vec![]);
}
let rect = || ctx.memory(|m| m.area_rect(egui::Id::new(id))).unwrap();
if id == "preferences-window" {
let before = rect();
for offset in [
Vec2::new(20., 20.),
Vec2::new(-40., 80.),
Vec2::new(100., -60.),
Vec2::new(-120., -90.),
] {
frame(vec![egui::Event::PointerMoved(before.center() + offset)]);
}
let after = rect();
assert!(
(after.size() - before.size()).length() < 1.,
"Preferences must not resize on mouse movement: {before:?} -> {after:?}"
);
}
for delta in [Vec2::new(120., 80.), Vec2::new(-180., -180.)] {
let before = rect();
let start = before.right_bottom() - Vec2::splat(2.);
@ -1797,7 +1824,7 @@ fn preferences_window_stays_on_the_presenter_that_opened_it() {
output
.shapes
.iter()
.any(|shape| contains(&shape.shape, "Memory and cache"))
.any(|shape| contains(&shape.shape, "Appearance"))
};
assert!(render(0, "one"));
assert!(!render(1, "two"));
@ -1805,11 +1832,13 @@ fn preferences_window_stays_on_the_presenter_that_opened_it() {
#[test]
fn preferences_show_the_running_executable_path() {
fn contains(shape: &egui::Shape, text: &str) -> bool {
fn find(shape: &egui::Shape, text: &str) -> Option<Pos2> {
match shape {
egui::Shape::Text(label) => label.galley.text() == text,
egui::Shape::Vec(shapes) => shapes.iter().any(|shape| contains(shape, text)),
_ => false,
egui::Shape::Text(label) if label.galley.text() == text => {
Some(label.pos + label.galley.size() * 0.5)
}
egui::Shape::Vec(shapes) => shapes.iter().find_map(|shape| find(shape, text)),
_ => None,
}
}
let ctx = Context::default();
@ -1825,17 +1854,35 @@ fn preferences_show_the_running_executable_path() {
presenter_ui::presenter(root, &mut s, &mut ui)
});
}
let storage = output
.shapes
.iter()
.find_map(|shape| find(&shape.shape, "Storage"))
.expect("Preferences should expose a Storage tab");
for pressed in [true, false] {
let mut raw = input(Vec2::new(1280., 900.));
raw.events = vec![
egui::Event::PointerMoved(storage),
egui::Event::PointerButton {
pos: storage,
button: egui::PointerButton::Primary,
pressed,
modifiers: Default::default(),
},
];
output = ctx.run_ui(raw, |root| presenter_ui::presenter(root, &mut s, &mut ui));
}
assert!(
output
.shapes
.iter()
.any(|shape| contains(&shape.shape, "Application executable"))
.any(|shape| find(&shape.shape, "Application executable").is_some())
);
assert!(
output
.shapes
.iter()
.any(|shape| contains(&shape.shape, &expected))
.any(|shape| find(&shape.shape, &expected).is_some())
);
}

View File

@ -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());

View File

@ -2,6 +2,39 @@
## 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.
- Publish the full five-target release with Linux x86_64, Linux ARM64, Windows x86_64,
Apple Silicon macOS and Intel macOS portable and cargo-binstall archives; see the
[release notes](development/release-notes/v0.1.101.md).
### 0.1.100
- Keep the Preferences window size stable while the pointer moves by removing a
self-referential width constraint and reserving the full footer spacing.
### 0.1.99
- Organize Preferences into General, Performance and Storage tabs. Each tab has its
own small-screen scroll position, and every Presenter remembers its selected tab.
### 0.1.98
- Shorten the Presenter menu by removing its duplicate All slides command and moving
theme, language and slide colors into the Preferences window. Keep zoom, fitted
zoom behavior, automatic Slides output and Autoplay available directly.
- Keep the menu vertically scrollable on small screens while leaving Quit visible
without scrolling at ordinary Presenter window sizes.
### 0.1.97
- Publish future release assets to both Gitea and GitHub from one reviewed build,
using a separate named token for each service.
### 0.1.96
- Rename the application, crate, executable, repository links, desktop identity,

View File

@ -0,0 +1,52 @@
# Deckstride 0.1.101
This release adds installable language and theme packs while keeping Deckstride's
fast, portable presentation workflow intact. Packs are ordinary data-only ZIP files:
they work offline, are validated before installation, and appear in Preferences as
soon as they are imported.
## Highlights since 0.1.96
- Import language packs and theme packs from **Preferences → General → Appearance**.
Installed choices persist globally and load without network access.
- Use the included documented example packs as templates for a new translation or
visual theme. Pack sizes, paths, identifiers, revisions and expanded contents are
bounded and validated before Deckstride accepts them.
- Reorganize Preferences into clearer General, Presentation, Performance and Storage
sections, while keeping the presentation controls that need quick access in the
main menu.
- Keep the Preferences window stable instead of resizing as the pointer moves.
Deckstride continues to provide independent Presenter and Slides windows, flexible
multi-monitor routing and mirroring, per-screen layouts, buffered PDF rendering,
notes, zoom, pointer and drawing tools, automatic playback, and display recovery.
## Downloads
Portable packages and cargo-binstall archives are provided for:
- Linux x86_64 GNU
- Linux ARM64 musl
- Windows x86_64 GNU
- Apple Silicon macOS 13+
- Intel macOS 13+
Windows and macOS packages are unsigned. On macOS, extract the archive and run:
```sh
xattr -dr com.apple.quarantine /path/to/deckstride
chmod +x /path/to/deckstride
```
Rehearse Deckstride on the actual presentation computer, adapters and display
arrangement before a live event.
## Validation
Linux formatting, warnings-denied Clippy and rustdoc, the Rust workspace tests,
native GUI smoke and Python helper tests pass. The coverage runner completed its
tests but could not satisfy the configured whole-application floor because LLVM
profiles from intentionally terminated worker processes are incomplete. All five
release targets are built and packaged from the tagged commit. Windows multi-screen
behavior has been extensively tested in earlier releases; native runtime testing of
each newly built archive remains appropriate before use in a live show.

View File

@ -39,9 +39,14 @@ commit, push that commit/tag, then run:
```sh
rust_realease . --package deckstride \
--message-file docs/development/release-notes/vVERSION.md \
--token-file ../gitea-token.txt
--token-file ../release-tokens.json
```
`release-tokens.json` is an untracked JSON object with `gitea` and `github`
keys. The matching tokens need repository read and release write access. As an
alternative, set `GITEA_TOKEN` and `GITHUB_TOKEN` in the release environment.
The publisher uploads and verifies the same artifacts on both services.
`--dry-run` previews without remote mutation. Before tagging, its missing-tag
prerequisite is expected. Do not use automatic tag/push options as part of local
preparation. Never put credentials in configuration, artifacts or Git.

29
docs/packs/README.md Normal file
View File

@ -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 `<locale>.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.

Binary file not shown.

Binary file not shown.

View File

@ -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"
}

View File

@ -0,0 +1,12 @@
{
"version": 2,
"id": "example-language",
"revision": 1,
"languages": [
{
"locale": "eo-example",
"name": "Example Esperanto",
"native_name": "Ekzempla Esperanto"
}
]
}

View File

@ -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."
}

View File

@ -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.

View File

@ -1,6 +1,18 @@
[release]
tag-prefix = "v"
[[release.endpoints]]
name = "gitea"
provider = "gitea"
repository = "https://proxy.dandaedre.com/gitea/idle-org/deckstride"
token-env = "GITEA_TOKEN"
[[release.endpoints]]
name = "github"
provider = "github"
repository = "https://github.com/idle-org/Deckstride"
token-env = "GITHUB_TOKEN"
[build]
targets = [
"x86_64-unknown-linux-gnu",
@ -43,6 +55,3 @@ files = [
[[repository.fallbacks]]
origin = "https://git.dandaedre.com/idle-org/deckstride"
fallback-url = "https://proxy.dandaedre.com/gitea/idle-org/deckstride"
[gitea]
token-env = "GITEA_TOKEN"