sorokin.oleg.edu/ARCADIA-Studio
1
0
Fork 0
Code Issues 37 Pull Requests 2 Packages Projects Releases 9 Wiki Activity
Files
d6aabb5dec82900ebfac1183abb4036ca06cc0e5
ARCADIA-Studio/harness/experiments/state-bends-b868541-20260923/gates/failed-targeted-02/changes.patch
T

824 lines
37 KiB
Diff
Raw Blame History

diff --git a/crates/oa-desktop/src/app/state_attachment_escape_tests.rs b/crates/oa-desktop/src/app/state_attachment_escape_tests.rs
index 552828a..2f997ee 100644
--- a/crates/oa-desktop/src/app/state_attachment_escape_tests.rs
+++ b/crates/oa-desktop/src/app/state_attachment_escape_tests.rs
@@ -54,6 +54,8 @@ async fn armed() -> (App, Mounted, Id) {
object: relation,
placement: None,
anchor: iced::Point::new(450., 400.),
+ bend: None,
+ route_segment: None,
},
);
mounted.settle(&mut app).await;
diff --git a/crates/oa-desktop/src/app/state_diagram.rs b/crates/oa-desktop/src/app/state_diagram.rs
index 4ff0438..279e8c3 100644
--- a/crates/oa-desktop/src/app/state_diagram.rs
+++ b/crates/oa-desktop/src/app/state_diagram.rs
@@ -157,10 +157,14 @@ impl App {
object,
placement,
anchor,
+ bend,
+ route_segment,
} => {
let mut request = crate::model_menu::Request::object(object, anchor);
request.canvas = Some(context);
request.placement = placement;
+ request.bend = bend;
+ request.route_segment = route_segment;
return self.handle(Message::Menu(crate::model_menu::Event::Open(request)));
}
Event::EditTransition(_, id) => {
@@ -228,6 +232,11 @@ impl App {
let Some(context) = self.state_context() else {
return Task::none();
};
+ if let Event::SetBends { relation, .. } = &mutation
+ && *relation != self.selected
+ {
+ return Task::none();
+ }
if let Event::SetAttachment {
relation,
end,
@@ -246,6 +255,14 @@ impl App {
}
match state_edit::plan(self.project(), context, &mutation) {
Ok(plan) => {
+ if let Command::SetEdgeRoute { diagram, route } = &plan.command
+ && crate::route_edit::stored_route(
+ &self.project().diagrams[diagram],
+ route.edge,
+ ) == *route
+ {
+ return Task::none();
+ }
if self.execute(plan.command) {
self.behavior.diagram.diagram = Some(plan.diagram);
self.behavior.diagram.placement = plan.placement;
diff --git a/crates/oa-desktop/src/app/state_diagram_tests.rs b/crates/oa-desktop/src/app/state_diagram_tests.rs
index b3a7bb5..ba4f9aa 100644
--- a/crates/oa-desktop/src/app/state_diagram_tests.rs
+++ b/crates/oa-desktop/src/app/state_diagram_tests.rs
@@ -2,6 +2,8 @@
use super::*;
#[path = "state_attachment_escape_tests.rs"]
mod attachment_escape;
+#[path = "state_bend_tests.rs"]
+mod bends;
use crate::behavior::{
self,
state_edit::{self, Context, Endpoint, Event, Tool},
diff --git a/crates/oa-desktop/src/behavior/state_canvas.rs b/crates/oa-desktop/src/behavior/state_canvas.rs
index bd5ece6..baacea1 100644
--- a/crates/oa-desktop/src/behavior/state_canvas.rs
+++ b/crates/oa-desktop/src/behavior/state_canvas.rs
@@ -44,6 +44,8 @@ pub struct State {
source: Option<Id>,
preview: Option<(Id, Position)>,
attachment_preview: Option<AttachmentPreview>,
+ bend: Option<BendGesture>,
+ bend_preview: Option<EdgeRoute>,
pan_from: Option<(mouse::Button, Point)>,
viewport: Option<Size>,
attachment_viewport: Option<(f32, Vector, Rectangle)>,
@@ -84,6 +86,16 @@ enum Press {
placement: Id,
start: Point,
},
+ Bend {
+ relation: Id,
+ },
+}
+
+struct BendGesture {
+ start: Point,
+ route: EdgeRoute,
+ index: usize,
+ baseline: Arc<Scene>,
}
#[derive(Clone, Copy, PartialEq)]
@@ -103,6 +115,7 @@ struct CachedScene {
context: Context,
preview: Option<(Id, Position)>,
attachment_preview: Option<AttachmentPreview>,
+ bend_preview: Option<EdgeRoute>,
scene: Arc<Scene>,
}
#[derive(PartialEq)]
@@ -110,6 +123,7 @@ struct PaintKey {
context: Context,
preview: Option<(Id, Position)>,
attachment_preview: Option<AttachmentPreview>,
+ bend_preview: Option<EdgeRoute>,
selected: Id,
zoom: f32,
pan: Vector,
@@ -126,6 +140,8 @@ impl State {
self.press = None;
self.preview = None;
self.attachment_preview = None;
+ self.bend = None;
+ self.bend_preview = None;
self.attachment_viewport = None;
self.pan_from = None;
}
@@ -669,25 +685,31 @@ impl StateCanvas<'_> {
&& state_edit::validate_context(self.project, self.context, self.context).is_ok()
}
fn scene(&self, state: &State) -> Option<Arc<Scene>> {
+ self.scene_with_bounds(state, None)
+ }
+ fn scene_with_bounds(&self, state: &State, bounds: Option<Rectangle>) -> Option<Arc<Scene>> {
if !self.valid() {
return None;
}
+ let route_active = self.gesture_active(state) && self.route_viewport_current(state, bounds);
let preview = self
.gesture_active(state)
.then_some(state.preview)
.flatten();
- let attachment_preview = self
- .gesture_active(state)
- .then_some(state.attachment_preview)
- .flatten();
+ let attachment_preview = route_active.then_some(state.attachment_preview).flatten();
+ let bend_preview = route_active.then(|| state.bend_preview.clone()).flatten();
if let Some(cached) = state.scene.borrow().as_ref()
&& cached.context == self.context
&& cached.preview == preview
&& cached.attachment_preview == attachment_preview
+ && cached.bend_preview == bend_preview
{
return Some(cached.scene.clone());
}
let mut diagram = self.project.diagrams.get(&self.diagram)?.clone();
+ if let Some(route) = &bend_preview {
+ crate::route_edit::with_route(&mut diagram, route.clone());
+ }
if let Some(preview) = attachment_preview {
let mut route = crate::route_edit::stored_route(&diagram, preview.relation);
route.set_attachment(preview.end, Some(preview.attachment));
@@ -717,7 +739,17 @@ impl StateCanvas<'_> {
}
}
let view = projection::project_diagram(self.project, &diagram);
- let routed = routing::route_diagram(self.project, &diagram, &view);
+ let routed = if let Some(gesture) = state.bend.as_ref().filter(|_| bend_preview.is_some()) {
+ routing::route_edge_preview(
+ self.project,
+ &diagram,
+ &view,
+ &gesture.baseline.routed,
+ gesture.route.edge,
+ )
+ } else {
+ routing::route_diagram(self.project, &diagram, &view)
+ };
let symbol_labels = symbol_labels(self.project, &view, &routed);
let scene = Arc::new(Scene {
view,
@@ -728,6 +760,7 @@ impl StateCanvas<'_> {
context: self.context,
preview,
attachment_preview,
+ bend_preview,
scene: scene.clone(),
});
Some(scene)
@@ -859,6 +892,84 @@ impl StateCanvas<'_> {
.min_by(|a, b| a.1.total_cmp(&b.1))
.map(|(endpoint, _)| (route.id, endpoint))
}
+ fn bend_at(&self, scene: &Scene, world: Point) -> Option<usize> {
+ let edge = scene.routed.edges.get(&self.selected)?;
+ if edge.custom_suspended {
+ return None;
+ }
+ edge.pins
+ .iter()
+ .enumerate()
+ .filter_map(|(index, pin)| {
+ let distance = world.distance(point(*pin));
+ (distance <= 8. / self.scale()).then_some((index, distance))
+ })
+ .min_by(|a, b| a.1.total_cmp(&b.1).then(a.0.cmp(&b.0)))
+ .map(|(index, _)| index)
+ }
+ /// Preserve the rendered traversal index; overlapping runs can have the
+ /// same world point but different positions among the authored pins.
+ fn segment_at(&self, scene: &Scene, relation: Id, world: Point) -> Option<(usize, Position)> {
+ let edge = scene.routed.edges.get(&relation)?;
+ if edge.custom_suspended {
+ return None;
+ }
+ edge.points
+ .windows(2)
+ .enumerate()
+ .filter(|(index, _)| *index > 0 && index + 2 < edge.points.len())
+ .filter_map(|(index, span)| {
+ let projection = routing::project_onto_polyline(span, position(world))?;
+ (projection.distance <= 7. / self.scale()).then_some((index, projection.distance))
+ })
+ .min_by(|a, b| a.1.total_cmp(&b.1).then(a.0.cmp(&b.0)))
+ .map(|(index, _)| (index, position(world)))
+ }
+ fn begin_bend(
+ &self,
+ state: &mut State,
+ scene: Arc<Scene>,
+ window: Point,
+ route: EdgeRoute,
+ index: usize,
+ bounds: Rectangle,
+ ) {
+ state.press = Some(Press::Bend {
+ relation: route.edge,
+ });
+ state.attachment_viewport = Some((self.zoom, self.pan, bounds));
+ state.bend = Some(BendGesture {
+ start: window,
+ route,
+ index,
+ baseline: scene,
+ });
+ state.bend_preview = None;
+ }
+ fn move_bend_pointer(&self, state: &mut State, window: Point, local: Point) {
+ let Some(gesture) = &state.bend else {
+ return;
+ };
+ if window.distance(gesture.start) < 3. {
+ // Also discard a provisional insertion. The exact original route
+ // comes from the model, so an off-grid pin is never quantized here.
+ state.bend_preview = None;
+ return;
+ }
+ let world = self.world(local);
+ if !world.x.is_finite() || !world.y.is_finite() {
+ state.cancel_gesture();
+ return;
+ }
+ let mut changed = gesture.route.clone();
+ changed.waypoints[gesture.index] = Position {
+ x: (world.x / 5.).round() * 5.,
+ y: (world.y / 5.).round() * 5.,
+ };
+ let original =
+ crate::route_edit::stored_route(&self.project.diagrams[&self.diagram], changed.edge);
+ state.bend_preview = (changed != original).then_some(changed);
+ }
fn owner_at(&self, scene: &Scene, world: Point, kind: Kind) -> Option<Id> {
self.node_at(scene, world)
.filter(|n| state_edit::eligible_owner(self.project, self.diagram, n.element, kind))
@@ -887,7 +998,22 @@ impl StateCanvas<'_> {
}
}
fn gesture_active(&self, state: &State) -> bool {
- self.editable && state.context == Some(self.context) && state.tool == Some(self.tool)
+ self.editable
+ && state.context == Some(self.context)
+ && state.tool == Some(self.tool)
+ && state
+ .bend
+ .as_ref()
+ .is_none_or(|g| g.route.edge == self.selected)
+ }
+ fn route_viewport_current(&self, state: &State, bounds: Option<Rectangle>) -> bool {
+ state
+ .attachment_viewport
+ .is_none_or(|(zoom, pan, captured)| {
+ zoom == self.zoom
+ && pan == self.pan
+ && bounds.is_none_or(|current| current == captured)
+ })
}
fn move_attachment_pointer(&self, state: &mut State, window: Point, local: Point) {
let Some(Press::Attachment {
@@ -941,6 +1067,23 @@ impl StateCanvas<'_> {
if !self.editable {
return "Pending edits · apply or cancel them before editing the diagram".into();
}
+ if state.bend.is_some()
+ && self.gesture_active(state)
+ && self.route_viewport_current(state, None)
+ {
+ return "Move bend · release to keep · Esc cancels".into();
+ }
+ if self.tool == Tool::Select
+ && state.press.is_none()
+ && scene
+ .routed
+ .edges
+ .get(&self.selected)
+ .is_some_and(|edge| !edge.custom_suspended)
+ {
+ return "Drag line to add a bend · squares move bends · right-click a square to remove"
+ .into();
+ }
if let Tool::AdjustAttachment { relation, end } = self.tool {
return format!(
"Adjust {end:?} attachment of {} · drag that tip around its existing vertex boundary · Esc cancels · relation unchanged",
@@ -1035,11 +1178,16 @@ impl canvas::Program<Event> for StateCanvas<'_> {
state.tool = Some(self.tool);
}
if !self.editable {
- state.press = None;
- state.preview = None;
- state.attachment_preview = None;
+ state.cancel_gesture();
state.source = None;
}
+ if state
+ .bend
+ .as_ref()
+ .is_some_and(|g| g.route.edge != self.selected)
+ {
+ state.cancel_gesture();
+ }
if state
.attachment_viewport
.is_some_and(|view| view != (self.zoom, self.pan, bounds))
@@ -1055,6 +1203,9 @@ impl canvas::Program<Event> for StateCanvas<'_> {
}
canvas::Event::Mouse(mouse::Event::CursorLeft) => {
state.pointer = None;
+ if state.bend.is_some() {
+ state.cancel_gesture();
+ }
cursor
}
canvas::Event::Mouse(
@@ -1150,10 +1301,23 @@ impl canvas::Program<Event> for StateCanvas<'_> {
}
if *button == mouse::Button::Right {
state.reset();
- let (object, placement) = match self.hit(&scene, world) {
- Some(Hit::Node { element, placement }) => (element, Some(placement)),
- Some(Hit::Transition(id) | Hit::StateAction(id)) => (id, None),
- None => (self.diagram, None),
+ // A canceled provisional pin shifts indices in its preview.
+ // Menu commands must target the committed route instead.
+ let scene = self.scene(state)?;
+ let bend = self.bend_at(&scene, world);
+ let (object, placement) = if bend.is_some() {
+ (self.selected, None)
+ } else {
+ match self.hit(&scene, world) {
+ Some(Hit::Node { element, placement }) => (element, Some(placement)),
+ Some(Hit::Transition(id) | Hit::StateAction(id)) => (id, None),
+ None => (self.diagram, None),
+ }
+ };
+ let route_segment = if bend.is_none() {
+ self.segment_at(&scene, object, world)
+ } else {
+ None
};
return Some(
Action::publish(Event::ContextMenu {
@@ -1161,6 +1325,8 @@ impl canvas::Program<Event> for StateCanvas<'_> {
object,
placement,
anchor: window,
+ bend,
+ route_segment,
})
.and_capture(),
);
@@ -1178,6 +1344,14 @@ impl canvas::Program<Event> for StateCanvas<'_> {
});
return Some(Action::capture());
}
+ if let Some(index) = self.bend_at(&scene, world) {
+ let route = crate::route_edit::stored_route(
+ &self.project.diagrams[&self.diagram],
+ self.selected,
+ );
+ self.begin_bend(state, scene.clone(), window, route, index, bounds);
+ return Some(Action::capture());
+ }
match self.hit(&scene, world) {
Some(Hit::Node { placement, element }) => {
let original = self
@@ -1198,6 +1372,36 @@ impl canvas::Program<Event> for StateCanvas<'_> {
)
}
Some(Hit::Transition(id) | Hit::StateAction(id)) => {
+ if id == self.selected
+ && let Some(edge) = scene.routed.edges.get(&id)
+ && !Rectangle::new(
+ point(edge.label.bounds.position),
+ Size::new(
+ edge.label.bounds.size.width,
+ edge.label.bounds.size.height,
+ ),
+ )
+ .contains(world)
+ && let Some((segment, at)) = self.segment_at(&scene, id, world)
+ {
+ let mut route = crate::route_edit::stored_route(
+ &self.project.diagrams[&self.diagram],
+ id,
+ );
+ if let Some(index) = crate::route_edit::insert_pin_on_segment(
+ &mut route, edge, segment, at,
+ ) {
+ self.begin_bend(
+ state,
+ scene.clone(),
+ window,
+ route,
+ index,
+ bounds,
+ );
+ return Some(Action::capture());
+ }
+ }
Some(Action::publish(Event::Select(self.context, id)).and_capture())
}
None => {
@@ -1275,6 +1479,7 @@ impl canvas::Program<Event> for StateCanvas<'_> {
self.move_pointer(state, window);
if let Some(local) = local {
self.move_attachment_pointer(state, window, local);
+ self.move_bend_pointer(state, window, local);
}
Some(Action::request_redraw())
}
@@ -1298,14 +1503,24 @@ impl canvas::Program<Event> for StateCanvas<'_> {
self.move_pointer(state, window);
if let Some(local) = local {
self.move_attachment_pointer(state, window, local);
+ self.move_bend_pointer(state, window, local);
}
}
let press = state.press.take()?;
state.attachment_viewport = None;
let preview = state.preview.take();
let attachment_preview = state.attachment_preview.take();
+ let bend_preview = state.bend_preview.take();
+ state.bend = None;
let world = local.map(|p| self.world(p));
let event = match press {
+ Press::Bend { relation } if inside => bend_preview
+ .filter(|route| route.edge == relation)
+ .map(|route| Event::SetBends {
+ context: self.context,
+ relation,
+ waypoints: route.waypoints,
+ }),
Press::Move { node, .. } => preview.map(|(_, position)| Event::Move {
context: self.context,
node,
@@ -1416,19 +1631,19 @@ impl canvas::Program<Event> for StateCanvas<'_> {
bounds: Rectangle,
cursor: mouse::Cursor,
) -> Vec<canvas::Geometry> {
- let Some(scene) = self.scene(state) else {
+ let Some(scene) = self.scene_with_bounds(state, Some(bounds)) else {
return vec![];
};
+ let route_active =
+ self.gesture_active(state) && self.route_viewport_current(state, Some(bounds));
let key = PaintKey {
context: self.context,
preview: self
.gesture_active(state)
.then_some(state.preview)
.flatten(),
- attachment_preview: self
- .gesture_active(state)
- .then_some(state.attachment_preview)
- .flatten(),
+ attachment_preview: route_active.then_some(state.attachment_preview).flatten(),
+ bend_preview: route_active.then(|| state.bend_preview.clone()).flatten(),
selected: self.selected,
zoom: self.scale(),
pan: self.pan,
@@ -1508,6 +1723,22 @@ impl canvas::Program<Event> for StateCanvas<'_> {
style::MUTED,
);
if active {
+ if !edge.custom_suspended && self.tool == Tool::Select {
+ for pin in &edge.pins {
+ let radius = 4. / self.scale();
+ let handle = Path::rectangle(
+ point(*pin) - Vector::new(radius, radius),
+ Size::new(radius * 2., radius * 2.),
+ );
+ frame.fill(&handle, Color::WHITE);
+ frame.stroke(
+ &handle,
+ Stroke::default()
+ .with_color(style::TEAL)
+ .with_width(1.6 / self.scale()),
+ );
+ }
+ }
for end in [edge.points.first(), edge.points.last()]
.into_iter()
.flatten()
@@ -1922,6 +2153,8 @@ mod tests {
use super::*;
use crate::document::Document;
+ include!("state_bend_tests.rs");
+
struct Fixture {
project: Project,
diagram: Id,
@@ -2377,7 +2610,7 @@ mod tests {
motion(&canvas, &mut state, at, at);
assert!(matches!(input(&canvas, &mut state,
mouse::Event::ButtonPressed(mouse::Button::Right), at),
- Some(Event::ContextMenu { context, object, placement: Some(node), anchor })
+ Some(Event::ContextMenu { context, object, placement: Some(node), anchor, .. })
if context == canvas.context && object == f.b
&& node == placement(&f, f.b) && anchor == at));
let background = Point::new(
@@ -2387,7 +2620,7 @@ mod tests {
motion(&canvas, &mut state, background, background);
assert!(matches!(input(&canvas, &mut state,
mouse::Event::ButtonPressed(mouse::Button::Right), background),
- Some(Event::ContextMenu { context, object, placement: None, anchor })
+ Some(Event::ContextMenu { context, object, placement: None, anchor, .. })
if context == canvas.context && object == f.diagram && anchor == background));
}
diff --git a/crates/oa-desktop/src/behavior/state_edit.rs b/crates/oa-desktop/src/behavior/state_edit.rs
index 9ccf01d..e066657 100644
--- a/crates/oa-desktop/src/behavior/state_edit.rs
+++ b/crates/oa-desktop/src/behavior/state_edit.rs
@@ -39,6 +39,8 @@ pub enum Event {
object: Id,
placement: Option<Id>,
anchor: iced::Point,
+ bend: Option<usize>,
+ route_segment: Option<(usize, Position)>,
},
CreateAt {
context: Context,
@@ -74,6 +76,25 @@ pub enum Event {
placement: Id,
attachment: Option<EdgeAttachment>,
},
+ SetBends {
+ context: Context,
+ relation: Id,
+ waypoints: Vec<Position>,
+ },
+ AddBend {
+ context: Context,
+ relation: Id,
+ segment: Option<(usize, Position)>,
+ },
+ RemoveBend {
+ context: Context,
+ relation: Id,
+ index: usize,
+ },
+ ClearBends {
+ context: Context,
+ relation: Id,
+ },
}
impl Event {
@@ -93,7 +114,11 @@ impl Event {
| Self::Move { context: c, .. }
| Self::Connect { context: c, .. }
| Self::Reconnect { context: c, .. }
- | Self::SetAttachment { context: c, .. } => Some(*c),
+ | Self::SetAttachment { context: c, .. }
+ | Self::SetBends { context: c, .. }
+ | Self::AddBend { context: c, .. }
+ | Self::RemoveBend { context: c, .. }
+ | Self::ClearBends { context: c, .. } => Some(*c),
}
}
}
@@ -288,6 +313,24 @@ pub fn attachment_node(
view.nodes.iter().find(|node| node.id == owner).cloned()
}
+/// Actual visible State transition geometry, never an internal row or folded proxy.
+pub fn bend_route(
+ project: &Project,
+ diagram: Id,
+ relation: Id,
+) -> Option<oa_core::routing::RoutedEdge> {
+ machine(project, diagram).ok()?;
+ if project.relations.get(&relation)?.kind() != RelationKind::StateTransition {
+ return None;
+ }
+ let stored = project.diagrams.get(&diagram)?;
+ let view = projection::project_diagram(project, stored);
+ let geometry = oa_core::routing::route_diagram(project, stored, &view)
+ .edges
+ .remove(&relation)?;
+ (!geometry.custom_suspended).then_some(geometry)
+}
+
fn checked(project: &Project, plan: Plan) -> Result<Plan, ModelError> {
prepare_command(project, &plan.command)?;
Ok(plan)
@@ -547,6 +590,66 @@ pub fn plan(project: &Project, current: Context, event: &Event) -> Result<Plan,
route.set_attachment(end, attachment);
(Command::SetEdgeRoute { diagram, route }, relation, None)
}
+ Event::SetBends { relation, .. }
+ | Event::AddBend { relation, .. }
+ | Event::RemoveBend { relation, .. }
+ | Event::ClearBends { relation, .. } => {
+ let geometry = bend_route(project, diagram, relation)
+ .ok_or_else(|| error("Choose an actual visible transition route in this view."))?;
+ let mut route = crate::route_edit::stored_route(&project.diagrams[&diagram], relation);
+ match event {
+ Event::SetBends { waypoints, .. } => {
+ if waypoints.len() > 128 {
+ return Err(error("A route supports at most 128 bends."));
+ }
+ for &point in waypoints {
+ finite(point)?;
+ }
+ route.waypoints = waypoints.clone();
+ }
+ Event::AddBend { segment, .. } => {
+ let (segment, point) = segment
+ .or_else(|| {
+ geometry
+ .points
+ .windows(2)
+ .enumerate()
+ .filter(|(index, _)| {
+ *index > 0 && index + 2 < geometry.points.len()
+ })
+ .max_by(|(_, a), (_, b)| {
+ let length = |s: &[Position]| {
+ (s[1].x - s[0].x).abs() + (s[1].y - s[0].y).abs()
+ };
+ length(a).total_cmp(&length(b))
+ })
+ .map(|(index, span)| {
+ (
+ index,
+ Position {
+ x: (span[0].x + span[1].x) / 2.,
+ y: (span[0].y + span[1].y) / 2.,
+ },
+ )
+ })
+ })
+ .ok_or_else(|| error("This route has no interior segment for a bend."))?;
+ crate::route_edit::insert_pin_on_segment(&mut route, &geometry, segment, point)
+ .ok_or_else(|| {
+ error("The bend segment is stale, invalid, or at capacity.")
+ })?;
+ }
+ Event::RemoveBend { index, .. } => {
+ if *index >= route.waypoints.len() {
+ return Err(error("This bend no longer exists."));
+ }
+ route.waypoints.remove(*index);
+ }
+ Event::ClearBends { .. } => route.waypoints.clear(),
+ _ => unreachable!(),
+ }
+ (Command::SetEdgeRoute { diagram, route }, relation, None)
+ }
_ => {
return Err(error(
"Handle this navigation or tool request without a model command.",
diff --git a/crates/oa-desktop/src/behavior/state_menu.rs b/crates/oa-desktop/src/behavior/state_menu.rs
index 02c6a09..dbbacf5 100644
--- a/crates/oa-desktop/src/behavior/state_menu.rs
+++ b/crates/oa-desktop/src/behavior/state_menu.rs
@@ -161,6 +161,53 @@ pub fn popup(app: &App, opened: &Opened, clean: bool) -> Option<Menu<Message>> {
);
entries.push(item("Edit transition", edit, true));
if let Some(context) = context {
+ let bend_geometry = state_edit::bend_route(project, context.diagram, id);
+ let bend_count = bend_geometry.as_ref().map_or(0, |route| route.pins.len());
+ let can_add = bend_geometry.as_ref().is_some_and(|route| {
+ bend_count < 128
+ && request.route_segment.map_or_else(
+ || route.points.len() >= 4,
+ |(index, point)| {
+ index
+ .checked_add(2)
+ .is_some_and(|end| end <= route.points.len())
+ && point.x.is_finite()
+ && point.y.is_finite()
+ },
+ )
+ });
+ entries.push(item(
+ if request.route_segment.is_some() {
+ "Add bend here"
+ } else {
+ "Add bend"
+ },
+ diagram_event(Event::AddBend {
+ context,
+ relation: id,
+ segment: request.route_segment,
+ }),
+ can_add,
+ ));
+ if let Some(index) = request.bend {
+ entries.push(item(
+ "Remove bend",
+ diagram_event(Event::RemoveBend {
+ context,
+ relation: id,
+ index,
+ }),
+ bend_geometry.is_some() && index < bend_count,
+ ));
+ }
+ entries.push(item(
+ "Clear bends",
+ diagram_event(Event::ClearBends {
+ context,
+ relation: id,
+ }),
+ bend_geometry.is_some() && bend_count > 0,
+ ));
let visible = projection::project_view(project, context.diagram)
.edges
.iter()
diff --git a/crates/oa-desktop/src/guide.rs b/crates/oa-desktop/src/guide.rs
index 110ee04..e3afadf 100644
--- a/crates/oa-desktop/src/guide.rs
+++ b/crates/oa-desktop/src/guide.rs
@@ -565,6 +565,7 @@ fn article(topic: Topic) -> Article {
"Choose + Region and click the highlighted machine, or a State/Mode for a nested region. Choose Initial, State, Mode or another kind from + State / symbol, then click its highlighted owning region. Rename the new element in Properties.",
"Choose Transition and drag from a source vertex to a compatible target, or click the source and then the target. In Select / move, drag states or containers to arrange them; a container moves its descendant placements without changing ownership.",
"Select a drawn transition and drag its endpoint handle to reconnect it. Its right-click menu also offers Reconnect source and Reconnect target; choose one, then click a compatible vertex. To change only where a line touches its existing vertex, choose Adjust source attachment or Adjust target attachment, then drag the highlighted tip along the boundary. Reset source attachment or Reset target attachment restores automatic placement for that end without changing the transition's meaning or other route settings. Escape cancels an attachment drag.",
+ "To shape a selected transition, drag an exposed line segment to add a bend, or drag a square bend handle to move it. Right-click a square and choose Remove bend. The transition's Actions menu also offers Add bend and Clear bends; clearing bends keeps its attachment points and label placement. Bends belong to this saved view. A click alone changes nothing, Escape cancels a drag, and Undo restores the complete edit. Internal transition rows and folded connections do not expose bend editing while their route is hidden.",
"Right-click a state or the background for New transition with details… to create Local, Internal or timed behavior. Right-click an existing transition and choose Edit transition to edit its kind, triggers, guard and effects. EntryPoint outgoing transitions use Local. Apply accepts the complete form; invalid drafts remain available for correction.",
],
),
diff --git a/crates/oa-desktop/src/model_menu.rs b/crates/oa-desktop/src/model_menu.rs
index 6c137f5..c0a4cbf 100644
--- a/crates/oa-desktop/src/model_menu.rs
+++ b/crates/oa-desktop/src/model_menu.rs
@@ -14,6 +14,7 @@ pub struct Request {
pub placement: Option<Id>,
pub bend: Option<usize>,
pub route_point: Option<Position>,
+ pub route_segment: Option<(usize, Position)>,
pub creation_point: Option<Position>,
pub canvas: Option<route_edit::Context>,
pub source_file: Option<String>,
@@ -26,6 +27,7 @@ impl Request {
placement: None,
bend: None,
route_point: None,
+ route_segment: None,
creation_point: None,
canvas: None,
source_file: None,
diff --git a/crates/oa-desktop/src/route_edit.rs b/crates/oa-desktop/src/route_edit.rs
index 9d096d0..ce9c0f1 100644
--- a/crates/oa-desktop/src/route_edit.rs
+++ b/crates/oa-desktop/src/route_edit.rs
@@ -137,6 +137,34 @@ pub fn stored_route(diagram: &Diagram, edge: Id) -> EdgeRoute {
}
/// Insert after the pins preceding the clicked segment along the routed path.
+pub fn insert_pin_on_segment(
+ route: &mut EdgeRoute,
+ geometry: &RoutedEdge,
+ segment: usize,
+ point: Position,
+) -> Option<usize> {
+ if route.edge != geometry.id
+ || geometry.custom_suspended
+ || route.waypoints != geometry.pins
+ || route.waypoints.len() >= 128
+ || !point.x.is_finite()
+ || !point.y.is_finite()
+ || geometry
+ .points
+ .get(segment..segment.checked_add(2)?)
+ .is_none()
+ {
+ return None;
+ }
+ let index = pin_insertion_index(geometry, segment, point);
+ if index > route.waypoints.len() {
+ return None;
+ }
+ route.waypoints.insert(index, point);
+ Some(index)
+}
+
+/// Find a segment when an ordinary caller has only a point, not a captured hit.
pub fn insert_pin(route: &mut EdgeRoute, geometry: &RoutedEdge, point: Position) -> usize {
let segment = geometry
.points
Reference in New Issue View Git Blame Copy Permalink