1774 lines
64 KiB
Rust
1774 lines
64 KiB
Rust
mod source_symbols;
|
||
mod text_workspace;
|
||
pub(crate) mod traceability;
|
||
use crate::{
|
||
app::{App, Choice, FileOperation, Message, Page, Pending},
|
||
diagram::DiagramCanvas,
|
||
forms, style,
|
||
};
|
||
use iced::{
|
||
Element as View, Fill, Font,
|
||
widget::{
|
||
self, Space, button, column, container, pick_list, row, scrollable, text, text_input,
|
||
tooltip,
|
||
},
|
||
};
|
||
use oa_core::*;
|
||
use unicode_segmentation::UnicodeSegmentation;
|
||
|
||
pub fn label<'a>(s: impl Into<String>) -> widget::Text<'a> {
|
||
text(s.into()).size(11).color(style::MUTED)
|
||
}
|
||
pub fn action<'a>(s: &str, m: Message) -> widget::Button<'a, Message> {
|
||
button(text(s.to_owned()).size(12))
|
||
.padding([8, 10])
|
||
.on_press(m)
|
||
.style(style::nav)
|
||
}
|
||
|
||
/// Optional instructions belong beside the work, without taking a canvas row.
|
||
/// The button also opens keyboard-accessible help; the tooltip is only a preview.
|
||
pub(crate) fn diagram_help<'a>(
|
||
topic: crate::guide::Topic,
|
||
hint: impl Into<String>,
|
||
) -> View<'a, Message> {
|
||
tooltip(
|
||
action("Help · F1", Message::ContextHelp(topic)),
|
||
container(text(hint.into()).size(12))
|
||
.padding(10)
|
||
.max_width(360)
|
||
.style(style::card),
|
||
tooltip::Position::Bottom,
|
||
)
|
||
.into()
|
||
}
|
||
pub fn short(s: &str, limit: usize) -> String {
|
||
let s = s.split_whitespace().collect::<Vec<_>>().join(" ");
|
||
if s.graphemes(true).count() > limit {
|
||
format!(
|
||
"{}…",
|
||
s.graphemes(true)
|
||
.take(limit.saturating_sub(1))
|
||
.collect::<String>()
|
||
)
|
||
} else {
|
||
s
|
||
}
|
||
}
|
||
pub fn heading<'a>(title: &str, subtitle: &str) -> View<'a, Message> {
|
||
column![
|
||
text(title.to_owned()).size(24).color(style::INK),
|
||
label(subtitle)
|
||
]
|
||
.spacing(6)
|
||
.into()
|
||
}
|
||
|
||
pub fn view(app: &App) -> View<'_, Message> {
|
||
let p = app.project();
|
||
let header = container(
|
||
row![
|
||
row![
|
||
text("◈").size(28).color(style::TEAL),
|
||
column![
|
||
text("ARCADIA STUDIO").size(14),
|
||
label("SYSTEMS ENGINEERING · V2")
|
||
]
|
||
.spacing(3)
|
||
]
|
||
.spacing(10)
|
||
.width(220),
|
||
column![text(short(&p.name, 46)).size(17), label(app.hosted_label())]
|
||
.spacing(3)
|
||
.width(Fill),
|
||
action("New", Message::Request(Pending::New)),
|
||
crate::hosted::view::header_action(),
|
||
action("Open", Message::Request(Pending::Open)),
|
||
action("Save as", Message::Save(true)),
|
||
button(text(app.save_label()).size(12))
|
||
.padding([10, 16])
|
||
.on_press(Message::Save(false))
|
||
]
|
||
.spacing(8)
|
||
.align_y(iced::Center),
|
||
)
|
||
.padding([14, 18])
|
||
.style(style::panel);
|
||
let mut nav = column![
|
||
label("ENGINEERING PERSPECTIVE"),
|
||
row![
|
||
button(text("01 Operational").size(11))
|
||
.padding(9)
|
||
.width(Fill)
|
||
.on_press(Message::Layer(Layer::Oa))
|
||
.style(if app.layer == Layer::Oa {
|
||
button::primary
|
||
} else {
|
||
style::nav
|
||
}),
|
||
button(text("02 System").size(11))
|
||
.padding(9)
|
||
.width(Fill)
|
||
.on_press(Message::Layer(Layer::Sa))
|
||
.style(if app.layer == Layer::Sa {
|
||
button::primary
|
||
} else {
|
||
style::nav
|
||
})
|
||
]
|
||
.spacing(3),
|
||
Space::new().height(5)
|
||
]
|
||
.spacing(8);
|
||
let mut task_nav = row![].spacing(2);
|
||
for (page, name) in [
|
||
(Page::Home, "Home"),
|
||
(Page::Diagram, "Architecture"),
|
||
(Page::Catalog, "Model explorer"),
|
||
(Page::Behavior, "Behavior & scenarios"),
|
||
(Page::Data, "Data & interfaces"),
|
||
(Page::Traces, "Traceability"),
|
||
(Page::Text, "Textual model"),
|
||
(Page::Validation, "Model checks"),
|
||
(Page::Guide, "Engineering guide"),
|
||
] {
|
||
task_nav = task_nav.push(
|
||
button(text(name).size(12))
|
||
.padding([9, 11])
|
||
.on_press(Message::Page(page))
|
||
.style(if app.page == page {
|
||
style::selected
|
||
} else {
|
||
style::nav
|
||
}),
|
||
);
|
||
}
|
||
let task_nav = container(task_nav.wrap())
|
||
.width(Fill)
|
||
.padding([4, 14])
|
||
.style(style::panel);
|
||
let mut creation = column![label("CREATE ELEMENT")].spacing(8);
|
||
let kinds = Kind::ALL
|
||
.into_iter()
|
||
.filter(|k| k.supports(app.layer) && *k != Kind::Port)
|
||
.collect::<Vec<_>>();
|
||
creation = creation.push(
|
||
pick_list(kinds, Some(app.create_kind), Message::CreateKind)
|
||
.text_size(12)
|
||
.padding(8)
|
||
.width(Fill),
|
||
);
|
||
let allocated = app.create_kind.is_work()
|
||
&& p.elements
|
||
.get(&app.selected)
|
||
.is_some_and(|e| e.layer() == app.layer && e.kind().is_performer());
|
||
if crate::port_workflow::actions(p, app.selected)
|
||
.contains(&crate::port_workflow::Action::Component)
|
||
{
|
||
creation = creation.push(
|
||
button(text("+ Add port to selected…").size(12))
|
||
.padding(9)
|
||
.width(Fill)
|
||
.on_press(Message::PortAction(crate::port_workflow::Action::Component)),
|
||
);
|
||
}
|
||
creation = creation.push(
|
||
row![
|
||
button(text("+ At root").size(11))
|
||
.padding(8)
|
||
.style(style::nav)
|
||
.width(Fill)
|
||
.on_press_maybe(
|
||
validation::can_parent(p, app.create_kind, app.layer, None)
|
||
.then_some(Message::Add(false))
|
||
),
|
||
button(
|
||
text(if allocated {
|
||
"+ Allocated"
|
||
} else {
|
||
"+ In selected"
|
||
})
|
||
.size(11)
|
||
)
|
||
.padding(8)
|
||
.style(style::nav)
|
||
.width(Fill)
|
||
.on_press_maybe(
|
||
(allocated
|
||
|| validation::can_parent(p, app.create_kind, app.layer, Some(app.selected)))
|
||
.then_some(Message::Add(true))
|
||
)
|
||
]
|
||
.spacing(3),
|
||
);
|
||
nav = nav.push(
|
||
text_input("Search names or @aliases…", &app.search)
|
||
.on_input(Message::Search)
|
||
.size(12)
|
||
.padding(9),
|
||
);
|
||
nav = nav
|
||
.push(
|
||
row![
|
||
action("Collapse all", Message::ExplorerCollapseAll),
|
||
action("Locate", Message::ExplorerLocate)
|
||
]
|
||
.spacing(3),
|
||
)
|
||
.push(crate::explorer_view::sidebar(app));
|
||
if app.page != Page::Diagram {
|
||
nav = nav.push(creation);
|
||
}
|
||
nav = nav.push(action("Project properties", Message::SelectProject).width(Fill));
|
||
let sidebar = container(if app.page == Page::Text {
|
||
source_files(app)
|
||
} else {
|
||
nav.into()
|
||
})
|
||
.padding(14)
|
||
.width(260)
|
||
.height(Fill)
|
||
.style(style::panel);
|
||
let main = match app.page {
|
||
Page::Home => crate::home::view(
|
||
&app.home,
|
||
(app.dirty()
|
||
|| !p.elements.is_empty()
|
||
|| app.path.is_some()
|
||
|| app.hosted.session.is_some())
|
||
.then_some((p.name.as_str(), app.dirty())),
|
||
&app.recovery,
|
||
)
|
||
.map(Message::Home),
|
||
Page::Diagram => diagram(app),
|
||
Page::Catalog => crate::explorer_view::catalog(app),
|
||
Page::Data => data_catalog(app),
|
||
Page::Behavior => crate::behavior::view(app),
|
||
Page::Traces => traces(app),
|
||
Page::Text => source(app),
|
||
Page::Validation => checks(app),
|
||
Page::Guide => crate::guide::view(&app.guide),
|
||
};
|
||
let mut body = if app.page == Page::Home {
|
||
row![container(main).width(Fill).height(Fill)].height(Fill)
|
||
} else {
|
||
row![sidebar, container(main).width(Fill).height(Fill)].height(Fill)
|
||
};
|
||
if !matches!(app.page, Page::Home | Page::Text | Page::Guide) {
|
||
body = body.push(inspector(app));
|
||
}
|
||
let diagram_feedback = diagram_feedback(app);
|
||
// Keep operation outcomes visible even while a drawing hint is active.
|
||
let (status, status_detail) = if app.busy {
|
||
("Working…".into(), "Working…".into())
|
||
} else if let Some(feedback) = diagram_feedback.filter(|feedback| *feedback != app.status) {
|
||
(
|
||
format!("{} · {}", short(&app.status, 60), short(&feedback, 80)),
|
||
format!("{}\n{}", app.status, feedback),
|
||
)
|
||
} else {
|
||
(short(&app.status, 145), app.status.clone())
|
||
};
|
||
let footer = container(
|
||
row![
|
||
container(tooltip(
|
||
text(status).size(11).wrapping(widget::text::Wrapping::None),
|
||
container(text(status_detail).size(12))
|
||
.padding(10)
|
||
.max_width(600)
|
||
.style(style::card),
|
||
tooltip::Position::Top,
|
||
))
|
||
.width(Fill),
|
||
label(format!(
|
||
"{} objects · {} links",
|
||
p.elements.len(),
|
||
p.relations.len()
|
||
)),
|
||
action(
|
||
&format!("{} model checks", app.issue_count()),
|
||
Message::Page(Page::Validation)
|
||
)
|
||
]
|
||
.spacing(12)
|
||
.align_y(iced::Center),
|
||
)
|
||
.padding([4, 16])
|
||
.style(style::panel);
|
||
let root = crate::allocation_input::root(app, column![header, task_nav, body, footer]);
|
||
let root = crate::guide::protect_workspace(app.context_help, root);
|
||
if app.context_help {
|
||
return modal_width(
|
||
root,
|
||
column![
|
||
row![
|
||
text("Diagram help").size(18),
|
||
Space::new().width(Fill),
|
||
action("Close · Esc", Message::CloseContextHelp),
|
||
]
|
||
.align_y(iced::Center),
|
||
crate::guide::context_view(&app.guide),
|
||
]
|
||
.spacing(12)
|
||
.height((app.window_size.height - 140.).max(300.))
|
||
.into(),
|
||
(app.window_size.width - 80.).min(900.),
|
||
);
|
||
}
|
||
if app.architecture.as_ref().is_some_and(|s| s.modal()) {
|
||
return modal_width(
|
||
root,
|
||
crate::app::architecture_authoring::dialog(app),
|
||
(app.window_size.width - 50.).clamp(500., 820.),
|
||
);
|
||
}
|
||
if let Some(workflow) = &app.workflow {
|
||
if matches!(workflow, crate::workflow::Workflow::Semantic(_)) {
|
||
return modal_width(
|
||
root,
|
||
workflow.view(p),
|
||
(app.window_size.width - 50.).clamp(800., 1120.),
|
||
);
|
||
}
|
||
return modal(root, workflow.view(p));
|
||
}
|
||
if let Some(p) = &app.file_prompt {
|
||
let title = match p.operation {
|
||
FileOperation::Open => "Open model",
|
||
FileOperation::Save => "Save model",
|
||
FileOperation::Export => "Export diagram",
|
||
};
|
||
return modal(
|
||
root,
|
||
column![
|
||
text(title).size(21),
|
||
label(match p.operation {
|
||
FileOperation::Export => "Save this diagram as .svg.",
|
||
FileOperation::Save => "Choose a .arcadia entry in a new destination, or .json to export the model.",
|
||
FileOperation::Open => "Open an .arcadia project entry or import a .json model.",
|
||
}),
|
||
text_input("File path", &p.path)
|
||
.on_input(Message::FilePath)
|
||
.on_submit(Message::SubmitFile)
|
||
.padding(10)
|
||
.size(13),
|
||
text(match (p.operation, p.overwrite) {
|
||
(FileOperation::Export, true) =>
|
||
"This file exists. Replace it with the current diagram?",
|
||
(FileOperation::Export, false) =>
|
||
"Includes visible elements and their authored connection routes.",
|
||
(FileOperation::Save, _) => "Source Save As retains included file paths. Existing destination files are protected.",
|
||
(FileOperation::Open, _) => "Included source files are loaded together. Invalid drafts remain editable.",
|
||
})
|
||
.size(12),
|
||
row![
|
||
action("Cancel", Message::CancelFile),
|
||
button(text(if p.overwrite { "Replace file" } else { title }).size(12))
|
||
.padding(10)
|
||
.on_press(Message::SubmitFile)
|
||
]
|
||
.spacing(10)
|
||
]
|
||
.spacing(16)
|
||
.into(),
|
||
);
|
||
}
|
||
if let Some(target) = app.delete_target.as_ref().filter(|_| app.delete_pending) {
|
||
return modal(
|
||
root,
|
||
column![
|
||
text("Delete from model?").size(21),
|
||
text(p.named(target.snapshot.request.object)).size(16),
|
||
text(crate::app::diagram_removal::explanation(
|
||
app,
|
||
target.snapshot.request.object
|
||
))
|
||
.size(13),
|
||
row![
|
||
widget::container(action("Cancel", Message::CancelDelete)).id("delete-cancel"),
|
||
widget::container(
|
||
button("Delete from model")
|
||
.style(button::danger)
|
||
.padding(10)
|
||
.on_press(Message::ConfirmDelete(target.snapshot.token))
|
||
)
|
||
.id("delete-confirm")
|
||
]
|
||
.spacing(10)
|
||
]
|
||
.spacing(16)
|
||
.into(),
|
||
);
|
||
}
|
||
if app.pending.is_some() {
|
||
return modal(root,column![text("Keep your changes?").size(21),text("Save the model and pending edits before continuing. Invalid drafts stay available for correction.").size(13),row![action("Cancel",Message::Cancel),action("Discard changes",Message::Discard),button("Save & continue").padding(10).on_press(Message::SaveAndContinue)].spacing(8)].spacing(16).into());
|
||
}
|
||
if app.source_rename.open() {
|
||
return modal_width(
|
||
root,
|
||
crate::app::source_rename::dialog(app),
|
||
(app.window_size.width - 32.).clamp(120., 760.),
|
||
);
|
||
}
|
||
// Match modal_width's first child so help does not recreate the editor tree.
|
||
widget::stack![root].into()
|
||
}
|
||
fn modal<'a>(base: View<'a, Message>, content: View<'a, Message>) -> View<'a, Message> {
|
||
modal_width(base, content, 800.)
|
||
}
|
||
fn modal_width<'a>(
|
||
base: View<'a, Message>,
|
||
content: View<'a, Message>,
|
||
width: f32,
|
||
) -> View<'a, Message> {
|
||
widget::stack![
|
||
base,
|
||
widget::opaque(
|
||
container(
|
||
container(content)
|
||
.padding(26)
|
||
.width(width)
|
||
.style(style::card)
|
||
)
|
||
.center(Fill)
|
||
.style(|_| container::Style {
|
||
background: Some(iced::Color::from_rgba(0.08, 0.12, 0.18, 0.38).into()),
|
||
..Default::default()
|
||
})
|
||
)
|
||
]
|
||
.into()
|
||
}
|
||
fn diagram(app: &App) -> View<'_, Message> {
|
||
if app
|
||
.active_diagram
|
||
.and_then(|id| app.project().diagrams.get(&id))
|
||
.is_some_and(|d| d.projection.scenario().is_some())
|
||
{
|
||
return heading(
|
||
"Saved Scenario view",
|
||
crate::app::SAVED_SCENARIO_UNAVAILABLE,
|
||
);
|
||
}
|
||
let mut diagrams = app
|
||
.project()
|
||
.diagrams
|
||
.values()
|
||
.filter(|d| {
|
||
d.projection.scenario().is_none()
|
||
&& (d.layer == app.layer || d.projection == ProjectionKind::Traceability)
|
||
})
|
||
.map(|d| Choice {
|
||
id: d.id,
|
||
label: d.name.clone(),
|
||
})
|
||
.collect::<Vec<_>>();
|
||
diagrams.sort_by(|a, b| a.label.cmp(&b.label).then(a.id.cmp(&b.id)));
|
||
let selected = diagrams
|
||
.iter()
|
||
.find(|c| Some(c.id) == app.active_diagram)
|
||
.cloned();
|
||
let mut chooser = row![
|
||
pick_list(diagrams, selected, Message::Diagram)
|
||
.placeholder("Choose diagram")
|
||
.text_size(12)
|
||
.padding(8)
|
||
.width(Fill),
|
||
action("+ View", Message::AddDiagram)
|
||
]
|
||
.spacing(7)
|
||
.align_y(iced::Center);
|
||
let mut controls = row![
|
||
action("Fit", Message::Fit),
|
||
action("−", Message::Zoom(1. / 1.2)),
|
||
label(format!("{:.0}%", app.zoom * 100.)),
|
||
action("+", Message::Zoom(1.2)),
|
||
action("Export SVG", Message::Export)
|
||
]
|
||
.spacing(7)
|
||
.align_y(iced::Center);
|
||
if let Some(id) = app.active_diagram {
|
||
chooser = chooser.push(action("View properties", Message::Select(id)));
|
||
controls = controls.push(action("Auto-layout", Message::Command(Command::Layout(id))));
|
||
}
|
||
let toolbar = column![chooser, controls].spacing(6);
|
||
let projection = app
|
||
.active_diagram
|
||
.and_then(|id| app.project().diagrams.get(&id))
|
||
.map(|d| d.projection);
|
||
let mut modes = row![
|
||
label("View content"),
|
||
pick_list(
|
||
[
|
||
ProjectionKind::Allocation,
|
||
ProjectionKind::FunctionalDataflow,
|
||
ProjectionKind::Capabilities,
|
||
ProjectionKind::Decomposition,
|
||
ProjectionKind::Overview,
|
||
ProjectionKind::Traceability,
|
||
],
|
||
projection,
|
||
Message::Projection
|
||
)
|
||
.padding(8)
|
||
.text_size(12),
|
||
diagram_help(
|
||
crate::guide::Topic::Nesting,
|
||
if projection == Some(ProjectionKind::Traceability) {
|
||
"Shows OA and SA elements with correspondence lines. Place both ends of a trace to show it; port traces use their owner cards. Open Help for trace visibility and editing controls."
|
||
} else {
|
||
"Shift-click to add or remove selection. Right-click for actions; drag to arrange; scroll to zoom. Drag a connection line, bend or label to move it; Insert adds a bend and Escape cancels. Open Help for full editing controls."
|
||
},
|
||
)
|
||
]
|
||
.spacing(10)
|
||
.align_y(iced::Center);
|
||
let canvas: View<'_, Message> = if let Some(id) = app.active_diagram {
|
||
let program = DiagramCanvas {
|
||
selection: app.diagram_selection.as_ref(),
|
||
allocation: Some(app.allocation_capability()),
|
||
project: app.project(),
|
||
view_index: Some(app.document.view_index()),
|
||
diagram: id,
|
||
selected: app.selected,
|
||
navigation_focus: app
|
||
.diagram_focus(crate::diagram_usage::Surface::Saved(id))
|
||
.map(|usage| usage.bounds),
|
||
zoom: app.zoom,
|
||
pan: app.pan,
|
||
context: app.route_context().unwrap(),
|
||
selected_attachment: app
|
||
.selected_attachment
|
||
.filter(|(context, edge, _)| {
|
||
Some(*context) == app.route_context() && *edge == app.selected
|
||
})
|
||
.map(|(_, _, end)| end),
|
||
selected_bend: app
|
||
.selected_bend
|
||
.filter(|(edge, _)| *edge == app.selected)
|
||
.map(|(_, i)| i),
|
||
editable: !app.draft_dirty() && !app.source_dirty(),
|
||
placing: app.architecture.as_ref().is_some_and(|s| s.saved.placing),
|
||
connection: app.connection.as_ref(),
|
||
};
|
||
let mut scene = widget::stack![
|
||
crate::diagram::focus::wrap(
|
||
widget::canvas(program).width(Fill).height(Fill),
|
||
program.context,
|
||
crate::app::diagram_removal::focus_enabled(app),
|
||
app.busy,
|
||
Message::DiagramTraverse
|
||
),
|
||
widget::canvas(crate::diagram::PortLabels(program))
|
||
.width(Fill)
|
||
.height(Fill),
|
||
widget::canvas(crate::diagram::WorkFeedback(program))
|
||
.width(Fill)
|
||
.height(Fill),
|
||
];
|
||
if let Some(editor) = crate::app::architecture_authoring::inline_editor(app) {
|
||
scene = scene.push(editor);
|
||
}
|
||
let reveal = app.architecture_reveal_stamp(id);
|
||
row![
|
||
widget::sensor(
|
||
container(scene)
|
||
.id(crate::allocation_input::CANVAS_ID)
|
||
.width(Fill)
|
||
.height(Fill)
|
||
)
|
||
.on_show(
|
||
move |size| reveal.map_or(Message::CanvasResized(size), |(context, epoch)| {
|
||
Message::DiagramRevealViewport(context, epoch, size)
|
||
})
|
||
)
|
||
.on_resize(move |size| reveal
|
||
.map_or(Message::CanvasResized(size), |(context, epoch)| {
|
||
Message::DiagramRevealViewport(context, epoch, size)
|
||
})),
|
||
crate::app::architecture_authoring::palette(app)
|
||
]
|
||
.height(Fill)
|
||
.width(Fill)
|
||
.into()
|
||
} else {
|
||
container(
|
||
column![
|
||
text(if app.layer == Layer::Oa {
|
||
"Define the operational context"
|
||
} else {
|
||
"Define your system boundary"
|
||
})
|
||
.size(23),
|
||
text("Create a view, then add participants and the work they perform.")
|
||
.size(13)
|
||
.color(style::MUTED),
|
||
button("Create architecture view")
|
||
.padding(12)
|
||
.on_press(Message::AddDiagram)
|
||
]
|
||
.spacing(16),
|
||
)
|
||
.center(Fill)
|
||
.into()
|
||
};
|
||
if projection == Some(ProjectionKind::Allocation) {
|
||
modes = modes.push(tooltip(
|
||
action(
|
||
if app.allocation_drag.arrange_next {
|
||
"Arrange ✓"
|
||
} else {
|
||
"Arrange"
|
||
},
|
||
Message::WorkDrag(crate::app::allocation_drag::Event::ArrangeNext),
|
||
),
|
||
container(text(format!(
|
||
"Arrange next drag · {}. Move work within its current allocation; Escape cancels.",
|
||
crate::allocation_input::ARRANGE_SHORTCUT
|
||
)))
|
||
.padding(10)
|
||
.max_width(420)
|
||
.style(style::card),
|
||
tooltip::Position::Bottom,
|
||
));
|
||
}
|
||
let mut tools = column![toolbar].spacing(8);
|
||
if app.active_diagram.is_some() {
|
||
tools = tools.push(modes);
|
||
}
|
||
if projection == Some(ProjectionKind::Allocation) {
|
||
// Reserve this slot even when idle: changing feedback must never resize
|
||
// the measured canvas and invalidate a held gesture. Its identity is
|
||
// independent of status length, target geometry and the diagram zoom.
|
||
let destination = app
|
||
.allocation_drag
|
||
.feedback
|
||
.as_ref()
|
||
.map(|feedback| feedback.destination_identity())
|
||
.unwrap_or_else(|| "—".into());
|
||
let inspection = app
|
||
.allocation_drag
|
||
.feedback
|
||
.as_ref()
|
||
.map(|feedback| feedback.inspection_identity())
|
||
.unwrap_or_else(|| destination.clone());
|
||
let destination_control = container(tooltip(
|
||
text(format!("Destination: {}", short(&destination, 28)))
|
||
.size(13)
|
||
.wrapping(widget::text::Wrapping::None),
|
||
container(text(inspection).size(13))
|
||
.padding(10)
|
||
.max_width(420)
|
||
.style(style::card),
|
||
tooltip::Position::Top,
|
||
))
|
||
.id("allocation-destination")
|
||
.height(26)
|
||
.width(Fill)
|
||
.clip(true);
|
||
tools = tools.push(destination_control);
|
||
}
|
||
if let Some(diagram) = app.active_diagram {
|
||
let view = oa_core::projection::project_view(app.project(), diagram);
|
||
if projection == Some(ProjectionKind::Traceability) {
|
||
let correspondence_lines = view.edges.iter().filter(|edge| edge.trace).count();
|
||
tools = tools.push(
|
||
row![
|
||
label(format!("{correspondence_lines} trace lines")),
|
||
action(
|
||
"Add existing elements…",
|
||
Message::Architecture(crate::app::architecture_authoring::Event::Existing(
|
||
None
|
||
))
|
||
),
|
||
action("Review layer traces", Message::ReviewLayerTraces),
|
||
action("View visibility…", Message::Select(diagram)),
|
||
]
|
||
.spacing(7)
|
||
.align_y(iced::Center)
|
||
.wrap(),
|
||
);
|
||
}
|
||
let selection = app.multiselect_snapshot();
|
||
let count = selection.as_ref().map_or(0, |s| s.targets().len());
|
||
let mut selection_controls =
|
||
row![label(format!("{count} selected")).wrapping(widget::text::Wrapping::None)]
|
||
.spacing(7)
|
||
.align_y(iced::Center)
|
||
.height(32);
|
||
if let Some(snapshot) = selection.as_ref().filter(|s| s.targets().len() > 1) {
|
||
if crate::app::multiselect::placements(snapshot).is_some() {
|
||
selection_controls = selection_controls.push(action(
|
||
"Hide selected",
|
||
Message::DiagramSelection(crate::app::multiselect::Event::Hide(
|
||
snapshot.clone(),
|
||
)),
|
||
));
|
||
}
|
||
selection_controls = selection_controls
|
||
.push(action(
|
||
"Clear",
|
||
Message::DiagramSelection(crate::app::multiselect::Event::Clear(
|
||
snapshot.context(),
|
||
)),
|
||
))
|
||
.push(
|
||
label(format!(
|
||
"Properties: {} only",
|
||
short(app.project().named(app.selected), 14)
|
||
))
|
||
.wrapping(widget::text::Wrapping::None),
|
||
);
|
||
}
|
||
// Selection never moves the canvas. General controls live in Help;
|
||
// active gesture feedback uses the persistent application status bar.
|
||
tools = tools.push(
|
||
container(selection_controls)
|
||
.height(32)
|
||
.width(Fill)
|
||
.clip(true),
|
||
);
|
||
}
|
||
column![container(tools).padding(14), canvas].into()
|
||
}
|
||
|
||
fn diagram_feedback(app: &App) -> Option<String> {
|
||
if app.page != Page::Diagram {
|
||
return None;
|
||
}
|
||
if let Some(feedback) = &app.allocation_drag.feedback {
|
||
return Some(feedback.text.clone());
|
||
}
|
||
if let Some(session) = &app.connection {
|
||
return Some(
|
||
if session.source.is_none() {
|
||
session.tool.hint()
|
||
} else if session.candidates.is_empty() {
|
||
"No compatible targets visible. Expand containers or show an endpoint · Esc cancels"
|
||
} else {
|
||
"Choose a highlighted target · Esc cancels"
|
||
}
|
||
.into(),
|
||
);
|
||
}
|
||
let diagram = app.active_diagram?;
|
||
let view = oa_core::projection::project_view(app.project(), diagram);
|
||
let edge = view.edges.iter().find(|edge| edge.id == app.selected)?;
|
||
let (source, target) = oa_core::projection::edge_endpoint_placements(
|
||
app.project(),
|
||
&app.project().diagrams[&diagram],
|
||
edge.id,
|
||
)?;
|
||
(source != edge.source || target != edge.target)
|
||
.then(|| "Expand endpoint containers to edit this connection route".into())
|
||
}
|
||
|
||
fn inspector(app: &App) -> View<'_, Message> {
|
||
let p = app.project();
|
||
if let Some(target) = app.process_preview_primary() {
|
||
let endpoint = match target {
|
||
crate::diagram_usage::Target::ProcessOccurrence(endpoint) => endpoint.clone(),
|
||
crate::diagram_usage::Target::ProcessPreviewLink { source, .. } => source.clone(),
|
||
_ => unreachable!(),
|
||
};
|
||
let context = app.topology_context().unwrap();
|
||
return container(
|
||
column![
|
||
text(p.named(app.selected)).size(17),
|
||
label("Reused contents · read-only here"),
|
||
label("Open the referenced definition to edit this contribution or connection."),
|
||
action(
|
||
"Open referenced definition",
|
||
Message::TopologyCanvas(crate::behavior::topology::CanvasEvent::OpenQualified(
|
||
context, endpoint
|
||
))
|
||
),
|
||
crate::model_menu::trigger(app),
|
||
]
|
||
.spacing(12),
|
||
)
|
||
.padding(14)
|
||
.width(320)
|
||
.height(Fill)
|
||
.style(style::panel)
|
||
.into();
|
||
}
|
||
if app.source_dirty() {
|
||
let mut notice = column![
|
||
text("Source drafts pending").size(17),
|
||
label("Properties become editable after source drafts are applied or reverted."),
|
||
action("Open source drafts", Message::Page(Page::Text))
|
||
]
|
||
.spacing(12);
|
||
if app.draft_dirty() {
|
||
notice = notice
|
||
.push(label(
|
||
"A property draft is also retained. Revert it to apply the source drafts.",
|
||
))
|
||
.push(action("Revert property draft", Message::RevertProperties));
|
||
}
|
||
return container(notice)
|
||
.padding(14)
|
||
.width(320)
|
||
.height(Fill)
|
||
.style(style::panel)
|
||
.into();
|
||
}
|
||
let tabs = row![
|
||
action(
|
||
"Properties",
|
||
Message::InspectorTab(crate::navigation::InspectorTab::Properties)
|
||
)
|
||
.style(
|
||
if app.inspector_tab == crate::navigation::InspectorTab::Properties {
|
||
style::selected
|
||
} else {
|
||
style::nav
|
||
}
|
||
),
|
||
action(
|
||
"Connections",
|
||
Message::InspectorTab(crate::navigation::InspectorTab::Connections)
|
||
)
|
||
.style(
|
||
if app.inspector_tab == crate::navigation::InspectorTab::Connections {
|
||
style::selected
|
||
} else {
|
||
style::nav
|
||
}
|
||
),
|
||
]
|
||
.spacing(4);
|
||
if app.inspector_tab == crate::navigation::InspectorTab::Connections {
|
||
return container(
|
||
column![
|
||
tabs,
|
||
scrollable(crate::navigation::view(app, app.selected)).height(Fill)
|
||
]
|
||
.spacing(14),
|
||
)
|
||
.padding(14)
|
||
.width(320)
|
||
.height(Fill)
|
||
.style(style::panel)
|
||
.into();
|
||
}
|
||
let mut body = column![
|
||
row![
|
||
label("PROPERTIES"),
|
||
Space::new().width(Fill),
|
||
crate::model_menu::trigger(app)
|
||
]
|
||
.align_y(iced::Center)
|
||
]
|
||
.spacing(12);
|
||
if let Some(e) = p.elements.get(&app.selected) {
|
||
body = body.push(
|
||
row![
|
||
text(e.kind().label())
|
||
.size(17)
|
||
.color(style::kind_color(e.kind())),
|
||
Space::new().width(Fill),
|
||
label(e.layer().to_string())
|
||
]
|
||
.align_y(iced::Center),
|
||
);
|
||
body = body.push(
|
||
pick_list(
|
||
Kind::ALL
|
||
.into_iter()
|
||
.filter(|k| k.supports(e.layer()))
|
||
.collect::<Vec<_>>(),
|
||
Some(e.kind()),
|
||
Message::ElementKind,
|
||
)
|
||
.text_size(12)
|
||
.padding(8)
|
||
.width(Fill),
|
||
);
|
||
if let Some(parent) = e.parent {
|
||
body = body.push(
|
||
action(
|
||
&format!("Parent: {}", short(p.named(parent), 27)),
|
||
Message::Select(parent),
|
||
)
|
||
.width(Fill),
|
||
);
|
||
}
|
||
for r in p
|
||
.relations
|
||
.values()
|
||
.filter(|r| r.kind() == RelationKind::Allocation && r.target() == e.id)
|
||
{
|
||
body = body.push(
|
||
action(
|
||
&format!("Performer: {}", short(p.named(r.source()), 24)),
|
||
Message::Select(r.source()),
|
||
)
|
||
.width(Fill),
|
||
);
|
||
}
|
||
if !p
|
||
.relations
|
||
.values()
|
||
.any(|r| r.kind() == RelationKind::Allocation && r.target() == e.id)
|
||
&& let Some(performer) = oa_core::validation::allocation_summary(p, e.id)
|
||
{
|
||
body = body.push(label(
|
||
"Allocation summary: all leaf activities or functions belong to the same performer. The parent has no direct allocation.",
|
||
));
|
||
body = body.push(
|
||
action(
|
||
&format!("Leaf performer: {}", short(p.named(performer), 24)),
|
||
Message::Select(performer),
|
||
)
|
||
.width(Fill),
|
||
);
|
||
}
|
||
}
|
||
// Keep a discoverable primary action; secondary actions live in Actions.
|
||
if p.elements
|
||
.get(&app.selected)
|
||
.is_some_and(|e| e.layer() == Layer::Oa && matches!(e.kind(), Kind::Entity | Kind::Actor))
|
||
{
|
||
let draw = app.page == Page::Diagram
|
||
&& app.active_diagram.is_some_and(|diagram| {
|
||
crate::connection_edit::visible(&projection::project_view(p, diagram))
|
||
.any(|id| id == app.selected)
|
||
});
|
||
body = body.push(
|
||
button(
|
||
text(if draw {
|
||
"Draw communication means"
|
||
} else {
|
||
"Configure communication means…"
|
||
})
|
||
.size(12),
|
||
)
|
||
.padding(9)
|
||
.width(Fill)
|
||
.on_press(if draw {
|
||
Message::Connection(crate::connection_edit::Event::Begin(
|
||
crate::connection_tool::Tool::CommunicationMean,
|
||
app.selected,
|
||
))
|
||
} else {
|
||
Message::AddRelationKind(RelationKind::CommunicationMean, false)
|
||
}),
|
||
);
|
||
}
|
||
if p.elements
|
||
.get(&app.selected)
|
||
.is_some_and(|e| matches!(e.kind(), Kind::System | Kind::SystemActor))
|
||
{
|
||
body = body.push(
|
||
button(text("+ Add port…").size(12))
|
||
.padding(9)
|
||
.width(Fill)
|
||
.on_press(Message::PortAction(crate::port_workflow::Action::Component)),
|
||
);
|
||
}
|
||
if p.elements
|
||
.get(&app.selected)
|
||
.is_some_and(|e| matches!(port_contract(e), Some(PortContract::Component { .. })))
|
||
{
|
||
let draw = app.page == Page::Diagram
|
||
&& crate::connection_tool::Tool::BoundaryExchange.can_start(p, app.selected)
|
||
&& app.active_diagram.is_some_and(|diagram| {
|
||
crate::connection_edit::visible(&projection::project_view(p, diagram))
|
||
.any(|id| id == app.selected)
|
||
});
|
||
body = body.push(
|
||
button(
|
||
text(if draw {
|
||
"Draw boundary exchange"
|
||
} else {
|
||
"Configure boundary exchange…"
|
||
})
|
||
.size(12),
|
||
)
|
||
.padding(9)
|
||
.width(Fill)
|
||
.on_press(if draw {
|
||
Message::Connection(crate::connection_edit::Event::Begin(
|
||
crate::connection_tool::Tool::BoundaryExchange,
|
||
app.selected,
|
||
))
|
||
} else {
|
||
Message::AddRelationKind(
|
||
RelationKind::BoundaryExchange,
|
||
p.elements.get(&app.selected).is_some_and(|e| {
|
||
matches!(
|
||
port_contract(e),
|
||
Some(PortContract::Component {
|
||
kind: ComponentPortKind::Flow,
|
||
orientation: ComponentPortOrientation::In
|
||
})
|
||
)
|
||
}),
|
||
)
|
||
}),
|
||
);
|
||
}
|
||
if let Some(r) = p.relations.get(&app.selected) {
|
||
body = body.push(text(r.kind().to_string()).size(17));
|
||
if r.kind() != RelationKind::ContextualLink {
|
||
body = body.push(
|
||
pick_list(
|
||
RelationKind::ALL
|
||
.into_iter()
|
||
.filter(|kind| *kind != RelationKind::ContextualLink)
|
||
.collect::<Vec<_>>(),
|
||
Some(r.kind()),
|
||
Message::RelationKind,
|
||
)
|
||
.text_size(12)
|
||
.padding(8)
|
||
.width(Fill),
|
||
);
|
||
}
|
||
}
|
||
let actions = row![
|
||
button(text("Apply changes").size(12))
|
||
.padding([9, 12])
|
||
.on_press(Message::Apply)
|
||
.width(Fill),
|
||
action("Revert", Message::RevertProperties)
|
||
]
|
||
.spacing(5);
|
||
if let Some(d) = &app.draft {
|
||
body = body.push(forms::view(d, p));
|
||
}
|
||
container(
|
||
column![
|
||
column![
|
||
tabs,
|
||
container(actions).padding(iced::Padding {
|
||
right: 14.,
|
||
..Default::default()
|
||
})
|
||
]
|
||
.spacing(12),
|
||
scrollable(body.padding(iced::Padding {
|
||
right: 14.,
|
||
..Default::default()
|
||
}))
|
||
.id("inspector")
|
||
.height(Fill)
|
||
]
|
||
.spacing(12),
|
||
)
|
||
.padding(14)
|
||
.width(320)
|
||
.height(Fill)
|
||
.style(style::panel)
|
||
.into()
|
||
}
|
||
|
||
fn data_catalog(app: &App) -> View<'_, Message> {
|
||
crate::data_view::view(app)
|
||
}
|
||
|
||
fn traces(app: &App) -> View<'_, Message> {
|
||
let p = app.project();
|
||
use traceability::{Event as E, Filter};
|
||
let (traces, artifacts) = app.traceability.matching(p);
|
||
let mut tabs = row![].spacing(6);
|
||
for (filter, label) in [
|
||
(
|
||
Filter::All,
|
||
format!("All ({})", p.traces.len() + p.artifact_links.len()),
|
||
),
|
||
(Filter::Traces, format!("Layer traces ({})", p.traces.len())),
|
||
(
|
||
Filter::Artifacts,
|
||
format!("Development artifacts ({})", p.artifact_links.len()),
|
||
),
|
||
] {
|
||
tabs = tabs.push(
|
||
button(text(label).size(12))
|
||
.style(if app.traceability.filter == filter {
|
||
button::primary
|
||
} else {
|
||
style::nav
|
||
})
|
||
.on_press(Message::Traceability(E::Filter(filter))),
|
||
);
|
||
}
|
||
let header = column![
|
||
heading(
|
||
"Traceability",
|
||
"Connect operational needs, system responsibilities and development evidence."
|
||
),
|
||
row![
|
||
button(
|
||
text(
|
||
if p.layer_of(app.selected).unwrap_or(app.layer) == Layer::Oa {
|
||
"Create System counterpart…"
|
||
} else {
|
||
"Create Operational counterpart…"
|
||
}
|
||
)
|
||
.size(12)
|
||
)
|
||
.padding(9)
|
||
.on_press(Message::StartTransition),
|
||
action("+ Manual trace", Message::AddTrace),
|
||
action(
|
||
"Review counterpart changes…",
|
||
Message::StartSemanticReview(app.selected)
|
||
),
|
||
action("+ Artifact", Message::AddArtifact)
|
||
]
|
||
.spacing(8)
|
||
.wrap(),
|
||
tabs.wrap(),
|
||
row![
|
||
text_input(
|
||
"Search names, aliases, owners or artifact URI…",
|
||
&app.traceability.query
|
||
)
|
||
.on_input(|raw| Message::Traceability(E::Search(raw)))
|
||
.padding(8)
|
||
.size(12)
|
||
.width(Fill),
|
||
button("Clear search").on_press(Message::Traceability(E::Search(String::new())))
|
||
]
|
||
.spacing(6),
|
||
label(format!(
|
||
"{} matching traces · {} matching artifacts",
|
||
traces.len(),
|
||
artifacts.len()
|
||
))
|
||
]
|
||
.spacing(10)
|
||
.padding(24);
|
||
let mut out = column![].spacing(16);
|
||
for id in &traces {
|
||
let t = &p.traces[id];
|
||
let current = match (&t.baseline, p.properties(t.oa), p.properties(t.sa)) {
|
||
(Some(b), Some(oa), Some(sa)) if b.oa == oa && b.sa == sa => "Reviewed",
|
||
(Some(_), _, _) => "Review needed",
|
||
_ => "No review baseline",
|
||
};
|
||
out = out.push(
|
||
container(
|
||
column![
|
||
row![
|
||
action(p.named(t.oa), Message::Select(t.oa)).width(Fill),
|
||
text("→").color(style::TEAL),
|
||
action(p.named(t.sa), Message::Select(t.sa)).width(Fill)
|
||
]
|
||
.spacing(8)
|
||
.align_y(iced::Center),
|
||
row![
|
||
label(format!("{:?} · Prose: {current}", t.kind)),
|
||
Space::new().width(Fill),
|
||
action(
|
||
"Review counterpart changes…",
|
||
Message::StartSemanticReview(t.id)
|
||
),
|
||
action("Edit link", Message::Select(t.id))
|
||
],
|
||
text(crate::semantic_review::summary(p, t))
|
||
.size(11)
|
||
.color(style::MUTED),
|
||
text(short(&t.description, 130)).size(12)
|
||
]
|
||
.spacing(10),
|
||
)
|
||
.padding(16)
|
||
.style(style::card),
|
||
);
|
||
}
|
||
if !artifacts.is_empty() {
|
||
out = out.push(text("Development artifacts").size(18));
|
||
}
|
||
for id in &artifacts {
|
||
let a = &p.artifact_links[id];
|
||
let owner = traceability::owner_label(p, a.owner);
|
||
out = out.push(
|
||
container(
|
||
column![
|
||
row![
|
||
action(&a.name, Message::Select(a.id)).width(Fill),
|
||
label(format!("{:?}", a.relation))
|
||
],
|
||
text(&a.uri).size(12).font(Font::MONOSPACE),
|
||
label(format!(
|
||
"{}{}",
|
||
owner,
|
||
a.revision
|
||
.as_ref()
|
||
.map(|r| format!(" · revision {r}"))
|
||
.unwrap_or_default()
|
||
))
|
||
]
|
||
.spacing(8),
|
||
)
|
||
.padding(16)
|
||
.style(style::card),
|
||
);
|
||
}
|
||
if p.traces.is_empty() && p.artifact_links.is_empty() {
|
||
out=out.push(text("Select a model element, then connect it to the other perspective or attach a code, CAD, schematic or document reference.").size(14).color(style::MUTED));
|
||
} else if traces.is_empty() && artifacts.is_empty() {
|
||
out = out
|
||
.push(text("No matching records. Clear the search or choose another filter.").size(13));
|
||
}
|
||
column![
|
||
header,
|
||
scrollable(out.padding(iced::Padding::from(24).right(42)))
|
||
.id("traceability-list")
|
||
.height(Fill)
|
||
]
|
||
.height(Fill)
|
||
.into()
|
||
}
|
||
|
||
fn source_files(app: &App) -> View<'_, Message> {
|
||
let workspace = &app.source_workspace;
|
||
let panel = column![
|
||
row![
|
||
text("SOURCE FILES").size(13).width(Fill),
|
||
crate::context_menu::Area::left(
|
||
action("Actions ▾", Message::Menu(crate::model_menu::Event::Close)),
|
||
move |anchor| Message::SourceTree(crate::source_tree::Event::FileMenu(
|
||
workspace.active.clone(),
|
||
anchor
|
||
))
|
||
)
|
||
]
|
||
.align_y(iced::Center),
|
||
label(format!(
|
||
"{} files · one system model",
|
||
workspace.files.len()
|
||
)),
|
||
row![
|
||
action("Collapse all", Message::SourceTreeCollapse),
|
||
action("Locate", Message::SourceTreeLocate)
|
||
]
|
||
.spacing(3),
|
||
crate::source_tree::view(workspace, &app.source_diagnostics, &app.source_tree)
|
||
.map(Message::SourceTree),
|
||
action("Load includes", Message::SourceLoadIncludes).width(Fill),
|
||
text_input("oa/new-file.arcadia", &workspace.new_path)
|
||
.size(12)
|
||
.padding(8)
|
||
.on_input(Message::SourceNewPath)
|
||
.on_submit(Message::SourceCreateFile),
|
||
action("+ Create source file", Message::SourceCreateFile).width(Fill),
|
||
label("Includes define file membership. Closing a detached buffer never deletes its file."),
|
||
]
|
||
.spacing(9);
|
||
panel.into()
|
||
}
|
||
|
||
fn source(app: &App) -> View<'_, Message> {
|
||
use crate::app::text_workspace::DrawerTab;
|
||
use oa_core::source_project::SourceLocation;
|
||
let visible = app.text_workspace.drawer() == Some(DrawerTab::Problems);
|
||
let publication = app
|
||
.text_workspace
|
||
.diagnostic_publication()
|
||
.filter(|publication| visible && publication.source() == app.source_key());
|
||
let mut diagnostics = column![].spacing(3).width(Fill);
|
||
if visible {
|
||
if publication.is_none() && !app.source_diagnostics.is_empty() {
|
||
diagnostics = diagnostics
|
||
.push(text("Source changed. Waiting for current source checks…").size(12));
|
||
}
|
||
if app.source_diagnostics.is_empty() {
|
||
diagnostics = diagnostics.push(text("No source problems reported.").size(12));
|
||
}
|
||
for issue in &app.source_diagnostics {
|
||
let location = SourceLocation {
|
||
path: issue.path.clone(),
|
||
span: issue.diagnostic.span,
|
||
};
|
||
let severity = match issue.diagnostic.severity {
|
||
validation::Severity::Error => "Error",
|
||
validation::Severity::Warning => "Warning",
|
||
};
|
||
diagnostics = diagnostics.push(
|
||
button(
|
||
text(format!(
|
||
"{severity} · {}:{}:{} · {}",
|
||
issue.path,
|
||
issue.diagnostic.line,
|
||
issue.diagnostic.column,
|
||
issue.diagnostic.message,
|
||
))
|
||
.size(12)
|
||
.wrapping(widget::text::Wrapping::WordOrGlyph),
|
||
)
|
||
.width(Fill)
|
||
.padding([4, 6])
|
||
.style(style::nav)
|
||
.on_press_maybe(app.text_diagnostic_message(location)),
|
||
);
|
||
for related in &issue.related {
|
||
diagnostics = diagnostics.push(
|
||
button(
|
||
text(format!("Related declaration · {}", related.path))
|
||
.size(12)
|
||
.wrapping(widget::text::Wrapping::WordOrGlyph),
|
||
)
|
||
.width(Fill)
|
||
.padding([4, 12])
|
||
.style(style::nav)
|
||
.on_press_maybe(app.text_diagnostic_message(related.clone())),
|
||
);
|
||
}
|
||
}
|
||
}
|
||
let guard = crate::diagnostic_input::Guard::new(
|
||
publication.map(|p| (p.generation(), app.text_workspace.drawer_visit())),
|
||
diagnostics,
|
||
);
|
||
// The complete byte/evidence comparison is shared by the summary and rows,
|
||
// once per visible References rebuild; no parser or second query is started.
|
||
let references_current =
|
||
app.text_workspace.drawer() == Some(DrawerTab::References) && app.source_results_current();
|
||
text_workspace::view(
|
||
app,
|
||
source_symbols::panel(app, references_current),
|
||
guard.into(),
|
||
references_current,
|
||
)
|
||
}
|
||
|
||
pub(crate) fn source_binding(
|
||
press: widget::text_editor::KeyPress,
|
||
context: &crate::source_navigation::SymbolContext,
|
||
rename: Option<&crate::app::source_rename::Begin>,
|
||
) -> Option<widget::text_editor::Binding<Message>> {
|
||
use crate::source_navigation::{SymbolEvent, query::Action};
|
||
use iced::keyboard::{Key, key::Named};
|
||
use widget::text_editor::{Binding, Status};
|
||
if matches!(press.status, Status::Focused { .. })
|
||
&& press.key == Key::Named(Named::Tab)
|
||
&& (press.modifiers.is_empty() || press.modifiers == iced::keyboard::Modifiers::SHIFT)
|
||
{
|
||
return Some(Binding::Custom(Message::SourceIndent(
|
||
context.clone(),
|
||
press.modifiers.shift(),
|
||
)));
|
||
}
|
||
if matches!(press.status, Status::Focused { .. })
|
||
&& press.modifiers.is_empty()
|
||
&& press.key == Key::Named(Named::F2)
|
||
&& let Some(begin) = rename
|
||
{
|
||
return Some(Binding::Custom(Message::SourceRename(
|
||
crate::app::source_rename::Event::Begin(begin.clone()),
|
||
)));
|
||
}
|
||
// Windows owns Alt+Space for its window menu. Iced's default binding would
|
||
// otherwise insert a supplied space payload, even after that menu closes.
|
||
// Keep Ctrl+Alt (AltGr), shifted input, and ordinary Space unchanged.
|
||
#[cfg(target_os = "windows")]
|
||
if matches!(press.status, Status::Focused { .. })
|
||
&& press.modifiers == iced::keyboard::Modifiers::ALT
|
||
&& matches!(
|
||
press.key.as_ref(),
|
||
Key::Named(Named::Space) | Key::Character(" ")
|
||
)
|
||
{
|
||
return None;
|
||
}
|
||
if matches!(press.status, Status::Focused { .. })
|
||
&& !press.modifiers.control()
|
||
&& !press.modifiers.logo()
|
||
{
|
||
let event = match &press.key {
|
||
Key::Named(Named::F12) if !press.modifiers.alt() => {
|
||
Some(SymbolEvent::Query(if press.modifiers.shift() {
|
||
Action::References
|
||
} else {
|
||
Action::Definition
|
||
}))
|
||
}
|
||
Key::Named(Named::ArrowLeft) if press.modifiers.alt() && !press.modifiers.shift() => {
|
||
Some(SymbolEvent::Back)
|
||
}
|
||
_ => None,
|
||
};
|
||
if let Some(event) = event {
|
||
return Some(Binding::Custom(Message::SourceSymbols(
|
||
context.clone(),
|
||
event,
|
||
)));
|
||
}
|
||
}
|
||
Binding::from_key_press(press)
|
||
}
|
||
|
||
#[cfg(all(test, debug_assertions))]
|
||
pub(crate) mod source_tests {
|
||
use super::*;
|
||
use iced::advanced::{
|
||
Layout, Shell, graphics, layout, renderer, text as shaped, widget as core_widget,
|
||
};
|
||
use iced::{Background, Color, Pixels, Point, Rectangle, Size, Transformation};
|
||
|
||
// Measure real Iced paragraphs/editor text without constructing a window or GPU.
|
||
pub(crate) struct FontLayout;
|
||
impl renderer::Renderer for FontLayout {
|
||
fn start_layer(&mut self, _: Rectangle) {}
|
||
fn end_layer(&mut self) {}
|
||
fn start_transformation(&mut self, _: Transformation) {}
|
||
fn end_transformation(&mut self) {}
|
||
fn reset(&mut self, _: Rectangle) {}
|
||
fn fill_quad(&mut self, _: renderer::Quad, _: impl Into<Background>) {}
|
||
fn allocate_image(
|
||
&mut self,
|
||
handle: &iced::advanced::image::Handle,
|
||
callback: impl FnOnce(
|
||
Result<iced::advanced::image::Allocation, iced::advanced::image::Error>,
|
||
) + Send
|
||
+ 'static,
|
||
) {
|
||
renderer::Renderer::allocate_image(&mut (), handle, callback);
|
||
}
|
||
}
|
||
impl shaped::Renderer for FontLayout {
|
||
type Font = Font;
|
||
type Paragraph = graphics::text::Paragraph;
|
||
type Editor = graphics::text::Editor;
|
||
const ICON_FONT: Font = Font::DEFAULT;
|
||
const CHECKMARK_ICON: char = '0';
|
||
const ARROW_DOWN_ICON: char = '0';
|
||
const SCROLL_UP_ICON: char = '0';
|
||
const SCROLL_DOWN_ICON: char = '0';
|
||
const SCROLL_LEFT_ICON: char = '0';
|
||
const SCROLL_RIGHT_ICON: char = '0';
|
||
const ICED_LOGO: char = '0';
|
||
fn default_font(&self) -> Font {
|
||
Font::DEFAULT
|
||
}
|
||
fn default_size(&self) -> Pixels {
|
||
Pixels(16.)
|
||
}
|
||
fn fill_paragraph(&mut self, _: &Self::Paragraph, _: Point, _: Color, _: Rectangle) {}
|
||
fn fill_editor(&mut self, _: &Self::Editor, _: Point, _: Color, _: Rectangle) {}
|
||
fn fill_text(&mut self, _: shaped::Text, _: Point, _: Color, _: Rectangle) {}
|
||
}
|
||
|
||
#[cfg(target_os = "windows")]
|
||
#[test]
|
||
fn source_editor_windows_menu_payload_is_inert_but_space_and_altgr_still_edit() {
|
||
use core_widget::operation::Focusable;
|
||
use iced::keyboard::{
|
||
self, Key, Modifiers,
|
||
key::{Code, Named, Physical},
|
||
};
|
||
use widget::text_editor::{Binding, Content, KeyPress, State, Status};
|
||
let baseline = "// is excluded\r\n// 雨\r\n";
|
||
let context = crate::source_navigation::SymbolContext {
|
||
session: Id::new_v4(),
|
||
path: "救援/assess.arcadia".into(),
|
||
};
|
||
for (key, physical_key, modifiers, payload, inserted) in [
|
||
(
|
||
Key::Named(Named::Space),
|
||
Physical::Code(Code::Space),
|
||
Modifiers::ALT,
|
||
" ",
|
||
false,
|
||
),
|
||
(
|
||
Key::Character(" ".into()),
|
||
Physical::Code(Code::Space),
|
||
Modifiers::ALT,
|
||
" ",
|
||
false,
|
||
),
|
||
(
|
||
Key::Named(Named::Space),
|
||
Physical::Code(Code::Space),
|
||
Modifiers::empty(),
|
||
" ",
|
||
true,
|
||
),
|
||
(
|
||
Key::Named(Named::Space),
|
||
Physical::Code(Code::Space),
|
||
Modifiers::CTRL | Modifiers::ALT,
|
||
" ",
|
||
true,
|
||
),
|
||
(
|
||
Key::Character("e".into()),
|
||
Physical::Code(Code::KeyE),
|
||
Modifiers::CTRL | Modifiers::ALT,
|
||
"€",
|
||
true,
|
||
),
|
||
(
|
||
Key::Named(Named::Space),
|
||
Physical::Code(Code::Space),
|
||
Modifiers::ALT | Modifiers::SHIFT,
|
||
" ",
|
||
true,
|
||
),
|
||
] {
|
||
let mut content = Content::<FontLayout>::with_text(baseline);
|
||
content.move_to(widget::text_editor::Cursor {
|
||
position: widget::text_editor::Position { line: 0, column: 5 },
|
||
selection: None,
|
||
});
|
||
let press = KeyPress {
|
||
key: key.clone(),
|
||
modified_key: key.clone(),
|
||
physical_key,
|
||
modifiers,
|
||
text: Some(payload.into()),
|
||
status: Status::Focused { is_hovered: false },
|
||
};
|
||
assert!(
|
||
matches!(
|
||
Binding::<Message>::from_key_press(press),
|
||
Some(Binding::Insert(_))
|
||
),
|
||
"the supplied event must expose the default insertion path"
|
||
);
|
||
let mut messages = Vec::new();
|
||
{
|
||
let mut editor: View<'_, Message, iced::Theme, FontLayout> =
|
||
widget::text_editor(&content)
|
||
.on_action(Message::SourceEdit)
|
||
.font(Font::MONOSPACE)
|
||
.size(14)
|
||
.padding(16)
|
||
.height(Fill)
|
||
.key_binding(|press| source_binding(press, &context, None))
|
||
.into();
|
||
let mut tree = core_widget::Tree::new(editor.as_widget());
|
||
let size = Size::new(600., 240.);
|
||
let node = editor.as_widget_mut().layout(
|
||
&mut tree,
|
||
&FontLayout,
|
||
&layout::Limits::new(Size::ZERO, size),
|
||
);
|
||
tree.state
|
||
.downcast_mut::<State<shaped::highlighter::PlainText>>()
|
||
.focus();
|
||
let event = iced::Event::Keyboard(keyboard::Event::KeyPressed {
|
||
key: key.clone(),
|
||
modified_key: key,
|
||
physical_key,
|
||
location: keyboard::Location::Standard,
|
||
modifiers,
|
||
text: Some(payload.into()),
|
||
repeat: false,
|
||
});
|
||
let mut shell = Shell::new(&mut messages);
|
||
editor.as_widget_mut().update(
|
||
&mut tree,
|
||
&event,
|
||
Layout::new(&node),
|
||
iced::mouse::Cursor::Unavailable,
|
||
&FontLayout,
|
||
&mut iced::advanced::clipboard::Null,
|
||
&mut shell,
|
||
&Rectangle::with_size(size),
|
||
);
|
||
}
|
||
assert_eq!(
|
||
messages.len(),
|
||
usize::from(inserted),
|
||
"modifiers={modifiers:?}"
|
||
);
|
||
for message in messages {
|
||
let Message::SourceEdit(action) = message else {
|
||
panic!("unexpected navigation action");
|
||
};
|
||
content.perform(action);
|
||
}
|
||
let expected = if inserted {
|
||
format!("// is{payload} excluded\r\n// 雨\r\n")
|
||
} else {
|
||
baseline.into()
|
||
};
|
||
assert_eq!(content.text(), expected);
|
||
}
|
||
}
|
||
}
|
||
fn checks(app: &App) -> View<'_, Message> {
|
||
let issues = &app.model_issues;
|
||
let mut out = column![heading(
|
||
"Model checks",
|
||
"Structural validity and engineering completeness, with direct navigation."
|
||
)]
|
||
.spacing(15);
|
||
if let Some(report) = &app.migration {
|
||
let mut card = column![text(format!("Imported schema {} → {}", report.from_schema, report.to_schema)).size(19),
|
||
label("Import preserves the original file. Saving explicitly writes the current schema; legacy associations remain available for review.")].spacing(8);
|
||
for port in &report.preserved_ports {
|
||
card = card
|
||
.push(action(
|
||
&format!("Preserved port · @{}", port.alias),
|
||
Message::Select(port.id),
|
||
))
|
||
.push(label(&port.required_resolution));
|
||
}
|
||
for endpoint in &report.generated_endpoints {
|
||
card = card
|
||
.push(action(
|
||
&format!("Created {} endpoint · @{}", endpoint.side, endpoint.alias),
|
||
Message::Select(endpoint.port),
|
||
))
|
||
.push(label(format!(
|
||
"Owner: {} · exchange: {}",
|
||
app.project().named(endpoint.owner),
|
||
app.project().named(endpoint.exchange)
|
||
)));
|
||
}
|
||
card=card.push(label(format!("Data migration: {} semantic defaults · {} interface allocations · {} unresolved value addresses",report.semantic_defaults.len(),report.generated_interface_allocations.len(),report.unresolved_message_values.len())));
|
||
for default in report.semantic_defaults.iter().take(6) {
|
||
card = card
|
||
.push(action(
|
||
&format!(
|
||
"{} · {}",
|
||
app.project().named(default.object),
|
||
default.field
|
||
),
|
||
Message::Select(default.object),
|
||
))
|
||
.push(label(&default.description));
|
||
}
|
||
for allocation in report.generated_interface_allocations.iter().take(6) {
|
||
card = card
|
||
.push(action(
|
||
&format!(
|
||
"Created item allocation · @{} · order {}",
|
||
allocation.alias, allocation.order
|
||
),
|
||
Message::Select(allocation.id),
|
||
))
|
||
.push(label(format!(
|
||
"{} → {}",
|
||
app.project().named(allocation.source),
|
||
app.project().named(allocation.target)
|
||
)));
|
||
}
|
||
for value in report.unresolved_message_values.iter().take(6) {
|
||
card = card
|
||
.push(action(
|
||
&format!(
|
||
"Review qualified value · {}",
|
||
app.project().named(value.occurrence)
|
||
),
|
||
Message::EditProperties(value.occurrence),
|
||
))
|
||
.push(label(&value.reason));
|
||
}
|
||
if report.semantic_defaults.len() > 6
|
||
|| report.generated_interface_allocations.len() > 6
|
||
|| report.unresolved_message_values.len() > 6
|
||
{
|
||
card=card.push(label("Showing the first six entries in each data migration category. Model checks below link remaining unresolved contracts."));
|
||
}
|
||
for boundary in &report.orientation_defaults {
|
||
card = card.push(action(
|
||
&format!(
|
||
"Preserved directed exchange · {}",
|
||
app.project().named(boundary.exchange)
|
||
),
|
||
Message::Select(boundary.exchange),
|
||
));
|
||
}
|
||
out = out.push(container(card).padding(18).style(style::card));
|
||
}
|
||
if issues.is_empty() {
|
||
out = out.push(
|
||
container(
|
||
column![
|
||
text("Model checks passed").size(19).color(style::TEAL),
|
||
label("No structural errors or completeness warnings.")
|
||
]
|
||
.spacing(8),
|
||
)
|
||
.padding(20)
|
||
.style(style::card),
|
||
);
|
||
}
|
||
for issue in issues {
|
||
let mut card =
|
||
column![text(format!("{:?} · {}", issue.severity, issue.message)).size(13)].spacing(8);
|
||
if let Some(id) = issue.element {
|
||
card = card.push(action(
|
||
&format!("Open {}", app.project().named(id)),
|
||
Message::Select(id),
|
||
));
|
||
}
|
||
out = out.push(container(card).padding(15).style(style::card));
|
||
}
|
||
scrollable(out.padding(24)).into()
|
||
}
|
||
|
||
#[cfg(all(test, debug_assertions))]
|
||
pub(crate) fn captured_text_drawer_resize(app: &App) -> Message {
|
||
text_workspace::capture_drawer_resize(app)
|
||
}
|
||
|
||
#[cfg(all(test, debug_assertions))]
|
||
pub(crate) fn captured_source_reference_stale_summary(app: &App) -> bool {
|
||
text_workspace::summary_visibility_tests::rendered_stale(app)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::short;
|
||
|
||
#[test]
|
||
fn short_preserves_native_lifeline_clusters_at_cutoff() {
|
||
let oa = "abcdefghijklmnope\u{0301}尾";
|
||
assert_eq!(short(oa, 17), "abcdefghijklmnop…");
|
||
assert_eq!(short(oa, 18), oa);
|
||
assert_eq!(short(oa, 19), oa);
|
||
|
||
let sa = "abcdefghijklmnop👩\u{200d}🔬 tail";
|
||
assert_eq!(short(sa, 17), "abcdefghijklmnop…");
|
||
assert_eq!(short(sa, 18), "abcdefghijklmnop👩\u{200d}🔬…");
|
||
assert_eq!(short(sa, 19), "abcdefghijklmnop👩\u{200d}🔬 …");
|
||
assert_eq!(short(sa, 22), sa);
|
||
}
|
||
|
||
#[test]
|
||
fn short_never_splits_retained_extended_graphemes() {
|
||
for cluster in ["e\u{0301}", "👩\u{200d}🔬", "👍🏽", "🇫🇷"] {
|
||
let value = format!("A{cluster}BC");
|
||
assert_eq!(short(&value, 2), "A…");
|
||
assert_eq!(short(&value, 3), format!("A{cluster}…"));
|
||
assert_eq!(short(&value, 4), value);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn short_preserves_ascii_cjk_and_whitespace_policy() {
|
||
assert_eq!(short("abcd", 3), "ab…");
|
||
assert_eq!(short("abcd", 4), "abcd");
|
||
assert_eq!(short("abcd", 5), "abcd");
|
||
assert_eq!(short("甲乙丙丁", 3), "甲乙…");
|
||
assert_eq!(short("甲乙丙丁", 4), "甲乙丙丁");
|
||
assert_eq!(short(" \tA\r\n e\u{0301}\u{2003}B ", 5), "A e\u{0301} B");
|
||
assert_eq!(short(" \tA\r\n e\u{0301}\u{2003}B ", 4), "A e\u{0301}…");
|
||
}
|
||
|
||
#[test]
|
||
fn short_preserves_empty_and_small_limit_policy() {
|
||
for limit in [0, 1, 2] {
|
||
assert_eq!(short("", limit), "");
|
||
assert_eq!(short(" \t\r\n", limit), "");
|
||
}
|
||
assert_eq!(short("A", 0), "…");
|
||
assert_eq!(short("A", 1), "A");
|
||
assert_eq!(short("AB", 1), "…");
|
||
assert_eq!(short("e\u{0301}", 0), "…");
|
||
assert_eq!(short("e\u{0301}", 1), "e\u{0301}");
|
||
assert_eq!(short("e\u{0301}B", 1), "…");
|
||
}
|
||
}
|