tek/crates/tek_sequencer/src/arranger_main.rs

include!("lib.rs");

use tek_core::clap::{self, Parser};

pub fn main () -> Usually<()> {
    tek_core::run(Arc::new(RwLock::new(crate::ArrangerStandalone::from_args()?)))?;
    Ok(())
}

struct ArrangerStandalone {
    arranger:       Arranger,
    transport:      Option<Arc<RwLock<TransportToolbar>>>,
    show_sequencer: Option<tek_core::Direction>,
}

#[derive(Debug, Parser)]
#[command(version, about, long_about = None)]
pub struct ArrangerCli {
    /// Name of JACK client
    #[arg(short, long)] name: Option<String>,
    /// Pulses per quarter note (arruencer resolution; default: 96)
    #[arg(short, long)] ppq: Option<usize>,
    /// Whether to include a transport toolbar (default: true)
    #[arg(short, long)] transport: Option<bool>,
    /// Number of tracks
    #[arg(short = 'x', long, default_value_t = 8)] tracks: usize,
    /// Number of scenes
    #[arg(short, long, default_value_t = 8)] scenes: usize,
}

impl ArrangerStandalone {
    pub fn from_args () -> Usually<Self> {
        let args = ArrangerCli::parse();
        let mut app = ArrangerStandalone {
            arranger: Arranger::new(""),
            transport: match args.transport {
                Some(true) => Some(Arc::new(RwLock::new(TransportToolbar::new(None)))),
                _ => None
            },
            show_sequencer: Some(tek_core::Direction::Down),
        };
        if let Some(name) = args.name {
            app.arranger.name = name.clone();
        }
        for _ in 0..args.tracks {
            let track = app.arranger.track_add(None)?;
            for _ in 0..args.scenes {
                track.phrases.push(
                    Arc::new(RwLock::new(Phrase::new("", 96 * 4, None)))
                );
            }
        }
        for _ in 0..args.scenes {
            let scene = app.arranger.scene_add(None)?;
        }
        Ok(app)
    }
}

render!(ArrangerStandalone |self, buf, area| {
    let mut layout = Split::down();
    if let Some(transport) = &self.transport {
        layout = layout.add_ref(transport);
    }
    let sequencer = self.arranger.sequencer();
    if let Some(direction) = self.show_sequencer {
        layout = layout.add(Split::new(direction)
            .add_ref(&self.arranger)
            .add(sequencer))
    } else {
        layout = layout.add_ref(&self.arranger)
    }
    let result = layout.render(buf, area)?;
    if let Some(ref modal) = self.arranger.modal {
        fill_bg(buf, area, Nord::bg_lo(false, false));
        fill_fg(buf, area, Nord::bg_hi(false, false));
        modal.render(buf, area)?;
    }
    Ok(result)
});

handle!(ArrangerStandalone |self, e| {
    if let Some(modal) = self.arranger.modal.as_mut() {
        let result = modal.handle(e)?;
        if modal.exited() {
            self.arranger.modal = None;
        }
        Ok(result)
    } else {
        match e {
            AppEvent::Input(Event::Key(k)) => {
                if k.code == KeyCode::Tab {
                    self.arranger.focus_sequencer = !self.arranger.focus_sequencer;
                    Ok(true)
                } else if self.arranger.focus_sequencer {
                    if let Some(sequencer) = self.arranger.sequencer_mut() {
                        handle_keymap(sequencer, e, KEYMAP_SEQUENCER)
                    } else {
                        Ok(false)
                    }
                } else {
                    handle_keymap(&mut self.arranger, e, KEYMAP_ARRANGER)
                }
            },
            _ => Ok(false),
        }
    }
});