use std::sync::Arc;
use super::{
icon::Icon,
icons, names,
part_style::Length,
recipe::{Case, Interaction, Name, Recipe, ResolvedPart, ResolvedRecipe, Selector},
shared::{fading, glyph, pressable, tab_stop},
theme::{Themed, current_theme},
};
use crate::{
app::{
events::{KeyboardEvent, MouseEvent},
theme::{BorderSize, IconSize, OpacityLevel, PaletteColor, RadiusSize, Theme, TypographyStyle},
},
components::{self, Row},
layout::{Alignment, text_style::FontWeight},
node::{CursorIcon, Element, border::Border as Line, outline::Outline},
};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum TagPart {
Root,
Icon,
Term,
Label,
Remove,
RemoveIcon,
}
names!(TagPart {
Root => "root",
Icon => "icon",
Term => "term",
Label => "label",
Remove => "remove",
RemoveIcon => "remove_icon",
});
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum TagState {
Remove,
Pill,
Disabled,
}
names!(TagState {
Remove => "remove",
Pill => "pill",
Disabled => "disabled",
});
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum TagVariant {
#[default]
Neutral,
Info,
Success,
Warning,
Destructive,
}
names!(TagVariant {
Neutral => "neutral",
Info => "info",
Success => "success",
Warning => "warning",
Destructive => "destructive",
});
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum TagSize {
Sm,
#[default]
Md,
Lg,
}
names!(TagSize {
Sm => "sm",
Md => "md",
Lg => "lg",
});
#[derive(Clone)]
pub enum TagRemoveEvent {
Press(MouseEvent),
Key(KeyboardEvent),
}
impl TagRemoveEvent {
pub fn stop_propagation(&self) {
match self {
Self::Press(event) => event.stop_propagation(),
Self::Key(event) => event.stop_propagation(),
}
}
pub fn prevent_default(&self) {
match self {
Self::Press(event) => event.prevent_default(),
Self::Key(event) => event.prevent_default(),
}
}
}
type Removed = Arc<dyn Fn(&TagRemoveEvent) + Send + Sync>;
pub type TagRenderer = Arc<dyn Fn(TagView) -> Element + Send + Sync>;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum TagShape {
#[default]
Default,
Pill,
}
pub struct Tag {
label: Arc<str>,
term: Option<Arc<str>>,
variant: Name,
size: Name,
icon: Option<Name>,
shape: TagShape,
disabled: bool,
tab_stop: bool,
remove_label: Option<Arc<str>>,
states: Vec<Name>,
rules: Recipe,
forced: Option<Interaction>,
on_remove: Vec<Removed>,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl Tag {
pub fn new(label: &str) -> Self {
Self {
label: Arc::from(label),
term: None,
variant: TagVariant::default().into(),
size: TagSize::default().into(),
icon: None,
shape: TagShape::Default,
disabled: false,
tab_stop: true,
remove_label: None,
states: Vec::new(),
rules: Recipe::new(),
forced: None,
on_remove: Vec::new(),
id: None,
key: None,
}
}
pub fn variant(mut self, variant: impl Into<Name>) -> Self {
self.variant = variant.into();
self
}
pub fn size(mut self, size: impl Into<Name>) -> Self {
self.size = size.into();
self
}
pub fn icon(mut self, name: impl Into<Name>) -> Self {
self.icon = Some(name.into());
self
}
pub fn term(mut self, term: &str) -> Self {
self.term = Some(Arc::from(term));
self
}
pub fn shape(mut self, shape: TagShape) -> Self {
self.shape = shape;
self
}
pub fn remove_label(mut self, label: &str) -> Self {
self.remove_label = Some(Arc::from(label));
self
}
pub fn disabled(mut self, disabled: bool) -> Self {
self.disabled = disabled;
self
}
pub fn tab_stop(mut self, stops: bool) -> Self {
self.tab_stop = stops;
self
}
pub fn state(mut self, state: impl Into<Name>, on: bool) -> Self {
let state = state.into();
self.states.retain(|held| *held != state);
if on {
self.states.push(state);
}
self
}
pub fn on_remove(mut self, handler: impl Fn() + Send + Sync + 'static) -> Self {
self.on_remove.push(Arc::new(move |_: &TagRemoveEvent| handler()));
self
}
pub fn on_remove_event(mut self, handler: impl Fn(&TagRemoveEvent) + Send + Sync + 'static) -> Self {
self.on_remove.push(Arc::new(handler));
self
}
pub fn style(mut self, part: impl Into<Name>, style: impl FnOnce(super::PartStyle) -> super::PartStyle) -> Self {
self.rules = self.rules.base(part, style);
self
}
pub fn rules(mut self, rules: &Recipe) -> Self {
self.rules = self.rules.extend(rules);
self
}
pub fn force(mut self, interaction: Option<Interaction>) -> Self {
self.forced = interaction;
self
}
pub fn id(mut self, id: impl Into<Arc<str>>) -> Self {
self.id = Some(id.into());
self
}
pub fn key(mut self, key: impl Into<Arc<str>>) -> Self {
self.key = Some(key.into());
self
}
pub fn build(self, theme: &Theme) -> Element {
let removable = !self.on_remove.is_empty();
let case = Case {
variant: Some(self.variant),
size: Some(self.size),
density: None,
breakpoint: super::current_breakpoint(),
states: self.states.clone(),
}
.state(TagState::Remove, removable)
.state(TagState::Pill, self.shape == TagShape::Pill)
.state(TagState::Disabled, self.disabled);
let remove_label = self.remove_label.unwrap_or_else(|| {
Arc::from(crate::core::fill(
&super::current_locale().common.remove_named,
&[("name", &self.label)],
))
});
let view = TagView {
label: self.label,
term: self.term,
remove_label,
variant: self.variant,
size: self.size,
icon: self.icon,
shape: self.shape,
removable,
disabled: self.disabled,
tab_stop: self.tab_stop,
recipe: theme
.resolve::<Tag>(&case, Some(&self.rules))
.owned_by(self.id.as_ref()),
forced: self.forced,
on_remove: self.on_remove,
id: self.id,
key: self.key,
};
match theme.renderer::<Tag>() {
Some(renderer) => renderer(view),
None => view.render(),
}
}
}
impl From<Tag> for Element {
fn from(tag: Tag) -> Self {
tag.build(¤t_theme())
}
}
pub struct TagView {
pub label: Arc<str>,
pub term: Option<Arc<str>>,
pub remove_label: Arc<str>,
pub variant: Name,
pub size: Name,
pub icon: Option<Name>,
pub shape: TagShape,
pub removable: bool,
pub disabled: bool,
tab_stop: bool,
pub recipe: ResolvedRecipe,
forced: Option<Interaction>,
on_remove: Vec<Removed>,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl TagView {
pub fn part(&self, part: impl Into<Name>) -> ResolvedPart {
let part = part.into();
let resolved = self.recipe.part(part);
if part == Name::from(TagPart::Remove) {
resolved.forced(self.forced)
} else {
resolved
}
}
pub fn theme(&self) -> &Theme {
self.recipe.theme()
}
pub fn remove(&self) -> Option<components::Button> {
if !self.removable {
return None;
}
let part = self.part(TagPart::Remove);
let side = self
.part(TagPart::RemoveIcon)
.rest()
.width
.unwrap_or(Length::Icon(IconSize::Sm));
let mut remove = tab_stop(pressable(&part, self.disabled), self.tab_stop)
.describe("a11y_role", "button")
.describe("a11y_name", self.remove_label.clone())
.child(Icon::new(icons::CLOSE).size(side).build(self.theme()));
if let Some(id) = &self.id {
remove = remove.id(format!("{id}-remove"));
}
if !self.disabled {
let (clicked, keyed) = (self.on_remove.clone(), self.on_remove.clone());
remove = remove
.on_click(move |event: MouseEvent| {
let event = TagRemoveEvent::Press(event);
for handler in &clicked {
handler(&event);
}
})
.on_key_down(move |event: KeyboardEvent| {
let plain = !event.ctrl && !event.alt && !event.meta && !event.shift;
if event.focus_within && plain && matches!(event.key.as_str(), "Backspace" | "Delete") {
event.prevent_default();
let event = TagRemoveEvent::Key(event);
for handler in &keyed {
handler(&event);
}
}
});
}
Some(remove)
}
pub fn render(self) -> Element {
let mut root = Row::new()
.align_items(Alignment::Center)
.overflow_visible()
.part(&self.part(TagPart::Root));
if let Some(name) = self.icon {
root = root.child(glyph(&self.part(TagPart::Icon), name, false));
}
if let Some(term) = &self.term {
let part = self.part(TagPart::Term);
root = root.child(part.text(term).nowrap().part(&part));
}
let label = self.part(TagPart::Label);
root = root.child(label.text(&self.label).nowrap().part(&label));
if let Some(remove) = self.remove() {
root = root.child(remove);
}
if let Some(id) = &self.id {
root = root.id(id.clone());
}
if let Some(key) = &self.key {
root = root.key(key.clone());
}
root.into()
}
}
impl crate::ui::Styled for Tag {
type Component = Self;
fn rules(self, rules: &crate::ui::Recipe) -> Self {
Self::rules(self, rules)
}
fn state(self, state: impl Into<crate::ui::Name>, on: bool) -> Self {
Self::state(self, state, on)
}
}
impl Themed for Tag {
const NAME: &'static str = "tag";
type Renderer = TagRenderer;
fn parts() -> crate::ui::Declared {
TagPart::declared()
}
fn states() -> crate::ui::Declared {
TagState::declared()
}
fn recipe() -> Recipe {
use PaletteColor::*;
use TagPart::{Icon, Label, Remove, RemoveIcon, Root, Term};
let line = |color: PaletteColor| Line::inside(BorderSize::Sm, color);
let colored = |recipe: Recipe, variant: TagVariant, fill: PaletteColor, ink: PaletteColor| {
let term = ink.clone();
recipe
.variant(variant, Root, move |s| {
s.background(fill.clone()).border(line(fill)).foreground(ink)
})
.variant(variant, Term, |s| s.foreground(term))
};
let recipe = Recipe::new()
.base(Root, |s| {
s.height(24.0)
.padding_x(8.0)
.gap(4.0)
.radius(RadiusSize::Sm)
.background(Secondary)
.border(line(Border))
.foreground(SecondaryForeground)
})
.base(Label, |s| {
s.typography(TypographyStyle::Caption).weight(FontWeight::Medium)
})
.base(Term, |s| {
s.typography(TypographyStyle::Caption)
.weight(FontWeight::Normal)
.foreground(MutedForeground)
})
.base(Icon, |s| s.square(IconSize::Xs))
.base(Remove, |s| {
fading(
s.square(16.0)
.radius(3.0)
.foreground(MutedForeground)
.cursor(CursorIcon::Pointer),
)
})
.base(RemoveIcon, |s| s.square(11.0))
.hovered(Remove, |s| s.background(StateHover).foreground(Foreground))
.pressed(Remove, |s| s.background(StatePressed).foreground(Foreground))
.focus_visible(Remove, |s| s.outline(Outline::new(BorderSize::Md, Ring)))
.size(TagSize::Sm, Root, |s| s.height(20.0).padding_x(6.0))
.size(TagSize::Sm, Label, |s| s.font_size(11.0))
.size(TagSize::Sm, Term, |s| s.font_size(11.0))
.size(TagSize::Sm, Remove, |s| s.square(14.0))
.size(TagSize::Sm, RemoveIcon, |s| s.square(10.0))
.size(TagSize::Lg, Root, |s| s.height(28.0).padding_x(10.0).gap(6.0))
.size(TagSize::Lg, Label, |s| s.font_size(13.0))
.size(TagSize::Lg, Term, |s| s.font_size(13.0))
.size(TagSize::Lg, Icon, |s| s.square(IconSize::Sm))
.size(TagSize::Lg, Remove, |s| s.square(18.0))
.size(TagSize::Lg, RemoveIcon, |s| s.square(12.0))
.state(TagState::Remove, Root, |s| s.padding_end(4.0))
.when(
Selector::new().size(TagSize::Sm).state(TagState::Remove),
Root,
|s| s.padding_end(3.0),
)
.when(
Selector::new().size(TagSize::Lg).state(TagState::Remove),
Root,
|s| s.padding_end(5.0),
)
.state(TagState::Pill, Root, |s| {
s.radius(RadiusSize::Full)
.border(Line::inside(0.0, Border))
.padding_x(10.0)
})
.state(TagState::Pill, Remove, |s| s.square(12.0).radius(RadiusSize::Full))
.state(TagState::Pill, RemoveIcon, |s| s.square(12.0))
.when(Selector::new().size(TagSize::Sm).state(TagState::Pill), Root, |s| {
s.padding_x(8.0)
})
.when(Selector::new().size(TagSize::Lg).state(TagState::Pill), Root, |s| {
s.padding_x(12.0)
})
.when(
Selector::new().state(TagState::Pill).state(TagState::Remove),
Root,
|s| s.padding_end(6.0),
)
.when(
Selector::new()
.size(TagSize::Sm)
.state(TagState::Pill)
.state(TagState::Remove),
Root,
|s| s.padding_end(4.0),
)
.when(
Selector::new()
.size(TagSize::Lg)
.state(TagState::Pill)
.state(TagState::Remove),
Root,
|s| s.padding_end(8.0),
)
.state(TagState::Disabled, Root, |s| s.opacity(OpacityLevel::Disabled))
.state(TagState::Disabled, Remove, |s| s.cursor(CursorIcon::Default));
let recipe = colored(recipe, TagVariant::Info, InfoMuted, Info);
let recipe = colored(recipe, TagVariant::Success, SuccessMuted, Success);
let recipe = colored(recipe, TagVariant::Warning, WarningMuted, Warning);
colored(recipe, TagVariant::Destructive, DestructiveMuted, Destructive)
}
}