forked from 1b-agent/opencadstudio-upstream
362 lines
15 KiB
Rust
362 lines
15 KiB
Rust
//! ATTDEF (dialog), -ATTDEF (command line), AFLAGS, and the Edit Attribute
|
||
//! Definition dialog opened by double-click / TEXTEDIT / DDEDIT.
|
||
|
||
use crate::app::{Message, OpenCADStudio};
|
||
use crate::command::CadCommand;
|
||
use crate::modules::draw::draw::attdef::{
|
||
self as attdef, AttdefCommand, AttdefPickCommand, AttdefPlaceCommand, AttdefSpec, Justify,
|
||
};
|
||
use crate::ui::window::attdef_dialog::{
|
||
tag_error, AttdefDialogMsg, AttdefDialogState, AttdefEditState,
|
||
};
|
||
use iced::Task;
|
||
|
||
fn short(v: f64) -> String {
|
||
let t = format!("{v:.4}");
|
||
t.trim_end_matches('0').trim_end_matches('.').to_string()
|
||
}
|
||
|
||
impl OpenCADStudio {
|
||
pub(super) fn dispatch_attdef(&mut self, cmd: &str, i: usize) -> Option<Task<Message>> {
|
||
if matches!(cmd, "ATTDEF" | "-ATTDEF") {
|
||
// Placement measures the tag with its style's font.
|
||
crate::entities::common::set_fixed_text_heights(&self.tabs[i].scene.document);
|
||
}
|
||
match cmd {
|
||
"ATTDEF" => {
|
||
self.open_attdef_dialog(i);
|
||
Some(Task::none())
|
||
}
|
||
"-ATTDEF" => {
|
||
let defaults =
|
||
crate::scene::creation_style::current_text_defaults(&self.tabs[i].scene.document);
|
||
let styles: Vec<_> = self.tabs[i].scene.document.text_styles.iter().cloned().collect();
|
||
let command = AttdefCommand::new(
|
||
"-ATTDEF",
|
||
defaults.style_name,
|
||
defaults.height,
|
||
defaults.width_factor,
|
||
defaults.oblique_angle,
|
||
styles,
|
||
);
|
||
self.reset_command_start_state(i);
|
||
self.command_line.push_output(&command.intro());
|
||
self.command_line.push_info(&command.prompt());
|
||
self.tabs[i].active_cmd = Some(Box::new(command));
|
||
self.push_ucs_to_cmd(i);
|
||
Some(Task::none())
|
||
}
|
||
"ATTMODE0" => self.dispatch_draw("ATTDISP OFF", i),
|
||
"ATTMODE1" => self.dispatch_draw("ATTDISP NORMAL", i),
|
||
"ATTMODE2" => self.dispatch_draw("ATTDISP ON", i),
|
||
"_ATTDEF_VALUE" => {
|
||
let value = attdef::session().editor_value.take();
|
||
if let Some(state) = self.attdef_dialog.as_mut() {
|
||
if let Some(value) = value {
|
||
state.default = value;
|
||
}
|
||
self.active_modal = Some(crate::app::ModalKind::AttDef);
|
||
}
|
||
Some(Task::none())
|
||
}
|
||
cmd if cmd == "_ATTDEF_PICKED" || cmd.starts_with("_ATTDEF_PICKED ") => {
|
||
let mut parts = cmd.split_whitespace().skip(1);
|
||
if let (Some(kind), Some(value), Some(state)) =
|
||
(parts.next(), parts.next(), self.attdef_dialog.as_mut())
|
||
{
|
||
match kind {
|
||
"H" => state.height = value.to_string(),
|
||
"R" => state.rotation = value.to_string(),
|
||
_ => state.width = value.to_string(),
|
||
}
|
||
}
|
||
if self.attdef_dialog.is_some() {
|
||
self.active_modal = Some(crate::app::ModalKind::AttDef);
|
||
}
|
||
Some(Task::none())
|
||
}
|
||
_ => self.dispatch_aflags(cmd),
|
||
}
|
||
}
|
||
|
||
/// AFLAGS: the session's attribute modes (0–63, default 16).
|
||
fn dispatch_aflags(&mut self, cmd: &str) -> Option<Task<Message>> {
|
||
let rest = cmd.strip_prefix("SETVAR ").map(str::trim).unwrap_or(cmd);
|
||
let mut parts = rest.splitn(2, char::is_whitespace);
|
||
if !parts.next().unwrap_or("").eq_ignore_ascii_case("AFLAGS") {
|
||
return None;
|
||
}
|
||
let current = attdef::session().aflags;
|
||
match parts.next().map(str::trim).filter(|v| !v.is_empty()) {
|
||
None => {
|
||
self.command_line
|
||
.push_output(&format!("Enter new value for AFLAGS <{current}>:"));
|
||
self.pending_setvar = Some("AFLAGS".to_string());
|
||
}
|
||
Some(v) => match v.parse::<u8>().ok().filter(|v| *v <= 63) {
|
||
Some(v) => attdef::session().aflags = v,
|
||
None => {
|
||
self.command_line.push_error("Requires an integer between 0 and 63.");
|
||
self.command_line
|
||
.push_output(&format!("Enter new value for AFLAGS <{current}>:"));
|
||
self.pending_setvar = Some("AFLAGS".to_string());
|
||
}
|
||
},
|
||
}
|
||
Some(Task::none())
|
||
}
|
||
|
||
fn open_attdef_dialog(&mut self, i: usize) {
|
||
let document = &self.tabs[i].scene.document;
|
||
let defaults = crate::scene::creation_style::current_text_defaults(document);
|
||
let mut styles: Vec<String> = document
|
||
.text_styles
|
||
.iter()
|
||
.filter(|s| !s.name.is_empty())
|
||
.map(|s| s.name.clone())
|
||
.collect();
|
||
styles.sort_by_key(|s| s.to_lowercase());
|
||
let session = attdef::session();
|
||
self.attdef_dialog = Some(AttdefDialogState {
|
||
aflags: session.aflags,
|
||
annotative: session.annotative,
|
||
tag: String::new(),
|
||
prompt: String::new(),
|
||
default: String::new(),
|
||
justify: Justify::Left,
|
||
style: defaults.style_name,
|
||
styles,
|
||
height: short(defaults.height),
|
||
rotation: "0".into(),
|
||
width: "0".into(),
|
||
on_screen: session.on_screen,
|
||
coords: ["0".into(), "0".into(), "0".into()],
|
||
align_below: false,
|
||
can_align_below: session.last.is_some(),
|
||
error: None,
|
||
});
|
||
drop(session);
|
||
self.tabs[i].active_cmd = None;
|
||
self.active_modal = Some(crate::app::ModalKind::AttDef);
|
||
}
|
||
|
||
/// The Edit Attribute Definition dialog for `handle`.
|
||
pub(in crate::app) fn open_attdef_edit(&mut self, handle: codec::Handle) {
|
||
let i = self.active_tab;
|
||
let Some(codec::EntityType::AttributeDefinition(a)) = self.tabs[i].scene.document.get_entity(handle)
|
||
else {
|
||
return;
|
||
};
|
||
self.attdef_edit = Some(AttdefEditState {
|
||
handle,
|
||
tag: a.tag.clone(),
|
||
prompt: a.prompt.clone(),
|
||
default: a.default_value.clone(),
|
||
constant: a.flags.constant,
|
||
error: None,
|
||
});
|
||
self.active_modal = Some(crate::app::ModalKind::AttDefEdit);
|
||
}
|
||
|
||
pub(in crate::app) fn on_attdef_dialog(&mut self, m: AttdefDialogMsg) -> Task<Message> {
|
||
let i = self.active_tab;
|
||
if let Some(edit) = self.attdef_edit.as_mut() {
|
||
match m {
|
||
AttdefDialogMsg::EditTag(v) => edit.tag = v,
|
||
AttdefDialogMsg::EditPrompt(v) => edit.prompt = v,
|
||
AttdefDialogMsg::EditDefault(v) => edit.default = v,
|
||
AttdefDialogMsg::Help => self.command_line.push_info(
|
||
crate::t!("Changes the tag, prompt and default value of an attribute definition.")
|
||
.as_ref(),
|
||
),
|
||
AttdefDialogMsg::EditOk => return self.attdef_edit_ok(i),
|
||
AttdefDialogMsg::DismissError => edit.error = None,
|
||
_ => {}
|
||
}
|
||
return Task::none();
|
||
}
|
||
let Some(state) = self.attdef_dialog.as_mut() else {
|
||
return Task::none();
|
||
};
|
||
match m {
|
||
AttdefDialogMsg::Mode(bit, on) => {
|
||
if on {
|
||
state.aflags |= bit;
|
||
} else {
|
||
state.aflags &= !bit;
|
||
}
|
||
}
|
||
AttdefDialogMsg::Annotative(v) => state.annotative = v,
|
||
AttdefDialogMsg::Tag(v) => state.tag = v,
|
||
AttdefDialogMsg::Prompt(v) => state.prompt = v,
|
||
AttdefDialogMsg::Default(v) => state.default = v,
|
||
AttdefDialogMsg::Justify(c) => state.justify = c.0,
|
||
AttdefDialogMsg::Style(v) => state.style = v,
|
||
AttdefDialogMsg::Height(v) => state.height = v,
|
||
AttdefDialogMsg::Rotation(v) => state.rotation = v,
|
||
AttdefDialogMsg::Width(v) => state.width = v,
|
||
AttdefDialogMsg::OnScreen(v) => state.on_screen = v,
|
||
AttdefDialogMsg::Coord(k, v) => state.coords[k] = v,
|
||
AttdefDialogMsg::AlignBelow(v) => state.align_below = v,
|
||
AttdefDialogMsg::PickHeight | AttdefDialogMsg::PickRotation | AttdefDialogMsg::PickWidth => {
|
||
let (kind, current) = match m {
|
||
AttdefDialogMsg::PickHeight => ("H", state.height.clone()),
|
||
AttdefDialogMsg::PickRotation => ("R", state.rotation.clone()),
|
||
_ => ("W", state.width.clone()),
|
||
};
|
||
// Keep the dialog's fields; it reopens when the value is in.
|
||
self.active_modal = None;
|
||
let command = AttdefPickCommand::new(kind, current);
|
||
self.command_line.push_info(&command.prompt());
|
||
self.tabs[i].active_cmd = Some(Box::new(command));
|
||
self.push_ucs_to_cmd(i);
|
||
return self.focus_cmd_input();
|
||
}
|
||
AttdefDialogMsg::Help => self.command_line.push_info(
|
||
crate::t!("Defines an attribute: a tag, prompt and default value placed as text in a block definition.")
|
||
.as_ref(),
|
||
),
|
||
AttdefDialogMsg::Ok => return self.attdef_dialog_ok(i),
|
||
AttdefDialogMsg::DismissError => state.error = None,
|
||
AttdefDialogMsg::EditValue => {
|
||
// The dialog waits while the multi-line editor collects the value.
|
||
let initial = state.default.clone();
|
||
let height = state.height.trim().parse::<f64>().ok().filter(|h| *h > 0.0).unwrap_or(2.5);
|
||
self.active_modal = None;
|
||
attdef::session().editor_value = None;
|
||
self.tabs[i].active_cmd = Some(Box::new(attdef::AttdefValueCommand));
|
||
let pos = self.tabs[i].scene.camera.borrow().target;
|
||
return self.apply_cmd_result(crate::command::CmdResult::SuspendForMTextInput {
|
||
pos,
|
||
initial,
|
||
height,
|
||
});
|
||
}
|
||
_ => {}
|
||
}
|
||
Task::none()
|
||
}
|
||
|
||
/// Show a validation message in the dialog; it stays open.
|
||
fn attdef_dialog_error(&mut self, error: &str) -> Task<Message> {
|
||
if let Some(state) = self.attdef_dialog.as_mut() {
|
||
state.error = Some(crate::t!(error).into_owned());
|
||
}
|
||
Task::none()
|
||
}
|
||
|
||
fn attdef_dialog_ok(&mut self, i: usize) -> Task<Message> {
|
||
let Some(state) = self.attdef_dialog.clone() else {
|
||
return Task::none();
|
||
};
|
||
if let Some(error) = tag_error(&state.tag) {
|
||
return self.attdef_dialog_error(error);
|
||
}
|
||
let number = |s: &str| s.trim().parse::<f64>().ok().filter(|v| v.is_finite());
|
||
let height = match number(&state.height) {
|
||
Some(v) if v > 0.0 => v,
|
||
_ => {
|
||
return self.attdef_dialog_error("Value must be positive and nonzero.");
|
||
}
|
||
};
|
||
let Some(rotation) = number(&state.rotation) else {
|
||
return self.attdef_dialog_error("Requires valid numeric angle or second point.");
|
||
};
|
||
let width = number(&state.width).unwrap_or(0.0).max(0.0);
|
||
let defaults =
|
||
crate::scene::creation_style::current_text_defaults(&self.tabs[i].scene.document);
|
||
let spec = AttdefSpec {
|
||
aflags: state.aflags,
|
||
annotative: state.annotative,
|
||
tag: state.tag.clone(),
|
||
prompt: state.prompt.clone(),
|
||
value: state.default.clone(),
|
||
justify: state.justify,
|
||
style: state.style.clone(),
|
||
height,
|
||
rotation: rotation.to_radians(),
|
||
width_factor: defaults.width_factor,
|
||
oblique_angle: defaults.oblique_angle,
|
||
boundary_width: width,
|
||
line_spacing: 1.0,
|
||
};
|
||
self.attdef_dialog = None;
|
||
self.close_active_modal();
|
||
{
|
||
let mut session = attdef::session();
|
||
session.aflags = spec.aflags;
|
||
session.annotative = spec.annotative;
|
||
session.on_screen = state.on_screen;
|
||
}
|
||
// The choice is kept with the user settings, as the reference keeps it.
|
||
self.persist_settings_if_changed();
|
||
self.reset_command_start_state(i);
|
||
if state.align_below {
|
||
let previous = attdef::session().last.clone();
|
||
if let Some(previous) = previous {
|
||
let entity = attdef::build_below(&spec, &previous);
|
||
self.tabs[i].active_cmd = Some(Box::new(AttdefPlaceCommand::new(spec.clone())));
|
||
attdef::remember(&spec, &entity);
|
||
return self.apply_cmd_result(crate::command::CmdResult::CommitAndExit(entity));
|
||
}
|
||
}
|
||
let plane = if self.tabs[i].editing_model_space() {
|
||
self.tabs[i].ucs_xform().working_plane()
|
||
} else {
|
||
crate::command::WorkingPlane::default()
|
||
};
|
||
let mut command = AttdefPlaceCommand::new(spec);
|
||
command.set_working_plane(plane);
|
||
if state.on_screen {
|
||
self.command_line.push_info(&command.prompt());
|
||
self.tabs[i].active_cmd = Some(Box::new(command));
|
||
return self.focus_cmd_input();
|
||
}
|
||
let local = glam::DVec3::new(
|
||
number(&state.coords[0]).unwrap_or(0.0),
|
||
number(&state.coords[1]).unwrap_or(0.0),
|
||
number(&state.coords[2]).unwrap_or(0.0),
|
||
);
|
||
let result = command.on_point(plane.to_world(local));
|
||
self.tabs[i].active_cmd = Some(Box::new(command));
|
||
self.apply_cmd_result(result)
|
||
}
|
||
|
||
fn attdef_edit_ok(&mut self, i: usize) -> Task<Message> {
|
||
let Some(state) = self.attdef_edit.clone() else {
|
||
return Task::none();
|
||
};
|
||
if let Some(error) = tag_error(&state.tag) {
|
||
if let Some(edit) = self.attdef_edit.as_mut() {
|
||
edit.error = Some(crate::t!(error).into_owned());
|
||
}
|
||
return Task::none();
|
||
}
|
||
self.attdef_edit = None;
|
||
self.close_active_modal();
|
||
let changed = matches!(
|
||
self.tabs[i].scene.document.get_entity(state.handle),
|
||
Some(codec::EntityType::AttributeDefinition(a))
|
||
if a.tag != attdef::normalize_tag(&state.tag) || a.prompt != state.prompt || a.default_value != state.default
|
||
);
|
||
if changed && !self.reject_locked_edit(i, state.handle) {
|
||
self.push_undo_snapshot(i, "DDEDIT");
|
||
if let Some(codec::EntityType::AttributeDefinition(a)) =
|
||
self.tabs[i].scene.document.get_entity_mut(state.handle)
|
||
{
|
||
a.tag = attdef::normalize_tag(&state.tag);
|
||
if !a.flags.constant {
|
||
a.prompt = state.prompt.clone();
|
||
}
|
||
a.default_value = state.default.clone();
|
||
}
|
||
self.tabs[i]
|
||
.scene
|
||
.bump_entities(&[(state.handle, crate::scene::ChangeKind::Modified)]);
|
||
self.tabs[i].dirty = true;
|
||
self.refresh_properties();
|
||
}
|
||
self.post_editor_closed(changed)
|
||
}
|
||
}
|