use crate::manipulate::{HandleKind, drag_coalesce_key};
use indicatrix::geometry::meet_solver::MeetConstraint;
use indicatrix_cut_core::{
ConstraintTier, Design, Edit, EditError, FreshDesignSpec, History, OptimizeOutcome, PreformSpec,
};
use std::{
collections::BTreeSet,
sync::{
Arc,
atomic::{AtomicU64, Ordering},
},
time::Duration,
};
mod history_view;
mod relations;
mod selection;
mod tier_ops;
#[cfg(test)]
mod tests;
pub use selection::TierIndexMap;
pub use history_view::{HistorySnapshot, JumpFailure, JumpOutcome};
pub use relations::{ClearedRelation, RelationNotice, RelationRefusal, SessionEditError};
pub use tier_ops::{
DetachOutcome, DuplicateOutcome, GeneratedSeries, InlineAngle, MirrorOutcome, MovedTier,
RemoveTierError, RemovedTier, selection_after_remove,
};
pub const ANGLE_NUDGE_COALESCE_WINDOW: Duration = Duration::from_millis(1500);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct EditChange {
pub generation: u64,
pub tier_count_before: usize,
pub tier_count_after: usize,
pub concave_count_before: usize,
pub concave_count_after: usize,
}
impl EditChange {
#[must_use]
pub const fn tier_count_changed(&self) -> bool {
self.tier_count_before != self.tier_count_after
}
#[must_use]
pub const fn concave_count_changed(&self) -> bool {
self.concave_count_before != self.concave_count_after
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NudgeOutcome {
pub change: EditChange,
pub clamped_labels: Vec<String>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct PinOutcome {
pub change: EditChange,
pub replaced_meet: Option<MeetConstraint>,
}
pub struct EditorSession {
pub design: Design,
pub history: History,
pub multi_selected: BTreeSet<usize>,
pub selected_concave: Option<usize>,
pub generation: Arc<AtomicU64>,
pub saved_generation: u64,
relation_notice: Option<RelationNotice>,
notice_command_open: bool,
refusal: Option<SessionEditError>,
}
impl EditorSession {
#[must_use]
pub fn fresh() -> Self {
let preform = PreformSpec::cylinder(96, 1.5, 1.0, 1.5);
Self::with_history(
Design::fresh(preform, 96, 8, 1.54),
History::with_coalesce_window(ANGLE_NUDGE_COALESCE_WINDOW),
)
}
#[must_use]
pub fn from_spec(spec: FreshDesignSpec) -> Self {
Self::with_history(
Design::fresh_from_spec(spec),
History::with_coalesce_window(ANGLE_NUDGE_COALESCE_WINDOW),
)
}
#[must_use]
pub fn from_template(spec: FreshDesignSpec, template_index: i32) -> Self {
let mut session = Self::from_spec(spec);
if let Some(tiers) = template_tiers(template_index) {
session.design.tiers = tiers;
session.design.ensure_tier_ids();
}
session
}
#[must_use]
pub fn with_history(design: Design, history: History) -> Self {
Self {
design,
history,
multi_selected: BTreeSet::new(),
selected_concave: None,
generation: Arc::new(AtomicU64::new(0)),
saved_generation: 0,
relation_notice: None,
notice_command_open: false,
refusal: None,
}
}
#[must_use]
pub fn current_generation(&self) -> u64 {
self.generation.load(Ordering::Relaxed)
}
pub fn continue_generation_from(&mut self, previous: &Self) {
self.generation = Arc::clone(&previous.generation);
let now = self.generation.fetch_add(1, Ordering::Relaxed) + 1;
self.saved_generation = now;
}
pub fn replace_with(&mut self, mut replacement: Self) {
replacement.continue_generation_from(self);
*self = replacement;
}
#[must_use]
pub fn is_dirty(&self) -> bool {
self.generation.load(Ordering::Relaxed) != self.saved_generation
}
pub fn mark_saved(&mut self) {
self.saved_generation = self.current_generation();
}
pub fn apply(&mut self, edit: Edit) -> Result<EditChange, EditError> {
self.try_apply(edit)
.map_err(|error| self.legacy_edit_error(error))
}
pub fn apply_coalescing(
&mut self,
edit: Edit,
key: u64,
now: Duration,
) -> Result<EditChange, EditError> {
self.try_apply_coalescing(edit, key, now)
.map_err(|error| self.legacy_edit_error(error))
}
pub fn undo(&mut self) -> Result<Option<EditChange>, EditError> {
Ok(self.undo_mapped()?.map(|(change, _)| change))
}
pub fn undo_mapped(&mut self) -> Result<Option<(EditChange, TierIndexMap)>, EditError> {
self.expire_relation_notice();
let before = self.tier_counts();
let renumbering = self.history.peek_undo().map(TierIndexMap::of);
let undone = self.history.undo(&mut self.design)?;
Ok(undone.then(|| {
let change = self.record_change(before, renumbering.as_ref());
(change, renumbering.unwrap_or_default())
}))
}
pub fn redo(&mut self) -> Result<Option<EditChange>, EditError> {
Ok(self.redo_mapped()?.map(|(change, _)| change))
}
pub fn redo_mapped(&mut self) -> Result<Option<(EditChange, TierIndexMap)>, EditError> {
self.expire_relation_notice();
let before = self.tier_counts();
let renumbering = self.history.peek_redo().map(TierIndexMap::of);
let redone = self.history.redo(&mut self.design)?;
Ok(redone.then(|| {
let change = self.record_change(before, renumbering.as_ref());
(change, renumbering.unwrap_or_default())
}))
}
pub fn apply_optimize_outcome(
&mut self,
outcome: &OptimizeOutcome,
) -> Result<usize, EditError> {
if !self.design.tier_relations.is_empty() {
return self.apply_optimize_outcome_with_relations(outcome);
}
let result = indicatrix_cut_core::apply_optimize_outcome(
&mut self.history,
&mut self.design,
outcome,
);
match &result {
Ok(0) => {}
Ok(_) | Err(_) => {
self.generation.fetch_add(1, Ordering::Relaxed);
}
}
result
}
pub fn nudge_angles(
&mut self,
targets: &[usize],
delta_deg: f64,
now: Duration,
) -> Result<Option<NudgeOutcome>, EditError> {
self.nudge_with(targets, now, |_| delta_deg)
}
pub fn nudge_displayed_angles(
&mut self,
targets: &[usize],
delta_deg: f64,
now: Duration,
) -> Result<Option<NudgeOutcome>, EditError> {
self.nudge_with(targets, now, |tier| {
displayed_nudge_delta(tier.angle_deg, delta_deg)
})
}
fn nudge_with(
&mut self,
targets: &[usize],
now: Duration,
delta_for: impl Fn(&ConstraintTier) -> f64,
) -> Result<Option<NudgeOutcome>, EditError> {
let mut clamped_labels: Vec<String> = Vec::new();
let changes: Option<Vec<(usize, f64, f64)>> = targets
.iter()
.map(|&index| {
self.design.tiers.get(index).map(|tier| {
let wanted = tier.angle_deg + delta_for(tier);
let nudged = clamp_nudge_to_side(tier.angle_deg, wanted);
if nudged != wanted {
clamped_labels.push(tier_nudge_label(tier, index));
}
(index, tier.angle_deg, nudged)
})
})
.collect();
let Some(changes) = changes else {
return Ok(None);
};
if changes.is_empty() {
return Ok(None);
}
let key = angle_nudge_coalesce_key(targets);
let change = self.apply_coalescing(Edit::RetargetAngles { changes }, key, now)?;
Ok(Some(NudgeOutcome {
change,
clamped_labels,
}))
}
pub fn set_tier_angle(
&mut self,
tier: usize,
angle_deg: f64,
now: Duration,
) -> Result<Option<EditChange>, EditError> {
let Some(current) = self.design.tiers.get(tier) else {
return Ok(None);
};
let old = current.angle_deg;
let new = clamp_nudge_to_side(old, angle_deg);
if !new.is_finite() || new.to_bits() == old.to_bits() {
return Ok(None);
}
let key = drag_coalesce_key(tier, HandleKind::Angle);
let edit = Edit::RetargetAngles {
changes: vec![(tier, old, new)],
};
self.apply_coalescing(edit, key, now).map(Some)
}
pub fn pin_tier_mast(
&mut self,
tier: usize,
mast: f64,
now: Duration,
) -> Result<Option<PinOutcome>, EditError> {
let Some(current) = self.design.tiers.get(tier) else {
return Ok(None);
};
if !mast.is_finite() {
return Ok(None);
}
let previous = current.constraint.clone();
if matches!(&previous, MeetConstraint::ScaleReference(m) if m.to_bits() == mast.to_bits()) {
return Ok(None);
}
let replaced_meet =
(!matches!(previous, MeetConstraint::ScaleReference(_))).then_some(previous);
let key = drag_coalesce_key(tier, HandleKind::Depth);
let edit = Edit::SetConstraint {
index: tier,
constraint: MeetConstraint::ScaleReference(mast),
};
let change = self.apply_coalescing(edit, key, now)?;
Ok(Some(PinOutcome {
change,
replaced_meet,
}))
}
pub fn rotate_tier_indices(
&mut self,
tier: usize,
k_teeth: i64,
now: Duration,
) -> Result<Option<EditChange>, EditError> {
if k_teeth == 0 {
return Ok(None);
}
let edit = self.design.rotate_indices(tier, k_teeth as f64)?;
let key = drag_coalesce_key(tier, HandleKind::Index);
self.apply_coalescing(edit, key, now).map(Some)
}
pub fn complete_orbit(&mut self, index: usize) -> Result<bool, EditError> {
let Ok(units) = self.design.orbit_units(index) else {
return Ok(false);
};
let anchors: Vec<f64> = units
.iter()
.filter(|unit| !unit.is_complete())
.filter_map(|unit| unit.members.first().copied())
.collect();
if anchors.is_empty() {
return Ok(false);
}
let mut last_err = None;
for position in anchors {
let outcome = self
.design
.add_orbit_member(index, position)
.and_then(|edit| self.apply(edit));
if let Err(e) = outcome {
last_err = Some(e);
}
}
last_err.map_or(Ok(true), Err)
}
pub fn mirror_indices(&mut self, index: usize) -> Result<EditChange, EditError> {
self.design
.mirror_indices(index)
.and_then(|edit| self.apply(edit))
}
fn record_change(
&mut self,
(tier_count_before, concave_count_before): (usize, usize),
renumbering: Option<&TierIndexMap>,
) -> EditChange {
let generation = self.generation.fetch_add(1, Ordering::Relaxed) + 1;
self.renumber_selection(renumbering);
let (tier_count_after, concave_count_after) = self.tier_counts();
EditChange {
generation,
tier_count_before,
tier_count_after,
concave_count_before,
concave_count_after,
}
}
fn renumber_selection(&mut self, renumbering: Option<&TierIndexMap>) {
let (tier_count_after, concave_count_after) = self.tier_counts();
self.selected_concave = renumbering
.and_then(|map| map.map_concave(self.selected_concave?))
.filter(|&index| index < concave_count_after);
self.multi_selected = renumbering.map_or_else(BTreeSet::new, |map| {
map.remap(&self.multi_selected)
.into_iter()
.filter(|&index| index < tier_count_after)
.collect()
});
}
const fn tier_counts(&self) -> (usize, usize) {
(self.design.tiers.len(), self.design.concave_tiers.len())
}
}
#[must_use]
pub fn template_tiers(template_index: i32) -> Option<Vec<ConstraintTier>> {
usize::try_from(template_index - 1)
.ok()
.and_then(|table_index| indicatrix_cut_core::templates::TEMPLATES.get(table_index))
.map(indicatrix_cut_core::templates::TemplateSpec::tiers)
}
#[must_use]
pub const fn clamp_nudge_to_side(current: f64, nudged: f64) -> f64 {
if current.is_sign_negative() == nudged.is_sign_negative() {
return nudged;
}
if current.is_sign_negative() {
-0.0
} else {
0.0
}
}
#[must_use]
pub const fn displayed_nudge_delta(current: f64, displayed_delta: f64) -> f64 {
if current.is_sign_negative() {
-displayed_delta
} else {
displayed_delta
}
}
#[must_use]
pub fn tier_nudge_label(tier: &ConstraintTier, index: usize) -> String {
if tier.name.is_empty() {
format!("tier {}", index + 1)
} else {
format!("tier {} ({})", index + 1, tier.name)
}
}
#[must_use]
pub const fn result_is_stale(result_generation: Option<u64>, current_generation: u64) -> bool {
match result_generation {
Some(g) => g != current_generation,
None => false,
}
}
#[must_use]
pub fn angle_nudge_coalesce_key(targets: &[usize]) -> u64 {
use std::hash::{Hash, Hasher};
let mut sorted = targets.to_vec();
sorted.sort_unstable();
sorted.dedup();
let mut hasher = std::collections::hash_map::DefaultHasher::new();
sorted.len().hash(&mut hasher);
for value in &sorted {
value.hash(&mut hasher);
}
hasher.finish()
}