2022-12-26 15:33:04 -05:00
|
|
|
use std::fmt;
|
2020-01-04 22:55:04 -05:00
|
|
|
|
2020-07-08 21:39:30 -04:00
|
|
|
use crate::interner::InternedString;
|
|
|
|
|
|
2022-12-26 15:33:04 -05:00
|
|
|
pub(crate) use conversion::{known_compatibilities_by_unit, UNIT_CONVERSION_TABLE};
|
2020-03-18 10:08:40 -04:00
|
|
|
|
2020-03-19 16:24:31 -04:00
|
|
|
mod conversion;
|
2020-03-18 10:08:40 -04:00
|
|
|
|
2022-12-27 19:09:43 -05:00
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
|
2020-01-20 13:15:47 -05:00
|
|
|
pub(crate) enum Unit {
|
2020-01-04 22:55:04 -05:00
|
|
|
// Absolute units
|
|
|
|
|
/// Pixels
|
|
|
|
|
Px,
|
|
|
|
|
/// Millimeters
|
|
|
|
|
Mm,
|
|
|
|
|
/// Inches
|
|
|
|
|
In,
|
|
|
|
|
/// Centimeters
|
|
|
|
|
Cm,
|
|
|
|
|
/// Quarter-millimeters
|
|
|
|
|
Q,
|
|
|
|
|
/// Points
|
|
|
|
|
Pt,
|
|
|
|
|
/// Picas
|
|
|
|
|
Pc,
|
2020-01-25 10:11:26 -05:00
|
|
|
|
2020-01-04 22:55:04 -05:00
|
|
|
// Font relative units
|
|
|
|
|
/// Font size of the parent element
|
|
|
|
|
Em,
|
|
|
|
|
/// Font size of the root element
|
|
|
|
|
Rem,
|
|
|
|
|
/// Line height of the element
|
|
|
|
|
Lh,
|
|
|
|
|
/// x-height of the element's font
|
|
|
|
|
Ex,
|
|
|
|
|
/// The advance measure (width) of the glyph "0" of the element's font
|
|
|
|
|
Ch,
|
2020-04-17 13:06:54 -04:00
|
|
|
/// Represents the "cap height" (nominal height of capital letters) of the element's font
|
2020-01-04 22:55:04 -05:00
|
|
|
Cap,
|
2020-04-17 13:06:54 -04:00
|
|
|
/// Equal to the used advance measure of the "水" (CJK water ideograph, U+6C34) glyph
|
|
|
|
|
/// found in the font used to render it
|
2020-01-04 22:55:04 -05:00
|
|
|
Ic,
|
2020-04-17 13:06:54 -04:00
|
|
|
/// Equal to the computed value of the line-height property on the root element
|
|
|
|
|
/// (typically <html>), converted to an absolute length
|
2020-01-04 22:55:04 -05:00
|
|
|
Rlh,
|
|
|
|
|
|
|
|
|
|
// Viewport relative units
|
|
|
|
|
/// 1% of the viewport's width
|
|
|
|
|
Vw,
|
|
|
|
|
/// 1% of the viewport's height
|
|
|
|
|
Vh,
|
|
|
|
|
/// 1% of the viewport's smaller dimension
|
|
|
|
|
Vmin,
|
|
|
|
|
/// 1% of the viewport's larger dimension
|
|
|
|
|
Vmax,
|
2020-04-17 13:06:54 -04:00
|
|
|
/// Equal to 1% of the size of the initial containing block, in the direction of the root
|
|
|
|
|
/// element's inline axis
|
2020-01-04 22:55:04 -05:00
|
|
|
Vi,
|
2020-04-17 13:06:54 -04:00
|
|
|
/// Equal to 1% of the size of the initial containing block, in the direction of the root
|
|
|
|
|
/// element's block axis
|
2020-01-04 22:55:04 -05:00
|
|
|
Vb,
|
|
|
|
|
|
|
|
|
|
// Angle units
|
|
|
|
|
/// Represents an angle in degrees. One full circle is 360deg
|
|
|
|
|
Deg,
|
|
|
|
|
/// Represents an angle in gradians. One full circle is 400grad
|
|
|
|
|
Grad,
|
2020-04-17 13:06:54 -04:00
|
|
|
/// Represents an angle in radians. One full circle is 2π radians which approximates to 6.283rad
|
2020-01-04 22:55:04 -05:00
|
|
|
Rad,
|
|
|
|
|
/// Represents an angle in a number of turns. One full circle is 1turn
|
|
|
|
|
Turn,
|
|
|
|
|
|
|
|
|
|
// Time units
|
|
|
|
|
/// Represents a time in seconds
|
|
|
|
|
S,
|
|
|
|
|
/// Represents a time in milliseconds
|
|
|
|
|
Ms,
|
|
|
|
|
|
|
|
|
|
// Frequency units
|
|
|
|
|
/// Represents a frequency in hertz
|
|
|
|
|
Hz,
|
|
|
|
|
/// Represents a frequency in kilohertz
|
|
|
|
|
Khz,
|
|
|
|
|
|
|
|
|
|
// Resolution units
|
|
|
|
|
/// Represents the number of dots per inch
|
|
|
|
|
Dpi,
|
|
|
|
|
/// Represents the number of dots per centimeter
|
|
|
|
|
Dpcm,
|
|
|
|
|
/// Represents the number of dots per px unit
|
|
|
|
|
Dppx,
|
|
|
|
|
|
2020-01-25 10:11:26 -05:00
|
|
|
// Other units
|
2020-01-04 22:55:04 -05:00
|
|
|
/// Represents a fraction of the available space in the grid container
|
|
|
|
|
Fr,
|
2020-02-15 08:16:17 -05:00
|
|
|
Percent,
|
2020-01-22 00:54:43 -05:00
|
|
|
|
|
|
|
|
/// Unknown unit
|
2020-07-08 21:39:30 -04:00
|
|
|
Unknown(InternedString),
|
2020-01-04 22:55:04 -05:00
|
|
|
/// Unspecified unit
|
|
|
|
|
None,
|
2020-03-16 21:29:00 -04:00
|
|
|
|
2022-12-27 19:09:43 -05:00
|
|
|
Complex(Box<ComplexUnit>),
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
|
|
|
|
|
pub(crate) struct ComplexUnit {
|
|
|
|
|
pub(crate) numer: Vec<Unit>,
|
|
|
|
|
pub(crate) denom: Vec<Unit>,
|
2022-12-26 15:33:04 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub(crate) fn are_any_convertible(units1: &[Unit], units2: &[Unit]) -> bool {
|
|
|
|
|
for unit1 in units1 {
|
|
|
|
|
for unit2 in units2 {
|
|
|
|
|
if unit1.comparable(unit2) {
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2020-07-04 11:04:51 -04:00
|
|
|
|
2022-12-26 15:33:04 -05:00
|
|
|
false
|
2020-01-04 22:55:04 -05:00
|
|
|
}
|
2022-12-26 15:33:04 -05:00
|
|
|
|
2020-02-15 08:16:17 -05:00
|
|
|
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
|
|
|
|
|
pub(crate) enum UnitKind {
|
|
|
|
|
Absolute,
|
|
|
|
|
FontRelative,
|
|
|
|
|
ViewportRelative,
|
|
|
|
|
Angle,
|
|
|
|
|
Time,
|
|
|
|
|
Frequency,
|
|
|
|
|
Resolution,
|
|
|
|
|
Other,
|
|
|
|
|
None,
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-26 15:33:04 -05:00
|
|
|
impl Unit {
|
|
|
|
|
pub fn new(mut numer: Vec<Self>, denom: Vec<Self>) -> Self {
|
|
|
|
|
if denom.is_empty() && numer.is_empty() {
|
|
|
|
|
Unit::None
|
|
|
|
|
} else if denom.is_empty() && numer.len() == 1 {
|
|
|
|
|
numer.pop().unwrap()
|
2020-07-04 11:04:51 -04:00
|
|
|
} else {
|
2022-12-27 19:09:43 -05:00
|
|
|
Unit::Complex(Box::new(ComplexUnit { numer, denom }))
|
2020-07-04 11:04:51 -04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-26 15:33:04 -05:00
|
|
|
pub fn numer_and_denom(self) -> (Vec<Unit>, Vec<Unit>) {
|
|
|
|
|
match self {
|
2022-12-27 19:09:43 -05:00
|
|
|
Self::Complex(complex) => (complex.numer, complex.denom),
|
2022-12-26 15:33:04 -05:00
|
|
|
Self::None => (Vec::new(), Vec::new()),
|
|
|
|
|
v => (vec![v], Vec::new()),
|
2020-07-04 11:04:51 -04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-26 15:33:04 -05:00
|
|
|
pub fn invert(self) -> Self {
|
|
|
|
|
let (numer, denom) = self.numer_and_denom();
|
2020-07-04 11:04:51 -04:00
|
|
|
|
2022-12-26 15:33:04 -05:00
|
|
|
Self::new(denom, numer)
|
2020-07-04 11:04:51 -04:00
|
|
|
}
|
|
|
|
|
|
2022-12-26 15:33:04 -05:00
|
|
|
pub fn is_complex(&self) -> bool {
|
2022-12-27 19:09:43 -05:00
|
|
|
matches!(self, Unit::Complex(complex) if complex.numer.len() != 1 || !complex.denom.is_empty())
|
2020-07-04 11:04:51 -04:00
|
|
|
}
|
|
|
|
|
|
2020-02-15 08:16:17 -05:00
|
|
|
pub fn comparable(&self, other: &Unit) -> bool {
|
2020-03-31 02:10:22 -04:00
|
|
|
if other == &Unit::None {
|
|
|
|
|
return true;
|
|
|
|
|
}
|
2020-02-15 08:16:17 -05:00
|
|
|
match self.kind() {
|
|
|
|
|
UnitKind::FontRelative | UnitKind::ViewportRelative | UnitKind::Other => self == other,
|
|
|
|
|
UnitKind::None => true,
|
2020-03-31 02:10:22 -04:00
|
|
|
u => other.kind() == u,
|
2020-02-15 08:16:17 -05:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-17 13:12:06 -04:00
|
|
|
/// Used internally to determine if two units are comparable or not
|
|
|
|
|
fn kind(&self) -> UnitKind {
|
2020-02-15 08:16:17 -05:00
|
|
|
match self {
|
2020-02-16 11:59:04 -05:00
|
|
|
Unit::Px | Unit::Mm | Unit::In | Unit::Cm | Unit::Q | Unit::Pt | Unit::Pc => {
|
|
|
|
|
UnitKind::Absolute
|
|
|
|
|
}
|
2020-02-15 08:16:17 -05:00
|
|
|
Unit::Em
|
|
|
|
|
| Unit::Rem
|
|
|
|
|
| Unit::Lh
|
|
|
|
|
| Unit::Ex
|
|
|
|
|
| Unit::Ch
|
|
|
|
|
| Unit::Cap
|
|
|
|
|
| Unit::Ic
|
|
|
|
|
| Unit::Rlh => UnitKind::FontRelative,
|
2020-02-16 11:59:04 -05:00
|
|
|
Unit::Vw | Unit::Vh | Unit::Vmin | Unit::Vmax | Unit::Vi | Unit::Vb => {
|
|
|
|
|
UnitKind::ViewportRelative
|
|
|
|
|
}
|
|
|
|
|
Unit::Deg | Unit::Grad | Unit::Rad | Unit::Turn => UnitKind::Angle,
|
|
|
|
|
Unit::S | Unit::Ms => UnitKind::Time,
|
|
|
|
|
Unit::Hz | Unit::Khz => UnitKind::Frequency,
|
2022-12-26 15:33:04 -05:00
|
|
|
Unit::Dpi | Unit::Dpcm | Unit::Dppx => UnitKind::Resolution,
|
2020-02-15 08:16:17 -05:00
|
|
|
Unit::None => UnitKind::None,
|
2022-12-26 15:33:04 -05:00
|
|
|
Unit::Fr | Unit::Percent | Unit::Unknown(..) | Unit::Complex { .. } => UnitKind::Other,
|
2020-02-15 08:16:17 -05:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-06 12:01:40 -04:00
|
|
|
impl From<String> for Unit {
|
|
|
|
|
fn from(unit: String) -> Self {
|
|
|
|
|
match unit.to_ascii_lowercase().as_str() {
|
|
|
|
|
"px" => Unit::Px,
|
|
|
|
|
"mm" => Unit::Mm,
|
|
|
|
|
"in" => Unit::In,
|
|
|
|
|
"cm" => Unit::Cm,
|
|
|
|
|
"q" => Unit::Q,
|
|
|
|
|
"pt" => Unit::Pt,
|
|
|
|
|
"pc" => Unit::Pc,
|
|
|
|
|
"em" => Unit::Em,
|
|
|
|
|
"rem" => Unit::Rem,
|
|
|
|
|
"lh" => Unit::Lh,
|
|
|
|
|
"%" => Unit::Percent,
|
|
|
|
|
"ex" => Unit::Ex,
|
|
|
|
|
"ch" => Unit::Ch,
|
|
|
|
|
"cap" => Unit::Cap,
|
|
|
|
|
"ic" => Unit::Ic,
|
|
|
|
|
"rlh" => Unit::Rlh,
|
|
|
|
|
"vw" => Unit::Vw,
|
|
|
|
|
"vh" => Unit::Vh,
|
|
|
|
|
"vmin" => Unit::Vmin,
|
|
|
|
|
"vmax" => Unit::Vmax,
|
|
|
|
|
"vi" => Unit::Vi,
|
|
|
|
|
"vb" => Unit::Vb,
|
|
|
|
|
"deg" => Unit::Deg,
|
|
|
|
|
"grad" => Unit::Grad,
|
|
|
|
|
"rad" => Unit::Rad,
|
|
|
|
|
"turn" => Unit::Turn,
|
|
|
|
|
"s" => Unit::S,
|
|
|
|
|
"ms" => Unit::Ms,
|
|
|
|
|
"hz" => Unit::Hz,
|
|
|
|
|
"khz" => Unit::Khz,
|
|
|
|
|
"dpi" => Unit::Dpi,
|
|
|
|
|
"dpcm" => Unit::Dpcm,
|
|
|
|
|
"dppx" => Unit::Dppx,
|
|
|
|
|
"fr" => Unit::Fr,
|
2020-07-08 21:39:30 -04:00
|
|
|
_ => Unit::Unknown(InternedString::get_or_intern(unit)),
|
2020-01-04 22:55:04 -05:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl fmt::Display for Unit {
|
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
|
|
|
match self {
|
|
|
|
|
Unit::Px => write!(f, "px"),
|
|
|
|
|
Unit::Mm => write!(f, "mm"),
|
|
|
|
|
Unit::In => write!(f, "in"),
|
|
|
|
|
Unit::Cm => write!(f, "cm"),
|
2020-03-18 10:08:40 -04:00
|
|
|
Unit::Q => write!(f, "q"),
|
2020-01-04 22:55:04 -05:00
|
|
|
Unit::Pt => write!(f, "pt"),
|
|
|
|
|
Unit::Pc => write!(f, "pc"),
|
|
|
|
|
Unit::Em => write!(f, "em"),
|
|
|
|
|
Unit::Rem => write!(f, "rem"),
|
|
|
|
|
Unit::Lh => write!(f, "lh"),
|
|
|
|
|
Unit::Percent => write!(f, "%"),
|
|
|
|
|
Unit::Ex => write!(f, "ex"),
|
|
|
|
|
Unit::Ch => write!(f, "ch"),
|
|
|
|
|
Unit::Cap => write!(f, "cap"),
|
|
|
|
|
Unit::Ic => write!(f, "ic"),
|
|
|
|
|
Unit::Rlh => write!(f, "rlh"),
|
|
|
|
|
Unit::Vw => write!(f, "vw"),
|
|
|
|
|
Unit::Vh => write!(f, "vh"),
|
|
|
|
|
Unit::Vmin => write!(f, "vmin"),
|
|
|
|
|
Unit::Vmax => write!(f, "vmax"),
|
|
|
|
|
Unit::Vi => write!(f, "vi"),
|
|
|
|
|
Unit::Vb => write!(f, "vb"),
|
|
|
|
|
Unit::Deg => write!(f, "deg"),
|
|
|
|
|
Unit::Grad => write!(f, "grad"),
|
|
|
|
|
Unit::Rad => write!(f, "rad"),
|
|
|
|
|
Unit::Turn => write!(f, "turn"),
|
|
|
|
|
Unit::S => write!(f, "s"),
|
|
|
|
|
Unit::Ms => write!(f, "ms"),
|
|
|
|
|
Unit::Hz => write!(f, "Hz"),
|
|
|
|
|
Unit::Khz => write!(f, "kHz"),
|
|
|
|
|
Unit::Dpi => write!(f, "dpi"),
|
|
|
|
|
Unit::Dpcm => write!(f, "dpcm"),
|
2020-01-17 14:44:55 -05:00
|
|
|
Unit::Dppx => write!(f, "dppx"),
|
2020-01-04 22:55:04 -05:00
|
|
|
Unit::Fr => write!(f, "fr"),
|
2020-01-22 00:54:43 -05:00
|
|
|
Unit::Unknown(s) => write!(f, "{}", s),
|
2020-05-06 12:01:40 -04:00
|
|
|
Unit::None => Ok(()),
|
2022-12-27 19:09:43 -05:00
|
|
|
Unit::Complex(complex) => {
|
|
|
|
|
let numer = &complex.numer;
|
|
|
|
|
let denom = &complex.denom;
|
2022-12-26 15:33:04 -05:00
|
|
|
debug_assert!(
|
|
|
|
|
numer.len() > 1 || !denom.is_empty(),
|
|
|
|
|
"unsimplified complex unit"
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
let numer_rendered = numer
|
|
|
|
|
.iter()
|
|
|
|
|
.map(ToString::to_string)
|
|
|
|
|
.collect::<Vec<String>>()
|
|
|
|
|
.join("*");
|
|
|
|
|
|
|
|
|
|
let denom_rendered = denom
|
|
|
|
|
.iter()
|
2020-03-18 20:11:14 -04:00
|
|
|
.map(ToString::to_string)
|
2020-03-17 10:06:24 -04:00
|
|
|
.collect::<Vec<String>>()
|
2022-12-26 15:33:04 -05:00
|
|
|
.join("*");
|
|
|
|
|
|
|
|
|
|
if denom.is_empty() {
|
|
|
|
|
write!(f, "{}", numer_rendered)
|
|
|
|
|
} else if numer.is_empty() && denom.len() == 1 {
|
|
|
|
|
write!(f, "{}^-1", denom_rendered)
|
|
|
|
|
} else if numer.is_empty() {
|
|
|
|
|
write!(f, "({})^-1", denom_rendered)
|
|
|
|
|
} else {
|
|
|
|
|
write!(f, "{}/{}", numer_rendered, denom_rendered)
|
|
|
|
|
}
|
|
|
|
|
}
|
2020-01-04 22:55:04 -05:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
