summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorPhilipp Gesang <phg@phi-gamma.net>2021-12-12 10:54:20 +0100
committerPhilipp Gesang <phg@phi-gamma.net>2021-12-12 10:55:19 +0100
commit193318b7b59b02f66c27550cb9bd55b8a23715bc (patch)
tree19fa8bb114afd124cf90db88b5188e818765a5ac /src
parent39e5145258d6cdf189d973b7acf9d8fb98f7e5ee (diff)
downloadvtcol-193318b7b59b02f66c27550cb9bd55b8a23715bc.tar.gz
bin: refactor job into member functions + trait
Diffstat (limited to 'src')
-rw-r--r--src/vtcol.rs410
1 files changed, 222 insertions, 188 deletions
diff --git a/src/vtcol.rs b/src/vtcol.rs
index 0daccb0..3578986 100644
--- a/src/vtcol.rs
+++ b/src/vtcol.rs
@@ -18,6 +18,11 @@ macro_rules! vrb {
)}
}
+trait Run
+{
+ fn run(self) -> Result<()>;
+}
+
#[derive(Debug)]
enum LedJob
{
@@ -31,6 +36,85 @@ enum LedJob
SetIndividual(Option<bool>, Option<bool>, Option<bool>),
}
+impl Run for LedJob
+{
+ fn run(self) -> Result<()>
+ {
+ match self {
+ Self::Get(raw) => Self::get(raw),
+ Self::Revert => Self::revert(),
+ Self::Set(st) => Self::set(st),
+ Self::SetIndividual(c, n, s) => Self::set_individual(c, n, s),
+ }
+ }
+} /* [impl Run for LedJob] */
+
+impl LedJob
+{
+ /** Get the keyboard LED state. */
+ fn get(raw: bool) -> Result<()>
+ {
+ let fd = Console::current()?;
+ vrb!("console fd: {}", fd);
+
+ let leds = KbLedState::get(&fd)?;
+
+ if raw {
+ println!("{}", u8::from(leds));
+ } else {
+ println!("{}", leds);
+ }
+
+ Ok(())
+ }
+
+ /** Set the keyboard LED state. */
+ fn set(st: KbLedState) -> Result<()>
+ {
+ let fd = Console::current()?;
+ vrb!("console fd: {}", fd);
+
+ st.set(&fd)?;
+ vrb!("applied");
+
+ Ok(())
+ }
+
+ /** Set the state of the given LEDs using the current state as base. */
+ fn set_individual(
+ cap: Option<bool>,
+ num: Option<bool>,
+ scr: Option<bool>,
+ ) -> Result<()>
+ {
+ let fd = Console::current()?;
+ vrb!("console fd: {}", fd);
+
+ let mut st = KbLedState::get(&fd)?;
+
+ cap.map(|b| st.set_cap(b));
+ num.map(|b| st.set_num(b));
+ scr.map(|b| st.set_scr(b));
+
+ st.set(&fd)?;
+ vrb!("applied");
+
+ Ok(())
+ }
+
+ /** Revert the keyboard LED state. */
+ fn revert() -> Result<()>
+ {
+ let fd = Console::current()?;
+ vrb!("console fd: {}", fd);
+
+ KbLedState::revert(&fd)?;
+ vrb!("reverted");
+
+ Ok(())
+ }
+} /* [impl LedJob] */
+
#[derive(Debug)]
enum ColorJob
{
@@ -48,6 +132,138 @@ enum ColorJob
Fade(Option<Scheme>, Scheme, Duration, u8, bool),
}
+impl Run for ColorJob
+{
+ fn run(self) -> Result<()>
+ {
+ match self {
+ Self::Dump(scm) => Self::dump(scm),
+ Self::List => Self::list(),
+ Self::Set(scm) => Self::set(scm),
+ Self::Get(b64) => Self::get(b64),
+ Self::Toggle(one, two) => Self::toggle(one, two),
+ Self::Fade(from, to, ms, hz, clear) =>
+ Self::fade(from, to, ms, hz, clear),
+ }
+ }
+} /* [impl Run for ColorJob] */
+
+impl ColorJob
+{
+ fn list() -> Result<()>
+ {
+ println!("{} color schemes available:", vtcol::BUILTIN_SCHEMES.len());
+ for s in vtcol::BUILTIN_SCHEMES {
+ println!(" * {}", s.name());
+ }
+
+ Ok(())
+ }
+
+ 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 set(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(b64: bool) -> Result<()>
+ {
+ let fd = Console::current()?;
+ vrb!("console fd: {}", fd);
+
+ let scm = fd.current_scheme()?;
+ if b64 {
+ print!("{}", scm.base64()?);
+ } else {
+ vrb!("active scheme:");
+ println!("{}", scm);
+ }
+
+ Ok(())
+ }
+
+ /** Toggle between two schemes. Defaults to ``one`` in case neither scheme
+ is active.
+ */
+ fn toggle(one: Scheme, two: Scheme) -> Result<()>
+ {
+ let fd = Console::current()?;
+ vrb!("console fd: {}", fd);
+
+ if fd.current_palette()? == Palette::try_from(&one)? {
+ Self::set(two)
+ } else {
+ Self::set(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,
+ clear: bool,
+ ) -> 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, clear);
+
+ fade.commence(&fd)?;
+ Ok(())
+ }
+} /* [impl ColorJob] */
+
/** Subcommand and runtime parameters. */
#[derive(Debug)]
enum Job
@@ -429,208 +645,26 @@ impl<'a> Job
}
}
- 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()
}
+} /* [impl Job] */
- 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)),
- }
- }
-
+impl Run for Job
+{
fn run(self) -> Result<()>
{
match self {
- Self::Colors(ColorJob::Dump(scm)) => Self::dump(scm)?,
- Self::Colors(ColorJob::List) => Self::list_schemes(),
- Self::Colors(ColorJob::Set(scm)) => Self::set_scheme(scm)?,
- Self::Colors(ColorJob::Get(b64)) => Self::get_scheme(b64)?,
- Self::Colors(ColorJob::Toggle(one, two)) =>
- Self::toggle_scheme(one, two)?,
- Self::Colors(ColorJob::Fade(from, to, ms, hz, clear)) =>
- Self::fade(from, to, ms, hz, clear)?,
- Self::Leds(LedJob::Get(raw)) => Self::get_leds(raw)?,
- Self::Leds(LedJob::Revert) => Self::revert_leds()?,
- Self::Leds(LedJob::Set(st)) => Self::set_leds(st)?,
- Self::Leds(LedJob::SetIndividual(c, n, s)) =>
- Self::set_leds_individual(c, n, s)?,
- }
-
- 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(b64: bool) -> Result<()>
- {
- let fd = Console::current()?;
- vrb!("console fd: {}", fd);
-
- let scm = fd.current_scheme()?;
- if b64 {
- print!("{}", scm.base64()?);
- } else {
- 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,
- clear: bool,
- ) -> 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, clear);
-
- fade.commence(&fd)?;
- Ok(())
- }
-
- /** Get the keyboard LED state. */
- fn get_leds(raw: bool) -> Result<()>
- {
- let fd = Console::current()?;
- vrb!("console fd: {}", fd);
-
- let leds = KbLedState::get(&fd)?;
-
- if raw {
- println!("{}", u8::from(leds));
- } else {
- println!("{}", leds);
+ Self::Colors(cols) => cols.run()?,
+ Self::Leds(leds) => leds.run()?,
}
Ok(())
}
-
- /** Set the keyboard LED state. */
- fn set_leds(st: KbLedState) -> Result<()>
- {
- let fd = Console::current()?;
- vrb!("console fd: {}", fd);
-
- st.set(&fd)?;
- vrb!("applied");
-
- Ok(())
- }
-
- /** Set the state of the given LEDs using the current state as base. */
- fn set_leds_individual(
- cap: Option<bool>,
- num: Option<bool>,
- scr: Option<bool>,
- ) -> Result<()>
- {
- let fd = Console::current()?;
- vrb!("console fd: {}", fd);
-
- let mut st = KbLedState::get(&fd)?;
-
- cap.map(|b| st.set_cap(b));
- num.map(|b| st.set_num(b));
- scr.map(|b| st.set_scr(b));
-
- st.set(&fd)?;
- vrb!("applied");
-
- Ok(())
- }
-
- /** Revert the keyboard LED state. */
- fn revert_leds() -> Result<()>
- {
- let fd = Console::current()?;
- vrb!("console fd: {}", fd);
-
- KbLedState::revert(&fd)?;
- vrb!("reverted");
-
- Ok(())
- }
-} /* [impl Job] */
+} /* [impl Run for Job] */
fn main() -> Result<()>
{