mirror of
https://github.com/storytold/photocraft.git
synced 2026-11-16 07:02:42 +00:00
Refactor UI support for strict Clippy checks
This commit is contained in:
1 parent
79e9fa6f7c
commit
dccf6182eb
31 files changed
+374
-172
No files matched your search
@@ -3,7 +3,7 @@ use super::params::{
|
||||
BUTTONS, KEY_MODIFIERS, MAX_CLICKS, POINTER_MODIFIERS, UI_SET_FIELDS, bool_field, err, f32_field, f32_range, input_choice, input_modifiers, input_number,
|
||||
input_object, merged_object, modifiers_from, num_field, ok, screen_point, uint_field, whole_object,
|
||||
};
|
||||
use super::*;
|
||||
use super::{ControlRequest, DialogKind, Outcome, PhotocraftApp, SHELL_DIALOG, Tool, ToolEvent, Value, json, run_waiting, tool_event, wrap};
|
||||
|
||||
pub(super) fn dispatch(app: &mut PhotocraftApp, ctx: &egui::Context, req: &ControlRequest) -> Outcome {
|
||||
let p = &req.params;
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
use super::*;
|
||||
use super::{Outcome, PhotocraftApp, Value, json};
|
||||
|
||||
/// The fields `ui.set` reads. Anything else is rejected before a field is applied, and every
|
||||
/// field's value is validated before the first one is applied, so a typo, an unknown field, a
|
||||
|
||||
@@ -54,6 +54,11 @@ fn picker_lists_english_first_then_names_alphabetically() {
|
||||
|
||||
#[test]
|
||||
fn tags_map_to_languages() {
|
||||
western_and_legacy_tags_resolve();
|
||||
chinese_tags_resolve_by_region_and_script();
|
||||
}
|
||||
|
||||
fn western_and_legacy_tags_resolve() {
|
||||
assert_eq!(lang_from_tag("ja_JP.UTF-8"), Some(JA()));
|
||||
assert_eq!(lang_from_tag("ja-JP"), Some(JA()));
|
||||
assert_eq!(lang_from_tag("en_US.UTF-8"), Some(Lang::EN));
|
||||
@@ -73,6 +78,9 @@ fn tags_map_to_languages() {
|
||||
assert_eq!(lang_from_tag("tr_TR.UTF-8"), Lang::from_code("tr"));
|
||||
assert_eq!(lang_from_tag("tr-TR"), Lang::from_code("tr"));
|
||||
assert_eq!(lang_from_tag("tr"), Lang::from_code("tr"));
|
||||
}
|
||||
|
||||
fn chinese_tags_resolve_by_region_and_script() {
|
||||
// Traditional Chinese: by region, by script, and with a region after the script.
|
||||
assert_eq!(lang_from_tag("zh_TW.UTF-8"), Some(ZH()));
|
||||
assert_eq!(lang_from_tag("zh-TW"), Some(ZH()));
|
||||
|
||||
@@ -127,9 +127,8 @@ pub use dialogs::export_dialog;
|
||||
pub use dialogs::file_ui;
|
||||
pub use dialogs::fill_ui;
|
||||
pub use dialogs::filter_dialog;
|
||||
use dialogs::filter_preview_ui;
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
use dialogs::filter_preview_worker;
|
||||
use dialogs::filter_preview_ui;
|
||||
pub use dialogs::gallery_ui;
|
||||
pub use dialogs::guide_layout_ui;
|
||||
pub use dialogs::history_options_ui;
|
||||
@@ -473,7 +472,7 @@ pub struct PhotocraftApp {
|
||||
pub(crate) filter_preview: Option<filter_dialog::FilterPreview>,
|
||||
pub(crate) smart_filter_targets: smart_filter_dialog::Targets,
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
filter_preview_worker: filter_preview_worker::Worker,
|
||||
filter_preview_worker: crate::dialogs::filter_preview_worker::Worker,
|
||||
/// Full CPU canvas redraws running in the background, by document (#4024).
|
||||
pub(crate) redraws: std::collections::HashMap<photocraft_doc::DocId, background_redraw::Redraw>,
|
||||
/// The last finished background redraws, for going back to a state drawn a moment ago (#6528).
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
use super::dialogs::open_preferences;
|
||||
use super::fields::{choice_label, color_of, preference_matches};
|
||||
use super::*;
|
||||
use super::{AppearanceMode, Color32, DarkTheme, LightTheme, Map, PhotocraftApp, RichText, SavedTheme, Sense, ThemeKind, Tokens, Value, json, prefs, vec2};
|
||||
|
||||
/// The GPU canvas colours from Preferences › Transparency & Gamut.
|
||||
pub fn canvas_style(app: &PhotocraftApp) -> crate::gpu_canvas::CanvasStyle {
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use super::shortcuts::shortcut_items;
|
||||
use super::*;
|
||||
use super::{BTreeMap, DialogKind, Map, PhotocraftApp, RichText, SECTIONS, Tokens, Value, json, prefs};
|
||||
|
||||
// ------------------------------------------------------------------ menu routing
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@ use super::appearance::{AppearanceRows, appearance_rows, system_theme};
|
||||
use super::dialogs::{mismatch_body, presets_body, presets_io_body, settings_height};
|
||||
use super::graphics::{gpu_memory_lines, gpu_status_rows, memory_usage_row, read_at_launch, rendering_mode_row};
|
||||
use super::shortcuts::shortcuts_body;
|
||||
use super::*;
|
||||
use super::{Color32, Map, PhotocraftApp, RichText, SECTIONS, Sense, Tokens, Value, json, prefs, vec2};
|
||||
|
||||
// ------------------------------------------------------------------ bodies
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use super::fields::choice_label;
|
||||
use super::*;
|
||||
use super::{Map, PhotocraftApp, RichText, Tokens, Value, json, prefs};
|
||||
|
||||
/// Performance › Graphics: the compositor's GPU memory budget and whether the active document's
|
||||
/// layers fit it (the GPU Memory preference sets it).
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
use super::appearance::{canvas_style, sync_animations, sync_appearance, sync_display_scale, sync_tooltips};
|
||||
use super::startup::{load, presets_store, recovery, sync_rulers};
|
||||
use super::*;
|
||||
use super::{DocId, HashMap, PhotocraftApp, Value, prefs};
|
||||
|
||||
/// Per-frame upkeep: theme sync, persistence, autosave and the history log.
|
||||
pub fn tick(app: &mut PhotocraftApp, ctx: &egui::Context) {
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use super::dialogs::toolbar_tab;
|
||||
use super::*;
|
||||
use super::{BTreeMap, Map, PhotocraftApp, RichText, Tokens, Value, default_shortcut, json, prefs, vec2};
|
||||
|
||||
/// Every shortcut-bearing command (engine registry plus shell commands): (id, label, menu path,
|
||||
/// default shortcut), menu items first in Photoshop order.
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
use super::*;
|
||||
use super::{JobEvent, JobOutcome, PhotocraftApp, Started, Value, json, prefs};
|
||||
|
||||
/// View › Rulers follows `unitsAndRulers.showRulers` when the preference changes (at launch, from
|
||||
/// `prefs.set` or a reset), so documents open with the rulers as last set.
|
||||
|
||||
@@ -509,114 +509,151 @@ fn actual_callback(output: &egui::FullOutput) -> Option<egui::ScreenshotCallback
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn completed_callback_revalidates_next_raw_input_before_actual_app_writes() {
|
||||
type ScreenshotWrites = std::rc::Rc<std::cell::RefCell<Vec<(String, Vec<u8>)>>>;
|
||||
type ScreenshotEncodes = std::rc::Rc<std::cell::RefCell<Vec<(u32, u32, Vec<u8>)>>>;
|
||||
|
||||
struct ActualCallbackFixture {
|
||||
app: crate::PhotocraftApp,
|
||||
ctx: Context,
|
||||
writes: ScreenshotWrites,
|
||||
encodes: ScreenshotEncodes,
|
||||
reply: std::sync::mpsc::Receiver<serde_json::Value>,
|
||||
document: Option<DocumentId>,
|
||||
old_geometry: CaptureGeometry,
|
||||
old_pixels: std::sync::Weak<ColorImage>,
|
||||
}
|
||||
|
||||
fn actual_callback_fixture() -> ActualCallbackFixture {
|
||||
use std::cell::RefCell;
|
||||
use std::rc::Rc;
|
||||
// Unchanged success, resize, DPI change, and minimized are separate real app instances.
|
||||
|
||||
let writes = Rc::new(RefCell::new(Vec::new()));
|
||||
let encodes = Rc::new(RefCell::new(Vec::new()));
|
||||
let (written, encoded) = (writes.clone(), encodes.clone());
|
||||
let services = crate::Services {
|
||||
automation_write: Some(Box::new(move |path, bytes| {
|
||||
written.borrow_mut().push((path.to_owned(), bytes.to_vec()));
|
||||
Ok(())
|
||||
})),
|
||||
encode_png: Some(Box::new(move |w, h, rgba| {
|
||||
encoded.borrow_mut().push((w, h, rgba.get(..4).unwrap_or_default().to_vec()));
|
||||
let image = photocraft_codecs::Image::from_u8(w, h, photocraft_codecs::ChannelLayout::Rgba, rgba.to_vec()).map_err(|error| error.to_string())?;
|
||||
photocraft_codecs::encode(&image, photocraft_codecs::Format::Png, &photocraft_codecs::EncodeOptions::default()).map_err(|error| error.to_string())
|
||||
})),
|
||||
..Default::default()
|
||||
};
|
||||
let mut app = crate::PhotocraftApp::new(photocraft_engine::Session::new(), services);
|
||||
app.run("file.new", serde_json::json!({"width": 32, "height": 32})).unwrap();
|
||||
let ctx = Context::default();
|
||||
for _ in 0..4 {
|
||||
actual_capture_frame(&mut app, &ctx, vec2(600.0, 400.0), 1.0, false);
|
||||
}
|
||||
let old_geometry = app.captures.last_geometry().expect("the old real UI geometry");
|
||||
let document = app.document_identity();
|
||||
let (tx, reply) = std::sync::mpsc::channel();
|
||||
app.captures.admit(91, Some("fixture/current.png".into()), tx, document, 0.0, super::screenshot::now()).unwrap();
|
||||
let mut callback = None;
|
||||
for _ in 0..8 {
|
||||
let output = actual_capture_frame(&mut app, &ctx, vec2(600.0, 400.0), 1.0, false);
|
||||
if let Some(found) = actual_callback(&output) {
|
||||
callback = Some(found);
|
||||
break;
|
||||
}
|
||||
}
|
||||
let old_image = Arc::new(ColorImage::filled(old_geometry.expected_pixels().unwrap(), Color32::RED));
|
||||
let old_pixels = Arc::downgrade(&old_image);
|
||||
callback.expect("actual app issued one screenshot callback").complete(old_image);
|
||||
assert!(writes.borrow().is_empty() && encodes.borrow().is_empty(), "the real callback only stores pixels");
|
||||
ActualCallbackFixture { app, ctx, writes, encodes, reply, document, old_geometry, old_pixels }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn completed_callback_revalidates_next_raw_input_before_actual_app_writes() {
|
||||
for (size, scale, minimized) in
|
||||
[(vec2(600.0, 400.0), 1.0, false), (vec2(640.0, 400.0), 1.0, false), (vec2(600.0, 400.0), 2.0, false), (vec2(600.0, 400.0), 1.0, true)]
|
||||
{
|
||||
let changed = size != vec2(600.0, 400.0) || scale != 1.0 || minimized;
|
||||
let writes = Rc::new(RefCell::new(Vec::new()));
|
||||
let encodes = Rc::new(RefCell::new(Vec::new()));
|
||||
let (written, encoded) = (writes.clone(), encodes.clone());
|
||||
let services = crate::Services {
|
||||
automation_write: Some(Box::new(move |path, bytes| {
|
||||
written.borrow_mut().push((path.to_owned(), bytes.to_vec()));
|
||||
Ok(())
|
||||
})),
|
||||
encode_png: Some(Box::new(move |w, h, rgba| {
|
||||
encoded.borrow_mut().push((w, h, rgba.get(..4).unwrap_or_default().to_vec()));
|
||||
let image =
|
||||
photocraft_codecs::Image::from_u8(w, h, photocraft_codecs::ChannelLayout::Rgba, rgba.to_vec()).map_err(|error| error.to_string())?;
|
||||
photocraft_codecs::encode(&image, photocraft_codecs::Format::Png, &photocraft_codecs::EncodeOptions::default())
|
||||
.map_err(|error| error.to_string())
|
||||
})),
|
||||
..Default::default()
|
||||
};
|
||||
let mut app = crate::PhotocraftApp::new(photocraft_engine::Session::new(), services);
|
||||
app.run("file.new", serde_json::json!({"width": 32, "height": 32})).unwrap();
|
||||
let ctx = Context::default();
|
||||
for _ in 0..4 {
|
||||
actual_capture_frame(&mut app, &ctx, vec2(600.0, 400.0), 1.0, false);
|
||||
let mut fixture = actual_callback_fixture();
|
||||
if size == vec2(600.0, 400.0) && scale == 1.0 && !minimized {
|
||||
verify_unchanged_capture(&mut fixture);
|
||||
} else {
|
||||
verify_changed_capture(&mut fixture, size, scale, minimized);
|
||||
}
|
||||
let old = app.captures.last_geometry().expect("the old real UI geometry");
|
||||
let document = app.document_identity();
|
||||
let (tx, rx) = std::sync::mpsc::channel();
|
||||
app.captures.admit(91, Some("fixture/current.png".into()), tx, document, 0.0, super::screenshot::now()).unwrap();
|
||||
let mut callback = None;
|
||||
for _ in 0..8 {
|
||||
let output = actual_capture_frame(&mut app, &ctx, vec2(600.0, 400.0), 1.0, false);
|
||||
if let Some(found) = actual_callback(&output) {
|
||||
callback = Some(found);
|
||||
break;
|
||||
}
|
||||
}
|
||||
let old_image = Arc::new(ColorImage::filled(old.expected_pixels().unwrap(), Color32::RED));
|
||||
let old_pixels = Arc::downgrade(&old_image);
|
||||
callback.expect("actual app issued one screenshot callback").complete(old_image);
|
||||
assert!(writes.borrow().is_empty() && encodes.borrow().is_empty(), "the real callback only stores pixels");
|
||||
let output = actual_capture_frame(&mut app, &ctx, size, scale, minimized);
|
||||
if changed {
|
||||
assert!(writes.borrow().is_empty() && encodes.borrow().is_empty(), "no stale encode/write on the first changed input");
|
||||
assert!(old_pixels.upgrade().is_none(), "old pixels are released on geometry rejection");
|
||||
let current = app.captures.last_geometry().unwrap();
|
||||
assert!(current.logical_size != old.logical_size || current.pixels_per_point != old.pixels_per_point || current.minimized != old.minimized);
|
||||
if minimized {
|
||||
// A minimized surface cannot be retried. It fails once, then an independent
|
||||
// request after restoration proves that cancellation releases its budget.
|
||||
let reply = rx.try_recv().expect("one minimized error");
|
||||
assert_eq!(reply["ok"], false, "{reply}");
|
||||
assert!(reply["error"].as_str().unwrap().contains("minimized"));
|
||||
assert_eq!(app.captures.pending(), 0);
|
||||
assert_eq!(app.captures.reserved_bytes(), 0);
|
||||
assert!(actual_callback(&output).is_none());
|
||||
actual_capture_frame(&mut app, &ctx, size, scale, false);
|
||||
let (tx, restored_rx) = std::sync::mpsc::channel();
|
||||
app.captures.admit(92, Some("fixture/restored.png".into()), tx, document, 0.0, super::screenshot::now()).unwrap();
|
||||
for _ in 0..8 {
|
||||
let output = actual_capture_frame(&mut app, &ctx, size, scale, false);
|
||||
if let Some(callback) = actual_callback(&output) {
|
||||
callback.complete(Arc::new(ColorImage::filled(app.captures.last_geometry().unwrap().expected_pixels().unwrap(), Color32::BLUE)));
|
||||
break;
|
||||
}
|
||||
}
|
||||
actual_capture_frame(&mut app, &ctx, size, scale, false);
|
||||
let reply = restored_rx.try_recv().expect("the restored window accepts a new request");
|
||||
assert_eq!(reply["ok"], true, "{reply}");
|
||||
assert_eq!(writes.borrow().len(), 1);
|
||||
assert!(writes.borrow()[0].1.starts_with(b"\x89PNG\r\n\x1a\n"));
|
||||
assert_eq!(encodes.borrow().len(), 1);
|
||||
assert_eq!(encodes.borrow()[0].2, [0, 0, 255, 255]);
|
||||
assert_eq!(app.captures.pending(), 0);
|
||||
assert_eq!(app.captures.reserved_bytes(), 0);
|
||||
assert!(rx.try_recv().is_err() && restored_rx.try_recv().is_err());
|
||||
continue;
|
||||
}
|
||||
assert!(rx.try_recv().is_err(), "bounded retry has not delivered a stale success");
|
||||
let mut retry = actual_callback(&output);
|
||||
for _ in 0..8 {
|
||||
if retry.is_some() {
|
||||
break;
|
||||
}
|
||||
retry = actual_callback(&actual_capture_frame(&mut app, &ctx, size, scale, minimized));
|
||||
}
|
||||
retry
|
||||
.expect("the actual app reissues at bounded current geometry")
|
||||
.complete(Arc::new(ColorImage::filled(current.expected_pixels().unwrap(), Color32::BLUE)));
|
||||
actual_capture_frame(&mut app, &ctx, size, scale, minimized);
|
||||
assert_eq!(encodes.borrow().first().map(|entry| entry.2.as_slice()), Some([0, 0, 255, 255].as_slice()), "only the new callback image is encoded");
|
||||
}
|
||||
let reply = rx.try_recv().expect("one response after the valid callback");
|
||||
assert_eq!(reply["ok"], true, "{reply}");
|
||||
assert_eq!(writes.borrow().len(), 1);
|
||||
assert!(writes.borrow()[0].1.starts_with(b"\x89PNG\r\n\x1a\n"), "real PNG encoding and automation_write ran");
|
||||
assert_eq!(encodes.borrow().len(), 1);
|
||||
assert_eq!(app.captures.pending(), 0);
|
||||
assert_eq!(app.captures.reserved_bytes(), 0);
|
||||
actual_capture_frame(&mut app, &ctx, size, scale, minimized);
|
||||
assert_eq!(writes.borrow().len(), 1, "no duplicate output");
|
||||
assert!(rx.try_recv().is_err());
|
||||
}
|
||||
}
|
||||
|
||||
fn verify_unchanged_capture(fixture: &mut ActualCallbackFixture) {
|
||||
actual_capture_frame(&mut fixture.app, &fixture.ctx, vec2(600.0, 400.0), 1.0, false);
|
||||
assert_successful_capture(fixture, vec2(600.0, 400.0), 1.0, false);
|
||||
}
|
||||
|
||||
fn verify_changed_capture(fixture: &mut ActualCallbackFixture, size: egui::Vec2, scale: f32, minimized: bool) {
|
||||
let output = actual_capture_frame(&mut fixture.app, &fixture.ctx, size, scale, minimized);
|
||||
assert!(fixture.writes.borrow().is_empty() && fixture.encodes.borrow().is_empty(), "no stale encode/write on the first changed input");
|
||||
assert!(fixture.old_pixels.upgrade().is_none(), "old pixels are released on geometry rejection");
|
||||
let current = fixture.app.captures.last_geometry().unwrap();
|
||||
assert!(
|
||||
current.logical_size != fixture.old_geometry.logical_size
|
||||
|| current.pixels_per_point != fixture.old_geometry.pixels_per_point
|
||||
|| current.minimized != fixture.old_geometry.minimized
|
||||
);
|
||||
if minimized {
|
||||
verify_minimized_capture(fixture, size, scale, &output);
|
||||
return;
|
||||
}
|
||||
assert!(fixture.reply.try_recv().is_err(), "bounded retry has not delivered a stale success");
|
||||
let mut retry = actual_callback(&output);
|
||||
for _ in 0..8 {
|
||||
if retry.is_some() {
|
||||
break;
|
||||
}
|
||||
retry = actual_callback(&actual_capture_frame(&mut fixture.app, &fixture.ctx, size, scale, minimized));
|
||||
}
|
||||
retry
|
||||
.expect("the actual app reissues at bounded current geometry")
|
||||
.complete(Arc::new(ColorImage::filled(current.expected_pixels().unwrap(), Color32::BLUE)));
|
||||
actual_capture_frame(&mut fixture.app, &fixture.ctx, size, scale, minimized);
|
||||
assert_eq!(fixture.encodes.borrow().first().map(|entry| entry.2.as_slice()), Some([0, 0, 255, 255].as_slice()), "only the new callback image is encoded");
|
||||
assert_successful_capture(fixture, size, scale, minimized);
|
||||
}
|
||||
|
||||
fn verify_minimized_capture(fixture: &mut ActualCallbackFixture, size: egui::Vec2, scale: f32, output: &egui::FullOutput) {
|
||||
let reply = fixture.reply.try_recv().expect("one minimized error");
|
||||
assert_eq!(reply["ok"], false, "{reply}");
|
||||
assert!(reply["error"].as_str().unwrap().contains("minimized"));
|
||||
assert_eq!(fixture.app.captures.pending(), 0);
|
||||
assert_eq!(fixture.app.captures.reserved_bytes(), 0);
|
||||
assert!(actual_callback(output).is_none());
|
||||
actual_capture_frame(&mut fixture.app, &fixture.ctx, size, scale, false);
|
||||
let (tx, restored_rx) = std::sync::mpsc::channel();
|
||||
fixture.app.captures.admit(92, Some("fixture/restored.png".into()), tx, fixture.document, 0.0, super::screenshot::now()).unwrap();
|
||||
for _ in 0..8 {
|
||||
let output = actual_capture_frame(&mut fixture.app, &fixture.ctx, size, scale, false);
|
||||
if let Some(callback) = actual_callback(&output) {
|
||||
callback.complete(Arc::new(ColorImage::filled(fixture.app.captures.last_geometry().unwrap().expected_pixels().unwrap(), Color32::BLUE)));
|
||||
break;
|
||||
}
|
||||
}
|
||||
actual_capture_frame(&mut fixture.app, &fixture.ctx, size, scale, false);
|
||||
let reply = restored_rx.try_recv().expect("the restored window accepts a new request");
|
||||
assert_eq!(reply["ok"], true, "{reply}");
|
||||
assert_eq!(fixture.writes.borrow().len(), 1);
|
||||
assert!(fixture.writes.borrow()[0].1.starts_with(b"\x89PNG\r\n\x1a\n"));
|
||||
assert_eq!(fixture.encodes.borrow().len(), 1);
|
||||
assert_eq!(fixture.encodes.borrow()[0].2, [0, 0, 255, 255]);
|
||||
assert_eq!(fixture.app.captures.pending(), 0);
|
||||
assert_eq!(fixture.app.captures.reserved_bytes(), 0);
|
||||
assert!(fixture.reply.try_recv().is_err() && restored_rx.try_recv().is_err());
|
||||
}
|
||||
|
||||
fn assert_successful_capture(fixture: &mut ActualCallbackFixture, size: egui::Vec2, scale: f32, minimized: bool) {
|
||||
let reply = fixture.reply.try_recv().expect("one response after the valid callback");
|
||||
assert_eq!(reply["ok"], true, "{reply}");
|
||||
assert_eq!(fixture.writes.borrow().len(), 1);
|
||||
assert!(fixture.writes.borrow()[0].1.starts_with(b"\x89PNG\r\n\x1a\n"), "real PNG encoding and automation_write ran");
|
||||
assert_eq!(fixture.encodes.borrow().len(), 1);
|
||||
assert_eq!(fixture.app.captures.pending(), 0);
|
||||
assert_eq!(fixture.app.captures.reserved_bytes(), 0);
|
||||
actual_capture_frame(&mut fixture.app, &fixture.ctx, size, scale, minimized);
|
||||
assert_eq!(fixture.writes.borrow().len(), 1, "no duplicate output");
|
||||
assert!(fixture.reply.try_recv().is_err());
|
||||
}
|
||||
@@ -1,4 +1,7 @@
|
||||
use super::*;
|
||||
use super::{
|
||||
CaptionStyle, Document, FileDialogFn, OsEvent, Value, dds_options_ui, jobs_ui, jpeg_options_ui, monitor_status, native_menu, screen_picker,
|
||||
targa_options_ui,
|
||||
};
|
||||
|
||||
/// The error a save gets while another save waits on its format prompt.
|
||||
pub(crate) const SAVE_OPTIONS_OPEN: &str = "Answer the TIFF, Targa, DDS or JPEG Options before starting another save";
|
||||
|
||||
@@ -657,6 +657,11 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn tool_names_parse() {
|
||||
basic_and_retouch_tool_names_parse();
|
||||
vector_tool_names_parse();
|
||||
}
|
||||
|
||||
fn basic_and_retouch_tool_names_parse() {
|
||||
assert_eq!(Tool::from_name("brush"), Some(Tool::Brush));
|
||||
assert_eq!(Tool::from_name("Rect"), Some(Tool::RectMarquee));
|
||||
assert_eq!(Tool::from_name("RectMarquee"), Some(Tool::RectMarquee));
|
||||
@@ -675,6 +680,9 @@ mod tests {
|
||||
assert_eq!(Tool::from_name("patternStamp"), Some(Tool::PatternStamp));
|
||||
assert_eq!(Tool::from_name("Pattern Stamp Tool"), Some(Tool::PatternStamp));
|
||||
assert_eq!(Tool::ALL.len(), 68);
|
||||
}
|
||||
|
||||
fn vector_tool_names_parse() {
|
||||
assert_eq!(Tool::from_name("Vertical Type Mask Tool"), Some(Tool::VerticalTypeMask));
|
||||
assert_eq!(Tool::from_name("addAnchorPoint"), Some(Tool::AddAnchorPoint));
|
||||
assert_eq!(Tool::from_name("Delete Anchor Point Tool"), Some(Tool::DeleteAnchorPoint));
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
use super::*;
|
||||
use super::{Deserialize, Serialize};
|
||||
|
||||
/// Selected tab per dock card.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
use super::*;
|
||||
use super::{Deserialize, Serialize};
|
||||
|
||||
/// Photoshop-style Layers panel display preferences; part of serialized UI state.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
use super::*;
|
||||
use super::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
||||
pub enum Tool {
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use super::tool::Tool;
|
||||
use super::*;
|
||||
use super::{Deserialize, Serialize};
|
||||
|
||||
/// Options-bar state for tools (Photoshop keeps these per tool).
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
use super::*;
|
||||
use super::{Deserialize, Serialize};
|
||||
|
||||
/// Edit › Transform's mode: what a handle drag does with no modifier keys held.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||||
|
||||
+185
-40
@@ -1180,52 +1180,197 @@ pub mod live {
|
||||
let mut unknown = Vec::new();
|
||||
let Some(obj) = v.as_object() else { return unknown };
|
||||
for (k, val) in obj {
|
||||
macro_rules! c {
|
||||
($($f:ident),*) => {
|
||||
match k.as_str() {
|
||||
$(stringify!($f) => { if let Some(c) = color(val) { t.$f = c; } })*
|
||||
"radius_sm" => { if let Some(x) = val.as_f64() { t.radius_sm = x as f32; } }
|
||||
"radius" => { if let Some(x) = val.as_f64() { t.radius = x as f32; } }
|
||||
"radius_lg" => { if let Some(x) = val.as_f64() { t.radius_lg = x as f32; } }
|
||||
_ => unknown.push(k.clone()),
|
||||
if override_chrome_color(t, k, val) || override_text_color(t, k, val) || override_accent_color(t, k, val) {
|
||||
continue;
|
||||
}
|
||||
match k.as_str() {
|
||||
"radius_sm" => {
|
||||
if let Some(x) = val.as_f64() {
|
||||
t.radius_sm = x as f32;
|
||||
}
|
||||
};
|
||||
}
|
||||
"radius" => {
|
||||
if let Some(x) = val.as_f64() {
|
||||
t.radius = x as f32;
|
||||
}
|
||||
}
|
||||
"radius_lg" => {
|
||||
if let Some(x) = val.as_f64() {
|
||||
t.radius_lg = x as f32;
|
||||
}
|
||||
}
|
||||
_ => unknown.push(k.clone()),
|
||||
}
|
||||
c!(
|
||||
caption_close,
|
||||
caption_close_text,
|
||||
chrome,
|
||||
canvas,
|
||||
canvas_dot,
|
||||
dock,
|
||||
card,
|
||||
card_border,
|
||||
field,
|
||||
field_border,
|
||||
hover,
|
||||
pressed,
|
||||
text,
|
||||
text_dim,
|
||||
text_faint,
|
||||
icon,
|
||||
accent,
|
||||
accent_soft,
|
||||
accent_border,
|
||||
accent_text,
|
||||
separator,
|
||||
shadow,
|
||||
primary_bg,
|
||||
primary_text,
|
||||
danger,
|
||||
warning,
|
||||
tab_strip,
|
||||
row_selected,
|
||||
scrim
|
||||
);
|
||||
}
|
||||
unknown
|
||||
}
|
||||
|
||||
fn override_chrome_color(t: &mut Tokens, key: &str, value: &serde_json::Value) -> bool {
|
||||
match key {
|
||||
"caption_close" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.caption_close = c;
|
||||
}
|
||||
}
|
||||
"caption_close_text" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.caption_close_text = c;
|
||||
}
|
||||
}
|
||||
"chrome" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.chrome = c;
|
||||
}
|
||||
}
|
||||
"canvas" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.canvas = c;
|
||||
}
|
||||
}
|
||||
"canvas_dot" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.canvas_dot = c;
|
||||
}
|
||||
}
|
||||
"dock" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.dock = c;
|
||||
}
|
||||
}
|
||||
"card" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.card = c;
|
||||
}
|
||||
}
|
||||
"card_border" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.card_border = c;
|
||||
}
|
||||
}
|
||||
"field" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.field = c;
|
||||
}
|
||||
}
|
||||
"field_border" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.field_border = c;
|
||||
}
|
||||
}
|
||||
_ => return false,
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
fn override_text_color(t: &mut Tokens, key: &str, value: &serde_json::Value) -> bool {
|
||||
match key {
|
||||
"hover" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.hover = c;
|
||||
}
|
||||
}
|
||||
"pressed" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.pressed = c;
|
||||
}
|
||||
}
|
||||
"text" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.text = c;
|
||||
}
|
||||
}
|
||||
"text_dim" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.text_dim = c;
|
||||
}
|
||||
}
|
||||
"text_faint" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.text_faint = c;
|
||||
}
|
||||
}
|
||||
"icon" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.icon = c;
|
||||
}
|
||||
}
|
||||
"separator" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.separator = c;
|
||||
}
|
||||
}
|
||||
"shadow" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.shadow = c;
|
||||
}
|
||||
}
|
||||
"primary_bg" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.primary_bg = c;
|
||||
}
|
||||
}
|
||||
"primary_text" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.primary_text = c;
|
||||
}
|
||||
}
|
||||
_ => return false,
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
fn override_accent_color(t: &mut Tokens, key: &str, value: &serde_json::Value) -> bool {
|
||||
match key {
|
||||
"accent" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.accent = c;
|
||||
}
|
||||
}
|
||||
"accent_soft" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.accent_soft = c;
|
||||
}
|
||||
}
|
||||
"accent_border" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.accent_border = c;
|
||||
}
|
||||
}
|
||||
"accent_text" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.accent_text = c;
|
||||
}
|
||||
}
|
||||
"danger" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.danger = c;
|
||||
}
|
||||
}
|
||||
"warning" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.warning = c;
|
||||
}
|
||||
}
|
||||
"tab_strip" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.tab_strip = c;
|
||||
}
|
||||
}
|
||||
"row_selected" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.row_selected = c;
|
||||
}
|
||||
}
|
||||
"scrim" => {
|
||||
if let Some(c) = color(value) {
|
||||
t.scrim = c;
|
||||
}
|
||||
}
|
||||
_ => return false,
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
//! Drop Shadow's light (#882), Motion Blur and the other direction angles of the filter
|
||||
//! dialogs (#3152) share it, as Photoshop's dialogs do.
|
||||
|
||||
use super::*;
|
||||
use super::{Response, Sense, Stroke, Tokens, Ui, value_field, vec2};
|
||||
|
||||
/// `Label (dial) [field°]` for a direction in document angles: counter-clockwise from three
|
||||
/// o'clock, y up. The dial points anywhere in -180..=180; the result is clamped to `range`, and
|
||||
@@ -61,6 +61,7 @@ pub fn angle_dial_row(ui: &mut Ui, label: &str, angle: &mut f32, range: std::ops
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use egui::Vec2;
|
||||
use egui_kittest::kittest::Queryable;
|
||||
|
||||
fn click(h: &mut egui_kittest::Harness<'_, f32>, delta: Vec2) {
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use super::panel::surface;
|
||||
use super::*;
|
||||
use super::{Color32, Rect, Response, Sense, Stroke, StrokeKind, Tokens, Ui, Vec2, pos2, theme, vec2};
|
||||
|
||||
/// iOS-style toggle switch.
|
||||
pub fn toggle(ui: &mut Ui, on: &mut bool, label: &str) -> Response {
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use super::dropdown::swatch_popup;
|
||||
use super::*;
|
||||
use super::{Color32, CornerRadius, Pos2, Rect, Response, Sense, Stroke, StrokeKind, Tokens, Ui, Vec2, pos2};
|
||||
|
||||
/// Cached RGB data; drawing work is bounded by the 256 display bins, never the image size.
|
||||
pub fn rgb_histogram(ui: &mut Ui, histogram: &photocraft_algo::histogram::RgbHistogram, height: f32) -> egui::Response {
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
//! Integer-only Indexed Color field and a linear slider with common palette sizes.
|
||||
|
||||
use super::*;
|
||||
use super::{Align2, Color32, Rect, Response, Sense, Stroke, StrokeKind, Tokens, Ui, pos2, surface, theme, vec2};
|
||||
|
||||
const STOPS: [u32; 6] = [8, 16, 32, 64, 128, 256];
|
||||
|
||||
@@ -102,6 +102,7 @@ pub fn color_count_row(ui: &mut Ui, label: &str, count: &mut u32) -> Response {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use egui::Pos2;
|
||||
use egui_kittest::{Harness, kittest::Queryable};
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
use super::panel::chevron_icon;
|
||||
use super::scrub::take_label_scrub_name;
|
||||
use super::slider::wheel_notches_of;
|
||||
use super::*;
|
||||
use super::{Pos2, Rect, Response, Ui, Vec2, type_ahead};
|
||||
|
||||
/// A compact labelled dropdown in the studio style.
|
||||
pub fn dropdown<T: PartialEq + Clone>(ui: &mut Ui, id: &str, name: &str, current: &mut T, options: &[(T, &str)], width: f32) -> bool {
|
||||
|
||||
@@ -3,7 +3,7 @@ use super::scrub::{label_scrub_response, take_label_scrub};
|
||||
use super::slider::slider;
|
||||
use super::text_field::first_field_id;
|
||||
use super::units::{FieldUnits, field_resolution_id, fmt_num, fmt_num_prec, fmt_num2, parse_num_in, plain, unit_of_suffix};
|
||||
use super::*;
|
||||
use super::{Align2, Color32, Rect, Response, Sense, Stroke, StrokeKind, Tokens, Ui, Vec2, pos2, theme, vec2};
|
||||
|
||||
/// Monospace numeric field with a dimmed unit suffix, Photoshop style. Drag to scrub. Typed
|
||||
/// arithmetic (`1920/2`) applies on Enter, Tab or click-away, and a unit after a number converts
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
use super::*;
|
||||
use super::{Color32, CornerRadius, Rect, Response, Sense, Stroke, StrokeKind, Tokens, Ui, pos2, theme, vec2};
|
||||
|
||||
/// Match the Spectrum application-menu padding and blue/white hover state in
|
||||
/// secondary menus (status bar, dock hamburger, layer context menus; #2187).
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
use super::*;
|
||||
use super::{Rect, Response, Sense, Ui};
|
||||
|
||||
/// A drag on a value field's label this frame, for the value field drawn next on the label's row
|
||||
/// (Photoshop's scrubby labels). Left by [`scrub_label`], taken by that field.
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
use super::fields::{FieldOpts, value_field_in};
|
||||
use super::panel::surface;
|
||||
use super::scrub::scrub_label_within;
|
||||
use super::*;
|
||||
use super::{Color32, Pos2, Rect, Response, Sense, Stroke, Tokens, Ui, Vec2, pos2, vec2};
|
||||
|
||||
/// Thin-track slider with a round knob. `gradient` paints the track (e.g. hue spectrum).
|
||||
pub fn slider(ui: &mut Ui, value: &mut f32, range: std::ops::RangeInclusive<f32>, gradient: Option<&[Color32]>) -> Response {
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use super::panel::surface;
|
||||
use super::*;
|
||||
use super::{Response, Sense, Stroke, StrokeKind, Tokens, Ui, Vec2, theme, vec2};
|
||||
|
||||
/// The most characters a [`text_field`] holds unless its caller sets a limit: far beyond any
|
||||
/// search, name or hex value, yet a pasted multi-gigabyte string is cut at the field instead of
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use super::fields::{FieldOpts, value_field_in};
|
||||
use super::*;
|
||||
use super::{Response, Ui};
|
||||
|
||||
/// A size dialog's unit key (`px`, `in`, `cm`, `mm`, `pt`, `pica`, `percent`) as a unit.
|
||||
pub fn unit_of_key(key: &str) -> photocraft_engine::prefs::Unit {
|
||||
|
||||
Reference in new issue
Block a user