use crate::prelude::*;
crate::macros::easy_enum! {row-gap normal [unit]}
crate::macros::easy_enum! {column-gap normal [unit]}
crate::macros::easy_enum! {grid-gap normal [unit]}
#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy, PartialOrd, Ord)]
pub enum GridSpan {
Auto,
Initial,
Inherit,
Unset,
Span(i32),
Absolute(i32),
}
impl std::fmt::Display for GridSpan {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Auto => "auto".fmt(f),
Self::Initial => "initial".fmt(f),
Self::Inherit => "inherit".fmt(f),
Self::Unset => "unset".fmt(f),
Self::Span(x) => write!(f, "span {}", x),
Self::Absolute(x) => x.fmt(f),
}
}
}
#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy, PartialOrd, Ord)]
pub enum GridAutoFlow {
Inherit,
Initial,
Unset,
Row,
Column,
RowDense,
ColumnDense,
}
#[rustfmt::skip]
impl std::fmt::Display for GridAutoFlow {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Inherit => "grid-auto-flow:inherit;".fmt(f),
Self::Initial => "grid-auto-flow:initial;".fmt(f),
Self::Unset => "grid-auto-flow:unset;".fmt(f),
Self::Row => "grid-auto-flow:row;".fmt(f),
Self::Column => "grid-auto-flow:column;".fmt(f),
Self::RowDense => "grid-auto-flow:row dense;".fmt(f),
Self::ColumnDense => "grid-auto-flow:column dense;".fmt(f),
}
}
}
#[macro_export]
macro_rules! grid_auto_flow {
(inherit) => {$crate::Property::GridAutoFlow($crate::GridAutoFlow::Inherit)};
(initial) => {$crate::Property::GridAutoFlow($crate::GridAutoFlow::Initial)};
(unset) => {$crate::Property::GridAutoFlow($crate::GridAutoFlow::Unset)};
(row) => {$crate::Property::GridAutoFlow($crate::GridAutoFlow::Row)};
(column) => {$crate::Property::GridAutoFlow($crate::GridAutoFlow::Column)};
(row dense) => {$crate::Property::GridAutoFlow($crate::GridAutoFlow::RowDense)};
(column dense) => {$crate::Property::GridAutoFlow($crate::GridAutoFlow::ColumnDense)};
}
#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy, PartialOrd, Ord)]
pub enum GridRepeatNumber {
AutoFit,
AutoFill,
Some(u32),
}
#[rustfmt::skip]
impl std::fmt::Display for GridRepeatNumber {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::AutoFit => "auto-fit".fmt(f),
Self::AutoFill => "auto-fill".fmt(f),
Self::Some(x) => x.fmt(f),
}
}
}
#[derive(Debug, PartialEq, Eq, Hash, Clone, PartialOrd, Ord)]
pub struct GridRepeat {
pub number: GridRepeatNumber,
pub values: Vec<Unit>,
}
#[rustfmt::skip]
impl std::fmt::Display for GridRepeat {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "repeat({},", self.number)?;
for value in &self.values {
write!(f, " {}", value)?;
}
")".fmt(f)
}
}
#[derive(Debug, PartialEq, Eq, Hash, Clone, PartialOrd, Ord)]
pub enum GridTemplate {
Inherit,
Initial,
Unset,
None,
Some(Vec<GridTemplateValue>),
}
#[rustfmt::skip]
impl std::fmt::Display for GridTemplate {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Inherit => "inherit".fmt(f),
Self::Initial => "initial".fmt(f),
Self::Unset => "unset".fmt(f),
Self::None => "none".fmt(f),
Self::Some(values) => {
if let Some((first, rest)) = values.split_first() {
write!(f, "{}", first)?;
for value in rest {
write!(f, " {}", value)?;
}
}
Ok(())
},
}
}
}
#[derive(Debug, PartialEq, Eq, Hash, Clone, PartialOrd, Ord)]
pub enum GridTemplateValue {
Repeat(GridRepeat),
Unit(Unit),
}
#[rustfmt::skip]
impl std::fmt::Display for GridTemplateValue {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Unit(x) => x.fmt(f),
Self::Repeat(x) => x.fmt(f),
}
}
}
#[derive(Debug, PartialEq, Eq, Hash, Clone, PartialOrd, Ord)]
pub enum GridAuto {
Inherit,
Initial,
Unset,
Auto,
Some(Vec<Unit>),
}
#[rustfmt::skip]
impl std::fmt::Display for GridAuto {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Inherit => "inherit".fmt(f),
Self::Initial => "initial".fmt(f),
Self::Unset => "unset".fmt(f),
Self::Auto => "auto".fmt(f),
Self::Some(units) => {
if let Some((first, rest)) = units.split_first() {
write!(f, "{}", first)?;
for unit in rest {
write!(f, " {}", unit)?;
}
}
Ok(())
},
}
}
}
#[doc(hidden)]
#[macro_export]
macro_rules! __repeat_number {
(auto-fit) => {$crate::GridRepeatNumber::AutoFit};
(auto-fill) => {$crate::GridRepeatNumber::AutoFill};
($x:expr) => {$crate::GridRepeatNumber::Some($x)};
}
#[doc(hidden)]
#[macro_export]
macro_rules! __nested_unit {
(($($tt:tt)+)) => {$crate::unit!($($tt)+)};
}
#[doc(hidden)]
#[macro_export]
macro_rules! __repeat {
($($repeat_number:tt)-+, $($v:tt)+) => {
$crate::GridRepeat {
number: $crate::__repeat_number!($($repeat_number)-+),
values: vec![$($crate::__nested_unit!($v)),+],
}
};
}
#[doc(hidden)]
#[macro_export]
macro_rules! __grid_template_value {
(repeat($($tt:tt)+)) => {$crate::GridTemplateValue::Repeat($crate::__repeat!($($tt)+))};
(($($tt:tt)+)) => {$crate::GridTemplateValue::Unit($crate::unit!($($tt)+))};
}
#[doc(hidden)]
#[macro_export]
macro_rules! __grid_template {
(
kind = $kind:ident,
acc = $acc:expr,
current = ($($current:tt)+),
rest = ($(,)*),
) => {{
$acc.push($crate::__grid_template_value!($($current)+));
let acc = $acc;
$crate::paste::item!{$crate::Property::[<GridTemplate $kind>]($crate::GridTemplate::Some(acc))}
}};
(
kind = $kind:ident,
acc = $acc:expr,
current = ($($current:tt)+),
rest = (, $($rest:tt)*),
) => {{
$acc.push($crate::__grid_template_value!($($current)+));
$crate::__grid_template!(
kind = $kind,
acc = $acc,
current = (),
rest = ($($rest)*),
)
}};
(
kind = $kind:ident,
acc = $acc:expr,
current = ($($current:tt)*),
rest = ($token:tt $($rest:tt)*),
) => {
$crate::__grid_template!(
kind = $kind,
acc = $acc,
current = ($($current)* $token),
rest = ($($rest)*),
)
};
}
#[macro_export]
macro_rules! grid_template_columns {
($($tt:tt)+) => {{
let mut acc = Vec::new();
$crate::__grid_template!(
kind = Columns,
acc = acc,
current = (),
rest = ($($tt)+),
)
}};
}
#[macro_export]
macro_rules! grid_template_rows {
($($tt:tt)+) => {{
let mut acc = Vec::new();
$crate::__grid_template!(
kind = Rows,
acc = acc,
current = (),
rest = ($($tt)+),
)
}};
}