2bc41aeb8602
simplify_slider.rs
//! Object › Path › Simplify's slider: a strip under the selection with Auto-Simplify, a slider from
//! the fewest anchor points (left) to the closest fit to the original (right), and More Options,
//! which opens the Simplify dialog at the slider's tolerance. While the strip is open, the canvas
//! previews `object.path.simplify {level}`; Enter or a click outside the strip keeps the result as
//! one undo step, and Escape puts the paths back. The slider opens at Auto-Simplify's level for
//! the selection (`vectorcraft_engine::auto_simplify_level`), so the canvas first shows the
//! auto-simplified paths, as the Simplify help page describes
//! (https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/modify-paths/manually-simplify-paths.html).
//! `vectorcraft_pathops::simplify_level_tolerance` maps levels to tolerances.
//!
//! The strip itself ([`Strip`]) is shared with Object › Path › Smooth's slider (`smooth_slider`).
//!
//! Fields: `level` (0..=100, the command's parameter).
use egui::{Color32, CornerRadius, Order, Pos2, Sense, Stroke, vec2};
use serde_json::{Value, json};
use vectorcraft_engine::{SIMPLIFY_LEVEL, auto_simplify_level, simplify_level_tolerance};
use vectorcraft_geom::Rect;
use super::{DialogResult, DialogSpec, form, modal};
use crate::state::Dialog;
use crate::theme::Tokens;
use crate::{VectorcraftApp, widgets};
/// The dialog kind of the Simplify slider.
pub(crate) const KIND: &str = "simplifySlider";
pub(super) const SPEC: DialogSpec = DialogSpec { window: Some(show), confirm, preview: true, ..DialogSpec::FORM };
/// What the Simplify slider previews, and its buttons.
const STRIP: Strip = Strip {
kind: KIND,
cmd: "object.path.simplify",
label: "Simplify",
default_level: SIMPLIFY_LEVEL,
auto: ("Auto-Simplify", auto),
more_options: Some(more_options),
};
/// A UI command a button of a strip runs.
type Button = fn(&mut VectorcraftApp) -> Result<Value, String>;
/// A slider strip under the selection that previews `cmd {level}` while it is open: its first
/// button picks the level `cmd {auto: true}` does, and an optional last one, More Options, opens a
/// dialog in its place. Enter or a click outside the strip keeps the result as one undo step, and
/// Escape puts the paths back.
pub(super) struct Strip {
/// The dialog kind.
pub kind: &'static str,
/// The command previewed.
pub cmd: &'static str,
/// The undo step's name, and the slider's.
pub label: &'static str,
/// The level when the field holds no number.
pub default_level: f64,
/// The auto button's tip, and what it runs.
pub auto: (&'static str, Button),
/// What More Options runs, when the strip has it.
pub more_options: Option<Button>,
}
impl Strip {
/// Whether this strip is open.
pub fn showing(&self, app: &VectorcraftApp) -> bool {
app.ui.dialog.as_ref().is_some_and(|d| d.kind == self.kind)
}
/// The open strip, if it is this one.
pub fn open(&self, app: &VectorcraftApp) -> Option<Dialog> {
app.ui.dialog.clone().filter(|d| d.kind == self.kind)
}
/// The slider's level, a whole number from 0 to 100.
fn level(&self, d: &Dialog) -> f64 {
let l = d.f64("level", self.default_level);
if l.is_finite() { l.round().clamp(0.0, 100.0) } else { self.default_level }
}
fn params(&self, d: &Dialog) -> Value {
json!({ "level": self.level(d) })
}
pub fn confirm(&self, app: &mut VectorcraftApp, d: &Dialog) -> DialogResult {
form::commit_preview(app, self.cmd, self.params(d))
}
/// The open strip `d` moves to the level `cmd {auto: true}` picks for the selection, and the
/// canvas previews it → {level}.
pub fn auto(&self, app: &mut VectorcraftApp, mut d: Dialog) -> Result<Value, String> {
app.begin_interaction(self.label)?;
let r = app.session.preview(self.cmd, &json!({ "auto": true })).map_err(|e| e.to_string())?;
let level = r["level"].as_f64().unwrap_or(self.default_level);
d.fields.insert("level".into(), json!(level));
d.fields.insert(form::PREVIEWED.into(), self.params(&d));
app.ui.dialog = Some(d);
Ok(json!({ "level": level }))
}
pub fn show(&self, app: &mut VectorcraftApp, ctx: &egui::Context) {
let Some(mut d) = app.ui.dialog.clone() else { return };
let t = Tokens::get(ctx);
let id = egui::Id::unique(("dialog", self.kind));
let b = bounds(app, &mut d);
let pos = place(app, ctx, id, b);
// A click anywhere else keeps the result, and the rest of the app doesn't take it.
// Not focusable (`Sense::click()` is): Tab goes through the strip's controls, not the backdrop.
let dim = modal::backdrop();
let outside =
egui::Area::new(dim.id).order(dim.order).fixed_pos(Pos2::ZERO).show(ctx, |ui| ui.allocate_rect(ctx.content_rect(), Sense::CLICK)).inner;
let mut action: Option<Button> = None;
egui::Area::new(id).order(Order::Foreground).fixed_pos(pos).show(ctx, |ui| {
egui::Frame::NONE
.fill(t.panel)
.stroke(Stroke::new(1.0, t.tool_active))
.corner_radius(CornerRadius::same(5))
.inner_margin(egui::Margin::symmetric(8, 6))
.shadow(egui::epaint::Shadow { offset: [0, 3], blur: 10, spread: 0, color: Color32::from_black_alpha(70) })
.show(ui, |ui| {
ui.horizontal(|ui| {
ui.spacing_mut().item_spacing.x = 6.0;
if widgets::icon_button(ui, "wand-sparkles", tl!(self.auto.0), false, 28.0).clicked() {
action = Some(self.auto.1);
}
let rail = t.input_border;
form::slider_rail_named(ui, &mut d, "level", tl!(self.label), 0.0..=100.0, &|_| rail);
if let Some(more) = self.more_options
&& widgets::icon_button(ui, "ellipsis", tl!("More Options"), false, 28.0).clicked()
{
action = Some(more);
}
});
});
});
let p = self.params(&d);
let _ = form::preview_now(app, &mut d, self.label, self.cmd, p);
app.ui.dialog = Some(d);
let r = match action {
Some(run) => run(app),
None if outside.clicked() || ctx.input(|i| i.key_pressed(egui::Key::Enter)) => super::confirm(app),
None => Ok(Value::Null),
};
if let Err(e) = r {
app.status(e);
}
}
}
/// The fields the slider opens with: Auto-Simplify's level for the selection, or
/// [`SIMPLIFY_LEVEL`] without a document.
pub(crate) fn fields(app: &VectorcraftApp) -> Value {
json!({ "level": auto_simplify_level(&app.session).unwrap_or(SIMPLIFY_LEVEL) })
}
/// Whether the Simplify slider is open.
pub(crate) fn showing(app: &VectorcraftApp) -> bool {
STRIP.showing(app)
}
fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> DialogResult {
STRIP.confirm(app, d)
}
fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
STRIP.show(app, ctx);
}
/// Auto-Simplify (`ui.simplifyAuto`): the open slider moves to the level `object.path.simplify
/// {auto: true}` picks for the selection, and the canvas previews it → {level}.
pub(crate) fn auto(app: &mut VectorcraftApp) -> Result<Value, String> {
let d = STRIP.open(app).ok_or_else(|| "the Simplify slider is not open".to_string())?;
STRIP.auto(app, d)
}
/// More Options (`ui.simplifyMoreOptions`): the Simplify dialog takes the slider's place, at the
/// slider's tolerance → {tolerance}.
pub(crate) fn more_options(app: &mut VectorcraftApp) -> Result<Value, String> {
let d = STRIP.open(app).ok_or_else(|| "the Simplify slider is not open".to_string())?;
let tolerance = simplify_level_tolerance(STRIP.level(&d));
app.ui.dialog = Some(Dialog::new("simplify", super::path_ops::simplify_dialog(tolerance)));
Ok(json!({ "tolerance": tolerance }))
}
/// The private field that holds the selection's bounds before the preview, `[x0, y0, x1, y1]`.
const BOUNDS: &str = "__bounds";
/// The selection's bounds before the preview: the interaction's snapshot when a preview runs, read
/// once and kept in `d`, so the strip stays where it opened while the preview changes the paths.
fn bounds(app: &mut VectorcraftApp, d: &mut Dialog) -> Option<Rect> {
if let Some([x0, y0, x1, y1]) = d.fields.get(BOUNDS).and_then(|v| serde_json::from_value::<[f64; 4]>(v.clone()).ok()) {
return Some(Rect::new(x0, y0, x1, y1));
}
let b = match app.session.active().and_then(|st| st.interaction.as_ref()) {
Some(it) => it.doc.bounds_of(&it.selection.objects, true),
None => app.selection_bounds(),
}?;
d.fields.insert(BOUNDS.into(), json!([b.x0, b.y0, b.x1, b.y1]));
Some(b)
}
/// Where the strip goes: under the lowest corner on screen of `bounds` (the selection's, before the
/// preview), centered on them, kept on the canvas.
fn place(app: &mut VectorcraftApp, ctx: &egui::Context, id: egui::Id, bounds: Option<Rect>) -> Pos2 {
let size = egui::AreaState::load(ctx, id).and_then(|s| s.size).unwrap_or(vec2(270.0, 42.0));
let screen = ctx.content_rect();
let Some((rect, xf)) = app.canvas_rect.zip(app.canvas_xf()) else { return screen.center() - size / 2.0 };
let under = match bounds {
Some(b) => {
let lowest = xf.quad(b).iter().map(|c| c.y).fold(f32::NEG_INFINITY, f32::max);
Pos2::new(xf.to_screen(b.center()).x - size.x / 2.0, lowest + 28.0)
}
None => rect.center() - size / 2.0,
};
let bounds = rect.shrink(8.0);
under.clamp(bounds.min, (bounds.max - size).max(bounds.min))
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.