mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-19 02:03:02 +00:00
ui.paramDialog for edit.findReplace used to drop a field of the wrong type, such as a number for find, and open on the last search. It now returns an error and leaves the dialog closed. A null field still gives none, as the menu item's does.
366 lines
16 KiB
Rust
366 lines
16 KiB
Rust
//! Edit › Find and Replace…: the Find and Replace With fields, Match Case, Find Whole Word, Search
|
||
//! Backwards, Check Hidden Layers and Check Locked Layers, and the Find, Replace, Replace & Find,
|
||
//! Replace All and Done buttons, as "Find and replace text" in the public
|
||
//! [reference](https://helpx.adobe.com/pdf/illustrator_reference.pdf) describes them. The dialog
|
||
//! stays open: Find goes to the next match (`edit.findNext`), Replace changes that match
|
||
//! (`edit.replaceMatch`), Replace & Find changes it and goes to the next, and Replace All changes
|
||
//! every match (`edit.findReplace`). Each Replace is one undo step, and so is Replace All.
|
||
//!
|
||
//! These rules are VectorCraft's own. A match is shown in the dialog in its line of text with its
|
||
//! place among the matches, and its type object is selected, unless it is on a hidden or locked
|
||
//! layer. Enter runs Find. Replace and Replace & Find wait for a match that Find reached with the
|
||
//! Find text and the options as they are now. Edit › Find Next goes on from the last search while
|
||
//! the dialog is closed, and opens the dialog when there has been none.
|
||
//!
|
||
//! Fields: `find`, `replace`, `matchCase`, `wholeWord`, `backwards`, `hiddenLayers`,
|
||
//! `lockedLayers` and `action` (what `ui.dialog.confirm` does: `find`, `replace`, `replaceFind`,
|
||
//! `replaceAll` or `done`; a button sets it and confirms). The dialog keeps the place the search
|
||
//! reached in `__at`, the `uid` of its document in `__doc` and the Find text and switches it was
|
||
//! reached with in `__atQuery`, the match found in `__found` and the line under the fields in
|
||
//! `__note`. A place in a document other than the active one, or reached with other Find text or
|
||
//! switches, is not used: the search starts again.
|
||
|
||
use serde_json::{Map, Value, json};
|
||
use vectorcraft_doc::{NodeId, NodeKind};
|
||
|
||
use super::{DialogAction, DialogSpec, form};
|
||
use crate::state::Dialog;
|
||
use crate::{VectorcraftApp, widgets};
|
||
|
||
/// The dialog kind of Find and Replace.
|
||
pub const KIND: &str = "findReplace";
|
||
|
||
/// The command of its menu item, which Replace All runs.
|
||
pub const COMMAND: &str = "edit.findReplace";
|
||
|
||
/// The command Find runs, and Edit › Find Next.
|
||
pub const NEXT: &str = "edit.findNext";
|
||
|
||
/// The command Replace runs.
|
||
const REPLACE: &str = "edit.replaceMatch";
|
||
|
||
/// The switches that decide what a match is and which type is searched.
|
||
const SWITCHES: [&str; 4] = ["matchCase", "wholeWord", "hiddenLayers", "lockedLayers"];
|
||
|
||
/// The place the search reached: `{id, start, end}`, a match or the text that replaced one.
|
||
const AT: &str = "__at";
|
||
/// The match Find reached, which Replace changes: `{index, count, query}`, with `query` the Find
|
||
/// text and the switches it was found with.
|
||
const FOUND: &str = "__found";
|
||
/// The line under the fields, in English: no matches, or how many Replace All replaced.
|
||
const NOTE: &str = "__note";
|
||
|
||
/// The characters of a match's line shown on either side of it.
|
||
const CONTEXT: usize = 24;
|
||
|
||
pub(super) const SPEC: DialogSpec = DialogSpec {
|
||
heading: |_| tl!("Find and Replace").into(),
|
||
body_with_actions: Some(body),
|
||
confirm,
|
||
ok: None,
|
||
min_width: 480.0,
|
||
..DialogSpec::FORM
|
||
};
|
||
|
||
/// The document a place in [`AT`] or the last search's `from` belongs to: its `uid`.
|
||
const DOC: &str = "__doc";
|
||
/// The Find text and switches the place in [`AT`] was reached with ([`query`]).
|
||
const AT_QUERY: &str = "__atQuery";
|
||
|
||
/// The params of the Edit menu's Find and Replace… item: a `find` of null, which gives the dialog
|
||
/// no field, so that it opens on the last search.
|
||
pub fn menu_params() -> Value {
|
||
json!({"find": null})
|
||
}
|
||
|
||
/// The `uid` of the active document.
|
||
fn active_uid(app: &VectorcraftApp) -> Option<u64> {
|
||
app.session.active().map(|d| d.uid)
|
||
}
|
||
|
||
/// Open Find and Replace on the last search when there has been one, with the fields that
|
||
/// `params` gives in its place. A null value, such as the menu item's `find` ([`menu_params`]),
|
||
/// gives none. A field given a value of another type is an error, and the dialog does not open.
|
||
pub fn open(app: &mut VectorcraftApp, params: &Map<String, Value>) -> Result<Value, String> {
|
||
let mut fields = Map::new();
|
||
fields.insert("find".into(), json!(""));
|
||
fields.insert("replace".into(), json!(""));
|
||
for key in SWITCHES.into_iter().chain(["backwards"]) {
|
||
fields.insert(key.into(), json!(false));
|
||
}
|
||
for (k, v) in params.iter().filter(|(_, v)| !v.is_null()) {
|
||
match fields.get(k) {
|
||
Some(Value::String(_)) if !v.is_string() => return Err(format!("`{k}` must be a string")),
|
||
Some(Value::Bool(_)) if !v.is_boolean() => return Err(format!("`{k}` must be true or false")),
|
||
_ => {}
|
||
}
|
||
}
|
||
let last = app.ui.last_find.as_ref().and_then(Value::as_object).cloned().unwrap_or_default();
|
||
for (k, v) in last.iter().chain(params) {
|
||
// Only the dialog's own fields, each of its own type.
|
||
if fields.get(k).is_some_and(|f| f.is_string() == v.is_string() && f.is_boolean() == v.is_boolean()) {
|
||
fields.insert(k.clone(), v.clone());
|
||
}
|
||
}
|
||
// The place the last search reached, while its document is the active one.
|
||
let uid = active_uid(app);
|
||
if let Some(at) = last.get("from").filter(|v| v.is_object() && uid.is_some() && last.get("doc").and_then(Value::as_u64) == uid) {
|
||
fields.insert(AT.into(), at.clone());
|
||
fields.insert(DOC.into(), json!(uid));
|
||
fields.insert(AT_QUERY.into(), query_in(&last));
|
||
}
|
||
fields.insert("action".into(), json!("find"));
|
||
fields.insert("__command".into(), json!(COMMAND));
|
||
app.ui.dialog = Some(Dialog { kind: KIND.into(), fields });
|
||
Ok(Value::Null)
|
||
}
|
||
|
||
/// Edit › Find Next with no text to find: the next match of the last search, from the place it
|
||
/// reached, with the options the dialog had. With no search yet, it opens the dialog.
|
||
pub fn find_next(app: &mut VectorcraftApp) -> Result<Value, String> {
|
||
let Some(mut last) = app.ui.last_find.clone().filter(|l| l.get("find").and_then(Value::as_str).is_some_and(|f| !f.is_empty())) else {
|
||
return open(app, &Map::new());
|
||
};
|
||
let uid = active_uid(app);
|
||
if let Some(o) = last.as_object_mut() {
|
||
o.remove("replace");
|
||
// A place in another document is no place in this one.
|
||
if uid.is_none() || o.remove("doc").and_then(|d| d.as_u64()) != uid {
|
||
o.remove("from");
|
||
}
|
||
}
|
||
let r = app.run(NEXT, last)?;
|
||
if r["id"].is_null() {
|
||
app.status("No matches found");
|
||
return Ok(r);
|
||
}
|
||
if let Some(l) = app.ui.last_find.as_mut() {
|
||
l["from"] = json!({ "id": r["id"], "start": r["start"], "end": r["end"] });
|
||
l["doc"] = json!(uid);
|
||
}
|
||
Ok(r)
|
||
}
|
||
|
||
/// The Find text and the switches of [`SWITCHES`]: what a match is, as params.
|
||
fn query(d: &Dialog) -> Value {
|
||
query_in(&d.fields)
|
||
}
|
||
|
||
/// [`query`] of the dialog fields, or of the last search, in `fields`.
|
||
fn query_in(fields: &Map<String, Value>) -> Value {
|
||
let mut q = json!({ "find": fields.get("find").and_then(Value::as_str).unwrap_or_default() });
|
||
for key in SWITCHES {
|
||
q[key] = json!(fields.get(key).and_then(Value::as_bool).unwrap_or(false));
|
||
}
|
||
q
|
||
}
|
||
|
||
/// The place the search reached, `{id, start, end}`, while its document is the active one and
|
||
/// the Find text and the switches are those it was reached with.
|
||
fn place<'a>(app: &VectorcraftApp, d: &'a Dialog) -> Option<&'a Value> {
|
||
let uid = active_uid(app)?;
|
||
let same = d.fields.get(DOC).and_then(Value::as_u64) == Some(uid) && d.fields.get(AT_QUERY) == Some(&query(d));
|
||
same.then(|| d.fields.get(AT)).flatten().filter(|at| at.is_object())
|
||
}
|
||
|
||
/// Keep `at`, a place in the active document, as the place the search reached.
|
||
fn set_place(app: &VectorcraftApp, d: &mut Dialog, at: Value) {
|
||
d.fields.insert(AT.into(), at);
|
||
d.fields.insert(DOC.into(), json!(active_uid(app)));
|
||
d.fields.insert(AT_QUERY.into(), query(d));
|
||
}
|
||
|
||
/// The match Replace changes, as `{id, start, end}`: the one Find reached in the active document,
|
||
/// while the Find text and the switches are as they were when it was found.
|
||
fn current_match<'a>(app: &VectorcraftApp, d: &'a Dialog) -> Option<&'a Value> {
|
||
let found = d.fields.get(FOUND)?;
|
||
(found.get("query") == Some(&query(d))).then(|| place(app, d)).flatten()
|
||
}
|
||
|
||
/// Keep what the dialog searched for and the place it reached, for Edit › Find Next and for the
|
||
/// next time the dialog opens.
|
||
fn remember(app: &mut VectorcraftApp, d: &Dialog) {
|
||
let mut last = query(d);
|
||
last["replace"] = json!(d.str("replace"));
|
||
last["backwards"] = json!(d.bool("backwards"));
|
||
if let Some(at) = place(app, d) {
|
||
last["from"] = at.clone();
|
||
last["doc"] = json!(active_uid(app));
|
||
}
|
||
app.ui.last_find = Some(last);
|
||
}
|
||
|
||
/// Find: the next match after the place the search reached, kept as that place and as the match
|
||
/// Replace changes. With no match, the note says so.
|
||
fn find(app: &mut VectorcraftApp, d: &mut Dialog) -> Result<Value, String> {
|
||
let mut p = query(d);
|
||
p["backwards"] = json!(d.bool("backwards"));
|
||
if let Some(at) = place(app, d) {
|
||
p["from"] = at.clone();
|
||
}
|
||
d.fields.remove(FOUND);
|
||
d.fields.remove(NOTE);
|
||
let r = app.run(NEXT, p)?;
|
||
if r["id"].is_null() {
|
||
app.status("No matches found");
|
||
d.fields.insert(NOTE.into(), json!(app.ui.status));
|
||
return Ok(r);
|
||
}
|
||
set_place(app, d, json!({ "id": r["id"], "start": r["start"], "end": r["end"] }));
|
||
d.fields.insert(FOUND.into(), json!({ "index": r["index"], "count": r["count"], "query": query(d) }));
|
||
Ok(r)
|
||
}
|
||
|
||
/// Replace: the match Find reached becomes the Replace With text, and the search goes on from
|
||
/// it. With no such match, it finds one.
|
||
fn replace(app: &mut VectorcraftApp, d: &mut Dialog) -> Result<Value, String> {
|
||
let Some(at) = current_match(app, d).cloned() else { return find(app, d) };
|
||
let mut p = query(d);
|
||
for key in ["hiddenLayers", "lockedLayers"] {
|
||
if let Some(o) = p.as_object_mut() {
|
||
o.remove(key);
|
||
}
|
||
}
|
||
p["replace"] = json!(d.str("replace"));
|
||
for key in ["id", "start", "end"] {
|
||
p[key] = at[key].clone();
|
||
}
|
||
d.fields.remove(FOUND);
|
||
d.fields.remove(NOTE);
|
||
let r = app.run(REPLACE, p)?;
|
||
set_place(app, d, json!({ "id": r["id"], "start": r["start"], "end": r["end"] }));
|
||
Ok(r)
|
||
}
|
||
|
||
/// Replace All: every match becomes the Replace With text, and the note says how many.
|
||
fn replace_all(app: &mut VectorcraftApp, d: &mut Dialog) -> Result<Value, String> {
|
||
let mut p = query(d);
|
||
p["replace"] = json!(d.str("replace"));
|
||
d.fields.remove(FOUND);
|
||
d.fields.remove(NOTE);
|
||
let r = app.run(COMMAND, p)?;
|
||
// The matches that changed: those that already read as the Replace With text do not count.
|
||
match (r["count"].as_u64().unwrap_or(0), r["replaced"].as_u64().unwrap_or(0)) {
|
||
(0, _) => app.status("No matches found"),
|
||
(_, n) => app.status(format!("Matches replaced: {n}")),
|
||
}
|
||
d.fields.insert(NOTE.into(), json!(app.ui.status));
|
||
Ok(r)
|
||
}
|
||
|
||
/// A button or `ui.dialog.confirm`: run the `action` and keep the dialog open, or close it for
|
||
/// `done`. What a command refuses is the note, and the dialog stays open.
|
||
fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
|
||
let mut d = d.clone();
|
||
let action = d.fields.insert("action".into(), json!("find")).and_then(|a| a.as_str().map(str::to_string)).unwrap_or_default();
|
||
let r = match action.as_str() {
|
||
"done" => {
|
||
remember(app, &d);
|
||
app.ui.dialog = None;
|
||
return Ok(Value::Null);
|
||
}
|
||
"" | "find" => find(app, &mut d),
|
||
"replace" => replace(app, &mut d),
|
||
"replaceFind" => match current_match(app, &d) {
|
||
Some(_) => replace(app, &mut d).and_then(|_| find(app, &mut d)),
|
||
None => find(app, &mut d),
|
||
},
|
||
"replaceAll" => replace_all(app, &mut d),
|
||
_ => Err("no such action".to_string()),
|
||
};
|
||
if let Err(e) = &r {
|
||
d.fields.insert(NOTE.into(), json!(e));
|
||
}
|
||
remember(app, &d);
|
||
app.ui.dialog = Some(d);
|
||
r
|
||
}
|
||
|
||
/// The match Find reached as it reads in its text: (the text before it on its line, the match,
|
||
/// the text after it), each at most [`CONTEXT`] characters, and its place among the matches.
|
||
fn shown_match(app: &VectorcraftApp, d: &Dialog) -> Option<([String; 3], String)> {
|
||
let at = current_match(app, d)?;
|
||
let found = d.fields.get(FOUND)?;
|
||
let whole = |v: &Value| v.as_u64().and_then(|n| usize::try_from(n).ok());
|
||
let (id, start, end) = (at["id"].as_u64()?, whole(&at["start"])?, whole(&at["end"])?);
|
||
let NodeKind::Text(t) = &app.session.active()?.doc.node(NodeId(id))?.kind else { return None };
|
||
let text = t.plain_text();
|
||
let (before, hit, after) = (text.get(..start)?, text.get(start..end)?, text.get(end..)?);
|
||
let before = before.rsplit(['\n', '\r']).next().unwrap_or_default();
|
||
let after = after.split(['\n', '\r']).next().unwrap_or_default();
|
||
let skip = before.chars().count().saturating_sub(CONTEXT);
|
||
let lead = if skip > 0 { "…" } else { "" };
|
||
let tail = if after.chars().count() > CONTEXT { "…" } else { "" };
|
||
let before = format!("{lead}{}", before.chars().skip(skip).collect::<String>());
|
||
let after = format!("{}{tail}", after.chars().take(CONTEXT).collect::<String>());
|
||
Some(([before, hit.to_string(), after], format!("{} / {}", found["index"], found["count"])))
|
||
}
|
||
|
||
fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> DialogAction {
|
||
let can_find = !d.str("find").is_empty();
|
||
let found = current_match(app, d).is_some();
|
||
let mut action = None;
|
||
ui.horizontal_top(|ui| {
|
||
ui.vertical(|ui| {
|
||
widgets::dim_label(ui, tl!("Find:"));
|
||
form::text(ui, d, "find", 320.0);
|
||
ui.add_space(6.0);
|
||
widgets::dim_label(ui, tl!("Replace With:"));
|
||
form::text(ui, d, "replace", 320.0);
|
||
ui.add_space(10.0);
|
||
ui.horizontal_top(|ui| {
|
||
ui.vertical(|ui| {
|
||
form::check(ui, d, "matchCase", "Match Case");
|
||
form::check(ui, d, "wholeWord", "Find Whole Word");
|
||
form::check(ui, d, "backwards", "Search Backwards");
|
||
});
|
||
ui.add_space(16.0);
|
||
ui.vertical(|ui| {
|
||
form::check(ui, d, "hiddenLayers", "Check Hidden Layers");
|
||
form::check(ui, d, "lockedLayers", "Check Locked Layers");
|
||
});
|
||
});
|
||
});
|
||
ui.add_space(16.0);
|
||
ui.vertical(|ui| {
|
||
let mut button = |ui: &mut egui::Ui, label: &str, enabled: bool, name: &'static str| {
|
||
if ui.add_enabled_ui(enabled, |ui| widgets::flat_button(ui, label, 130.0).clicked()).inner {
|
||
action = Some(name);
|
||
}
|
||
ui.add_space(6.0);
|
||
};
|
||
button(ui, if found { tl!("Find Next") } else { tl!("Find") }, can_find, "find");
|
||
button(ui, tl!("Replace"), can_find && found, "replace");
|
||
button(ui, tl!("Replace & Find"), can_find && found, "replaceFind");
|
||
button(ui, tl!("Replace All"), can_find, "replaceAll");
|
||
button(ui, tl!("Done"), true, "done");
|
||
});
|
||
});
|
||
ui.add_space(8.0);
|
||
if let Some(([before, hit, after], place)) = shown_match(app, d) {
|
||
let t = crate::theme::Tokens::get(ui.ctx());
|
||
ui.horizontal_wrapped(|ui| {
|
||
ui.spacing_mut().item_spacing.x = 0.0;
|
||
widgets::dim_name(ui, &format!("{place} {before}"));
|
||
ui.colored_label(t.text_strong, egui::RichText::new(hit).strong().underline());
|
||
widgets::dim_name(ui, &after);
|
||
});
|
||
} else if let Some(note) = d.fields.get(NOTE).and_then(Value::as_str) {
|
||
widgets::dim_name(ui, &crate::i18n::message(crate::i18n::current(), note));
|
||
}
|
||
// Enter finds, as the Find button does.
|
||
if action.is_none() && can_find && crate::shortcuts::pressed_anew(ui.ctx(), egui::Key::Enter) {
|
||
action = Some("find");
|
||
}
|
||
match action {
|
||
Some(name) => {
|
||
d.fields.insert("action".into(), json!(name));
|
||
DialogAction::Confirm
|
||
}
|
||
None => DialogAction::None,
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests;
|