path: root/src/vtcol.rs

pub mod lib;

use vtcol::{Console, Fade, Palette, Scheme};

use anyhow::{anyhow, Result};
use std::{io::{self, BufWriter},
          sync::atomic::{AtomicBool, Ordering},
          time::Duration};

static VERBOSITY: AtomicBool = AtomicBool::new(false);

const DEFAULT_FADE_DURATION_MS: u64 = 500;
const DEFAULT_FADE_UPDATE_HZ: u8 = 25;

macro_rules! vrb {
    ( $( $e:expr ),* ) => {(
            if VERBOSITY.load(Ordering::SeqCst) { println!( $( $e ),* ) }
    )}
}

/* struct Job -- Runtime parameters.
 */
#[derive(Debug)]
enum Job
{
    /** List available schemes. */
    List,
    /** Dump a scheme. */
    Dump(Scheme),
    /** Switch to color scheme. */
    Set(Scheme),
    /** Get currently active scheme. */
    Get,
    /** Toggle between two schemes. */
    Toggle(Scheme, Scheme),
    /** Fade from current scheme to another. */
    Fade(Option<Scheme>, Scheme, Duration, u8),
}

impl<'a> Job
{
    pub fn from_argv() -> Result<Job>
    {
        use clap::{App, Arg, SubCommand};

        let app = App::new(clap::crate_name!())
            .version(clap::crate_version!())
            .author(clap::crate_authors!())
            .about(clap::crate_description!())
            .subcommand(
                SubCommand::with_name("dump").about("dump a color scheme").arg(
                    Arg::with_name("scheme")
                        .help("name of the scheme")
                        .required(true)
                        .value_name("NAME")
                        .takes_value(true),
                ),
            )
            .subcommand(
                SubCommand::with_name("list").about("list available schemes"),
            )
            .subcommand(
                SubCommand::with_name("set")
                    .about("apply color scheme to current terminal")
                    .arg(
                        Arg::with_name("scheme")
                            .value_name("NAME")
                            .help("predefined color scheme")
                            .takes_value(true)
                            .conflicts_with("file"),
                    )
                    .arg(
                        Arg::with_name("file")
                            .short("f")
                            .long("file")
                            .value_name("PATH")
                            .help("apply scheme from file")
                            .takes_value(true),
                    ),
            )
            .subcommand(
                SubCommand::with_name("get").about("get current color scheme"),
            )
            .subcommand(
                SubCommand::with_name("toggle")
                    .about("toggle between two schemes")
                    .arg(
                        Arg::with_name("one")
                            .value_name("NAME1")
                            .help("predefined color scheme")
                            .takes_value(true),
                    )
                    .arg(
                        Arg::with_name("two")
                            .value_name("NAME2")
                            .help("predefined color scheme")
                            .takes_value(true),
                    ),
            )
            .subcommand(
                SubCommand::with_name("fade")
                    .about("fade from one scheme to another")
                    .arg(
                        Arg::with_name("from")
                            .short("f")
                            .long("from")
                            .value_name("NAME1")
                            .help("initial color scheme (default: current)")
                            .takes_value(true),
                    )
                    .arg(
                        Arg::with_name("to")
                            .short("t")
                            .long("to")
                            .value_name("NAME2")
                            .help("final color scheme")
                            .takes_value(true)
                            .required(true),
                    )
                    .arg(
                        Arg::with_name("ms")
                            .value_name("MS")
                            .short("m")
                            .long("ms")
                            .help("how long (in ms) the fade should take")
                            .takes_value(true),
                    )
                    .arg(
                        Arg::with_name("frequency")
                            .value_name("HZ")
                            .short("h")
                            .long("frequency")
                            .help("rate (HZ/s) of intermediate scheme changes")
                            .takes_value(true),
                    ),
            )
            .arg(
                Arg::with_name("verbose")
                    .short("v")
                    .long("verbose")
                    .help("enable extra diagnostics")
                    .takes_value(false),
            );

        let matches = app.get_matches();

        if matches.is_present("verbose") {
            VERBOSITY.store(true, Ordering::SeqCst);
        }

        match matches.subcommand() {
            ("dump", Some(subm)) => {
                if let Some(name) = subm.value_of("scheme") {
                    let scm = Scheme::from(name);
                    return Ok(Self::Dump(scm));
                }
                Err(anyhow!("dump requires an argument"))
            },
            ("list", _) => Ok(Self::List),
            ("set", Some(subm)) => {
                let scheme = match subm.value_of("scheme") {
                    Some("-") => Self::read_scheme_from_stdin(),
                    Some(name) => {
                        vrb!("pick predefined scheme [{}]", name);
                        Scheme::from(name)
                    },
                    None =>
                        match subm.value_of("file") {
                            None | Some("-") => Self::read_scheme_from_stdin(),
                            Some(fname) => {
                                vrb!(
                                    "read custom scheme from file [{}]",
                                    fname
                                );
                                Scheme::from_path(fname)
                            },
                        },
                };
                Ok(Self::Set(scheme))
            },
            ("get", _) => Ok(Self::Get),
            ("toggle", Some(subm)) => {
                match (subm.value_of("one"), subm.value_of("two")) {
                    (Some(one), Some(two)) => {
                        vrb!("toggle schemes [{}] and [{}]", one, two);
                        Ok(Self::Toggle(Scheme::from(one), Scheme::from(two)))
                    },
                    _ =>
                        Err(anyhow!(
                            "please supply two schemes to toggle between"
                        )),
                }
            },
            ("fade", Some(subm)) => {
                let dur: u64 = if let Some(ms) = subm.value_of("ms") {
                    ms.parse()?
                } else {
                    DEFAULT_FADE_DURATION_MS
                };
                let hz: u8 = if let Some(ms) = subm.value_of("frequency") {
                    ms.parse()?
                } else {
                    DEFAULT_FADE_UPDATE_HZ
                };
                let dur = Duration::from_millis(dur);

                match (subm.value_of("from"), subm.value_of("to")) {
                    (_, None) =>
                        Err(anyhow!("please supply color scheme to fade to")),
                    (from, Some(to)) =>
                        Ok(Self::Fade(
                            from.map(Scheme::from),
                            Scheme::from(to),
                            dur,
                            hz,
                        )),
                }
            },
            (junk, _) =>
                Err(anyhow!(
                    "invalid subcommand [{}]; try ``{} --help``",
                    junk,
                    clap::crate_name!()
                )),
        }
    }

    fn list_schemes()
    {
        println!("{} color schemes available:", vtcol::BUILTIN_SCHEMES.len());
        for s in vtcol::BUILTIN_SCHEMES {
            println!("      * {}", s.name());
        }
    }

    fn read_scheme_from_stdin() -> Scheme
    {
        vrb!("Go ahead, type your color scheme …");
        vrb!("vtcol>");
        Scheme::from_stdin()
    }

    fn dump(scm: Scheme) -> Result<()>
    {
        vrb!("Dumping color scheme {}", scm);
        let mut out = BufWriter::new(io::stdout());

        match scm {
            Scheme::Builtin(bltn) =>
                Palette::from(bltn.palette()).dump(&mut out).map_err(|e| {
                    anyhow!(
                        "error loading builtin scheme {}: {}",
                        bltn.name(),
                        e
                    )
                }),
            Scheme::Custom(None) =>
                Palette::from_stdin()?.dump(&mut out).map_err(|e| {
                    anyhow!("error loading palette from stdin: {}", e)
                }),
            Scheme::Custom(Some(fname)) =>
                Palette::from_file(&fname)?.dump(&mut out).map_err(|e| {
                    anyhow!(
                        "error loading palette from file [{}]: {}",
                        fname.display(),
                        e
                    )
                }),
            Scheme::Palette(pal) =>
                pal.dump(&mut out)
                    .map_err(|e| anyhow!("error dumping palette: {}", e)),
        }
    }

    fn run(self) -> Result<()>
    {
        match self {
            Self::Dump(scm) => Self::dump(scm)?,
            Self::List => Self::list_schemes(),
            Self::Set(scm) => Self::set_scheme(scm)?,
            Self::Get => Self::get_scheme()?,
            Self::Toggle(one, two) => Self::toggle_scheme(one, two)?,
            Self::Fade(from, to, ms, hz) => Self::fade(from, to, ms, hz)?,
        }

        Ok(())
    }

    fn set_scheme(scheme: Scheme) -> Result<()>
    {
        let con = Console::current()?;
        vrb!("console fd: {}", con);

        con.apply_scheme(&scheme)?;
        con.clear()?;

        vrb!("successfully enabled scheme {:?}", scheme);
        /* It’s fine to leak the fd, the kernel will clean up anyways. */
        Ok(())
    }

    fn get_scheme() -> Result<()>
    {
        let fd = Console::current()?;
        vrb!("console fd: {}", fd);

        let scm = fd.current_scheme()?;

        vrb!("active scheme:");
        println!("{}", scm);

        Ok(())
    }

    /** Toggle between two schemes. Defaults to ``one`` in case neither scheme
    is active.
    */
    fn toggle_scheme(one: Scheme, two: Scheme) -> Result<()>
    {
        let fd = Console::current()?;
        vrb!("console fd: {}", fd);

        if fd.current_palette()? == Palette::try_from(&one)? {
            Self::set_scheme(two)
        } else {
            Self::set_scheme(one)
        }
    }

    /** Fade from one scheme to another.

    If ``from`` is ``None``, the current palette is used as starting point. */
    fn fade(
        from: Option<Scheme>,
        to: Scheme,
        dur: Duration,
        hz: u8,
    ) -> Result<()>
    {
        let fd = Console::current()?;
        vrb!("console fd: {}", fd);

        let from = if let Some(from) = from {
            Palette::try_from(&from)?
        } else {
            fd.current_palette()?
        };
        let to = Palette::try_from(&to)?;

        let fade = Fade::new(from, to, dur, hz);

        fade.commence(&fd)?;
        Ok(())
    }
} /* [impl Job] */

fn main() -> Result<()>
{
    let job = Job::from_argv()?;
    vrb!("job parms: {:?}", job);

    job.run()
}