mirror of https://codeberg.org/topola/topola.git
110 lines
3.1 KiB
Rust
110 lines
3.1 KiB
Rust
// SPDX-FileCopyrightText: 2024 Topola contributors
|
|
//
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
use std::ops::ControlFlow;
|
|
|
|
use spade::InsertionError;
|
|
|
|
use crate::{
|
|
autorouter::{
|
|
execution::Command,
|
|
history::History,
|
|
invoker::{Invoker, InvokerError},
|
|
Autorouter,
|
|
},
|
|
board::{AccessMesadata, Board},
|
|
interactor::activity::{
|
|
ActivityContext, ActivityError, ActivityStepperWithStatus, InteractiveInput,
|
|
},
|
|
stepper::{Abort, Step},
|
|
};
|
|
|
|
/// Structure that manages the invoker and activities
|
|
pub struct Interactor<M> {
|
|
invoker: Invoker<M>,
|
|
activity: Option<ActivityStepperWithStatus>,
|
|
}
|
|
|
|
impl<M: AccessMesadata> Interactor<M> {
|
|
/// Create a new instance of Interactor with the given Board instance
|
|
pub fn new(board: Board<M>) -> Result<Self, InsertionError> {
|
|
Ok(Self {
|
|
invoker: Invoker::new(Autorouter::new(board)?),
|
|
activity: None,
|
|
})
|
|
}
|
|
|
|
/// Execute a command
|
|
pub fn execute(&mut self, command: Command) -> Result<(), InvokerError> {
|
|
self.invoker.execute(command)
|
|
}
|
|
|
|
/// Start executing an activity
|
|
pub fn schedule(&mut self, command: Command) -> Result<(), InvokerError> {
|
|
self.activity = Some(ActivityStepperWithStatus::new_execution(
|
|
self.invoker.execute_stepper(command)?,
|
|
));
|
|
Ok(())
|
|
}
|
|
|
|
/// Undo last command
|
|
pub fn undo(&mut self) -> Result<(), InvokerError> {
|
|
self.invoker.undo()
|
|
}
|
|
|
|
/// Redo last command
|
|
pub fn redo(&mut self) -> Result<(), InvokerError> {
|
|
self.invoker.redo()
|
|
}
|
|
|
|
/// Abort the currently running execution or activity
|
|
pub fn abort(&mut self) {
|
|
if let Some(ref mut activity) = self.activity {
|
|
activity.abort(&mut ActivityContext::<M> {
|
|
interactive_input: &InteractiveInput {
|
|
pointer_pos: [0.0, 0.0].into(),
|
|
dt: 0.0,
|
|
},
|
|
invoker: &mut self.invoker,
|
|
});
|
|
}
|
|
}
|
|
|
|
/// Replay last command
|
|
pub fn replay(&mut self, history: History) {
|
|
self.invoker.replay(history);
|
|
}
|
|
|
|
/// Update the currently running execution or activity
|
|
pub fn update(
|
|
&mut self,
|
|
interactive_input: &InteractiveInput,
|
|
) -> ControlFlow<Result<(), ActivityError>> {
|
|
if let Some(ref mut activity) = self.activity {
|
|
return match activity.step(&mut ActivityContext {
|
|
interactive_input,
|
|
invoker: &mut self.invoker,
|
|
}) {
|
|
Ok(ControlFlow::Continue(())) => ControlFlow::Continue(()),
|
|
Ok(ControlFlow::Break(msg)) => ControlFlow::Break(Ok(())),
|
|
Err(err) => {
|
|
self.activity = None;
|
|
ControlFlow::Break(Err(err))
|
|
}
|
|
};
|
|
}
|
|
ControlFlow::Break(Ok(()))
|
|
}
|
|
|
|
/// Returns the invoker
|
|
pub fn invoker(&self) -> &Invoker<M> {
|
|
&self.invoker
|
|
}
|
|
|
|
/// Returns the currently running activity
|
|
pub fn maybe_activity(&self) -> &Option<ActivityStepperWithStatus> {
|
|
&self.activity
|
|
}
|
|
}
|