A few straggling files that got left out of the prior commit
This commit is contained in:
parent
6833e39d52
commit
bb44f31dda
6 changed files with 1494 additions and 0 deletions
123
styles/src/engine.rs
Normal file
123
styles/src/engine.rs
Normal file
|
|
@ -0,0 +1,123 @@
|
|||
//! Implements a Theme Engine. This behaves a bit differently depending on
|
||||
//! the mode your application is compiled in.
|
||||
//!
|
||||
//! - In `debug`, it scans a few places and loads any CSS files that are
|
||||
//! necessary. It will also hot-reload CSS files as they change.
|
||||
//! - In `release`, it scans those same places, and compiles your CSS into
|
||||
//! your resulting binary. The hot-reloading functionality is not in release,
|
||||
//! however it can be enabled if desired.
|
||||
//!
|
||||
|
||||
use std::fs;
|
||||
use std::env;
|
||||
use std::sync::RwLock;
|
||||
use std::path::PathBuf;
|
||||
use std::collections::HashMap;
|
||||
|
||||
use toml;
|
||||
use serde::Deserialize;
|
||||
|
||||
use crate::StylesList;
|
||||
use crate::styles::Style;
|
||||
use crate::stylesheet::StyleSheet;
|
||||
|
||||
static CONFIG_FILE_NAME: &str = "alchemy.toml";
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct RawConfig<'d> {
|
||||
#[serde(borrow)]
|
||||
general: Option<General<'d>>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct General<'a> {
|
||||
#[serde(borrow)]
|
||||
dirs: Option<Vec<&'a str>>
|
||||
}
|
||||
|
||||
/// The `ThemeEngine` controls loading themes and registering associated
|
||||
/// styles.
|
||||
#[derive(Debug)]
|
||||
pub struct ThemeEngine {
|
||||
pub dirs: Vec<PathBuf>,
|
||||
pub themes: RwLock<HashMap<String, StyleSheet>>
|
||||
}
|
||||
|
||||
impl ThemeEngine {
|
||||
/// Creates a new 'ThemeEngine` instance.
|
||||
pub fn new() -> ThemeEngine {
|
||||
// This env var is set by Cargo... so if this code breaks, there's
|
||||
// bigger concerns, lol
|
||||
let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
|
||||
|
||||
let root = PathBuf::from(manifest_dir);
|
||||
let default_dirs = vec![root.join("themes")];
|
||||
|
||||
let toml_contents = read_config_file();
|
||||
let raw: RawConfig<'_> = toml::from_str(&toml_contents).expect(&format!("Invalid TOML in {}!", CONFIG_FILE_NAME));
|
||||
|
||||
let dirs = match raw.general {
|
||||
Some(General { dirs }) => (
|
||||
dirs.map_or(default_dirs, |v| {
|
||||
v.into_iter().map(|dir| root.join(dir)).collect()
|
||||
})
|
||||
),
|
||||
|
||||
None => default_dirs
|
||||
};
|
||||
|
||||
ThemeEngine { dirs, themes: RwLock::new(HashMap::new()) }
|
||||
}
|
||||
|
||||
/// Registers a stylesheet (typically created by the `styles! {}` macro) for a given
|
||||
/// theme.
|
||||
pub fn register_styles(&self, key: &str, stylesheet: StyleSheet) {
|
||||
let mut themes = self.themes.write().unwrap();
|
||||
if !themes.contains_key(key) {
|
||||
themes.insert(key.to_string(), stylesheet);
|
||||
return;
|
||||
}
|
||||
|
||||
// if let Some(existing_stylesheet) = self.themes.get_mut(key) {
|
||||
// *existing_stylesheet.merge(stylesheet);
|
||||
//}
|
||||
}
|
||||
|
||||
/// Given a theme key, style keys, and a style, configures the style for layout
|
||||
/// and appearance.
|
||||
pub fn configure_style_for_keys_in_theme(&self, theme: &str, keys: &StylesList, style: &mut Style) {
|
||||
let themes = self.themes.read().unwrap();
|
||||
|
||||
match themes.get(theme) {
|
||||
Some(theme) => {
|
||||
for key in &keys.0 {
|
||||
theme.apply_styles(key, style);
|
||||
}
|
||||
},
|
||||
|
||||
None => {
|
||||
eprintln!("No styles for theme!");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The same logic as `configure_style_for_keys_in_theme`, but defaults to the default theme.
|
||||
pub fn configure_style_for_keys(&self, keys: &StylesList, style: &mut Style) {
|
||||
self.configure_style_for_keys_in_theme("default", keys, style)
|
||||
}
|
||||
}
|
||||
|
||||
/// Utility method for reading a config file from the `CARGO_MANIFEST_DIR`. Hat tip to
|
||||
/// [askama](https://github.com/djc/askama) for this!
|
||||
pub fn read_config_file() -> String {
|
||||
let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
|
||||
let root = PathBuf::from(manifest_dir);
|
||||
let filename = root.join(CONFIG_FILE_NAME);
|
||||
|
||||
if filename.exists() {
|
||||
fs::read_to_string(&filename)
|
||||
.expect(&format!("Unable to read {}", filename.to_str().unwrap()))
|
||||
} else {
|
||||
"".to_string()
|
||||
}
|
||||
}
|
||||
262
styles/src/spacedlist.rs
Normal file
262
styles/src/spacedlist.rs
Normal file
|
|
@ -0,0 +1,262 @@
|
|||
//! A space separated list of values.
|
||||
//!
|
||||
//! This type represents a list of non-unique values represented as a string of
|
||||
//! values separated by spaces in HTML attributes. This is rarely used; a
|
||||
//! SpacedSet of unique values is much more common.
|
||||
|
||||
|
||||
use std::fmt::{Debug, Display, Error, Formatter};
|
||||
use std::iter::FromIterator;
|
||||
use std::ops::{Deref, DerefMut};
|
||||
use std::str::FromStr;
|
||||
|
||||
/// A space separated list of values.
|
||||
///
|
||||
/// This type represents a list of non-unique values represented as a string of
|
||||
/// values separated by spaces in HTML attributes. This is rarely used; a
|
||||
/// SpacedSet of unique values is much more common.
|
||||
#[derive(Clone, PartialEq, Eq, Hash)]
|
||||
pub struct SpacedList<A>(Vec<A>);
|
||||
|
||||
impl<A> SpacedList<A> {
|
||||
/// Construct an empty `SpacedList`.
|
||||
pub fn new() -> Self {
|
||||
SpacedList(Vec::new())
|
||||
}
|
||||
}
|
||||
|
||||
impl<A> Default for SpacedList<A> {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
impl<A> FromIterator<A> for SpacedList<A> {
|
||||
fn from_iter<I>(iter: I) -> Self
|
||||
where
|
||||
I: IntoIterator<Item = A>,
|
||||
{
|
||||
SpacedList(iter.into_iter().collect())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, A: 'a + Clone> FromIterator<&'a A> for SpacedList<A> {
|
||||
fn from_iter<I>(iter: I) -> Self
|
||||
where
|
||||
I: IntoIterator<Item = &'a A>,
|
||||
{
|
||||
SpacedList(iter.into_iter().cloned().collect())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, A: FromStr> From<&'a str> for SpacedList<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
fn from(s: &'a str) -> Self {
|
||||
Self::from_iter(s.split_whitespace().map(|s| FromStr::from_str(s).unwrap()))
|
||||
}
|
||||
}
|
||||
|
||||
impl<A> Deref for SpacedList<A> {
|
||||
type Target = Vec<A>;
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl<A> DerefMut for SpacedList<A> {
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl<A: Display> Display for SpacedList<A> {
|
||||
fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
|
||||
let mut it = self.0.iter().peekable();
|
||||
while let Some(class) = it.next() {
|
||||
Display::fmt(class, f)?;
|
||||
if it.peek().is_some() {
|
||||
Display::fmt(" ", f)?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl<A: Debug> Debug for SpacedList<A> {
|
||||
fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
|
||||
f.debug_list().entries(self.0.iter()).finish()
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b, A: FromStr> From<(&'a str, &'b str)> for SpacedList<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
fn from(s: (&str, &str)) -> Self {
|
||||
let mut list = Self::new();
|
||||
list.push(FromStr::from_str(s.0).unwrap());
|
||||
list.push(FromStr::from_str(s.1).unwrap());
|
||||
list
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b, 'c, A: FromStr> From<(&'a str, &'b str, &'c str)> for SpacedList<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
fn from(s: (&str, &str, &str)) -> Self {
|
||||
let mut list = Self::new();
|
||||
list.push(FromStr::from_str(s.0).unwrap());
|
||||
list.push(FromStr::from_str(s.1).unwrap());
|
||||
list.push(FromStr::from_str(s.2).unwrap());
|
||||
list
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b, 'c, 'd, A: FromStr> From<(&'a str, &'b str, &'c str, &'d str)> for SpacedList<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
fn from(s: (&str, &str, &str, &str)) -> Self {
|
||||
let mut list = Self::new();
|
||||
list.push(FromStr::from_str(s.0).unwrap());
|
||||
list.push(FromStr::from_str(s.1).unwrap());
|
||||
list.push(FromStr::from_str(s.2).unwrap());
|
||||
list.push(FromStr::from_str(s.3).unwrap());
|
||||
list
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b, 'c, 'd, 'e, A: FromStr> From<(&'a str, &'b str, &'c str, &'d str, &'e str)>
|
||||
for SpacedList<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
fn from(s: (&str, &str, &str, &str, &str)) -> Self {
|
||||
let mut list = Self::new();
|
||||
list.push(FromStr::from_str(s.0).unwrap());
|
||||
list.push(FromStr::from_str(s.1).unwrap());
|
||||
list.push(FromStr::from_str(s.2).unwrap());
|
||||
list.push(FromStr::from_str(s.3).unwrap());
|
||||
list.push(FromStr::from_str(s.4).unwrap());
|
||||
list
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b, 'c, 'd, 'e, 'f, A: FromStr>
|
||||
From<(&'a str, &'b str, &'c str, &'d str, &'e str, &'f str)> for SpacedList<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
fn from(s: (&str, &str, &str, &str, &str, &str)) -> Self {
|
||||
let mut list = Self::new();
|
||||
list.push(FromStr::from_str(s.0).unwrap());
|
||||
list.push(FromStr::from_str(s.1).unwrap());
|
||||
list.push(FromStr::from_str(s.2).unwrap());
|
||||
list.push(FromStr::from_str(s.3).unwrap());
|
||||
list.push(FromStr::from_str(s.4).unwrap());
|
||||
list.push(FromStr::from_str(s.5).unwrap());
|
||||
list
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, A: FromStr>
|
||||
From<(
|
||||
&'a str,
|
||||
&'b str,
|
||||
&'c str,
|
||||
&'d str,
|
||||
&'e str,
|
||||
&'f str,
|
||||
&'g str,
|
||||
)> for SpacedList<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
fn from(s: (&str, &str, &str, &str, &str, &str, &str)) -> Self {
|
||||
let mut list = Self::new();
|
||||
list.push(FromStr::from_str(s.0).unwrap());
|
||||
list.push(FromStr::from_str(s.1).unwrap());
|
||||
list.push(FromStr::from_str(s.2).unwrap());
|
||||
list.push(FromStr::from_str(s.3).unwrap());
|
||||
list.push(FromStr::from_str(s.4).unwrap());
|
||||
list.push(FromStr::from_str(s.5).unwrap());
|
||||
list.push(FromStr::from_str(s.6).unwrap());
|
||||
list
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, A: FromStr>
|
||||
From<(
|
||||
&'a str,
|
||||
&'b str,
|
||||
&'c str,
|
||||
&'d str,
|
||||
&'e str,
|
||||
&'f str,
|
||||
&'g str,
|
||||
&'h str,
|
||||
)> for SpacedList<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
fn from(s: (&str, &str, &str, &str, &str, &str, &str, &str)) -> Self {
|
||||
let mut list = Self::new();
|
||||
list.push(FromStr::from_str(s.0).unwrap());
|
||||
list.push(FromStr::from_str(s.1).unwrap());
|
||||
list.push(FromStr::from_str(s.2).unwrap());
|
||||
list.push(FromStr::from_str(s.3).unwrap());
|
||||
list.push(FromStr::from_str(s.4).unwrap());
|
||||
list.push(FromStr::from_str(s.5).unwrap());
|
||||
list.push(FromStr::from_str(s.6).unwrap());
|
||||
list.push(FromStr::from_str(s.7).unwrap());
|
||||
list
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! spacedlist_from_array {
|
||||
($num:tt) => {
|
||||
impl<'a, A: FromStr> From<[&'a str; $num]> for SpacedList<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
fn from(s: [&str; $num]) -> Self {
|
||||
Self::from_iter(s.into_iter().map(|s| FromStr::from_str(*s).unwrap()))
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
spacedlist_from_array!(1);
|
||||
spacedlist_from_array!(2);
|
||||
spacedlist_from_array!(3);
|
||||
spacedlist_from_array!(4);
|
||||
spacedlist_from_array!(5);
|
||||
spacedlist_from_array!(6);
|
||||
spacedlist_from_array!(7);
|
||||
spacedlist_from_array!(8);
|
||||
spacedlist_from_array!(9);
|
||||
spacedlist_from_array!(10);
|
||||
spacedlist_from_array!(11);
|
||||
spacedlist_from_array!(12);
|
||||
spacedlist_from_array!(13);
|
||||
spacedlist_from_array!(14);
|
||||
spacedlist_from_array!(15);
|
||||
spacedlist_from_array!(16);
|
||||
spacedlist_from_array!(17);
|
||||
spacedlist_from_array!(18);
|
||||
spacedlist_from_array!(19);
|
||||
spacedlist_from_array!(20);
|
||||
spacedlist_from_array!(21);
|
||||
spacedlist_from_array!(22);
|
||||
spacedlist_from_array!(23);
|
||||
spacedlist_from_array!(24);
|
||||
spacedlist_from_array!(25);
|
||||
spacedlist_from_array!(26);
|
||||
spacedlist_from_array!(27);
|
||||
spacedlist_from_array!(28);
|
||||
spacedlist_from_array!(29);
|
||||
spacedlist_from_array!(30);
|
||||
spacedlist_from_array!(31);
|
||||
spacedlist_from_array!(32);
|
||||
293
styles/src/spacedset.rs
Normal file
293
styles/src/spacedset.rs
Normal file
|
|
@ -0,0 +1,293 @@
|
|||
//! A space separated set of unique values.
|
||||
//!
|
||||
//! This type represents a set of unique values represented as a string of
|
||||
//! values separated by spaces in HTML attributes.
|
||||
|
||||
use std::collections::BTreeSet;
|
||||
use std::fmt::{Debug, Display, Error, Formatter};
|
||||
use std::iter::FromIterator;
|
||||
use std::ops::{Deref, DerefMut};
|
||||
use std::str::FromStr;
|
||||
|
||||
/// A space separated set of unique values.
|
||||
///
|
||||
/// This type represents a set of unique values represented as a string of
|
||||
/// values separated by spaces in HTML attributes.
|
||||
#[derive(Clone, PartialEq, Eq, Hash)]
|
||||
pub struct SpacedSet<A: Ord>(pub BTreeSet<A>);
|
||||
|
||||
impl<A: Ord> SpacedSet<A> {
|
||||
/// Construct an empty `SpacedSet`.
|
||||
pub fn new() -> Self {
|
||||
SpacedSet(BTreeSet::new())
|
||||
}
|
||||
|
||||
/// Add a value to the `SpacedSet`.
|
||||
pub fn add<T: Into<A>>(&mut self, value: T) -> bool {
|
||||
self.0.insert(value.into())
|
||||
}
|
||||
}
|
||||
|
||||
impl<A: Ord> Default for SpacedSet<A> {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
impl<A: Ord> FromIterator<A> for SpacedSet<A> {
|
||||
fn from_iter<I>(iter: I) -> Self
|
||||
where
|
||||
I: IntoIterator<Item = A>,
|
||||
{
|
||||
SpacedSet(iter.into_iter().collect())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, A: 'a + Ord + Clone> FromIterator<&'a A> for SpacedSet<A> {
|
||||
fn from_iter<I>(iter: I) -> Self
|
||||
where
|
||||
I: IntoIterator<Item = &'a A>,
|
||||
{
|
||||
SpacedSet(iter.into_iter().cloned().collect())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, A: Ord + FromStr> FromStr for SpacedSet<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
type Err = <A as FromStr>::Err;
|
||||
|
||||
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
||||
let result: Result<Vec<A>, Self::Err> =
|
||||
s.split_whitespace().map(|s| FromStr::from_str(s)).collect();
|
||||
result.map(Self::from_iter)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, A: Ord + FromStr> From<&'a str> for SpacedSet<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
fn from(s: &'a str) -> Self {
|
||||
Self::from_iter(s.split_whitespace().map(|s| FromStr::from_str(s).unwrap()))
|
||||
}
|
||||
}
|
||||
|
||||
impl<A: Ord> Deref for SpacedSet<A> {
|
||||
type Target = BTreeSet<A>;
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl<A: Ord> DerefMut for SpacedSet<A> {
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl<A: Ord + Display> Display for SpacedSet<A> {
|
||||
fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
|
||||
let mut it = self.0.iter().peekable();
|
||||
while let Some(class) = it.next() {
|
||||
Display::fmt(class, f)?;
|
||||
if it.peek().is_some() {
|
||||
Display::fmt(" ", f)?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl<A: Ord + Debug> Debug for SpacedSet<A> {
|
||||
fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
|
||||
f.debug_list().entries(self.0.iter()).finish()
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, A: Ord + FromStr> From<Vec<&'a str>> for SpacedSet<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
fn from(s: Vec<&'a str>) -> Self {
|
||||
let mut list = Self::new();
|
||||
|
||||
for key in s {
|
||||
list.insert(FromStr::from_str(key).unwrap());
|
||||
}
|
||||
|
||||
list
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b, A: Ord + FromStr> From<(&'a str, &'b str)> for SpacedSet<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
fn from(s: (&str, &str)) -> Self {
|
||||
let mut list = Self::new();
|
||||
list.insert(FromStr::from_str(s.0).unwrap());
|
||||
list.insert(FromStr::from_str(s.1).unwrap());
|
||||
list
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b, 'c, A: Ord + FromStr> From<(&'a str, &'b str, &'c str)> for SpacedSet<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
fn from(s: (&str, &str, &str)) -> Self {
|
||||
let mut list = Self::new();
|
||||
list.insert(FromStr::from_str(s.0).unwrap());
|
||||
list.insert(FromStr::from_str(s.1).unwrap());
|
||||
list.insert(FromStr::from_str(s.2).unwrap());
|
||||
list
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b, 'c, 'd, A: Ord + FromStr> From<(&'a str, &'b str, &'c str, &'d str)> for SpacedSet<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
fn from(s: (&str, &str, &str, &str)) -> Self {
|
||||
let mut list = Self::new();
|
||||
list.insert(FromStr::from_str(s.0).unwrap());
|
||||
list.insert(FromStr::from_str(s.1).unwrap());
|
||||
list.insert(FromStr::from_str(s.2).unwrap());
|
||||
list.insert(FromStr::from_str(s.3).unwrap());
|
||||
list
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b, 'c, 'd, 'e, A: Ord + FromStr> From<(&'a str, &'b str, &'c str, &'d str, &'e str)>
|
||||
for SpacedSet<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
fn from(s: (&str, &str, &str, &str, &str)) -> Self {
|
||||
let mut list = Self::new();
|
||||
list.insert(FromStr::from_str(s.0).unwrap());
|
||||
list.insert(FromStr::from_str(s.1).unwrap());
|
||||
list.insert(FromStr::from_str(s.2).unwrap());
|
||||
list.insert(FromStr::from_str(s.3).unwrap());
|
||||
list.insert(FromStr::from_str(s.4).unwrap());
|
||||
list
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b, 'c, 'd, 'e, 'f, A: Ord + FromStr>
|
||||
From<(&'a str, &'b str, &'c str, &'d str, &'e str, &'f str)> for SpacedSet<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
fn from(s: (&str, &str, &str, &str, &str, &str)) -> Self {
|
||||
let mut list = Self::new();
|
||||
list.insert(FromStr::from_str(s.0).unwrap());
|
||||
list.insert(FromStr::from_str(s.1).unwrap());
|
||||
list.insert(FromStr::from_str(s.2).unwrap());
|
||||
list.insert(FromStr::from_str(s.3).unwrap());
|
||||
list.insert(FromStr::from_str(s.4).unwrap());
|
||||
list.insert(FromStr::from_str(s.5).unwrap());
|
||||
list
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, A: Ord + FromStr>
|
||||
From<(
|
||||
&'a str,
|
||||
&'b str,
|
||||
&'c str,
|
||||
&'d str,
|
||||
&'e str,
|
||||
&'f str,
|
||||
&'g str,
|
||||
)> for SpacedSet<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
fn from(s: (&str, &str, &str, &str, &str, &str, &str)) -> Self {
|
||||
let mut list = Self::new();
|
||||
list.insert(FromStr::from_str(s.0).unwrap());
|
||||
list.insert(FromStr::from_str(s.1).unwrap());
|
||||
list.insert(FromStr::from_str(s.2).unwrap());
|
||||
list.insert(FromStr::from_str(s.3).unwrap());
|
||||
list.insert(FromStr::from_str(s.4).unwrap());
|
||||
list.insert(FromStr::from_str(s.5).unwrap());
|
||||
list.insert(FromStr::from_str(s.6).unwrap());
|
||||
list
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, A: Ord + FromStr>
|
||||
From<(
|
||||
&'a str,
|
||||
&'b str,
|
||||
&'c str,
|
||||
&'d str,
|
||||
&'e str,
|
||||
&'f str,
|
||||
&'g str,
|
||||
&'h str,
|
||||
)> for SpacedSet<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
fn from(s: (&str, &str, &str, &str, &str, &str, &str, &str)) -> Self {
|
||||
let mut list = Self::new();
|
||||
list.insert(FromStr::from_str(s.0).unwrap());
|
||||
list.insert(FromStr::from_str(s.1).unwrap());
|
||||
list.insert(FromStr::from_str(s.2).unwrap());
|
||||
list.insert(FromStr::from_str(s.3).unwrap());
|
||||
list.insert(FromStr::from_str(s.4).unwrap());
|
||||
list.insert(FromStr::from_str(s.5).unwrap());
|
||||
list.insert(FromStr::from_str(s.6).unwrap());
|
||||
list.insert(FromStr::from_str(s.7).unwrap());
|
||||
list
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! spacedlist_from_array {
|
||||
($num:tt) => {
|
||||
impl<'a, A: Ord + FromStr> From<[&'a str; $num]> for SpacedSet<A>
|
||||
where
|
||||
<A as FromStr>::Err: Debug,
|
||||
{
|
||||
fn from(s: [&str; $num]) -> Self {
|
||||
Self::from_iter(s.into_iter().map(|s| FromStr::from_str(*s).unwrap()))
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
spacedlist_from_array!(1);
|
||||
spacedlist_from_array!(2);
|
||||
spacedlist_from_array!(3);
|
||||
spacedlist_from_array!(4);
|
||||
spacedlist_from_array!(5);
|
||||
spacedlist_from_array!(6);
|
||||
spacedlist_from_array!(7);
|
||||
spacedlist_from_array!(8);
|
||||
spacedlist_from_array!(9);
|
||||
spacedlist_from_array!(10);
|
||||
spacedlist_from_array!(11);
|
||||
spacedlist_from_array!(12);
|
||||
spacedlist_from_array!(13);
|
||||
spacedlist_from_array!(14);
|
||||
spacedlist_from_array!(15);
|
||||
spacedlist_from_array!(16);
|
||||
spacedlist_from_array!(17);
|
||||
spacedlist_from_array!(18);
|
||||
spacedlist_from_array!(19);
|
||||
spacedlist_from_array!(20);
|
||||
spacedlist_from_array!(21);
|
||||
spacedlist_from_array!(22);
|
||||
spacedlist_from_array!(23);
|
||||
spacedlist_from_array!(24);
|
||||
spacedlist_from_array!(25);
|
||||
spacedlist_from_array!(26);
|
||||
spacedlist_from_array!(27);
|
||||
spacedlist_from_array!(28);
|
||||
spacedlist_from_array!(29);
|
||||
spacedlist_from_array!(30);
|
||||
spacedlist_from_array!(31);
|
||||
spacedlist_from_array!(32);
|
||||
83
styles/src/style_keys.rs
Normal file
83
styles/src/style_keys.rs
Normal file
|
|
@ -0,0 +1,83 @@
|
|||
//! A valid CSS class.
|
||||
//!
|
||||
//! A CSS class is a non-empty string that starts with an alphanumeric character
|
||||
//! and is followed by any number of alphanumeric characters and the
|
||||
//! `_`, `-` and `.` characters.
|
||||
|
||||
use std::fmt::{Display, Error, Formatter};
|
||||
use std::ops::Deref;
|
||||
use std::str::FromStr;
|
||||
|
||||
/// A valid CSS class.
|
||||
///
|
||||
/// A CSS class is a non-empty string that starts with an alphanumeric character
|
||||
/// and is followed by any number of alphanumeric characters and the
|
||||
/// `_`, `-` and `.` characters.
|
||||
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
|
||||
pub struct StyleKey(String);
|
||||
|
||||
impl StyleKey {
|
||||
/// Construct a new styles list from a string.
|
||||
///
|
||||
/// Returns `Err` if the provided string is invalid.
|
||||
pub fn try_new<S: Into<String>>(id: S) -> Result<Self, &'static str> {
|
||||
let id = id.into();
|
||||
{
|
||||
let mut chars = id.chars();
|
||||
match chars.next() {
|
||||
None => return Err("style keys cannot be empty"),
|
||||
Some(c) if !c.is_alphabetic() => {
|
||||
return Err("style keys must start with an alphabetic character")
|
||||
}
|
||||
_ => (),
|
||||
}
|
||||
for c in chars {
|
||||
if !c.is_alphanumeric() && c != '-' {
|
||||
return Err(
|
||||
"style keys can only contain alphanumerics (dash included)",
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(StyleKey(id))
|
||||
}
|
||||
|
||||
/// Construct a new class name from a string.
|
||||
///
|
||||
/// Panics if the provided string is invalid.
|
||||
pub fn new<S: Into<String>>(id: S) -> Self {
|
||||
let id = id.into();
|
||||
Self::try_new(id.clone()).unwrap_or_else(|err| {
|
||||
panic!(
|
||||
"alchemy::dom::types::StyleKey: {:?} is not a valid class name: {}",
|
||||
id, err
|
||||
)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl FromStr for StyleKey {
|
||||
type Err = &'static str;
|
||||
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
||||
StyleKey::try_new(s)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<&'a str> for StyleKey {
|
||||
fn from(str: &'a str) -> Self {
|
||||
StyleKey::from_str(str).unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
impl Display for StyleKey {
|
||||
fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
|
||||
Display::fmt(&self.0, f)
|
||||
}
|
||||
}
|
||||
|
||||
impl Deref for StyleKey {
|
||||
type Target = String;
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
308
styles/src/stylesheet.rs
Normal file
308
styles/src/stylesheet.rs
Normal file
|
|
@ -0,0 +1,308 @@
|
|||
//! Implements a `StyleSheet`, which contains inner logic for
|
||||
//! determining what styles should be applied to a given widget.
|
||||
//!
|
||||
//! You can think of this as a compiled form of your CSS. You generally
|
||||
//! don't need to create these structs yourself, but feel free to if
|
||||
//! you have some creative use.
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::styles::{Dimension, Rect, Size, Style, Styles};
|
||||
|
||||
/// A `StyleSheet` contains selectors and parsed `Styles` attributes.
|
||||
/// It also has some logic to apply styles for n keys to a given `Style` node.
|
||||
#[derive(Debug)]
|
||||
pub struct StyleSheet(HashMap<&'static str, Vec<Styles>>);
|
||||
|
||||
impl StyleSheet {
|
||||
/// Creates a new `Stylesheet`.
|
||||
pub fn new(styles: HashMap<&'static str, Vec<Styles>>) -> Self {
|
||||
StyleSheet(styles)
|
||||
}
|
||||
|
||||
pub fn apply_styles(&self, key: &str, style: &mut Style) {
|
||||
match self.0.get(key) {
|
||||
Some(styles) => { reduce_styles_into_style(styles, style); },
|
||||
None => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// This takes a list of styles, and a mutable style object, and attempts to configure the
|
||||
/// style object in a way that makes sense given n styles.
|
||||
fn reduce_styles_into_style(styles: &Vec<Styles>, layout: &mut Style) {
|
||||
for style in styles { match style {
|
||||
Styles::AlignContent(val) => { layout.align_content = *val; },
|
||||
Styles::AlignItems(val) => { layout.align_items = *val; },
|
||||
Styles::AlignSelf(val) => { layout.align_self = *val; },
|
||||
Styles::AspectRatio(val) => { layout.aspect_ratio = *val; },
|
||||
Styles::BackfaceVisibility(_val) => { },
|
||||
Styles::BackgroundColor(val) => { layout.background_color = *val; },
|
||||
|
||||
Styles::BorderColor(_val) => { },
|
||||
Styles::BorderEndColor(_val) => { },
|
||||
Styles::BorderBottomColor(_val) => { },
|
||||
Styles::BorderLeftColor(_val) => { },
|
||||
Styles::BorderRightColor(_val) => { },
|
||||
Styles::BorderTopColor(_val) => { },
|
||||
Styles::BorderStartColor(_val) => { },
|
||||
|
||||
Styles::BorderStyle(_val) => { },
|
||||
Styles::BorderEndStyle(_val) => { },
|
||||
Styles::BorderBottomStyle(_val) => { },
|
||||
Styles::BorderLeftStyle(_val) => { },
|
||||
Styles::BorderRightStyle(_val) => { },
|
||||
Styles::BorderTopStyle(_val) => { },
|
||||
Styles::BorderStartStyle(_val) => { },
|
||||
|
||||
Styles::BorderWidth(_val) => { },
|
||||
Styles::BorderEndWidth(_val) => { },
|
||||
Styles::BorderBottomWidth(_val) => { },
|
||||
Styles::BorderLeftWidth(_val) => { },
|
||||
Styles::BorderRightWidth(_val) => { },
|
||||
Styles::BorderTopWidth(_val) => { },
|
||||
Styles::BorderStartWidth(_val) => { },
|
||||
|
||||
Styles::BorderRadius(_val) => { },
|
||||
Styles::BorderBottomEndRadius(_val) => { },
|
||||
Styles::BorderBottomLeftRadius(_val) => { },
|
||||
Styles::BorderBottomRightRadius(_val) => { },
|
||||
Styles::BorderBottomStartRadius(_val) => { },
|
||||
Styles::BorderTopLeftRadius(_val) => { },
|
||||
Styles::BorderTopRightRadius(_val) => { },
|
||||
Styles::BorderTopEndRadius(_val) => { },
|
||||
Styles::BorderTopStartRadius(_val) => { },
|
||||
|
||||
Styles::Bottom(val) => {
|
||||
layout.position = Rect {
|
||||
start: layout.position.start,
|
||||
end: layout.position.end,
|
||||
top: layout.position.top,
|
||||
bottom: Dimension::Points(*val)
|
||||
};
|
||||
},
|
||||
|
||||
Styles::Direction(val) => { layout.direction = *val; },
|
||||
Styles::Display(val) => { layout.display = *val; },
|
||||
|
||||
Styles::End(val) => {
|
||||
layout.position = Rect {
|
||||
start: layout.position.start,
|
||||
end: Dimension::Points(*val),
|
||||
top: layout.position.top,
|
||||
bottom: layout.position.bottom
|
||||
};
|
||||
},
|
||||
|
||||
Styles::FlexBasis(val) => { layout.flex_basis = Dimension::Points(*val); },
|
||||
Styles::FlexDirection(val) => { layout.flex_direction = *val; },
|
||||
Styles::FlexGrow(val) => { layout.flex_grow = *val; },
|
||||
Styles::FlexShrink(val) => { layout.flex_shrink = *val; },
|
||||
Styles::FlexWrap(val) => { layout.flex_wrap = *val; },
|
||||
|
||||
Styles::FontFamily(_val) => { },
|
||||
Styles::FontLineHeight(_val) => { },
|
||||
Styles::FontSize(val) => { layout.font_size = *val; },
|
||||
Styles::FontStyle(val) => { layout.font_style = *val; },
|
||||
Styles::FontWeight(val) => { layout.font_weight = *val; },
|
||||
|
||||
Styles::Height(val) => {
|
||||
layout.size = Size {
|
||||
width: layout.size.width,
|
||||
height: Dimension::Points(*val)
|
||||
};
|
||||
},
|
||||
|
||||
Styles::JustifyContent(val) => { layout.justify_content = *val; },
|
||||
|
||||
Styles::Left(val) => {
|
||||
layout.position = Rect {
|
||||
start: Dimension::Points(*val),
|
||||
end: layout.position.end,
|
||||
top: layout.position.top,
|
||||
bottom: layout.position.bottom
|
||||
};
|
||||
},
|
||||
|
||||
Styles::MarginBottom(val) => {
|
||||
layout.margin = Rect {
|
||||
start: layout.margin.start,
|
||||
end: layout.margin.end,
|
||||
top: layout.margin.top,
|
||||
bottom: Dimension::Points(*val)
|
||||
};
|
||||
},
|
||||
|
||||
Styles::MarginEnd(val) => {
|
||||
layout.margin = Rect {
|
||||
start: layout.margin.start,
|
||||
end: Dimension::Points(*val),
|
||||
top: layout.margin.top,
|
||||
bottom: layout.margin.bottom
|
||||
};
|
||||
},
|
||||
|
||||
Styles::MarginLeft(val) => {
|
||||
layout.margin = Rect {
|
||||
start: Dimension::Points(*val),
|
||||
end: layout.margin.end,
|
||||
top: layout.margin.top,
|
||||
bottom: layout.margin.bottom
|
||||
};
|
||||
},
|
||||
|
||||
Styles::MarginRight(val) => {
|
||||
layout.margin = Rect {
|
||||
start: layout.margin.start,
|
||||
end: Dimension::Points(*val),
|
||||
top: layout.margin.top,
|
||||
bottom: layout.margin.bottom
|
||||
};
|
||||
},
|
||||
|
||||
Styles::MarginStart(val) => {
|
||||
layout.margin = Rect {
|
||||
start: Dimension::Points(*val),
|
||||
end: layout.margin.end,
|
||||
top: layout.margin.top,
|
||||
bottom: layout.margin.bottom
|
||||
};
|
||||
},
|
||||
|
||||
Styles::MarginTop(val) => {
|
||||
layout.margin = Rect {
|
||||
start: layout.margin.start,
|
||||
end: layout.margin.end,
|
||||
top: Dimension::Points(*val),
|
||||
bottom: layout.margin.bottom
|
||||
};
|
||||
},
|
||||
|
||||
Styles::MaxHeight(val) => {
|
||||
layout.max_size = Size {
|
||||
width: layout.max_size.width,
|
||||
height: Dimension::Points(*val)
|
||||
};
|
||||
},
|
||||
|
||||
Styles::MaxWidth(val) => {
|
||||
layout.max_size = Size {
|
||||
width: Dimension::Points(*val),
|
||||
height: layout.max_size.height
|
||||
};
|
||||
},
|
||||
|
||||
Styles::MinHeight(val) => {
|
||||
layout.min_size = Size {
|
||||
width: layout.min_size.width,
|
||||
height: Dimension::Points(*val)
|
||||
};
|
||||
},
|
||||
|
||||
Styles::MinWidth(val) => {
|
||||
layout.min_size = Size {
|
||||
width: Dimension::Points(*val),
|
||||
height: layout.min_size.height
|
||||
};
|
||||
},
|
||||
|
||||
Styles::Opacity(val) => { layout.opacity = *val; },
|
||||
Styles::Overflow(val) => { layout.overflow = *val; },
|
||||
|
||||
Styles::PaddingBottom(val) => {
|
||||
layout.padding = Rect {
|
||||
start: layout.padding.start,
|
||||
end: layout.padding.end,
|
||||
top: layout.padding.top,
|
||||
bottom: Dimension::Points(*val)
|
||||
};
|
||||
},
|
||||
|
||||
Styles::PaddingEnd(val) => {
|
||||
layout.padding = Rect {
|
||||
start: layout.padding.start,
|
||||
end: Dimension::Points(*val),
|
||||
top: layout.padding.top,
|
||||
bottom: layout.padding.bottom
|
||||
};
|
||||
},
|
||||
|
||||
Styles::PaddingLeft(val) => {
|
||||
layout.padding = Rect {
|
||||
start: Dimension::Points(*val),
|
||||
end: layout.padding.end,
|
||||
top: layout.padding.top,
|
||||
bottom: layout.padding.bottom
|
||||
};
|
||||
},
|
||||
|
||||
Styles::PaddingRight(val) => {
|
||||
layout.padding = Rect {
|
||||
start: layout.padding.start,
|
||||
end: Dimension::Points(*val),
|
||||
top: layout.padding.top,
|
||||
bottom: layout.padding.bottom
|
||||
};
|
||||
},
|
||||
|
||||
Styles::PaddingStart(val) => {
|
||||
layout.padding = Rect {
|
||||
start: Dimension::Points(*val),
|
||||
end: layout.padding.end,
|
||||
top: layout.padding.top,
|
||||
bottom: layout.padding.bottom
|
||||
};
|
||||
},
|
||||
|
||||
Styles::PaddingTop(val) => {
|
||||
layout.padding = Rect {
|
||||
start: layout.padding.start,
|
||||
end: layout.padding.end,
|
||||
top: Dimension::Points(*val),
|
||||
bottom: layout.padding.bottom
|
||||
};
|
||||
},
|
||||
|
||||
Styles::PositionType(val) => { layout.position_type = *val; },
|
||||
|
||||
Styles::Right(val) => {
|
||||
layout.position = Rect {
|
||||
start: layout.position.start,
|
||||
end: Dimension::Points(*val),
|
||||
top: layout.position.top,
|
||||
bottom: layout.position.bottom
|
||||
};
|
||||
},
|
||||
|
||||
Styles::Start(val) => {
|
||||
layout.position = Rect {
|
||||
start: Dimension::Points(*val),
|
||||
end: layout.position.end,
|
||||
top: layout.position.top,
|
||||
bottom: layout.position.bottom
|
||||
};
|
||||
},
|
||||
|
||||
Styles::TextAlignment(val) => { layout.text_alignment = *val; },
|
||||
Styles::TextColor(val) => { layout.text_color = *val; },
|
||||
Styles::TextDecorationColor(val) => { layout.text_decoration_color = *val; },
|
||||
Styles::TextShadowColor(val) => { layout.text_shadow_color = *val; },
|
||||
Styles::TintColor(val) => { layout.tint_color = *val; },
|
||||
|
||||
Styles::Top(val) => {
|
||||
layout.position = Rect {
|
||||
start: layout.position.start,
|
||||
end: layout.position.end,
|
||||
top: Dimension::Points(*val),
|
||||
bottom: layout.position.bottom
|
||||
};
|
||||
},
|
||||
|
||||
Styles::Width(val) => {
|
||||
layout.size = Size {
|
||||
width: Dimension::Points(*val),
|
||||
height: layout.size.height
|
||||
};
|
||||
}
|
||||
}}
|
||||
}
|
||||
Reference in a new issue