ARCADIA-Studio/crates/oa-desktop/src/diagram/work_drag.rs

use super::*;
use crate::app::allocation_drag::{self as input, Event, Press, Stamp};

impl DiagramCanvas<'_> {
    pub(crate) fn work_dirty_point(&self, bounds: Rectangle, screen: Point) -> bool {
        let diagram = &self.project.diagrams[&self.diagram];
        let view = self.projected(diagram);
        let routed = routing::route_diagram(self.project, diagram, &view);
        self.work_dirty_press(
            &view,
            &routed,
            Point::new(screen.x - bounds.x, screen.y - bounds.y),
        )
    }
    pub(super) fn work_preview(&self) -> Option<&Arc<input::Preview>> {
        let capability = self.allocation?;
        let feedback = capability.state.feedback.as_ref()?;
        (capability.clean
            && feedback.press.stamp.context == self.context
            && feedback.press.stamp.epoch == capability.state.epoch
            && feedback.press.stamp.pan == self.pan
            && feedback.press.stamp.zoom == self.zoom)
            .then_some(capability.state.preview.as_ref())
            .flatten()
    }
    pub(super) fn work_eligible(&self, placement: Id) -> bool {
        self.allocation.is_some()
            && self.project.diagrams[&self.diagram].projection == ProjectionKind::Allocation
            && self.project.diagrams[&self.diagram]
                .nodes
                .get(&placement)
                .and_then(|n| self.project.elements.get(&n.element))
                .is_some_and(|e| e.kind().is_work())
    }
    pub(super) fn work_dirty_press(
        &self,
        view: &ProjectedView,
        routed: &RoutedView,
        local: Point,
    ) -> bool {
        self.allocation.is_some_and(|c| !c.clean)
            && !self.placing
            && self.connection.is_none()
            && self.project.diagrams[&self.diagram].projection == ProjectionKind::Allocation
            && (self.hit(view, local).is_some()
                || self.hit_port(view, local).is_some()
                || self.hit_edge(routed, local).is_some()
                || self.hit_label(routed, local).is_some()
                || self.hit_association_label(routed, local).is_some())
    }
    pub(super) fn begin_work(
        &self,
        state: &mut State,
        node: Id,
        screen: Point,
        bounds: Rectangle,
        view: &ProjectedView,
        routed: &RoutedView,
    ) -> Action<Message> {
        let capability = self.allocation.unwrap();
        state.drag = None;
        state.preview = None;
        state.port_drag = None;
        state.route_drag = None;
        if !capability.clean {
            return Action::publish(Message::WorkDrag(Event::Refused(
                capability.state.epoch,
                input::FINISH_EDIT.into(),
            )))
            .and_capture();
        }
        let work = self.project.diagrams[&self.diagram].nodes[&node].element;
        let scope = match crate::allocation_drag::capture(self.project, self.diagram, work, node) {
            Ok(scope) => scope,
            Err(reason) => {
                return Action::publish(Message::WorkDrag(Event::Refused(
                    capability.state.epoch,
                    input::refusal(&reason),
                )))
                .and_capture();
            }
        };
        let frozen = input::Frozen::capture(self.project, &scope, view, routed, self.zoom);
        let press = Arc::new(Press {
            stamp: Stamp {
                context: self.context,
                epoch: capability.state.epoch,
                snapshot: capability.snapshot,
                bounds,
                pan: self.pan,
                zoom: self.zoom,
            },
            token: Id::new_v4(),
            start: screen,
            scope,
            frozen,
            arrange: capability.state.arrange_next,
        });
        state.work = Some(press.clone());
        Action::publish(Message::WorkDrag(Event::Press(press))).and_capture()
    }
    pub(super) fn work_lifetime(
        &self,
        state: &mut State,
        event: &canvas::Event,
        bounds: Rectangle,
    ) -> Option<Action<Message>> {
        let press = state.work.as_ref()?;
        let cancel = self
            .allocation
            .is_none_or(|c| !c.clean || c.state.epoch != press.stamp.epoch)
            || press.stamp.context != self.context
            || press.stamp.bounds != bounds
            || press.stamp.pan != self.pan
            || press.stamp.zoom != self.zoom
            || matches!(
                event,
                canvas::Event::Window(iced::window::Event::Unfocused)
                    | canvas::Event::Mouse(mouse::Event::CursorLeft)
                    | canvas::Event::Mouse(mouse::Event::ButtonPressed(
                        mouse::Button::Middle | mouse::Button::Right
                    ))
                    | canvas::Event::Mouse(mouse::Event::WheelScrolled { .. })
            )
            || matches!(event, canvas::Event::Keyboard(iced::keyboard::Event::KeyPressed { key, .. })
                if *key == iced::keyboard::Key::Named(iced::keyboard::key::Named::Escape));
        if cancel {
            let token = press.token;
            state.work = None;
            state.pointer = None;
            return Some(Action::publish(Message::WorkDrag(Event::Cancel(token))).and_capture());
        }
        None
    }
}

/// Passive frozen target outlines. Destination identity is in the toolbar so
/// feedback cannot cover candidate text or change the target hit geometry.
pub struct WorkFeedback<'a>(pub DiagramCanvas<'a>);
impl canvas::Program<Message> for WorkFeedback<'_> {
    type State = ();
    fn draw(
        &self,
        _: &(),
        renderer: &Renderer,
        _: &Theme,
        bounds: Rectangle,
        _: mouse::Cursor,
    ) -> Vec<canvas::Geometry> {
        let Some(capability) = self.0.allocation else {
            return vec![];
        };
        let Some(feedback) = &capability.state.feedback else {
            return vec![];
        };
        if feedback.press.stamp.epoch != capability.state.epoch
            || feedback.press.stamp.context != self.0.context
            || feedback.press.stamp.bounds != bounds
        {
            return vec![];
        }
        let mut frame = Frame::new(renderer, bounds.size());
        let color = if feedback.refused {
            Color::from_rgb8(173, 66, 41)
        } else {
            style::TEAL
        };
        for index in &feedback.targets {
            let target = &feedback.press.frozen.targets[*index];
            let region = target.region;
            let top = Point::new(
                region.x * self.0.zoom + self.0.pan.x,
                region.y * self.0.zoom + self.0.pan.y,
            );
            frame.stroke(
                &Path::rectangle(
                    top,
                    iced::Size::new(region.width * self.0.zoom, region.height * self.0.zoom),
                ),
                Stroke::default().with_color(color).with_width(3.),
            );
        }
        vec![frame.into_geometry()]
    }
}