Skip to main content

aylis_core/
palette.rs

1//! Cores com nome: as do tema (`primary`, `text_3`...) e as do projeto (a paleta do
2//! `.aylisproj`), usadas em qualquer propriedade de cor e nos estilos.
3//!
4//! Uma cor pode ser escrita como:
5//! - `#RRGGBB` / `#RRGGBBAA` — a cor em si;
6//! - `nome` — uma cor do tema em uso ou da paleta do projeto (`success`, `brand`);
7//! - `nome/NN` — a mesma cor com NN % de opacidade (`text/85`, `primary/20`, `white/12`);
8//! - `white`, `black`, `transparent`.
9//!
10//! A paleta do projeto entra em todo tema que o [`Ui`](crate::Ui) usa (por cima das
11//! cores do tema, que ela pode citar). Uma entrada pode ter um valor por modo: no tema
12//! escuro vale `dark`, no claro `light`.
13//!
14//! Numa propriedade de cor com um nome, o `Ui` lembra o nome: ao trocar de tema a cor é
15//! recalculada, e o form salvo guarda o nome (não o hex).
16
17use std::collections::HashMap;
18
19use crate::{Color, Theme};
20
21/// Uma cor da paleta do projeto: a mesma nos dois modos ou uma por modo.
22#[derive(Clone, Debug, PartialEq)]
23pub struct PaletteColor {
24    pub dark: String,
25    pub light: String,
26}
27
28impl PaletteColor {
29    pub fn same(spec: impl Into<String>) -> Self {
30        let spec = spec.into();
31        Self { dark: spec.clone(), light: spec }
32    }
33
34    pub fn by_mode(dark: impl Into<String>, light: impl Into<String>) -> Self {
35        Self { dark: dark.into(), light: light.into() }
36    }
37
38    /// O valor para o modo do tema.
39    pub fn for_theme(&self, dark: bool) -> &str {
40        if dark { &self.dark } else { &self.light }
41    }
42}
43
44/// A paleta do projeto, na ordem em que foi escrita (uma entrada pode citar as anteriores).
45pub type Palette = Vec<(String, PaletteColor)>;
46
47/// Interpreta uma cor escrita com [`resolve`] nas cores de `colors`.
48pub fn resolve_in(colors: &HashMap<String, Color>, spec: &str) -> Option<Color> {
49    let spec = spec.trim();
50    let (name, alpha) = match spec.rsplit_once('/') {
51        Some((name, pct)) => (name.trim(), Some(pct.trim().trim_end_matches('%').parse::<f32>().ok()? / 100.0)),
52        None => (spec, None),
53    };
54    // O hex também aceita a opacidade (`#2563EB/15`), como os nomes (relatório do InsightDB,
55    // 11/11: só valia para os nomes).
56    let base = match name {
57        _ if name.starts_with('#') => Color::from_hex(name),
58        "white" => Some(Color::WHITE),
59        "black" => Some(Color::rgb(0, 0, 0)),
60        "transparent" => Some(Color::TRANSPARENT),
61        _ => colors.get(name).copied().or_else(|| colors.get(&name.replace('-', "_")).copied()),
62    }?;
63    Some(match alpha {
64        Some(a) => base.with_opacity(a.clamp(0.0, 1.0)),
65        None => base,
66    })
67}
68
69/// É um nome (ou nome/NN), não um hex? Vazio não é.
70pub fn is_named(spec: &str) -> bool {
71    let s = spec.trim();
72    !s.is_empty() && !s.starts_with('#')
73}
74
75impl Theme {
76    /// Uma cor escrita como `#hex`, `nome` ou `nome/NN` (veja o módulo [`palette`](crate::palette)).
77    pub fn resolve_color(&self, spec: &str) -> Option<Color> {
78        resolve_in(&self.colors, spec)
79    }
80
81    /// Os nomes de cor que os estilos citam e o tema não tem: `(estilo, nome)`, em ordem. Um
82    /// nome desconhecido pinta transparente, sem erro (o relatório do Tabernáculo, C07); a
83    /// verificação do projeto avisa.
84    pub fn unknown_color_tokens(&self) -> Vec<(String, String)> {
85        let mut out = Vec::new();
86        for (key, style) in &self.styles {
87            for props in [&style.base, &style.hover, &style.pressed, &style.focused, &style.checked, &style.disabled] {
88                for c in [&props.fill, &props.text, &props.border_color].into_iter().flatten() {
89                    if let crate::theme::ColorRef::Token(name) = c
90                        && name != "transparent"
91                        && self.resolve_color(name).is_none()
92                        && !out.iter().any(|(k, n)| k == key && n == name)
93                    {
94                        out.push((key.clone(), name.clone()));
95                    }
96                }
97            }
98        }
99        out.sort();
100        out
101    }
102
103    /// Põe a paleta do projeto no tema (no modo dele). Uma entrada pode citar outra, em
104    /// qualquer ordem; a que não se resolve (nome desconhecido) fica de fora.
105    pub fn apply_palette(&mut self, palette: &Palette) {
106        let mut pending: Vec<&(String, PaletteColor)> = palette.iter().collect();
107        while !pending.is_empty() {
108            let before = pending.len();
109            pending.retain(|(name, color)| {
110                let spec = color.for_theme(self.dark);
111                // Um nome que é ele mesmo (`"primary": "primary/90"`) olha a cor do tema.
112                match self.resolve_color(spec) {
113                    Some(c) => {
114                        self.colors.insert(name.clone(), c);
115                        false
116                    }
117                    None => true,
118                }
119            });
120            if pending.len() == before {
121                break;
122            }
123        }
124    }
125}