132 lines
3.4 KiB
Rust
132 lines
3.4 KiB
Rust
//! Color handling.
|
|
|
|
use std::fmt::{self, Debug, Formatter};
|
|
use std::str::FromStr;
|
|
|
|
/// An 8-bit RGBA color.
|
|
///
|
|
/// # Example
|
|
/// ```typst
|
|
/// [page: background=#423abaff]
|
|
/// ^^^^^^^^
|
|
/// ```
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub struct RgbaColor {
|
|
/// Red channel.
|
|
pub r: u8,
|
|
/// Green channel.
|
|
pub g: u8,
|
|
/// Blue channel.
|
|
pub b: u8,
|
|
/// Alpha channel.
|
|
pub a: u8,
|
|
/// Whether the color was provided as a fail-over by the parser because the
|
|
/// user-defined value was invalid.
|
|
///
|
|
/// If this is true, the color may be replaced with any color deemed
|
|
/// appropriate at the use-site.
|
|
pub healed: bool,
|
|
}
|
|
|
|
impl RgbaColor {
|
|
/// Constructs a new color.
|
|
pub fn new(r: u8, g: u8, b: u8, a: u8) -> Self {
|
|
Self { r, g, b, a, healed: false }
|
|
}
|
|
|
|
/// Constructs a new color with the healed property set to true.
|
|
pub fn new_healed(r: u8, g: u8, b: u8, a: u8) -> Self {
|
|
Self { r, g, b, a, healed: true }
|
|
}
|
|
}
|
|
|
|
impl FromStr for RgbaColor {
|
|
type Err = ParseColorError;
|
|
|
|
/// Constructs a new color from a hex string like `7a03c2`. Do not specify a
|
|
/// leading `#`.
|
|
fn from_str(hex_str: &str) -> Result<Self, Self::Err> {
|
|
if !hex_str.is_ascii() {
|
|
return Err(ParseColorError);
|
|
}
|
|
|
|
let len = hex_str.len();
|
|
let long = len == 6 || len == 8;
|
|
let short = len == 3 || len == 4;
|
|
let alpha = len == 4 || len == 8;
|
|
|
|
if !long && !short {
|
|
return Err(ParseColorError);
|
|
}
|
|
|
|
let mut values: [u8; 4] = [255; 4];
|
|
|
|
for elem in if alpha { 0 .. 4 } else { 0 .. 3 } {
|
|
let item_len = if long { 2 } else { 1 };
|
|
let pos = elem * item_len;
|
|
|
|
let item = &hex_str[pos .. (pos + item_len)];
|
|
values[elem] = u8::from_str_radix(item, 16).map_err(|_| ParseColorError)?;
|
|
|
|
if short {
|
|
// Duplicate number for shorthand notation, i.e. `a` -> `aa`
|
|
values[elem] += values[elem] * 16;
|
|
}
|
|
}
|
|
|
|
Ok(Self::new(values[0], values[1], values[2], values[3]))
|
|
}
|
|
}
|
|
|
|
impl Debug for RgbaColor {
|
|
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
|
|
if f.alternate() {
|
|
write!(
|
|
f,
|
|
"rgba({:02}, {:02}, {:02}, {:02})",
|
|
self.r, self.g, self.b, self.a,
|
|
)?;
|
|
} else {
|
|
write!(
|
|
f,
|
|
"#{:02x}{:02x}{:02x}{:02x}",
|
|
self.r, self.g, self.b, self.a,
|
|
)?;
|
|
}
|
|
if self.healed {
|
|
f.write_str(" [healed]")?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// The error when parsing an `RgbaColor` fails.
|
|
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
|
|
pub struct ParseColorError;
|
|
|
|
impl std::error::Error for ParseColorError {}
|
|
|
|
impl fmt::Display for ParseColorError {
|
|
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
|
|
f.pad("invalid color")
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn parse_color_strings() {
|
|
fn test(hex: &str, r: u8, g: u8, b: u8, a: u8) {
|
|
assert_eq!(RgbaColor::from_str(hex), Ok(RgbaColor::new(r, g, b, a)));
|
|
}
|
|
|
|
test("f61243ff", 0xf6, 0x12, 0x43, 0xff);
|
|
test("b3d8b3", 0xb3, 0xd8, 0xb3, 0xff);
|
|
test("fCd2a9AD", 0xfc, 0xd2, 0xa9, 0xad);
|
|
test("233", 0x22, 0x33, 0x33, 0xff);
|
|
test("111b", 0x11, 0x11, 0x11, 0xbb);
|
|
}
|
|
}
|