837 lines
29 KiB
Rust
837 lines
29 KiB
Rust
//! Pure, bounded allocation-drag composition. See the v2 interaction contract.
|
|
//!
|
|
//! These values are not input capabilities. The App must independently admit a
|
|
//! clean press and retire its token on every document/input/camera lifetime
|
|
//! change. Cache a SemanticPlan per token and destination; only `place` belongs
|
|
//! on pointer motion. `finish` rechecks the live accepted Project and commands,
|
|
//! but Document::execute still owns source admission and atomic history.
|
|
use oa_core::{
|
|
projection::{self, ProjectedNode, ProjectedView},
|
|
validation::{self, Issue, Severity},
|
|
view_options::ViewIndex,
|
|
*,
|
|
};
|
|
use std::collections::{BTreeMap, BTreeSet};
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum Destination {
|
|
LayoutOnly,
|
|
Performer(Id),
|
|
OutsidePerformers,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum Uniform {
|
|
Assigned(Id),
|
|
Unassigned,
|
|
MixedOrUnresolved,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub struct Leaf {
|
|
pub direct: Option<Relation>,
|
|
pub role_assignments: Vec<Relation>,
|
|
pub role_realizations: Vec<Relation>,
|
|
pub effective_performer: Option<Id>,
|
|
}
|
|
|
|
/// Exact semantic scope S, leaf scope L and active placement scope Q, including
|
|
/// folded/unplaced leaves. Retaining records detects first-child responsibility
|
|
/// transfer. Revision and input-epoch guards remain the caller's responsibility.
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub struct Scope {
|
|
pub project: Id,
|
|
pub work: Id,
|
|
pub placement: Id,
|
|
pub work_records: BTreeMap<Id, Element>,
|
|
pub leaves: BTreeMap<Id, Leaf>,
|
|
pub placements: BTreeMap<Id, NodePlacement>,
|
|
pub diagram: Diagram,
|
|
pub uniform: Uniform,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ChangedRecord {
|
|
pub id: Id,
|
|
pub name: String,
|
|
pub category: &'static str,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub enum Refusal {
|
|
Ineligible(String),
|
|
StaleScope,
|
|
MixedLayoutRequired,
|
|
RoleExitRequired {
|
|
work: Id,
|
|
roles: Vec<Id>,
|
|
performers: Vec<Id>,
|
|
message: String,
|
|
},
|
|
MissingAllocationId(Id),
|
|
InvalidCandidate(String),
|
|
CollateralChangeRequired(Vec<ChangedRecord>),
|
|
LayoutRequired(String),
|
|
}
|
|
|
|
pub fn capture(p: &Project, diagram: Id, work: Id, placement: Id) -> Result<Scope, Refusal> {
|
|
validate_candidate(p).map_err(|e| Refusal::InvalidCandidate(e.to_string()))?;
|
|
let d = p.diagrams.get(&diagram).ok_or(Refusal::StaleScope)?;
|
|
let root = p.elements.get(&work).ok_or(Refusal::StaleScope)?;
|
|
if !root.kind().is_work()
|
|
|| d.projection != ProjectionKind::Allocation
|
|
|| d.layer != root.layer()
|
|
{
|
|
return Err(Refusal::Ineligible(
|
|
"Select an activity or function in an Allocation view.".into(),
|
|
));
|
|
}
|
|
if d.nodes.get(&placement).is_none_or(|n| n.element != work) {
|
|
return Err(Refusal::StaleScope);
|
|
}
|
|
let mut work_records = BTreeMap::new();
|
|
let mut leaves = BTreeMap::new();
|
|
let mut pending = vec![work];
|
|
while let Some(id) = pending.pop() {
|
|
let element = p.elements.get(&id).ok_or(Refusal::StaleScope)?;
|
|
if element.kind() != root.kind() || work_records.insert(id, element.clone()).is_some() {
|
|
return Err(Refusal::StaleScope);
|
|
}
|
|
let children: Vec<_> = p
|
|
.children(id)
|
|
.filter(|e| e.kind() == root.kind())
|
|
.map(|e| e.id)
|
|
.collect();
|
|
if !children.is_empty() {
|
|
pending.extend(children);
|
|
continue;
|
|
}
|
|
let direct: Vec<_> = p
|
|
.relations
|
|
.values()
|
|
.filter(|r| r.kind() == RelationKind::Allocation && r.target() == id)
|
|
.cloned()
|
|
.collect();
|
|
if direct.len() > 1 {
|
|
return Err(Refusal::StaleScope);
|
|
}
|
|
let role_assignments: Vec<_> = p
|
|
.relations
|
|
.values()
|
|
.filter(|r| r.kind() == RelationKind::RoleAssignment && r.target() == id)
|
|
.cloned()
|
|
.collect();
|
|
let roles: BTreeSet<_> = role_assignments.iter().map(Relation::source).collect();
|
|
let role_realizations = p
|
|
.relations
|
|
.values()
|
|
.filter(|r| r.kind() == RelationKind::RoleRealization && roles.contains(&r.target()))
|
|
.cloned()
|
|
.collect();
|
|
leaves.insert(
|
|
id,
|
|
Leaf {
|
|
direct: direct.into_iter().next(),
|
|
role_assignments,
|
|
role_realizations,
|
|
effective_performer: validation::effective_performer(p, id),
|
|
},
|
|
);
|
|
}
|
|
if leaves.is_empty() {
|
|
return Err(Refusal::StaleScope);
|
|
}
|
|
let uniform = if leaves
|
|
.values()
|
|
.all(|l| l.direct.is_none() && l.role_assignments.is_empty())
|
|
{
|
|
Uniform::Unassigned
|
|
} else if let Some(performer) = leaves.values().next().and_then(|l| l.effective_performer)
|
|
&& leaves
|
|
.values()
|
|
.all(|l| l.effective_performer == Some(performer))
|
|
{
|
|
Uniform::Assigned(performer)
|
|
} else {
|
|
Uniform::MixedOrUnresolved
|
|
};
|
|
let placements = d
|
|
.nodes
|
|
.iter()
|
|
.filter(|(_, n)| work_records.contains_key(&n.element))
|
|
.map(|(id, n)| (*id, n.clone()))
|
|
.collect();
|
|
Ok(Scope {
|
|
project: p.id,
|
|
work,
|
|
placement,
|
|
work_records,
|
|
leaves,
|
|
placements,
|
|
diagram: d.clone(),
|
|
uniform,
|
|
})
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct SemanticPlan {
|
|
pub scope: Scope,
|
|
pub destination: Destination,
|
|
pub label: String,
|
|
pub warnings: Vec<Issue>,
|
|
accepted: Project,
|
|
candidate: Project,
|
|
index: ViewIndex,
|
|
commands: Vec<Command>,
|
|
before_visible: ProjectedView,
|
|
before_expanded: ProjectedView,
|
|
}
|
|
|
|
impl SemanticPlan {
|
|
/// All preview drawing, ports and routing must use this candidate and index.
|
|
pub fn project(&self) -> &Project {
|
|
&self.candidate
|
|
}
|
|
#[cfg(test)]
|
|
pub fn index(&self) -> &ViewIndex {
|
|
&self.index
|
|
}
|
|
}
|
|
|
|
/// Allocation identities are allocated once by the gesture owner, keyed by leaf,
|
|
/// and reused on target revisits and release. No random identity generation here.
|
|
pub fn plan_semantics(
|
|
p: &Project,
|
|
scope: &Scope,
|
|
destination: Destination,
|
|
allocation_ids: &BTreeMap<Id, Id>,
|
|
) -> Result<SemanticPlan, Refusal> {
|
|
if &capture(p, scope.diagram.id, scope.work, scope.placement)? != scope {
|
|
return Err(Refusal::StaleScope);
|
|
}
|
|
if scope.work_records.len() > 1 && scope.uniform == Uniform::MixedOrUnresolved {
|
|
return Err(Refusal::MixedLayoutRequired);
|
|
}
|
|
if let Destination::Performer(id) = destination {
|
|
let valid = p
|
|
.elements
|
|
.get(&id)
|
|
.is_some_and(|e| e.kind().is_performer() && e.layer() == scope.diagram.layer);
|
|
if !valid {
|
|
return Err(Refusal::Ineligible(
|
|
"Choose a performer in this layer.".into(),
|
|
));
|
|
}
|
|
}
|
|
let before_index = ViewIndex::new(p);
|
|
let before_visible = projection::project_diagram_with_index(p, &scope.diagram, &before_index);
|
|
let before_expanded = expanded_view(p, &scope.diagram, scope, &before_index);
|
|
if scope.work_records.len() > 1 && !coherent(scope, &before_expanded) {
|
|
return Err(Refusal::MixedLayoutRequired);
|
|
}
|
|
let same_performer =
|
|
matches!(destination, Destination::Performer(id) if scope.uniform == Uniform::Assigned(id));
|
|
let mut expected = p.clone();
|
|
let mut commands = Vec::new();
|
|
let mut deleted = BTreeSet::new();
|
|
if destination != Destination::LayoutOnly && !same_performer {
|
|
for (work, leaf) in &scope.leaves {
|
|
match destination {
|
|
Destination::Performer(performer) => {
|
|
if let Some(existing) = &leaf.direct {
|
|
if existing.source() != performer {
|
|
let mut edited = existing.clone();
|
|
edited.body = RelationBody::Allocation {
|
|
source: performer,
|
|
target: *work,
|
|
};
|
|
expected.relations.insert(edited.id, edited.clone());
|
|
commands.push(Command::EditRelation(edited.id, edited));
|
|
}
|
|
} else {
|
|
let id = *allocation_ids
|
|
.get(work)
|
|
.ok_or(Refusal::MissingAllocationId(*work))?;
|
|
if id.is_nil() || expected.contains(id) {
|
|
return Err(Refusal::InvalidCandidate(
|
|
"The gesture's allocation identity is already in use.".into(),
|
|
));
|
|
}
|
|
let name = format!("{} performs {}", p.named(performer), p.named(*work));
|
|
let relation = Relation {
|
|
id,
|
|
alias: expected.fresh_alias(&name, "allocation", id),
|
|
name,
|
|
description: String::new(),
|
|
body: RelationBody::Allocation {
|
|
source: performer,
|
|
target: *work,
|
|
},
|
|
};
|
|
expected.relations.insert(id, relation.clone());
|
|
commands.push(Command::CreateRelation(relation));
|
|
}
|
|
}
|
|
Destination::OutsidePerformers => {
|
|
if !leaf.role_assignments.is_empty() {
|
|
let roles: Vec<_> = leaf
|
|
.role_assignments
|
|
.iter()
|
|
.map(Relation::source)
|
|
.collect::<BTreeSet<_>>()
|
|
.into_iter()
|
|
.collect();
|
|
let performers: Vec<_> = leaf
|
|
.role_realizations
|
|
.iter()
|
|
.map(Relation::source)
|
|
.collect::<BTreeSet<_>>()
|
|
.into_iter()
|
|
.collect();
|
|
let message = if leaf.direct.is_some() && performers.len() == 1 {
|
|
format!(
|
|
"Removing direct assignment would place {} in {} through its role.",
|
|
p.named(*work),
|
|
p.named(performers[0])
|
|
)
|
|
} else {
|
|
format!(
|
|
"{} retains role responsibility through {}{}; edit that responsibility before moving outside performers.",
|
|
p.named(*work),
|
|
roles
|
|
.iter()
|
|
.map(|id| p.named(*id))
|
|
.collect::<Vec<_>>()
|
|
.join(", "),
|
|
if performers.is_empty() {
|
|
String::new()
|
|
} else {
|
|
format!(
|
|
" ({})",
|
|
performers
|
|
.iter()
|
|
.map(|id| p.named(*id))
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
)
|
|
}
|
|
)
|
|
};
|
|
return Err(Refusal::RoleExitRequired {
|
|
work: *work,
|
|
roles,
|
|
performers,
|
|
message,
|
|
});
|
|
}
|
|
if let Some(existing) = &leaf.direct {
|
|
expected.relations.remove(&existing.id);
|
|
deleted.insert(existing.id);
|
|
commands.push(Command::Delete(existing.id));
|
|
}
|
|
}
|
|
Destination::LayoutOnly => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
// A route cannot survive the intentional deletion of its own edge, even in
|
|
// another diagram. No other saved-view cleanup is authorized by this drag.
|
|
for diagram in expected.diagrams.values_mut() {
|
|
diagram.routes.retain(|r| !deleted.contains(&r.edge));
|
|
}
|
|
let actual = prepare_command(p, &Command::Batch(commands.clone()))
|
|
.map_err(|e| Refusal::InvalidCandidate(e.to_string()))?
|
|
.project;
|
|
exact_project(&expected, &actual)?;
|
|
let retained_roles = scope
|
|
.leaves
|
|
.values()
|
|
.any(|l| !l.role_assignments.is_empty());
|
|
let label = match destination {
|
|
Destination::LayoutOnly => "Arrange only".into(),
|
|
Destination::Performer(id) if same_performer => format!("Arrange within {}", p.named(id)),
|
|
Destination::Performer(id) => format!(
|
|
"Assign {} leaf {} to {}{}",
|
|
scope.leaves.len(),
|
|
match (scope.diagram.layer, scope.leaves.len()) {
|
|
(Layer::Oa, 1) => "activity",
|
|
(Layer::Oa, _) => "activities",
|
|
(Layer::Sa, 1) => "function",
|
|
(Layer::Sa, _) => "functions",
|
|
},
|
|
p.named(id),
|
|
if retained_roles {
|
|
" — explicit assignment; role responsibility retained"
|
|
} else {
|
|
""
|
|
}
|
|
),
|
|
Destination::OutsidePerformers if commands.is_empty() => {
|
|
"Arrange unassigned work — decomposition retained".into()
|
|
}
|
|
Destination::OutsidePerformers => "Remove assignment — decomposition retained".into(),
|
|
};
|
|
let warnings = validation::validate(&actual)
|
|
.into_iter()
|
|
.filter(|i| i.severity == Severity::Warning)
|
|
.collect();
|
|
let index = ViewIndex::new(&actual);
|
|
Ok(SemanticPlan {
|
|
scope: scope.clone(),
|
|
destination,
|
|
label,
|
|
warnings,
|
|
accepted: p.clone(),
|
|
candidate: actual,
|
|
index,
|
|
commands,
|
|
before_visible,
|
|
before_expanded,
|
|
})
|
|
}
|
|
|
|
/// World-space rectangle in the gesture's frozen transform. The UI resolver
|
|
/// owns half-open pointer hits, semantic target precedence and occlusion.
|
|
#[derive(Debug, Clone, Copy, PartialEq)]
|
|
pub struct Rect {
|
|
pub position: Position,
|
|
pub size: Size,
|
|
}
|
|
|
|
impl Rect {
|
|
fn valid(self) -> bool {
|
|
[
|
|
self.position.x,
|
|
self.position.y,
|
|
self.size.width,
|
|
self.size.height,
|
|
]
|
|
.iter()
|
|
.all(|n| n.is_finite() && n.abs() <= MAX_COORDINATE)
|
|
&& self.size.width > 0.
|
|
&& self.size.height > 0.
|
|
}
|
|
fn contains(self, other: Self) -> bool {
|
|
other.position.x >= self.position.x
|
|
&& other.position.y >= self.position.y
|
|
&& other.position.x + other.size.width <= self.position.x + self.size.width
|
|
&& other.position.y + other.size.height <= self.position.y + self.size.height
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq)]
|
|
pub struct TargetPresentation {
|
|
pub placement: Id,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq)]
|
|
pub struct PresentationContext {
|
|
/// Visible world rectangle derived from the actual captured pan/zoom/bounds.
|
|
pub viewport: Rect,
|
|
pub zoom: f32,
|
|
pub target: Option<TargetPresentation>,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct PlacementPlan {
|
|
pub diagram: Diagram,
|
|
pub view: ProjectedView,
|
|
pub delta: Position,
|
|
pub unfolded: Option<Id>,
|
|
requested: Position,
|
|
presentation: PresentationContext,
|
|
commands: Vec<Command>,
|
|
}
|
|
|
|
/// `requested` is the original selected placement position plus pointer motion
|
|
/// in the frozen transform (therefore preserving the press offset). Snap only
|
|
/// this root; apply the resulting identical delta to captured Q and its routes.
|
|
/// No whole Project clone, validator or semantic ViewIndex rebuild occurs here.
|
|
pub fn place(
|
|
plan: &SemanticPlan,
|
|
requested: Position,
|
|
presentation: PresentationContext,
|
|
) -> Result<PlacementPlan, Refusal> {
|
|
if !requested.x.is_finite()
|
|
|| !requested.y.is_finite()
|
|
|| !presentation.viewport.valid()
|
|
|| !presentation.zoom.is_finite()
|
|
|| presentation.zoom <= 0.
|
|
{
|
|
return Err(Refusal::LayoutRequired(
|
|
"Make room or adjust the view, then drag again.".into(),
|
|
));
|
|
}
|
|
let root = &plan.scope.placements[&plan.scope.placement];
|
|
let delta = Position {
|
|
x: (requested.x / 10.).round() * 10. - root.position.x,
|
|
y: (requested.y / 10.).round() * 10. - root.position.y,
|
|
};
|
|
let mut diagram = plan.candidate.diagrams[&plan.scope.diagram.id].clone();
|
|
let mut commands = Vec::new();
|
|
let mut deltas = BTreeMap::new();
|
|
for (id, original) in &plan.scope.placements {
|
|
let node = diagram.nodes.get_mut(id).ok_or(Refusal::StaleScope)?;
|
|
node.position = Position {
|
|
x: original.position.x + delta.x,
|
|
y: original.position.y + delta.y,
|
|
};
|
|
if !(Rect {
|
|
position: node.position,
|
|
size: node.size,
|
|
})
|
|
.valid()
|
|
{
|
|
return Err(Refusal::InvalidCandidate(
|
|
"Moved coordinates exceed the model bounds.".into(),
|
|
));
|
|
}
|
|
deltas.insert(*id, delta);
|
|
if node != original {
|
|
commands.push(Command::EditNode {
|
|
diagram: diagram.id,
|
|
original: *id,
|
|
node: node.clone(),
|
|
});
|
|
}
|
|
}
|
|
// Resolve endpoints using the captured accepted semantics, not a newly
|
|
// regrouped descendant walk. Own-edge deletions were removed above already.
|
|
for route in projection::translated_routes(&plan.accepted, &plan.scope.diagram, &deltas) {
|
|
if let Some(existing) = diagram.routes.iter_mut().find(|r| r.edge == route.edge) {
|
|
if route.waypoints.iter().any(|p| {
|
|
!p.x.is_finite()
|
|
|| !p.y.is_finite()
|
|
|| p.x.abs() > MAX_COORDINATE
|
|
|| p.y.abs() > MAX_COORDINATE
|
|
}) {
|
|
return Err(Refusal::InvalidCandidate(
|
|
"Moved route exceeds the model bounds.".into(),
|
|
));
|
|
}
|
|
*existing = route.clone();
|
|
commands.push(Command::SetEdgeRoute {
|
|
diagram: diagram.id,
|
|
route,
|
|
});
|
|
}
|
|
}
|
|
let mut unfolded = None;
|
|
if let Destination::Performer(performer) = plan.destination {
|
|
let target = presentation.target.ok_or_else(|| {
|
|
Refusal::LayoutRequired("A visible accepted performer target is required.".into())
|
|
})?;
|
|
let node = diagram
|
|
.nodes
|
|
.get_mut(&target.placement)
|
|
.ok_or(Refusal::StaleScope)?;
|
|
let visible_target = plan
|
|
.before_visible
|
|
.nodes
|
|
.iter()
|
|
.any(|n| n.id == target.placement && n.element == performer);
|
|
if node.element != performer || !visible_target {
|
|
return Err(Refusal::LayoutRequired(
|
|
"Make room or adjust the view, then drag again.".into(),
|
|
));
|
|
}
|
|
if node.collapsed && !plan.commands.is_empty() {
|
|
node.collapsed = false;
|
|
unfolded = Some(node.id);
|
|
commands.push(Command::EditNode {
|
|
diagram: diagram.id,
|
|
original: node.id,
|
|
node: node.clone(),
|
|
});
|
|
}
|
|
} else if presentation.target.is_some() {
|
|
return Err(Refusal::Ineligible(
|
|
"This layout/outside destination has no performer target.".into(),
|
|
));
|
|
}
|
|
let view = projection::project_diagram_with_index(&plan.candidate, &diagram, &plan.index);
|
|
let expanded = expanded_view(&plan.candidate, &diagram, &plan.scope, &plan.index);
|
|
check_geometry(plan, &view, &expanded, delta)?;
|
|
let selected = view
|
|
.nodes
|
|
.iter()
|
|
.find(|n| n.id == plan.scope.placement)
|
|
.ok_or_else(|| {
|
|
Refusal::LayoutRequired("The selected work header would be hidden.".into())
|
|
})?;
|
|
let header = Rect {
|
|
position: selected.position,
|
|
size: Size {
|
|
width: selected.size.width,
|
|
height: selected.size.height.min(62.),
|
|
},
|
|
};
|
|
if !presentation.viewport.contains(header) {
|
|
return Err(Refusal::LayoutRequired(
|
|
"Make room or adjust the view, then drag again.".into(),
|
|
));
|
|
}
|
|
// Destination identity lives in a fixed toolbar slot. Frozen hit geometry
|
|
// and its outline never introduce an opaque label over this work header.
|
|
Ok(PlacementPlan {
|
|
diagram,
|
|
view,
|
|
delta,
|
|
unfolded,
|
|
requested,
|
|
presentation,
|
|
commands,
|
|
})
|
|
}
|
|
|
|
/// Final semantic/presentation equality gate, after the App has checked its
|
|
/// current token, owner, revision, clean drafts, frozen target and transform.
|
|
/// Recompute geometry to avoid accepting a modified/stale placement result.
|
|
/// None means a snapped no-op: the caller must not execute or add history.
|
|
pub fn finish(
|
|
plan: &SemanticPlan,
|
|
live: &Project,
|
|
placement: &PlacementPlan,
|
|
) -> Result<Option<Command>, Refusal> {
|
|
if live != &plan.accepted {
|
|
return Err(Refusal::StaleScope);
|
|
}
|
|
let checked = place(plan, placement.requested, placement.presentation)?;
|
|
if checked.diagram != placement.diagram
|
|
|| checked.view != placement.view
|
|
|| checked.delta != placement.delta
|
|
|| checked.unfolded != placement.unfolded
|
|
|| checked.commands != placement.commands
|
|
{
|
|
return Err(Refusal::StaleScope);
|
|
}
|
|
let mut expected = plan.candidate.clone();
|
|
expected
|
|
.diagrams
|
|
.insert(checked.diagram.id, checked.diagram);
|
|
let mut commands = plan.commands.clone();
|
|
commands.extend(checked.commands);
|
|
let command = Command::Batch(commands);
|
|
let actual = prepare_command(live, &command)
|
|
.map_err(|e| Refusal::InvalidCandidate(e.to_string()))?
|
|
.project;
|
|
exact_project(&expected, &actual)?;
|
|
Ok((actual != *live).then_some(command))
|
|
}
|
|
|
|
fn expanded_view(
|
|
p: &Project,
|
|
diagram: &Diagram,
|
|
scope: &Scope,
|
|
index: &ViewIndex,
|
|
) -> ProjectedView {
|
|
let mut expanded = diagram.clone();
|
|
for id in scope.placements.keys() {
|
|
if let Some(node) = expanded.nodes.get_mut(id) {
|
|
node.collapsed = false;
|
|
}
|
|
}
|
|
projection::project_diagram_with_index(p, &expanded, index)
|
|
}
|
|
|
|
fn ancestors(view: &ProjectedView) -> BTreeMap<Id, BTreeSet<Id>> {
|
|
let parents: BTreeMap<_, _> = view.nodes.iter().map(|n| (n.id, n.visual_parent)).collect();
|
|
parents
|
|
.keys()
|
|
.map(|node| {
|
|
let mut current = parents[node];
|
|
let mut seen = BTreeSet::new();
|
|
while let Some(id) = current {
|
|
if !seen.insert(id) {
|
|
break;
|
|
}
|
|
current = parents.get(&id).copied().flatten();
|
|
}
|
|
(*node, seen)
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
fn coherent(scope: &Scope, view: &ProjectedView) -> bool {
|
|
let ancestors = ancestors(view);
|
|
scope.placements.keys().all(|id| {
|
|
ancestors
|
|
.get(id)
|
|
.is_some_and(|parents| *id == scope.placement || parents.contains(&scope.placement))
|
|
})
|
|
}
|
|
|
|
fn overlap(a: &ProjectedNode, b: &ProjectedNode) -> f32 {
|
|
let width = (a.position.x + a.size.width).min(b.position.x + b.size.width)
|
|
- a.position.x.max(b.position.x);
|
|
let height = (a.position.y + a.size.height).min(b.position.y + b.size.height)
|
|
- a.position.y.max(b.position.y);
|
|
width.max(0.) * height.max(0.)
|
|
}
|
|
|
|
fn overlaps(before: &ProjectedView, after: &ProjectedView) -> bool {
|
|
// Build geometry ancestry once, avoiding a repeated descendant walk for
|
|
// every pair during pointer motion. Pairwise collision checking is bounded
|
|
// to these two projected scenes and does not traverse/clone model semantics.
|
|
let before_ancestors = ancestors(before);
|
|
let after_ancestors = ancestors(after);
|
|
let prior_nodes: BTreeMap<_, _> = before.nodes.iter().map(|n| (n.id, n)).collect();
|
|
for (i, a) in after.nodes.iter().enumerate() {
|
|
for b in &after.nodes[i + 1..] {
|
|
if after_ancestors[&a.id].contains(&b.id) || after_ancestors[&b.id].contains(&a.id) {
|
|
continue;
|
|
}
|
|
let prior = match (prior_nodes.get(&a.id), prior_nodes.get(&b.id)) {
|
|
(Some(x), Some(y))
|
|
if !before_ancestors[&x.id].contains(&y.id)
|
|
&& !before_ancestors[&y.id].contains(&x.id) =>
|
|
{
|
|
overlap(x, y)
|
|
}
|
|
_ => 0.,
|
|
};
|
|
if overlap(a, b) > prior + 0.01 {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
false
|
|
}
|
|
|
|
fn check_geometry(
|
|
plan: &SemanticPlan,
|
|
visible: &ProjectedView,
|
|
expanded: &ProjectedView,
|
|
delta: Position,
|
|
) -> Result<(), Refusal> {
|
|
if visible.nodes.iter().chain(&expanded.nodes).any(|n| {
|
|
!(Rect {
|
|
position: n.position,
|
|
size: n.size,
|
|
})
|
|
.valid()
|
|
}) {
|
|
return Err(Refusal::InvalidCandidate(
|
|
"The projected enclosure exceeds the model bounds.".into(),
|
|
));
|
|
}
|
|
if plan.scope.work_records.len() > 1 {
|
|
if !coherent(&plan.scope, expanded) {
|
|
return Err(Refusal::MixedLayoutRequired);
|
|
}
|
|
for id in plan.scope.placements.keys() {
|
|
let old = plan
|
|
.before_expanded
|
|
.nodes
|
|
.iter()
|
|
.find(|n| n.id == *id)
|
|
.ok_or(Refusal::MixedLayoutRequired)?;
|
|
let new = expanded
|
|
.nodes
|
|
.iter()
|
|
.find(|n| n.id == *id)
|
|
.ok_or(Refusal::MixedLayoutRequired)?;
|
|
if (new.position.x - old.position.x - delta.x).abs() > 0.01
|
|
|| (new.position.y - old.position.y - delta.y).abs() > 0.01
|
|
|| (new.size.width - old.size.width).abs() > 0.01
|
|
|| (new.size.height - old.size.height).abs() > 0.01
|
|
{
|
|
return Err(Refusal::LayoutRequired("This work subtree requires an explicit layout; its footprint cannot be translated unchanged.".into()));
|
|
}
|
|
}
|
|
}
|
|
if overlaps(&plan.before_visible, visible) || overlaps(&plan.before_expanded, expanded) {
|
|
return Err(Refusal::LayoutRequired("Make room before moving work: the candidate would introduce or enlarge overlapping cards.".into()));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Compare complete records, not just removed IDs. Deleting an Allocation can
|
|
/// rewrite a surviving Constraint, remove artifacts/traces or prune view options.
|
|
fn exact_project(expected: &Project, actual: &Project) -> Result<(), Refusal> {
|
|
if expected == actual {
|
|
return Ok(());
|
|
}
|
|
let mut records = Vec::new();
|
|
fn changes<T: PartialEq>(
|
|
expected: &BTreeMap<Id, T>,
|
|
actual: &BTreeMap<Id, T>,
|
|
category: &'static str,
|
|
project: &Project,
|
|
other: &Project,
|
|
records: &mut Vec<ChangedRecord>,
|
|
) {
|
|
let ids: BTreeSet<_> = expected.keys().chain(actual.keys()).copied().collect();
|
|
for id in ids {
|
|
if expected.get(&id) != actual.get(&id) {
|
|
records.push(ChangedRecord {
|
|
id,
|
|
name: if project.contains(id) {
|
|
project.named(id)
|
|
} else {
|
|
other.named(id)
|
|
}
|
|
.into(),
|
|
category,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
changes(
|
|
&expected.elements,
|
|
&actual.elements,
|
|
"element",
|
|
expected,
|
|
actual,
|
|
&mut records,
|
|
);
|
|
changes(
|
|
&expected.relations,
|
|
&actual.relations,
|
|
"relation",
|
|
expected,
|
|
actual,
|
|
&mut records,
|
|
);
|
|
changes(
|
|
&expected.diagrams,
|
|
&actual.diagrams,
|
|
"diagram",
|
|
expected,
|
|
actual,
|
|
&mut records,
|
|
);
|
|
changes(
|
|
&expected.artifact_links,
|
|
&actual.artifact_links,
|
|
"artifact",
|
|
expected,
|
|
actual,
|
|
&mut records,
|
|
);
|
|
changes(
|
|
&expected.traces,
|
|
&actual.traces,
|
|
"trace",
|
|
expected,
|
|
actual,
|
|
&mut records,
|
|
);
|
|
if expected.schema_version != actual.schema_version
|
|
|| expected.id != actual.id
|
|
|| expected.alias != actual.alias
|
|
|| expected.name != actual.name
|
|
|| expected.description != actual.description
|
|
{
|
|
records.push(ChangedRecord {
|
|
id: expected.id,
|
|
name: expected.name.clone(),
|
|
category: "project",
|
|
});
|
|
}
|
|
Err(Refusal::CollateralChangeRequired(records))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests;
|