Dialogs: automation surface for every StackDialog

StackDialog gains json_fields and set_json_field; DialogHost lists its open
dialogs with their fields, sets one by id, and confirms or cancels by id
whatever the type. HostedParamDialog (values by parameter row, with a
programmatic OK), StandardPrompt and UnsavedChangesDialog (their choice)
implement them. craft_automation::dialogs runs ui.dialog.set/confirm/cancel
on a host and lists its dialogs for ui.inspect.
This commit is contained in:
aiongg
2026-11-12 22:27:40 +00:00
parent 15fe3dba92
commit e51e929e48
15 changed files with 311 additions and 18 deletions
Generated
+2
View File
@@ -2654,6 +2654,7 @@ dependencies = [
"craft-ui-widgets",
"egui",
"serde",
"serde_json",
"toml",
]
@@ -2673,6 +2674,7 @@ dependencies = [
"craft-ui-test-kit",
"egui",
"serde",
"serde_json",
"toml",
"toml_edit",
"zeroize",
+69
View File
@@ -0,0 +1,69 @@
//! `ui.dialog.set`, `ui.dialog.confirm` and `ui.dialog.cancel` on an app's [`DialogHost`], for every dialog type.
//!
//! The app's method table hands these methods to [`dialog_method`] and lists [`inspect`] under `ui.inspect`'s
//! `dialogs`. A dialog is named by the `id` number `inspect` lists; its fields are its
//! [`StackDialog::json_fields`](craft_ui::dialog::StackDialog::json_fields). Opening a dialog (`ui.dialog.open`) and
//! running the command its answer is for stay the app's: an answer waits for the app's `DialogHost::take` as a
//! click's would.
use craft_ui::dialog::{DialogHost, DialogId};
use egui::Context;
use serde_json::{Value, json};
use crate::protocol::Params;
/// The open dialogs, the top one last: `{id, parent, key, fields}`, `null` for a missing parent, key or fields.
pub fn inspect(host: &DialogHost) -> Value {
host.open_dialogs()
.into_iter()
.map(|dialog| json!({"id": dialog.id.value(), "parent": dialog.parent.map(|id| id.value()), "key": dialog.key, "fields": dialog.fields}))
.collect()
}
/// Runs a `ui.dialog.*` method on `host`; `None` when `method` is not one of them.
///
/// - `ui.dialog.set {dialog, field, value}` sets one field ([`DialogHost::set_json_field`]).
/// - `ui.dialog.confirm {dialog, choice?}` answers OK, as the default button would, after setting the `choice` field
/// when one is given (which button of a prompt).
/// - `ui.dialog.cancel {dialog}` closes the dialog and its children with Cancel.
pub fn dialog_method(host: &mut DialogHost, ctx: &Context, method: &str, params: &Value) -> Option<Result<Value, String>> {
let fields: &[&str] = match method {
"ui.dialog.set" => &["dialog", "field", "value"],
"ui.dialog.confirm" => &["dialog", "choice"],
"ui.dialog.cancel" => &["dialog"],
_ => return None,
};
Some(run(host, ctx, method, params, fields))
}
fn run(host: &mut DialogHost, ctx: &Context, method: &str, params: &Value, fields: &[&str]) -> Result<Value, String> {
let params = Params(params).only(None, fields)?;
let read = Params(&params);
let id = dialog(host, read)?;
match method {
"ui.dialog.set" => {
let field = read.str_field("field")?.ok_or("missing `field`")?;
host.set_json_field(id, field, params.get("value").cloned().unwrap_or(Value::Null))?;
}
"ui.dialog.confirm" => {
if let Some(choice) = params.get("choice") {
host.set_json_field(id, "choice", choice.clone())?;
}
if !host.confirm_by_id(ctx, id) {
return Err("the dialog refuses OK: it is disabled, or the dialog has no programmatic OK".to_owned());
}
}
_ => {
if !host.cancel_by_id(ctx, id) {
return Err(format!("no dialog {}", id.value()));
}
}
}
Ok(Value::Null)
}
/// The dialog `params.dialog` names, from the stack; one the app shows beside the host is refused by the host.
fn dialog(host: &DialogHost, params: Params<'_>) -> Result<DialogId, String> {
let value = params.uint_field("dialog")?.ok_or("missing `dialog`")?;
host.stack().ids().find(|id| id.value() == value).ok_or_else(|| format!("no dialog {value}"))
}
+2
View File
@@ -23,6 +23,8 @@ pub mod ui;
pub mod args;
#[cfg(all(feature = "ui", not(target_arch = "wasm32")))]
pub mod control;
#[cfg(all(feature = "ui", not(target_arch = "wasm32")))]
pub mod dialogs;
#[cfg(not(target_arch = "wasm32"))]
pub mod profiler;
#[cfg(not(target_arch = "wasm32"))]
+54
View File
@@ -0,0 +1,54 @@
//! `ui.dialog.*` on typed dialogs through one generic path.
use craft_automation::dialogs::{dialog_method, inspect};
use craft_ui::contract::Bind;
use craft_ui::dialog::{DialogHost, DialogResult, PromptChoice, PromptKind, StandardPrompt};
use craft_ui::patterns::form_dialogs::{DialogFields, HostedParamDialog, Param, ParamDialog};
use craft_ui::testing::trial;
use egui::Context;
use serde_json::{Value, json};
fn call(host: &mut DialogHost, ctx: &Context, method: &str, params: Value) -> Result<Value, String> {
dialog_method(host, ctx, method, &params).expect("a ui.dialog method")
}
/// A parameter dialog and a prompt are listed with their fields, set by key and answered by id, with no code that
/// knows their types; a value the row can't hold and an unknown choice are refused.
#[trial]
fn dialog_methods_read_set_and_answer_typed_dialogs() {
let ctx = Context::default();
let mut host = DialogHost::new();
host.open(HostedParamDialog::new("gaussianBlur", DialogFields::from_pairs([("radius", 1.0)]), |fields| {
ParamDialog::new("gaussianBlur", "Gaussian Blur", Param::parse_list(r#"{"radius":0.1..1000=1,"method":"spin|zoom"}"#))
.values(Bind::bound(fields))
}));
let listed = inspect(&host);
assert_eq!(listed[0]["key"], "gaussianBlur");
assert_eq!(listed[0]["fields"], json!({"radius": 1.0}));
let blur = listed[0]["id"].clone();
assert_eq!(call(&mut host, &ctx, "ui.dialog.set", json!({"dialog": blur, "field": "radius", "value": 4.5})), Ok(Value::Null));
assert!(call(&mut host, &ctx, "ui.dialog.set", json!({"dialog": blur, "field": "radius", "value": 5000})).is_err_and(|e| e.contains("radius")));
assert!(
call(&mut host, &ctx, "ui.dialog.set", json!({"dialog": blur, "field": "angle", "value": 1})).is_err_and(|e| e.contains("unknown field"))
);
assert_eq!(inspect(&host)[0]["fields"]["radius"], 4.5);
assert_eq!(call(&mut host, &ctx, "ui.dialog.confirm", json!({"dialog": blur})), Ok(Value::Null));
let Some(DialogResult::Ok(result)) = host.take::<HostedParamDialog>() else { panic!("the blur dialog answers OK") };
assert_eq!((result.fields.number("radius"), result.fields.text("method")), (Some(4.5), Some("spin")));
assert_eq!(inspect(&host), json!([]));
host.open(StandardPrompt::new(PromptKind::TrashMask));
let prompt = inspect(&host)[0]["id"].clone();
assert_eq!(inspect(&host)[0]["fields"]["choice"], "proceed");
assert!(call(&mut host, &ctx, "ui.dialog.confirm", json!({"dialog": prompt, "choice": "maybe"})).is_err());
assert_eq!(call(&mut host, &ctx, "ui.dialog.confirm", json!({"dialog": prompt, "choice": "alternate"})), Ok(Value::Null));
let Some(DialogResult::Ok(answer)) = host.take::<StandardPrompt>() else { panic!("the prompt answers") };
assert_eq!(answer.choice, PromptChoice::Alternate);
host.open(StandardPrompt::new(PromptKind::TrashMask));
let prompt = inspect(&host)[0]["id"].clone();
assert_eq!(call(&mut host, &ctx, "ui.dialog.cancel", json!({"dialog": prompt})), Ok(Value::Null));
assert!(matches!(host.take::<StandardPrompt>(), Some(DialogResult::Cancel)));
assert!(call(&mut host, &ctx, "ui.dialog.cancel", json!({"dialog": prompt})).is_err());
}
+1
View File
@@ -2,4 +2,5 @@
mod actions;
mod control;
mod dialogs;
mod screenshot;
+1 -1
View File
@@ -341,7 +341,7 @@ impl FilePanels {
/// The dialog ids of the Replace questions open on the app's dialog host, for an app that lists
/// its open prompts to automation (`ui.inspect`) and answers them by id
/// (`DialogHost::confirm_by_id::<StandardPrompt>`).
/// (`DialogHost::confirm_by_id`).
#[cfg(feature = "ui")]
pub fn open_questions(&self) -> impl Iterator<Item = craft_ui::dialog::DialogId> + '_ {
self.prompts.iter().filter_map(|asked| asked.dialog)
+1
View File
@@ -31,6 +31,7 @@ craft-host = { workspace = true }
craft-quit = { workspace = true }
craft-i18n = { workspace = true, features = ["collate"] }
serde = { workspace = true }
serde_json = { workspace = true }
[dev-dependencies]
craft-ui-panels = { path = ".", features = ["testing"] }
+67 -9
View File
@@ -8,6 +8,7 @@ use std::any::{Any, TypeId};
use std::fmt;
use egui::{Context, Ui};
use serde_json::Value;
use super::stack::{DialogId, DialogStack};
use crate::contract::{Pattern, PatternKind, PatternProbe};
@@ -72,6 +73,19 @@ pub trait StackDialog: Any + Send {
None
}
/// The dialog's values as a JSON object, keyed as [`set_json_field`](StackDialog::set_json_field) takes them:
/// what automation lists for the open dialog (`ui.inspect`). `None` (the default) for a dialog without values.
fn json_fields(&self) -> Option<Value> {
None
}
/// Sets the value `field` names, as the user editing that control would (`ui.dialog.set`); a prompt's answer
/// is its `choice` field. `Err` says why the dialog refused: no such field, or a value the control can't hold.
/// Refuses everything by default.
fn set_json_field(&mut self, field: &str, _value: Value) -> Result<(), String> {
Err(format!("unknown field `{field}`: this dialog has no fields"))
}
/// Called when the host closes the dialog from outside with [`DialogResult::Cancel`]
/// ([`DialogHost::cancel`], a dialog of the same type opened over it, or its parent closing),
/// so it can release what it holds: a pick ticket (`Files::forget`), an armed dropper. The
@@ -114,6 +128,8 @@ trait AnyStackDialog: Send {
fn key(&self) -> Option<String>;
fn instance(&self) -> Option<DialogId>;
fn confirm_erased(&mut self, ctx: &Context) -> Option<Box<dyn Any + Send>>;
fn json_fields(&self) -> Option<Value>;
fn set_json_field(&mut self, field: &str, value: Value) -> Result<(), String>;
fn show_erased(&mut self, ui: &mut Ui, stack: &DialogStack) -> Option<Box<dyn Any + Send>>;
/// `DialogResult::<D::Result>::Cancel`, boxed, for a dialog closed from outside.
fn cancelled(&self) -> Box<dyn Any + Send>;
@@ -144,6 +160,14 @@ impl<D: StackDialog> AnyStackDialog for D {
self.confirm(ctx).map(|result| Box::new(DialogResult::Ok(result)) as Box<dyn Any + Send>)
}
fn json_fields(&self) -> Option<Value> {
StackDialog::json_fields(self)
}
fn set_json_field(&mut self, field: &str, value: Value) -> Result<(), String> {
StackDialog::set_json_field(self, field, value)
}
fn show_erased(&mut self, ui: &mut Ui, stack: &DialogStack) -> Option<Box<dyn Any + Send>> {
self.show(ui, stack).map(|result| Box::new(result) as Box<dyn Any + Send>)
}
@@ -195,7 +219,11 @@ impl<D: StackDialog> AnyStackDialog for D {
/// [`open_unless_open`](DialogHost::open_unless_open) refuses while any `D` is open and leaves
/// it alone (PhotoCraft's `confirmationPending`).
/// - Automation: [`get`](DialogHost::get) and [`get_mut`](DialogHost::get_mut) reach the open
/// dialog's value, so a script sets fields and a test reads them like a user would.
/// dialog's value for code that knows its type. A script that doesn't goes by id:
/// [`open_dialogs`](DialogHost::open_dialogs) lists every open dialog with its
/// [`json_fields`](StackDialog::json_fields), [`set_json_field`](DialogHost::set_json_field) sets one,
/// and [`confirm_by_id`](DialogHost::confirm_by_id) and [`cancel_by_id`](DialogHost::cancel_by_id) close it,
/// whatever its type.
#[derive(Default)]
pub struct DialogHost {
stack: DialogStack,
@@ -207,6 +235,20 @@ pub struct DialogHost {
replaced: Vec<Box<dyn AnyStackDialog>>,
}
/// One open dialog as automation sees it ([`DialogHost::open_dialogs`]).
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct OpenDialog {
/// The id the `_by_id` calls take.
pub id: DialogId,
/// The dialog it was opened from, for a child.
pub parent: Option<DialogId>,
/// [`StackDialog::key`].
pub key: Option<String>,
/// [`StackDialog::json_fields`].
pub fields: Option<Value>,
}
/// A finished dialog's answer, with the key the dialog had.
struct StoredResult {
type_id: TypeId,
@@ -329,9 +371,9 @@ impl DialogHost {
}
}
/// [`confirm`](DialogHost::confirm) for the open `D` that `id` names.
pub fn confirm_by_id<D: StackDialog>(&mut self, ctx: &Context, id: DialogId) -> bool {
match self.position_by_id::<D>(id) {
/// [`confirm`](DialogHost::confirm) for the open dialog `id` names, whatever its type.
pub fn confirm_by_id(&mut self, ctx: &Context, id: DialogId) -> bool {
match self.position_by_id(id) {
Some(at) => self.confirm_at(ctx, at),
None => false,
}
@@ -356,9 +398,9 @@ impl DialogHost {
}
}
/// [`cancel`](DialogHost::cancel) for the open `D` that `id` names.
pub fn cancel_by_id<D: StackDialog>(&mut self, ctx: &Context, id: DialogId) -> bool {
match self.position_by_id::<D>(id) {
/// [`cancel`](DialogHost::cancel) for the open dialog `id` names, whatever its type.
pub fn cancel_by_id(&mut self, ctx: &Context, id: DialogId) -> bool {
match self.position_by_id(id) {
Some(at) => self.cancel_at(ctx, at),
None => false,
}
@@ -374,6 +416,22 @@ impl DialogHost {
true
}
/// The open dialogs in opening order (the top one last), with their fields.
pub fn open_dialogs(&self) -> Vec<OpenDialog> {
self.open
.iter()
.map(|dialog| OpenDialog { id: dialog.id(), parent: self.stack.parent(dialog.id()), key: dialog.key(), fields: dialog.json_fields() })
.collect()
}
/// Sets `field` of the open dialog `id` names ([`StackDialog::set_json_field`]), whatever its type.
pub fn set_json_field(&mut self, id: DialogId, field: &str, value: Value) -> Result<(), String> {
match self.open.iter_mut().find(|dialog| dialog.id() == id) {
Some(dialog) => dialog.set_json_field(field, value),
None => Err("no such dialog".to_owned()),
}
}
/// The open dialog `id` ([`dialog_id`](super::dialog_id) of its key) as `Any`, for an app with
/// many dialog types that looks the top one up by id and downcasts.
pub fn get_dyn(&self, id: DialogId) -> Option<&dyn Any> {
@@ -411,8 +469,8 @@ impl DialogHost {
self.open.iter().rposition(|dialog| dialog.result_type() == TypeId::of::<D>())
}
fn position_by_id<D: StackDialog>(&self, id: DialogId) -> Option<usize> {
self.open.iter().position(|dialog| dialog.id() == id && dialog.result_type() == TypeId::of::<D>())
fn position_by_id(&self, id: DialogId) -> Option<usize> {
self.open.iter().position(|dialog| dialog.id() == id)
}
fn store_result(&mut self, dialog: &dyn AnyStackDialog, result: Box<dyn Any + Send>) {
+1 -1
View File
@@ -25,7 +25,7 @@ pub use blocking::{BlockingOverlay, BlockingOverlayStyle};
pub use frame::{DialogFrame, DialogFrameStyle, DialogOutput, FooterCx, FooterHooks};
#[doc(hidden)]
pub use host::dialog_probe;
pub use host::{DialogHost, DialogResult, StackDialog, StartupStage};
pub use host::{DialogHost, DialogResult, OpenDialog, StackDialog, StartupStage};
pub use modal::{Dialog, DialogStyle};
pub use prompt::{Prompt, PromptOutput};
pub use prompts::{PromptAnswer, PromptChoice, PromptKind, StandardPrompt, StandardPromptOutput};
+23 -2
View File
@@ -15,6 +15,7 @@ use craft_behavior::Mixed;
use craft_i18n::{Count, Format};
use craft_theme::variant::Tone;
use egui::{Context, Response, Ui};
use serde_json::{Value, json};
use std::any::Any;
use std::fmt;
@@ -61,8 +62,9 @@ pub enum PromptKind {
Custom,
}
/// The answer to a `StandardPrompt`.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
/// The answer to a `StandardPrompt`. Automation names it in camel case (`"proceed"`).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub enum PromptChoice {
/// The default button: Delete, Open Anyway, Replace, Apply.
@@ -449,4 +451,23 @@ impl StackDialog for StandardPrompt {
fn confirm(&mut self, _: &Context) -> Option<PromptAnswer> {
Some(self.answer(self.chosen, self.skip))
}
/// `choice`, the answer a programmatic OK gives, and `skip`, the "Don't show again" box where the prompt has
/// one.
fn json_fields(&self) -> Option<Value> {
let mut fields = json!({ "choice": self.chosen });
if self.skip_box {
fields["skip"] = Value::Bool(self.skip);
}
Some(fields)
}
fn set_json_field(&mut self, field: &str, value: Value) -> Result<(), String> {
match field {
"choice" => self.set_choice(serde_json::from_value(value).map_err(|error| format!("`choice`: {error}"))?),
"skip" if self.skip_box => self.skip = value.as_bool().ok_or("`skip` takes true or false")?,
_ => return Err(format!("unknown field `{field}`")),
}
Ok(())
}
}
+5
View File
@@ -83,6 +83,11 @@ impl DialogStack {
self.entries.iter().any(|(_, parent)| *parent == Some(id))
}
/// The dialog `id` was opened from, when it is a child.
pub fn parent(&self, id: DialogId) -> Option<DialogId> {
self.entries.iter().find(|(entry, _)| *entry == id)?.1
}
/// The dialogs opened from `id`, in opening order.
pub fn children(&self, id: DialogId) -> impl Iterator<Item = DialogId> + '_ {
self.entries.iter().filter(move |(_, parent)| *parent == Some(id)).map(|(entry, _)| *entry)
+48 -3
View File
@@ -15,6 +15,7 @@ use craft_behavior::Mixed;
use craft_host::target::Os;
use craft_quit::{CloseAnswer, CloseScope};
use egui::{Context, Response, Ui};
use serde_json::{Value, json};
/// The answer for one document, with whether it applies to the rest.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
@@ -76,6 +77,17 @@ impl UnsavedChangesDialog {
self.chosen = Some(answer);
}
/// What a programmatic OK answers.
fn chosen(&self) -> CloseAnswer {
let accepting = if self.scope == CloseScope::Revert { CloseAnswer::DontSave } else { CloseAnswer::Save };
self.chosen.unwrap_or(accepting)
}
/// Whether the "Apply to All" box shows: the guard has more documents, and the question is not a revert.
fn offers_apply_to_all(&self) -> bool {
self.remaining > 1 && self.scope != CloseScope::Revert
}
/// How many documents the guard still asks about, this one included; above one the "Apply to All" box shows.
#[must_use]
pub fn remaining(mut self, remaining: usize) -> Self {
@@ -124,7 +136,7 @@ impl UnsavedChangesDialog {
let replies: Vec<Reply> = replies.into_iter().map(|(_, reply)| reply).collect();
let mut prompt = Prompt::new(words.unsaved_title.clone(), message).answers(buttons(&env, replies));
let mut ticked = hosted && self.apply_to_all;
if self.remaining > 1 && self.scope != CloseScope::Revert {
if self.offers_apply_to_all() {
let label = words.unsaved_apply_to_all.clone();
let tick = &mut ticked;
let mut value = hosted.then_some(&mut self.apply_to_all);
@@ -163,7 +175,40 @@ impl StackDialog for UnsavedChangesDialog {
/// The answer set with `set_answer`; the accepting answer's (Save, or Don't Save when reverting) unless set.
fn confirm(&mut self, _: &Context) -> Option<UnsavedAnswer> {
let accepting = if self.scope == CloseScope::Revert { CloseAnswer::DontSave } else { CloseAnswer::Save };
Some(self.answer(self.chosen.unwrap_or(accepting)))
Some(self.answer(self.chosen()))
}
/// `choice` (`save`, `dontSave` or `cancel`), the answer a programmatic OK gives, and `applyToAll` while the
/// guard has more documents.
fn json_fields(&self) -> Option<Value> {
let choice = match self.chosen() {
CloseAnswer::Save => "save",
CloseAnswer::DontSave => "dontSave",
CloseAnswer::Cancel => "cancel",
};
let mut fields = json!({ "choice": choice });
if self.offers_apply_to_all() {
fields["applyToAll"] = Value::Bool(self.apply_to_all);
}
Some(fields)
}
fn set_json_field(&mut self, field: &str, value: Value) -> Result<(), String> {
match field {
"choice" => self.set_answer(match value.as_str() {
Some("save") if self.scope != CloseScope::Revert => CloseAnswer::Save,
Some("dontSave") => CloseAnswer::DontSave,
Some("cancel") => CloseAnswer::Cancel,
_ => {
return Err(format!(
"`choice` takes {}",
if self.scope == CloseScope::Revert { "dontSave or cancel" } else { "save, dontSave or cancel" }
));
}
}),
"applyToAll" if self.offers_apply_to_all() => self.apply_to_all = value.as_bool().ok_or("`applyToAll` takes true or false")?,
_ => return Err(format!("unknown field `{field}`")),
}
Ok(())
}
}
+1
View File
@@ -29,6 +29,7 @@ egui = { workspace = true }
craft-host = { workspace = true }
craft-i18n = { workspace = true, features = ["collate"] }
serde = { workspace = true }
serde_json = { workspace = true }
# `patterns::preferences::SettingsDocument` turns an app's settings struct into a draft table and back; `toml_edit` gives
# the struct's field order, which a `toml::Table` sorts away.
toml = { version = "1.1", default-features = false, features = ["std", "parse", "serde"] }
@@ -6,7 +6,7 @@ use crate::runtime::requests::{ColorRequest, HostAnswer, PathRequest};
use super::form::FormDialog;
use super::host_requests::HostRequests;
use super::param::{Param, ParamKind, open_fields, set_color_field};
use super::param::{Param, ParamKind, fill_defaults, open_fields, set_color_field};
use super::preview::{PreviewPane, PreviewView, PreviewZoom};
use super::rows::{ParamRows, ParamRowsOutput};
@@ -27,7 +27,8 @@ use crate::runtime::words::CommonWords;
use crate::sections::{DialogRole, FooterButton};
use egui::load::SizedTexture;
use egui::{Response, Ui};
use egui::{Context, Response, Ui};
use serde_json::Value;
use std::borrow::Cow;
use std::cell::Cell;
@@ -686,4 +687,36 @@ impl StackDialog for HostedParamDialog {
fn instance(&self) -> Option<DialogId> {
self.instance
}
/// Answers OK as the button does: none while OK is disabled. The result keeps what a remembering dialog saves.
fn confirm(&mut self, _: &Context) -> Option<ParamResult> {
let ParamDialog { key, params, remember, ok_enabled, .. } = (self.build)(&mut self.fields);
if !ok_enabled {
return None;
}
let params = params.into_owned();
fill_defaults(&params, &mut self.fields);
let fields = self.fields.clone();
let remember = remember.map(|save| (save, ParamDialog::remembered(&params, &fields)));
Some(ParamResult { key, fields, remember })
}
/// The values by parameter key, as [`DialogFields`] serializes them.
fn json_fields(&self) -> Option<Value> {
serde_json::to_value(&self.fields).ok()
}
/// Keeps `value` when a parameter row (or its unit choice) takes it, as [`Param::accepts`] says.
fn set_json_field(&mut self, field: &str, value: Value) -> Result<(), String> {
let params = (self.build)(&mut self.fields).params.into_owned();
let parsed: FieldValue = serde_json::from_value(value.clone()).map_err(|error| format!("`{field}`: {error}"))?;
if params.iter().any(|param| param.accepts(field, &parsed)) {
self.fields.set(field, parsed);
Ok(())
} else if params.iter().any(|param| param.key == field || param.unit_key() == Some(field)) {
Err(format!("`{field}` can't take {value}"))
} else {
Err(format!("unknown field `{field}`"))
}
}
}
+1
View File
@@ -82,6 +82,7 @@ Rules of the host:
- `enqueue` queues a startup modal by `StartupStage` (recovery, first-launch offer, warning, update). Each opens when the stack is empty, one at a time.
- `cancel::<D>()` closes a dialog from outside as Escape would, and `StackDialog::cancelled` lets it release what it holds.
- `get`, `get_mut` and `confirm::<D>()` reach the open dialog's value, so a script or a test sets fields and answers OK as a user would.
- Automation that doesn't know the dialog's type goes by id. `open_dialogs` lists the open dialogs with their `StackDialog::json_fields`; `set_json_field(id, field, value)` sets one as the user would (a prompt's answer is its `choice` field); `confirm_by_id` and `cancel_by_id` close it. A dialog type opts in by implementing `json_fields` and `set_json_field`; `HostedParamDialog`, `StandardPrompt` and `UnsavedChangesDialog` do. `craft_automation::dialogs` runs `ui.dialog.set`, `ui.dialog.confirm` and `ui.dialog.cancel` on a host and lists its dialogs for `ui.inspect`, so an app's control channel needs no code per dialog type.
- `take_keyed` returns the result with `StackDialog::key`, so a Cancel still names the command it answers.
- While the host runs its dialogs, or inside a `with` closure, `BodyCx::dialogs` returns `None`. A dialog that the host runs opens children through its own `DialogHost` value.