1486 lines
54 KiB
Rust
1486 lines
54 KiB
Rust
use arc_swap::ArcSwap;
|
|
use parking_lot::Mutex;
|
|
use rand::rngs::StdRng;
|
|
use rand::SeedableRng;
|
|
use std::collections::HashMap;
|
|
use std::path::PathBuf;
|
|
use std::sync::{Arc, LazyLock};
|
|
|
|
use cagire_ratatui::CompletionCandidate;
|
|
|
|
use crossbeam_channel::Sender;
|
|
|
|
use crate::commands::AppCommand;
|
|
use crate::engine::{
|
|
LinkState, PatternChange, PatternSnapshot, SeqCommand, SequencerSnapshot, StepSnapshot,
|
|
};
|
|
use crate::midi::MidiState;
|
|
use crate::model::{self, Bank, Dictionary, Pattern, Rng, ScriptEngine, StepContext, Variables};
|
|
use crate::page::Page;
|
|
use crate::services::{clipboard, dict_nav, euclidean, help_nav, pattern_editor};
|
|
use crate::settings::Settings;
|
|
use crate::state::{
|
|
AudioSettings, CyclicEnum, EditorContext, EditorTarget, FlashKind, LiveKeyState, Metrics,
|
|
Modal, MuteState, OptionsState, PanelState, PatternField, PatternPropsField, PatternsNav,
|
|
PlaybackState, ProjectState, SampleTree, StagedChange, StagedPropChange, UiState,
|
|
};
|
|
|
|
const STEPS_PER_PAGE: usize = 32;
|
|
|
|
static COMPLETION_CANDIDATES: LazyLock<Vec<CompletionCandidate>> = LazyLock::new(|| {
|
|
model::WORDS
|
|
.iter()
|
|
.map(|w| CompletionCandidate {
|
|
name: w.name.to_string(),
|
|
signature: w.stack.to_string(),
|
|
description: w.desc.to_string(),
|
|
example: w.example.to_string(),
|
|
})
|
|
.collect()
|
|
});
|
|
|
|
pub struct App {
|
|
pub project_state: ProjectState,
|
|
pub ui: UiState,
|
|
pub playback: PlaybackState,
|
|
pub mute: MuteState,
|
|
|
|
pub page: Page,
|
|
pub editor_ctx: EditorContext,
|
|
|
|
pub patterns_nav: PatternsNav,
|
|
|
|
pub metrics: Metrics,
|
|
pub script_engine: ScriptEngine,
|
|
pub variables: Variables,
|
|
pub dict: Dictionary,
|
|
#[allow(dead_code)] // kept alive for ScriptEngine's Arc clone
|
|
pub rng: Rng,
|
|
pub live_keys: Arc<LiveKeyState>,
|
|
pub clipboard: Option<arboard::Clipboard>,
|
|
pub copied_patterns: Option<Vec<Pattern>>,
|
|
pub copied_banks: Option<Vec<Bank>>,
|
|
|
|
pub audio: AudioSettings,
|
|
pub options: OptionsState,
|
|
pub panel: PanelState,
|
|
pub midi: MidiState,
|
|
}
|
|
|
|
impl Default for App {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl App {
|
|
pub fn new() -> Self {
|
|
let variables = Arc::new(ArcSwap::from_pointee(HashMap::new()));
|
|
let dict = Arc::new(Mutex::new(HashMap::new()));
|
|
let rng = Arc::new(Mutex::new(StdRng::seed_from_u64(0)));
|
|
let script_engine =
|
|
ScriptEngine::new(Arc::clone(&variables), Arc::clone(&dict), Arc::clone(&rng));
|
|
let live_keys = Arc::new(LiveKeyState::new());
|
|
|
|
Self {
|
|
project_state: ProjectState::default(),
|
|
ui: UiState::default(),
|
|
playback: PlaybackState::default(),
|
|
mute: MuteState::default(),
|
|
|
|
page: Page::default(),
|
|
editor_ctx: EditorContext::default(),
|
|
|
|
patterns_nav: PatternsNav::default(),
|
|
|
|
metrics: Metrics::default(),
|
|
variables,
|
|
dict,
|
|
rng,
|
|
live_keys,
|
|
script_engine,
|
|
clipboard: arboard::Clipboard::new().ok(),
|
|
copied_patterns: None,
|
|
copied_banks: None,
|
|
|
|
audio: AudioSettings::default(),
|
|
options: OptionsState::default(),
|
|
panel: PanelState::default(),
|
|
midi: MidiState::new(),
|
|
}
|
|
}
|
|
|
|
pub fn save_settings(&self, link: &LinkState) {
|
|
let settings = Settings {
|
|
audio: crate::settings::AudioSettings {
|
|
output_device: self.audio.config.output_device.clone(),
|
|
input_device: self.audio.config.input_device.clone(),
|
|
channels: self.audio.config.channels,
|
|
buffer_size: self.audio.config.buffer_size,
|
|
max_voices: self.audio.config.max_voices,
|
|
},
|
|
display: crate::settings::DisplaySettings {
|
|
fps: self.audio.config.refresh_rate.to_fps(),
|
|
runtime_highlight: self.ui.runtime_highlight,
|
|
show_scope: self.audio.config.show_scope,
|
|
show_spectrum: self.audio.config.show_spectrum,
|
|
show_completion: self.ui.show_completion,
|
|
color_scheme: self.ui.color_scheme,
|
|
layout: self.audio.config.layout,
|
|
hue_rotation: self.ui.hue_rotation,
|
|
..Default::default()
|
|
},
|
|
link: crate::settings::LinkSettings {
|
|
enabled: link.is_enabled(),
|
|
tempo: link.tempo(),
|
|
quantum: link.quantum(),
|
|
},
|
|
midi: crate::settings::MidiSettings {
|
|
output_devices: {
|
|
let outputs = crate::midi::list_midi_outputs();
|
|
self.midi
|
|
.selected_outputs
|
|
.iter()
|
|
.map(|opt| {
|
|
opt.and_then(|idx| outputs.get(idx).map(|d| d.name.clone()))
|
|
.unwrap_or_default()
|
|
})
|
|
.collect()
|
|
},
|
|
input_devices: {
|
|
let inputs = crate::midi::list_midi_inputs();
|
|
self.midi
|
|
.selected_inputs
|
|
.iter()
|
|
.map(|opt| {
|
|
opt.and_then(|idx| inputs.get(idx).map(|d| d.name.clone()))
|
|
.unwrap_or_default()
|
|
})
|
|
.collect()
|
|
},
|
|
},
|
|
};
|
|
settings.save();
|
|
}
|
|
|
|
fn current_bank_pattern(&self) -> (usize, usize) {
|
|
(self.editor_ctx.bank, self.editor_ctx.pattern)
|
|
}
|
|
|
|
fn selected_steps(&self) -> Vec<usize> {
|
|
match self.editor_ctx.selection_range() {
|
|
Some(range) => range.collect(),
|
|
None => vec![self.editor_ctx.step],
|
|
}
|
|
}
|
|
|
|
pub fn mark_all_patterns_dirty(&mut self) {
|
|
self.project_state.mark_all_dirty();
|
|
}
|
|
|
|
pub fn toggle_playing(&mut self, link: &LinkState) {
|
|
let was_playing = self.playback.playing;
|
|
self.playback.toggle();
|
|
if !was_playing && self.playback.playing {
|
|
self.evaluate_prelude(link);
|
|
}
|
|
}
|
|
|
|
pub fn tempo_up(&self, link: &LinkState) {
|
|
let current = link.tempo();
|
|
link.set_tempo((current + 1.0).min(300.0));
|
|
}
|
|
|
|
pub fn tempo_down(&self, link: &LinkState) {
|
|
let current = link.tempo();
|
|
link.set_tempo((current - 1.0).max(20.0));
|
|
}
|
|
|
|
pub fn current_edit_pattern(&self) -> &Pattern {
|
|
let (bank, pattern) = self.current_bank_pattern();
|
|
self.project_state.project.pattern_at(bank, pattern)
|
|
}
|
|
|
|
pub fn next_step(&mut self) {
|
|
let len = self.current_edit_pattern().length;
|
|
self.editor_ctx.step = (self.editor_ctx.step + 1) % len;
|
|
self.load_step_to_editor();
|
|
}
|
|
|
|
pub fn prev_step(&mut self) {
|
|
let len = self.current_edit_pattern().length;
|
|
self.editor_ctx.step = (self.editor_ctx.step + len - 1) % len;
|
|
self.load_step_to_editor();
|
|
}
|
|
|
|
pub fn step_up(&mut self) {
|
|
let len = self.current_edit_pattern().length;
|
|
let page_start = (self.editor_ctx.step / STEPS_PER_PAGE) * STEPS_PER_PAGE;
|
|
let steps_on_page = (page_start + STEPS_PER_PAGE).min(len) - page_start;
|
|
let num_rows = steps_on_page.div_ceil(8);
|
|
let steps_per_row = steps_on_page.div_ceil(num_rows);
|
|
|
|
if self.editor_ctx.step >= steps_per_row {
|
|
self.editor_ctx.step -= steps_per_row;
|
|
} else {
|
|
self.editor_ctx.step = (self.editor_ctx.step + len - steps_per_row) % len;
|
|
}
|
|
self.load_step_to_editor();
|
|
}
|
|
|
|
pub fn step_down(&mut self) {
|
|
let len = self.current_edit_pattern().length;
|
|
let page_start = (self.editor_ctx.step / STEPS_PER_PAGE) * STEPS_PER_PAGE;
|
|
let steps_on_page = (page_start + STEPS_PER_PAGE).min(len) - page_start;
|
|
let num_rows = steps_on_page.div_ceil(8);
|
|
let steps_per_row = steps_on_page.div_ceil(num_rows);
|
|
|
|
self.editor_ctx.step = (self.editor_ctx.step + steps_per_row) % len;
|
|
self.load_step_to_editor();
|
|
}
|
|
|
|
pub fn toggle_steps(&mut self) {
|
|
let (bank, pattern) = self.current_bank_pattern();
|
|
for idx in self.selected_steps() {
|
|
pattern_editor::toggle_step(&mut self.project_state.project, bank, pattern, idx);
|
|
}
|
|
self.project_state.mark_dirty(bank, pattern);
|
|
}
|
|
|
|
pub fn length_increase(&mut self) {
|
|
let (bank, pattern) = self.current_bank_pattern();
|
|
let (change, _) =
|
|
pattern_editor::increase_length(&mut self.project_state.project, bank, pattern);
|
|
self.project_state.mark_dirty(change.bank, change.pattern);
|
|
}
|
|
|
|
pub fn length_decrease(&mut self) {
|
|
let (bank, pattern) = self.current_bank_pattern();
|
|
let (change, new_len) =
|
|
pattern_editor::decrease_length(&mut self.project_state.project, bank, pattern);
|
|
if self.editor_ctx.step >= new_len {
|
|
self.editor_ctx.step = new_len - 1;
|
|
self.load_step_to_editor();
|
|
}
|
|
self.project_state.mark_dirty(change.bank, change.pattern);
|
|
}
|
|
|
|
pub fn speed_increase(&mut self) {
|
|
let (bank, pattern) = self.current_bank_pattern();
|
|
let change = pattern_editor::increase_speed(&mut self.project_state.project, bank, pattern);
|
|
self.project_state.mark_dirty(change.bank, change.pattern);
|
|
}
|
|
|
|
pub fn speed_decrease(&mut self) {
|
|
let (bank, pattern) = self.current_bank_pattern();
|
|
let change = pattern_editor::decrease_speed(&mut self.project_state.project, bank, pattern);
|
|
self.project_state.mark_dirty(change.bank, change.pattern);
|
|
}
|
|
|
|
fn create_step_context(&self, step_idx: usize, link: &LinkState) -> StepContext<'static> {
|
|
let (bank, pattern) = self.current_bank_pattern();
|
|
let speed = self
|
|
.project_state
|
|
.project
|
|
.pattern_at(bank, pattern)
|
|
.speed
|
|
.multiplier();
|
|
StepContext {
|
|
step: step_idx,
|
|
beat: link.beat(),
|
|
bank,
|
|
pattern,
|
|
tempo: link.tempo(),
|
|
phase: link.phase(),
|
|
slot: 0,
|
|
runs: 0,
|
|
iter: 0,
|
|
speed,
|
|
fill: false,
|
|
nudge_secs: 0.0,
|
|
cc_access: None,
|
|
speed_key: "",
|
|
chain_key: "",
|
|
#[cfg(feature = "desktop")]
|
|
mouse_x: 0.5,
|
|
#[cfg(feature = "desktop")]
|
|
mouse_y: 0.5,
|
|
#[cfg(feature = "desktop")]
|
|
mouse_down: 0.0,
|
|
}
|
|
}
|
|
|
|
fn load_step_to_editor(&mut self) {
|
|
let (bank, pattern) = self.current_bank_pattern();
|
|
if let Some(script) = pattern_editor::get_step_script(
|
|
&self.project_state.project,
|
|
bank,
|
|
pattern,
|
|
self.editor_ctx.step,
|
|
) {
|
|
let lines: Vec<String> = if script.is_empty() {
|
|
vec![String::new()]
|
|
} else {
|
|
script.lines().map(String::from).collect()
|
|
};
|
|
self.editor_ctx.editor.set_content(lines);
|
|
self.editor_ctx.editor.set_candidates(COMPLETION_CANDIDATES.clone());
|
|
self.editor_ctx
|
|
.editor
|
|
.set_completion_enabled(self.ui.show_completion);
|
|
let tree = SampleTree::from_paths(&self.audio.config.sample_paths);
|
|
self.editor_ctx.editor.set_sample_folders(tree.all_folder_names());
|
|
if self.editor_ctx.show_stack {
|
|
crate::services::stack_preview::update_cache(&self.editor_ctx);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn save_editor_to_step(&mut self) {
|
|
let text = self.editor_ctx.editor.content();
|
|
let (bank, pattern) = self.current_bank_pattern();
|
|
let change = pattern_editor::set_step_script(
|
|
&mut self.project_state.project,
|
|
bank,
|
|
pattern,
|
|
self.editor_ctx.step,
|
|
text,
|
|
);
|
|
self.project_state.mark_dirty(change.bank, change.pattern);
|
|
}
|
|
|
|
pub fn open_prelude_editor(&mut self) {
|
|
let prelude = &self.project_state.project.prelude;
|
|
let lines: Vec<String> = if prelude.is_empty() {
|
|
vec![String::new()]
|
|
} else {
|
|
prelude.lines().map(String::from).collect()
|
|
};
|
|
self.editor_ctx.editor.set_content(lines);
|
|
self.editor_ctx.editor.set_candidates(COMPLETION_CANDIDATES.clone());
|
|
self.editor_ctx
|
|
.editor
|
|
.set_completion_enabled(self.ui.show_completion);
|
|
let tree = SampleTree::from_paths(&self.audio.config.sample_paths);
|
|
self.editor_ctx.editor.set_sample_folders(tree.all_folder_names());
|
|
self.editor_ctx.target = EditorTarget::Prelude;
|
|
self.ui.modal = Modal::Editor;
|
|
}
|
|
|
|
pub fn save_prelude(&mut self) {
|
|
let text = self.editor_ctx.editor.content();
|
|
self.project_state.project.prelude = text;
|
|
}
|
|
|
|
pub fn close_prelude_editor(&mut self) {
|
|
self.editor_ctx.target = EditorTarget::Step;
|
|
self.load_step_to_editor();
|
|
}
|
|
|
|
pub fn evaluate_prelude(&mut self, link: &LinkState) {
|
|
let prelude = &self.project_state.project.prelude;
|
|
if prelude.trim().is_empty() {
|
|
return;
|
|
}
|
|
let ctx = self.create_step_context(0, link);
|
|
match self.script_engine.evaluate(prelude, &ctx) {
|
|
Ok(_) => {
|
|
self.ui.flash("Prelude evaluated", 150, FlashKind::Info);
|
|
}
|
|
Err(e) => {
|
|
self.ui
|
|
.flash(&format!("Prelude error: {e}"), 300, FlashKind::Error);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn execute_script_oneshot(
|
|
&self,
|
|
script: &str,
|
|
link: &LinkState,
|
|
audio_tx: &arc_swap::ArcSwap<Sender<crate::engine::AudioCommand>>,
|
|
) -> Result<(), String> {
|
|
let ctx = self.create_step_context(self.editor_ctx.step, link);
|
|
let cmds = self.script_engine.evaluate(script, &ctx)?;
|
|
for cmd in cmds {
|
|
let _ = audio_tx
|
|
.load()
|
|
.send(crate::engine::AudioCommand::Evaluate { cmd, time: None });
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn compile_current_step(&mut self, link: &LinkState) {
|
|
let step_idx = self.editor_ctx.step;
|
|
let (bank, pattern) = self.current_bank_pattern();
|
|
|
|
let script =
|
|
pattern_editor::get_step_script(&self.project_state.project, bank, pattern, step_idx)
|
|
.unwrap_or_default();
|
|
|
|
if script.trim().is_empty() {
|
|
return;
|
|
}
|
|
|
|
let ctx = self.create_step_context(step_idx, link);
|
|
|
|
match self.script_engine.evaluate(&script, &ctx) {
|
|
Ok(_) => {
|
|
self.ui.flash("Script compiled", 150, FlashKind::Info);
|
|
}
|
|
Err(e) => {
|
|
self.ui
|
|
.flash(&format!("Script error: {e}"), 300, FlashKind::Error);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn compile_all_steps(&mut self, link: &LinkState) {
|
|
let pattern_len = self.current_edit_pattern().length;
|
|
let (bank, pattern) = self.current_bank_pattern();
|
|
|
|
for step_idx in 0..pattern_len {
|
|
let script = pattern_editor::get_step_script(
|
|
&self.project_state.project,
|
|
bank,
|
|
pattern,
|
|
step_idx,
|
|
)
|
|
.unwrap_or_default();
|
|
|
|
if script.trim().is_empty() {
|
|
continue;
|
|
}
|
|
|
|
let ctx = self.create_step_context(step_idx, link);
|
|
let _ = self.script_engine.evaluate(&script, &ctx);
|
|
}
|
|
}
|
|
|
|
pub fn stage_pattern_toggle(
|
|
&mut self,
|
|
bank: usize,
|
|
pattern: usize,
|
|
snapshot: &SequencerSnapshot,
|
|
) {
|
|
let is_playing = snapshot.is_playing(bank, pattern);
|
|
let pattern_data = self.project_state.project.pattern_at(bank, pattern);
|
|
|
|
let existing = self.playback.staged_changes.iter().position(|c| {
|
|
c.change.pattern_id().bank == bank && c.change.pattern_id().pattern == pattern
|
|
});
|
|
|
|
if let Some(idx) = existing {
|
|
self.playback.staged_changes.remove(idx);
|
|
self.ui
|
|
.set_status(format!("B{:02}:P{:02} unstaged", bank + 1, pattern + 1));
|
|
} else if is_playing {
|
|
self.playback.staged_changes.push(StagedChange {
|
|
change: PatternChange::Stop { bank, pattern },
|
|
quantization: pattern_data.quantization,
|
|
sync_mode: pattern_data.sync_mode,
|
|
});
|
|
self.ui.set_status(format!(
|
|
"B{:02}:P{:02} staged to stop",
|
|
bank + 1,
|
|
pattern + 1
|
|
));
|
|
} else {
|
|
self.playback.staged_changes.push(StagedChange {
|
|
change: PatternChange::Start { bank, pattern },
|
|
quantization: pattern_data.quantization,
|
|
sync_mode: pattern_data.sync_mode,
|
|
});
|
|
self.ui.set_status(format!(
|
|
"B{:02}:P{:02} staged to play",
|
|
bank + 1,
|
|
pattern + 1
|
|
));
|
|
}
|
|
}
|
|
|
|
/// Commits staged pattern, mute/solo, and prop changes.
|
|
/// Returns true if mute state changed (caller should send to sequencer).
|
|
pub fn commit_staged_changes(&mut self) -> bool {
|
|
let pattern_count = self.playback.staged_changes.len();
|
|
let mute_count = self.playback.staged_mute_changes.len();
|
|
let prop_count = self.playback.staged_prop_changes.len();
|
|
|
|
if pattern_count == 0 && mute_count == 0 && prop_count == 0 {
|
|
self.ui.set_status("No changes to commit".to_string());
|
|
return false;
|
|
}
|
|
|
|
// Commit pattern changes (queued for quantization)
|
|
if pattern_count > 0 {
|
|
self.playback
|
|
.queued_changes
|
|
.append(&mut self.playback.staged_changes);
|
|
}
|
|
|
|
// Apply mute/solo changes immediately
|
|
let mute_changed = mute_count > 0;
|
|
for change in self.playback.staged_mute_changes.drain() {
|
|
match change {
|
|
crate::state::StagedMuteChange::ToggleMute { bank, pattern } => {
|
|
self.mute.toggle_mute(bank, pattern);
|
|
}
|
|
crate::state::StagedMuteChange::ToggleSolo { bank, pattern } => {
|
|
self.mute.toggle_solo(bank, pattern);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Apply staged prop changes
|
|
for ((bank, pattern), props) in self.playback.staged_prop_changes.drain() {
|
|
let pat = self.project_state.project.pattern_at_mut(bank, pattern);
|
|
pat.name = props.name;
|
|
if let Some(len) = props.length {
|
|
pat.set_length(len);
|
|
}
|
|
pat.speed = props.speed;
|
|
pat.quantization = props.quantization;
|
|
pat.sync_mode = props.sync_mode;
|
|
self.project_state.mark_dirty(bank, pattern);
|
|
}
|
|
|
|
let total = pattern_count + mute_count + prop_count;
|
|
let status = format!("Committed {total} changes");
|
|
self.ui.set_status(status);
|
|
|
|
mute_changed
|
|
}
|
|
|
|
pub fn clear_staged_changes(&mut self) {
|
|
let pattern_count = self.playback.staged_changes.len();
|
|
let mute_count = self.playback.staged_mute_changes.len();
|
|
let prop_count = self.playback.staged_prop_changes.len();
|
|
|
|
if pattern_count == 0 && mute_count == 0 && prop_count == 0 {
|
|
return;
|
|
}
|
|
|
|
self.playback.staged_changes.clear();
|
|
self.playback.staged_mute_changes.clear();
|
|
self.playback.staged_prop_changes.clear();
|
|
|
|
let total = pattern_count + mute_count + prop_count;
|
|
let status = format!("Cleared {total} staged changes");
|
|
self.ui.set_status(status);
|
|
}
|
|
|
|
pub fn select_edit_pattern(&mut self, pattern: usize) {
|
|
self.editor_ctx.pattern = pattern;
|
|
self.editor_ctx.step = 0;
|
|
self.load_step_to_editor();
|
|
}
|
|
|
|
pub fn select_edit_bank(&mut self, bank: usize) {
|
|
self.editor_ctx.bank = bank;
|
|
self.editor_ctx.pattern = 0;
|
|
self.editor_ctx.step = 0;
|
|
self.load_step_to_editor();
|
|
}
|
|
|
|
pub fn save(&mut self, path: PathBuf, link: &LinkState, snapshot: &SequencerSnapshot) {
|
|
self.save_editor_to_step();
|
|
self.project_state.project.sample_paths = self.audio.config.sample_paths.clone();
|
|
self.project_state.project.tempo = link.tempo();
|
|
self.project_state.project.playing_patterns = snapshot
|
|
.active_patterns
|
|
.iter()
|
|
.map(|p| (p.bank, p.pattern))
|
|
.collect();
|
|
match model::save(&self.project_state.project, &path) {
|
|
Ok(final_path) => {
|
|
self.ui
|
|
.set_status(format!("Saved: {}", final_path.display()));
|
|
self.project_state.file_path = Some(final_path);
|
|
}
|
|
Err(e) => {
|
|
self.ui.set_status(format!("Save error: {e}"));
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn load(&mut self, path: PathBuf, link: &LinkState) {
|
|
match model::load(&path) {
|
|
Ok(project) => {
|
|
let tempo = project.tempo;
|
|
let playing = project.playing_patterns.clone();
|
|
|
|
self.project_state.project = project;
|
|
self.editor_ctx.step = 0;
|
|
self.load_step_to_editor();
|
|
self.compile_all_steps(link);
|
|
self.mark_all_patterns_dirty();
|
|
link.set_tempo(tempo);
|
|
|
|
self.playback.clear_queues();
|
|
self.variables.store(Arc::new(HashMap::new()));
|
|
self.dict.lock().clear();
|
|
|
|
self.evaluate_prelude(link);
|
|
|
|
for (bank, pattern) in playing {
|
|
self.playback.queued_changes.push(StagedChange {
|
|
change: PatternChange::Start { bank, pattern },
|
|
quantization: crate::model::LaunchQuantization::Immediate,
|
|
sync_mode: crate::model::SyncMode::PhaseLock,
|
|
});
|
|
}
|
|
|
|
self.ui.set_status(format!("Loaded: {}", path.display()));
|
|
self.project_state.file_path = Some(path);
|
|
}
|
|
Err(e) => {
|
|
self.ui.set_status(format!("Load error: {e}"));
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn delete_step(&mut self, bank: usize, pattern: usize, step: usize) {
|
|
let edit = pattern_editor::delete_step(&mut self.project_state.project, bank, pattern, step);
|
|
self.project_state.mark_dirty(edit.bank, edit.pattern);
|
|
if self.editor_ctx.bank == bank
|
|
&& self.editor_ctx.pattern == pattern
|
|
&& self.editor_ctx.step == step
|
|
{
|
|
self.load_step_to_editor();
|
|
}
|
|
self.ui.flash("Step deleted", 150, FlashKind::Success);
|
|
}
|
|
|
|
pub fn delete_steps(&mut self, bank: usize, pattern: usize, steps: &[usize]) {
|
|
let edit = pattern_editor::delete_steps(&mut self.project_state.project, bank, pattern, steps);
|
|
self.project_state.mark_dirty(edit.bank, edit.pattern);
|
|
if self.editor_ctx.bank == bank && self.editor_ctx.pattern == pattern {
|
|
self.load_step_to_editor();
|
|
}
|
|
self.editor_ctx.clear_selection();
|
|
self.ui.flash(
|
|
&format!("{} steps deleted", steps.len()),
|
|
150,
|
|
FlashKind::Success,
|
|
);
|
|
}
|
|
|
|
pub fn reset_pattern(&mut self, bank: usize, pattern: usize) {
|
|
let edit = pattern_editor::reset_pattern(&mut self.project_state.project, bank, pattern);
|
|
self.project_state.mark_dirty(edit.bank, edit.pattern);
|
|
if self.editor_ctx.bank == bank && self.editor_ctx.pattern == pattern {
|
|
self.load_step_to_editor();
|
|
}
|
|
self.ui.flash("Pattern reset", 150, FlashKind::Success);
|
|
}
|
|
|
|
pub fn reset_bank(&mut self, bank: usize) {
|
|
let pat_count = pattern_editor::reset_bank(&mut self.project_state.project, bank);
|
|
for pattern in 0..pat_count {
|
|
self.project_state.mark_dirty(bank, pattern);
|
|
}
|
|
if self.editor_ctx.bank == bank {
|
|
self.load_step_to_editor();
|
|
}
|
|
self.ui.flash("Bank reset", 150, FlashKind::Success);
|
|
}
|
|
|
|
pub fn copy_pattern(&mut self, bank: usize, pattern: usize) {
|
|
self.copied_patterns = Some(vec![clipboard::copy_pattern(
|
|
&self.project_state.project,
|
|
bank,
|
|
pattern,
|
|
)]);
|
|
self.ui.flash("Pattern copied", 150, FlashKind::Success);
|
|
}
|
|
|
|
pub fn paste_pattern(&mut self, bank: usize, pattern: usize) {
|
|
if let Some(src) = self.copied_patterns.as_ref().and_then(|v| v.first()) {
|
|
let src = src.clone();
|
|
clipboard::paste_pattern(&mut self.project_state.project, bank, pattern, &src);
|
|
self.project_state.mark_dirty(bank, pattern);
|
|
if self.editor_ctx.bank == bank && self.editor_ctx.pattern == pattern {
|
|
self.load_step_to_editor();
|
|
}
|
|
self.ui.flash("Pattern pasted", 150, FlashKind::Success);
|
|
}
|
|
}
|
|
|
|
pub fn copy_patterns(&mut self, bank: usize, patterns: &[usize]) {
|
|
self.copied_patterns = Some(clipboard::copy_patterns(
|
|
&self.project_state.project,
|
|
bank,
|
|
patterns,
|
|
));
|
|
let n = patterns.len();
|
|
self.ui.flash(
|
|
&format!("{n} pattern{} copied", if n == 1 { "" } else { "s" }),
|
|
150,
|
|
FlashKind::Success,
|
|
);
|
|
}
|
|
|
|
pub fn paste_patterns(&mut self, bank: usize, start: usize) {
|
|
if let Some(sources) = self.copied_patterns.clone() {
|
|
let count = clipboard::paste_patterns(
|
|
&mut self.project_state.project,
|
|
bank,
|
|
start,
|
|
&sources,
|
|
);
|
|
for i in 0..count {
|
|
self.project_state.mark_dirty(bank, start + i);
|
|
}
|
|
if self.editor_ctx.bank == bank {
|
|
self.load_step_to_editor();
|
|
}
|
|
self.ui.flash(
|
|
&format!("{count} pattern{} pasted", if count == 1 { "" } else { "s" }),
|
|
150,
|
|
FlashKind::Success,
|
|
);
|
|
}
|
|
}
|
|
|
|
pub fn copy_bank(&mut self, bank: usize) {
|
|
self.copied_banks = Some(vec![clipboard::copy_bank(
|
|
&self.project_state.project,
|
|
bank,
|
|
)]);
|
|
self.ui.flash("Bank copied", 150, FlashKind::Success);
|
|
}
|
|
|
|
pub fn paste_bank(&mut self, bank: usize) {
|
|
if let Some(src) = self.copied_banks.as_ref().and_then(|v| v.first()) {
|
|
let src = src.clone();
|
|
let pat_count =
|
|
clipboard::paste_bank(&mut self.project_state.project, bank, &src);
|
|
for pattern in 0..pat_count {
|
|
self.project_state.mark_dirty(bank, pattern);
|
|
}
|
|
if self.editor_ctx.bank == bank {
|
|
self.load_step_to_editor();
|
|
}
|
|
self.ui.flash("Bank pasted", 150, FlashKind::Success);
|
|
}
|
|
}
|
|
|
|
pub fn copy_banks(&mut self, banks: &[usize]) {
|
|
self.copied_banks = Some(clipboard::copy_banks(
|
|
&self.project_state.project,
|
|
banks,
|
|
));
|
|
let n = banks.len();
|
|
self.ui.flash(
|
|
&format!("{n} bank{} copied", if n == 1 { "" } else { "s" }),
|
|
150,
|
|
FlashKind::Success,
|
|
);
|
|
}
|
|
|
|
pub fn paste_banks(&mut self, start: usize) {
|
|
if let Some(sources) = self.copied_banks.clone() {
|
|
let count = clipboard::paste_banks(
|
|
&mut self.project_state.project,
|
|
start,
|
|
&sources,
|
|
);
|
|
for i in 0..count {
|
|
let bank = start + i;
|
|
for pattern in 0..model::MAX_PATTERNS {
|
|
self.project_state.mark_dirty(bank, pattern);
|
|
}
|
|
}
|
|
if (start..start + count).contains(&self.editor_ctx.bank) {
|
|
self.load_step_to_editor();
|
|
}
|
|
self.ui.flash(
|
|
&format!("{count} bank{} pasted", if count == 1 { "" } else { "s" }),
|
|
150,
|
|
FlashKind::Success,
|
|
);
|
|
}
|
|
}
|
|
|
|
pub fn reset_patterns(&mut self, bank: usize, patterns: &[usize]) {
|
|
for &pattern in patterns {
|
|
let edit =
|
|
pattern_editor::reset_pattern(&mut self.project_state.project, bank, pattern);
|
|
self.project_state.mark_dirty(edit.bank, edit.pattern);
|
|
}
|
|
if self.editor_ctx.bank == bank && patterns.contains(&self.editor_ctx.pattern) {
|
|
self.load_step_to_editor();
|
|
}
|
|
let n = patterns.len();
|
|
self.ui.flash(
|
|
&format!("{n} pattern{} reset", if n == 1 { "" } else { "s" }),
|
|
150,
|
|
FlashKind::Success,
|
|
);
|
|
}
|
|
|
|
pub fn reset_banks(&mut self, banks: &[usize]) {
|
|
for &bank in banks {
|
|
let pat_count =
|
|
pattern_editor::reset_bank(&mut self.project_state.project, bank);
|
|
for pattern in 0..pat_count {
|
|
self.project_state.mark_dirty(bank, pattern);
|
|
}
|
|
}
|
|
if banks.contains(&self.editor_ctx.bank) {
|
|
self.load_step_to_editor();
|
|
}
|
|
let n = banks.len();
|
|
self.ui.flash(
|
|
&format!("{n} bank{} reset", if n == 1 { "" } else { "s" }),
|
|
150,
|
|
FlashKind::Success,
|
|
);
|
|
}
|
|
|
|
pub fn harden_steps(&mut self) {
|
|
let (bank, pattern) = self.current_bank_pattern();
|
|
let indices = self.selected_steps();
|
|
let count = clipboard::harden_steps(&mut self.project_state.project, bank, pattern, &indices);
|
|
if count == 0 {
|
|
self.ui.set_status("No linked steps to harden".to_string());
|
|
return;
|
|
}
|
|
self.project_state.mark_dirty(bank, pattern);
|
|
self.load_step_to_editor();
|
|
self.editor_ctx.clear_selection();
|
|
if count == 1 {
|
|
self.ui.flash("Step hardened", 150, FlashKind::Success);
|
|
} else {
|
|
self.ui
|
|
.flash(&format!("{count} steps hardened"), 150, FlashKind::Success);
|
|
}
|
|
}
|
|
|
|
pub fn copy_steps(&mut self) {
|
|
let (bank, pattern) = self.current_bank_pattern();
|
|
let indices = self.selected_steps();
|
|
let (copied, scripts) = clipboard::copy_steps(
|
|
&self.project_state.project,
|
|
bank,
|
|
pattern,
|
|
&indices,
|
|
);
|
|
let count = copied.steps.len();
|
|
self.editor_ctx.copied_steps = Some(copied);
|
|
if let Some(clip) = &mut self.clipboard {
|
|
let _ = clip.set_text(scripts.join("\n"));
|
|
}
|
|
self.ui
|
|
.flash(&format!("Copied {count} steps"), 150, FlashKind::Info);
|
|
}
|
|
|
|
pub fn paste_steps(&mut self, link: &LinkState) {
|
|
let Some(copied) = self.editor_ctx.copied_steps.clone() else {
|
|
self.ui.set_status("Nothing copied".to_string());
|
|
return;
|
|
};
|
|
let (bank, pattern) = self.current_bank_pattern();
|
|
let cursor = self.editor_ctx.step;
|
|
let result = clipboard::paste_steps(
|
|
&mut self.project_state.project,
|
|
bank,
|
|
pattern,
|
|
cursor,
|
|
&copied,
|
|
);
|
|
self.project_state.mark_dirty(bank, pattern);
|
|
self.load_step_to_editor();
|
|
for &target in &result.compile_targets {
|
|
let saved = self.editor_ctx.step;
|
|
self.editor_ctx.step = target;
|
|
self.compile_current_step(link);
|
|
self.editor_ctx.step = saved;
|
|
}
|
|
self.editor_ctx.clear_selection();
|
|
self.ui.flash(
|
|
&format!("Pasted {} steps", result.count),
|
|
150,
|
|
FlashKind::Success,
|
|
);
|
|
}
|
|
|
|
pub fn link_paste_steps(&mut self) {
|
|
let Some(copied) = self.editor_ctx.copied_steps.clone() else {
|
|
self.ui.set_status("Nothing copied".to_string());
|
|
return;
|
|
};
|
|
let (bank, pattern) = self.current_bank_pattern();
|
|
let cursor = self.editor_ctx.step;
|
|
match clipboard::link_paste_steps(
|
|
&mut self.project_state.project,
|
|
bank,
|
|
pattern,
|
|
cursor,
|
|
&copied,
|
|
) {
|
|
None => {
|
|
self.ui
|
|
.set_status("Can only link within same pattern".to_string());
|
|
}
|
|
Some(count) => {
|
|
self.project_state.mark_dirty(bank, pattern);
|
|
self.load_step_to_editor();
|
|
self.editor_ctx.clear_selection();
|
|
self.ui.flash(
|
|
&format!("Linked {count} steps"),
|
|
150,
|
|
FlashKind::Success,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn duplicate_steps(&mut self, link: &LinkState) {
|
|
let (bank, pattern) = self.current_bank_pattern();
|
|
let indices = self.selected_steps();
|
|
let result = clipboard::duplicate_steps(
|
|
&mut self.project_state.project,
|
|
bank,
|
|
pattern,
|
|
&indices,
|
|
);
|
|
self.project_state.mark_dirty(bank, pattern);
|
|
self.load_step_to_editor();
|
|
for &target in &result.compile_targets {
|
|
let saved = self.editor_ctx.step;
|
|
self.editor_ctx.step = target;
|
|
self.compile_current_step(link);
|
|
self.editor_ctx.step = saved;
|
|
}
|
|
self.editor_ctx.clear_selection();
|
|
self.ui.flash(
|
|
&format!("Duplicated {} steps", result.count),
|
|
150,
|
|
FlashKind::Success,
|
|
);
|
|
}
|
|
|
|
pub fn open_pattern_modal(&mut self, field: PatternField) {
|
|
let current = match field {
|
|
PatternField::Length => self.current_edit_pattern().length.to_string(),
|
|
PatternField::Speed => self.current_edit_pattern().speed.label().to_string(),
|
|
};
|
|
self.ui.modal = Modal::SetPattern {
|
|
field,
|
|
input: current,
|
|
};
|
|
}
|
|
|
|
pub fn open_pattern_props_modal(&mut self, bank: usize, pattern: usize) {
|
|
let pat = self.project_state.project.pattern_at(bank, pattern);
|
|
self.ui.modal = Modal::PatternProps {
|
|
bank,
|
|
pattern,
|
|
field: PatternPropsField::default(),
|
|
name: pat.name.clone().unwrap_or_default(),
|
|
length: pat.length.to_string(),
|
|
speed: pat.speed,
|
|
quantization: pat.quantization,
|
|
sync_mode: pat.sync_mode,
|
|
};
|
|
}
|
|
|
|
pub fn dispatch(&mut self, cmd: AppCommand, link: &LinkState, snapshot: &SequencerSnapshot) {
|
|
match cmd {
|
|
// Playback
|
|
AppCommand::TogglePlaying => self.toggle_playing(link),
|
|
AppCommand::TempoUp => self.tempo_up(link),
|
|
AppCommand::TempoDown => self.tempo_down(link),
|
|
|
|
// Navigation
|
|
AppCommand::NextStep => self.next_step(),
|
|
AppCommand::PrevStep => self.prev_step(),
|
|
AppCommand::StepUp => self.step_up(),
|
|
AppCommand::StepDown => self.step_down(),
|
|
|
|
// Pattern editing
|
|
AppCommand::ToggleSteps => self.toggle_steps(),
|
|
AppCommand::LengthIncrease => self.length_increase(),
|
|
AppCommand::LengthDecrease => self.length_decrease(),
|
|
AppCommand::SpeedIncrease => self.speed_increase(),
|
|
AppCommand::SpeedDecrease => self.speed_decrease(),
|
|
AppCommand::SetLength {
|
|
bank,
|
|
pattern,
|
|
length,
|
|
} => {
|
|
let (change, new_len) = pattern_editor::set_length(
|
|
&mut self.project_state.project,
|
|
bank,
|
|
pattern,
|
|
length,
|
|
);
|
|
if self.editor_ctx.bank == bank
|
|
&& self.editor_ctx.pattern == pattern
|
|
&& self.editor_ctx.step >= new_len
|
|
{
|
|
self.editor_ctx.step = new_len - 1;
|
|
}
|
|
self.project_state.mark_dirty(change.bank, change.pattern);
|
|
}
|
|
AppCommand::SetSpeed {
|
|
bank,
|
|
pattern,
|
|
speed,
|
|
} => {
|
|
let change = pattern_editor::set_speed(
|
|
&mut self.project_state.project,
|
|
bank,
|
|
pattern,
|
|
speed,
|
|
);
|
|
self.project_state.mark_dirty(change.bank, change.pattern);
|
|
}
|
|
|
|
// Script editing
|
|
AppCommand::SaveEditorToStep => self.save_editor_to_step(),
|
|
AppCommand::CompileCurrentStep => self.compile_current_step(link),
|
|
AppCommand::DeleteStep {
|
|
bank,
|
|
pattern,
|
|
step,
|
|
} => {
|
|
self.delete_step(bank, pattern, step);
|
|
}
|
|
AppCommand::DeleteSteps {
|
|
bank,
|
|
pattern,
|
|
steps,
|
|
} => {
|
|
self.delete_steps(bank, pattern, &steps);
|
|
}
|
|
AppCommand::ResetPattern { bank, pattern } => {
|
|
self.reset_pattern(bank, pattern);
|
|
}
|
|
AppCommand::ResetBank { bank } => {
|
|
self.reset_bank(bank);
|
|
}
|
|
AppCommand::CopyPattern { bank, pattern } => {
|
|
self.copy_pattern(bank, pattern);
|
|
}
|
|
AppCommand::PastePattern { bank, pattern } => {
|
|
self.paste_pattern(bank, pattern);
|
|
}
|
|
AppCommand::CopyPatterns { bank, patterns } => {
|
|
self.copy_patterns(bank, &patterns);
|
|
}
|
|
AppCommand::PastePatterns { bank, start } => {
|
|
self.paste_patterns(bank, start);
|
|
}
|
|
AppCommand::CopyBank { bank } => {
|
|
self.copy_bank(bank);
|
|
}
|
|
AppCommand::PasteBank { bank } => {
|
|
self.paste_bank(bank);
|
|
}
|
|
AppCommand::CopyBanks { banks } => {
|
|
self.copy_banks(&banks);
|
|
}
|
|
AppCommand::PasteBanks { start } => {
|
|
self.paste_banks(start);
|
|
}
|
|
AppCommand::ResetPatterns { bank, patterns } => {
|
|
self.reset_patterns(bank, &patterns);
|
|
}
|
|
AppCommand::ResetBanks { banks } => {
|
|
self.reset_banks(&banks);
|
|
}
|
|
|
|
// Clipboard
|
|
AppCommand::HardenSteps => self.harden_steps(),
|
|
AppCommand::CopySteps => self.copy_steps(),
|
|
AppCommand::PasteSteps => self.paste_steps(link),
|
|
AppCommand::LinkPasteSteps => self.link_paste_steps(),
|
|
AppCommand::DuplicateSteps => self.duplicate_steps(link),
|
|
|
|
// Pattern playback (staging)
|
|
AppCommand::ClearStagedChanges => {
|
|
self.clear_staged_changes();
|
|
}
|
|
|
|
// Project
|
|
AppCommand::RenameBank { bank, name } => {
|
|
self.project_state.project.banks[bank].name = name;
|
|
}
|
|
AppCommand::RenamePattern {
|
|
bank,
|
|
pattern,
|
|
name,
|
|
} => {
|
|
self.project_state.project.banks[bank].patterns[pattern].name = name;
|
|
}
|
|
AppCommand::RenameStep {
|
|
bank,
|
|
pattern,
|
|
step,
|
|
name,
|
|
} => {
|
|
if let Some(s) =
|
|
self.project_state.project.banks[bank].patterns[pattern].step_mut(step)
|
|
{
|
|
s.name = name;
|
|
}
|
|
self.project_state.mark_dirty(bank, pattern);
|
|
}
|
|
AppCommand::Save(path) => self.save(path, link, snapshot),
|
|
AppCommand::Load(path) => self.load(path, link),
|
|
|
|
// UI
|
|
AppCommand::SetStatus(msg) => self.ui.set_status(msg),
|
|
AppCommand::ClearStatus => self.ui.clear_status(),
|
|
AppCommand::OpenModal(modal) => {
|
|
if matches!(modal, Modal::Editor) {
|
|
// If current step is a shallow copy, navigate to source step
|
|
let pattern = &self.project_state.project.banks[self.editor_ctx.bank].patterns
|
|
[self.editor_ctx.pattern];
|
|
if let Some(source) = pattern.step(self.editor_ctx.step).and_then(|s| s.source)
|
|
{
|
|
self.editor_ctx.step = source as usize;
|
|
}
|
|
self.load_step_to_editor();
|
|
}
|
|
self.ui.modal = modal;
|
|
}
|
|
AppCommand::CloseModal => self.ui.modal = Modal::None,
|
|
AppCommand::OpenPatternModal(field) => self.open_pattern_modal(field),
|
|
AppCommand::OpenPatternPropsModal { bank, pattern } => {
|
|
self.open_pattern_props_modal(bank, pattern);
|
|
}
|
|
AppCommand::StagePatternProps {
|
|
bank,
|
|
pattern,
|
|
name,
|
|
length,
|
|
speed,
|
|
quantization,
|
|
sync_mode,
|
|
} => {
|
|
self.playback.staged_prop_changes.insert(
|
|
(bank, pattern),
|
|
StagedPropChange {
|
|
name,
|
|
length,
|
|
speed,
|
|
quantization,
|
|
sync_mode,
|
|
},
|
|
);
|
|
self.ui.set_status(format!(
|
|
"B{:02}:P{:02} props staged",
|
|
bank + 1,
|
|
pattern + 1
|
|
));
|
|
}
|
|
|
|
// Page navigation
|
|
AppCommand::PageLeft => self.page.left(),
|
|
AppCommand::PageRight => self.page.right(),
|
|
AppCommand::PageUp => self.page.up(),
|
|
AppCommand::PageDown => self.page.down(),
|
|
|
|
// Help navigation
|
|
AppCommand::HelpToggleFocus => help_nav::toggle_focus(&mut self.ui),
|
|
AppCommand::HelpNextTopic(n) => help_nav::next_topic(&mut self.ui, n),
|
|
AppCommand::HelpPrevTopic(n) => help_nav::prev_topic(&mut self.ui, n),
|
|
AppCommand::HelpScrollDown(n) => help_nav::scroll_down(&mut self.ui, n),
|
|
AppCommand::HelpScrollUp(n) => help_nav::scroll_up(&mut self.ui, n),
|
|
AppCommand::HelpActivateSearch => help_nav::activate_search(&mut self.ui),
|
|
AppCommand::HelpClearSearch => help_nav::clear_search(&mut self.ui),
|
|
AppCommand::HelpSearchInput(c) => help_nav::search_input(&mut self.ui, c),
|
|
AppCommand::HelpSearchBackspace => help_nav::search_backspace(&mut self.ui),
|
|
AppCommand::HelpSearchConfirm => help_nav::search_confirm(&mut self.ui),
|
|
|
|
// Dictionary navigation
|
|
AppCommand::DictToggleFocus => dict_nav::toggle_focus(&mut self.ui),
|
|
AppCommand::DictNextCategory => dict_nav::next_category(&mut self.ui),
|
|
AppCommand::DictPrevCategory => dict_nav::prev_category(&mut self.ui),
|
|
AppCommand::DictScrollDown(n) => dict_nav::scroll_down(&mut self.ui, n),
|
|
AppCommand::DictScrollUp(n) => dict_nav::scroll_up(&mut self.ui, n),
|
|
AppCommand::DictActivateSearch => dict_nav::activate_search(&mut self.ui),
|
|
AppCommand::DictClearSearch => dict_nav::clear_search(&mut self.ui),
|
|
AppCommand::DictSearchInput(c) => dict_nav::search_input(&mut self.ui, c),
|
|
AppCommand::DictSearchBackspace => dict_nav::search_backspace(&mut self.ui),
|
|
AppCommand::DictSearchConfirm => dict_nav::search_confirm(&mut self.ui),
|
|
|
|
// Patterns view
|
|
AppCommand::PatternsCursorLeft => {
|
|
self.patterns_nav.move_left();
|
|
}
|
|
AppCommand::PatternsCursorRight => {
|
|
self.patterns_nav.move_right();
|
|
}
|
|
AppCommand::PatternsCursorUp => {
|
|
self.patterns_nav.move_up();
|
|
}
|
|
AppCommand::PatternsCursorDown => {
|
|
self.patterns_nav.move_down();
|
|
}
|
|
AppCommand::PatternsEnter => {
|
|
let bank = self.patterns_nav.selected_bank();
|
|
let pattern = self.patterns_nav.selected_pattern();
|
|
self.select_edit_bank(bank);
|
|
self.select_edit_pattern(pattern);
|
|
self.page.down();
|
|
}
|
|
AppCommand::PatternsBack => {
|
|
self.page.down();
|
|
}
|
|
|
|
// Mute/Solo (staged)
|
|
AppCommand::StageMute { bank, pattern } => {
|
|
self.playback.stage_mute(bank, pattern);
|
|
}
|
|
AppCommand::StageSolo { bank, pattern } => {
|
|
self.playback.stage_solo(bank, pattern);
|
|
}
|
|
AppCommand::ClearMutes => {
|
|
self.playback.clear_staged_mutes();
|
|
self.mute.clear_mute();
|
|
}
|
|
AppCommand::ClearSolos => {
|
|
self.playback.clear_staged_solos();
|
|
self.mute.clear_solo();
|
|
}
|
|
|
|
// UI state
|
|
AppCommand::ClearMinimap => {
|
|
self.ui.minimap_until = None;
|
|
}
|
|
AppCommand::HideTitle => {
|
|
self.ui.show_title = false;
|
|
}
|
|
AppCommand::ToggleEditorStack => {
|
|
self.editor_ctx.show_stack = !self.editor_ctx.show_stack;
|
|
if self.editor_ctx.show_stack {
|
|
crate::services::stack_preview::update_cache(&self.editor_ctx);
|
|
}
|
|
}
|
|
AppCommand::SetColorScheme(scheme) => {
|
|
self.ui.color_scheme = scheme;
|
|
let base_theme = scheme.to_theme();
|
|
let rotated = cagire_ratatui::theme::transform::rotate_theme(base_theme, self.ui.hue_rotation);
|
|
crate::theme::set(rotated);
|
|
}
|
|
AppCommand::SetHueRotation(degrees) => {
|
|
self.ui.hue_rotation = degrees;
|
|
let base_theme = self.ui.color_scheme.to_theme();
|
|
let rotated = cagire_ratatui::theme::transform::rotate_theme(base_theme, degrees);
|
|
crate::theme::set(rotated);
|
|
}
|
|
AppCommand::ToggleRuntimeHighlight => {
|
|
self.ui.runtime_highlight = !self.ui.runtime_highlight;
|
|
}
|
|
AppCommand::ToggleCompletion => {
|
|
self.ui.show_completion = !self.ui.show_completion;
|
|
self.editor_ctx
|
|
.editor
|
|
.set_completion_enabled(self.ui.show_completion);
|
|
}
|
|
// Live keys
|
|
AppCommand::ToggleLiveKeysFill => {
|
|
self.live_keys.flip_fill();
|
|
}
|
|
|
|
// Panel
|
|
AppCommand::ClosePanel => {
|
|
self.panel.visible = false;
|
|
self.panel.focus = crate::state::PanelFocus::Main;
|
|
}
|
|
|
|
// Selection
|
|
AppCommand::SetSelectionAnchor(step) => {
|
|
self.editor_ctx.selection_anchor = Some(step);
|
|
}
|
|
|
|
// Audio settings (engine page)
|
|
AppCommand::AudioNextSection => {
|
|
self.audio.next_section();
|
|
}
|
|
AppCommand::AudioPrevSection => {
|
|
self.audio.prev_section();
|
|
}
|
|
AppCommand::AudioOutputListUp => {
|
|
self.audio.output_list.move_up();
|
|
}
|
|
AppCommand::AudioOutputListDown(count) => {
|
|
self.audio.output_list.move_down(count);
|
|
}
|
|
AppCommand::AudioOutputPageUp => {
|
|
self.audio.output_list.page_up();
|
|
}
|
|
AppCommand::AudioOutputPageDown(count) => {
|
|
self.audio.output_list.page_down(count);
|
|
}
|
|
AppCommand::AudioInputListUp => {
|
|
self.audio.input_list.move_up();
|
|
}
|
|
AppCommand::AudioInputListDown(count) => {
|
|
self.audio.input_list.move_down(count);
|
|
}
|
|
AppCommand::AudioInputPageDown(count) => {
|
|
self.audio.input_list.page_down(count);
|
|
}
|
|
AppCommand::AudioSettingNext => {
|
|
self.audio.setting_kind = self.audio.setting_kind.next();
|
|
}
|
|
AppCommand::AudioSettingPrev => {
|
|
self.audio.setting_kind = self.audio.setting_kind.prev();
|
|
}
|
|
AppCommand::SetOutputDevice(name) => {
|
|
self.audio.config.output_device = Some(name);
|
|
}
|
|
AppCommand::SetInputDevice(name) => {
|
|
self.audio.config.input_device = Some(name);
|
|
}
|
|
AppCommand::SetDeviceKind(kind) => {
|
|
self.audio.device_kind = kind;
|
|
}
|
|
AppCommand::AdjustAudioSetting { setting, delta } => {
|
|
use crate::state::SettingKind;
|
|
match setting {
|
|
SettingKind::Channels => self.audio.adjust_channels(delta as i16),
|
|
SettingKind::BufferSize => self.audio.adjust_buffer_size(delta),
|
|
SettingKind::Polyphony => self.audio.adjust_max_voices(delta),
|
|
SettingKind::Nudge => {
|
|
self.metrics.nudge_ms =
|
|
(self.metrics.nudge_ms + delta as f64).clamp(-50.0, 50.0);
|
|
}
|
|
}
|
|
}
|
|
AppCommand::AudioTriggerRestart => {
|
|
self.audio.trigger_restart();
|
|
}
|
|
AppCommand::RemoveLastSamplePath => {
|
|
self.audio.remove_last_sample_path();
|
|
}
|
|
AppCommand::AudioRefreshDevices => {
|
|
self.audio.refresh_devices();
|
|
}
|
|
|
|
// Options page
|
|
AppCommand::OptionsNextFocus => {
|
|
self.options.next_focus();
|
|
}
|
|
AppCommand::OptionsPrevFocus => {
|
|
self.options.prev_focus();
|
|
}
|
|
AppCommand::ToggleRefreshRate => {
|
|
self.audio.toggle_refresh_rate();
|
|
}
|
|
AppCommand::ToggleScope => {
|
|
self.audio.config.show_scope = !self.audio.config.show_scope;
|
|
}
|
|
AppCommand::ToggleSpectrum => {
|
|
self.audio.config.show_spectrum = !self.audio.config.show_spectrum;
|
|
}
|
|
|
|
// Metrics
|
|
AppCommand::ResetPeakVoices => {
|
|
self.metrics.peak_voices = 0;
|
|
}
|
|
|
|
// Euclidean distribution
|
|
AppCommand::ApplyEuclideanDistribution {
|
|
bank,
|
|
pattern,
|
|
source_step,
|
|
pulses,
|
|
steps,
|
|
rotation,
|
|
} => {
|
|
let targets = euclidean::apply_distribution(
|
|
&mut self.project_state.project,
|
|
bank,
|
|
pattern,
|
|
source_step,
|
|
pulses,
|
|
steps,
|
|
rotation,
|
|
);
|
|
let created_count = targets.len();
|
|
self.project_state.mark_dirty(bank, pattern);
|
|
for &target in &targets {
|
|
let saved = self.editor_ctx.step;
|
|
self.editor_ctx.step = target;
|
|
self.compile_current_step(link);
|
|
self.editor_ctx.step = saved;
|
|
}
|
|
self.load_step_to_editor();
|
|
self.ui.flash(
|
|
&format!("Created {created_count} linked steps (E({pulses},{steps}))"),
|
|
200,
|
|
FlashKind::Success,
|
|
);
|
|
}
|
|
|
|
// Prelude
|
|
AppCommand::OpenPreludeEditor => self.open_prelude_editor(),
|
|
AppCommand::SavePrelude => self.save_prelude(),
|
|
AppCommand::EvaluatePrelude => self.evaluate_prelude(link),
|
|
AppCommand::ClosePreludeEditor => self.close_prelude_editor(),
|
|
}
|
|
}
|
|
|
|
pub fn flush_queued_changes(&mut self, cmd_tx: &Sender<SeqCommand>) {
|
|
for staged in self.playback.queued_changes.drain(..) {
|
|
match staged.change {
|
|
PatternChange::Start { bank, pattern } => {
|
|
let _ = cmd_tx.send(SeqCommand::PatternStart {
|
|
bank,
|
|
pattern,
|
|
quantization: staged.quantization,
|
|
sync_mode: staged.sync_mode,
|
|
});
|
|
}
|
|
PatternChange::Stop { bank, pattern } => {
|
|
let _ = cmd_tx.send(SeqCommand::PatternStop {
|
|
bank,
|
|
pattern,
|
|
quantization: staged.quantization,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn send_mute_state(&self, cmd_tx: &Sender<SeqCommand>) {
|
|
let _ = cmd_tx.send(SeqCommand::SetMuteState {
|
|
muted: self.mute.muted.clone(),
|
|
soloed: self.mute.soloed.clone(),
|
|
});
|
|
}
|
|
|
|
pub fn flush_dirty_patterns(&mut self, cmd_tx: &Sender<SeqCommand>) {
|
|
for (bank, pattern) in self.project_state.take_dirty() {
|
|
let pat = self.project_state.project.pattern_at(bank, pattern);
|
|
let snapshot = PatternSnapshot {
|
|
speed: pat.speed,
|
|
length: pat.length,
|
|
steps: pat
|
|
.steps
|
|
.iter()
|
|
.take(pat.length)
|
|
.map(|s| StepSnapshot {
|
|
active: s.active,
|
|
script: s.script.clone(),
|
|
source: s.source,
|
|
})
|
|
.collect(),
|
|
quantization: pat.quantization,
|
|
sync_mode: pat.sync_mode,
|
|
};
|
|
let _ = cmd_tx.send(SeqCommand::PatternUpdate {
|
|
bank,
|
|
pattern,
|
|
data: snapshot,
|
|
});
|
|
}
|
|
}
|
|
}
|