use std::sync::Arc;
use parking_lot::Mutex;
use super::{
avatar::{Avatar, AvatarSize},
field::{FieldControl, InField},
icon::Icon,
names,
part_style::{Length, PartStyle},
recipe::{Case, Interaction, Name, Recipe, ResolvedPart, ResolvedRecipe},
text_box::TextBoxSize,
theme::{Themed, current_theme},
token_input::{MENTION, Token, TokenInput, TokenInputPart, TokenInputView},
};
use crate::{
app::{
ctx::Placement,
events::{KeyboardEvent, TextInputEvent},
theme::{BorderSize, IconSize, OpacityLevel, PaletteColor, RadiusSize, ShadowStyle, Theme, TypographyStyle},
},
components::{Column, Popup, Row, TextInputController},
core::{ElementRef, Signal},
layout::Alignment,
node::{CursorIcon, Element, border::Border},
};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum MentionsPart {
Root,
Control,
Panel,
Item,
ItemAvatar,
ItemIcon,
ItemLabel,
}
names!(MentionsPart {
Root => "root",
Control => "control",
Panel => "panel",
Item => "item",
ItemAvatar => "item_avatar",
ItemIcon => "item_icon",
ItemLabel => "item_label",
});
pub type MentionsSize = TextBoxSize;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum MentionsState {
Open,
Highlighted,
Disabled,
Fluid,
}
names!(MentionsState {
Open => "open",
Highlighted => "highlighted",
Disabled => "disabled",
Fluid => "fluid",
});
pub type MentionsRenderer = Arc<dyn Fn(MentionsView) -> Element + Send + Sync>;
pub struct Mention {
label: Arc<str>,
text: Option<Arc<str>>,
avatar: Option<Avatar>,
icon: Option<Name>,
disabled: bool,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl Mention {
pub fn new(label: &str) -> Self {
Self {
label: Arc::from(label),
text: None,
avatar: None,
icon: None,
disabled: false,
id: None,
key: None,
}
}
pub fn text(mut self, text: &str) -> Self {
self.text = Some(Arc::from(text));
self
}
pub fn avatar(mut self, avatar: Avatar) -> Self {
self.avatar = Some(avatar);
self
}
pub fn icon(mut self, name: impl Into<Name>) -> Self {
self.icon = Some(name.into());
self
}
pub fn disabled(mut self, disabled: bool) -> Self {
self.disabled = disabled;
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 label(&self) -> &str {
&self.label
}
fn inserted(&self, trigger: char) -> Arc<str> {
self
.text
.clone()
.unwrap_or_else(|| Arc::from(format!("{trigger}{}", self.label)))
}
}
pub enum MentionSource {
List(Vec<Mention>),
Find(Box<dyn Fn(&str) -> Vec<Mention> + Send + Sync>),
}
impl From<Vec<Mention>> for MentionSource {
fn from(list: Vec<Mention>) -> Self {
Self::List(list)
}
}
impl<F: Fn(&str) -> Vec<Mention> + Send + Sync + 'static> From<F> for MentionSource {
fn from(find: F) -> Self {
Self::Find(Box::new(find))
}
}
pub const MENTIONS_LIMIT: usize = 8;
impl MentionSource {
fn offers(self, trigger: char, query: &str) -> Vec<Mention> {
let mut offers = match self {
Self::Find(find) => find(query),
Self::List(list) => {
let query = query.to_lowercase();
list
.into_iter()
.filter(|offer| {
offer.label.to_lowercase().contains(&query) || offer.inserted(trigger).to_lowercase().contains(&query)
})
.collect()
}
};
offers.truncate(MENTIONS_LIMIT);
offers
}
}
#[derive(Clone)]
pub struct MentionsController {
input: TextInputController,
inner: Arc<Mutex<Kept>>,
tick: Signal<u64>,
anchor: ElementRef,
}
#[derive(Default)]
struct Kept {
active: usize,
query: Option<(usize, String)>,
dismissed: Option<usize>,
chosen: Vec<Arc<str>>,
}
impl Default for MentionsController {
fn default() -> Self {
Self::new()
}
}
impl MentionsController {
pub fn new() -> Self {
Self {
input: TextInputController::new(),
inner: Arc::default(),
tick: Signal::new(0),
anchor: ElementRef::new(),
}
}
pub fn input(&self) -> TextInputController {
self.input.clone()
}
pub fn mention(&self, text: &str) {
let mut kept = self.inner.lock();
if !kept.chosen.iter().any(|chosen| chosen.as_ref() == text) && !text.is_empty() {
kept.chosen.push(Arc::from(text));
}
drop(kept);
self.redraw();
}
pub fn mentioned(&self) -> Vec<Arc<str>> {
self.inner.lock().chosen.clone()
}
fn redraw(&self) {
self.tick.update(|tick| *tick = tick.wrapping_add(1));
}
fn choose(&self, trigger: usize, text: &str) {
let Ok(selection) = self.input.selection() else {
return;
};
if self.input.select(trigger, selection.caret.max(trigger)).is_err() {
return;
}
if self.input.replace_selection(&format!("{text} ")).unwrap_or(false) {
let mut kept = self.inner.lock();
if !kept.chosen.iter().any(|chosen| chosen.as_ref() == text) {
kept.chosen.push(Arc::from(text));
}
kept.active = 0;
kept.query = None;
kept.dismissed = None;
}
self.redraw();
}
}
struct Trigger {
character: char,
source: MentionSource,
}
pub struct Mentions {
input: TokenInput,
controller: MentionsController,
triggers: Vec<Trigger>,
states: Vec<Name>,
rules: Recipe,
forced: Option<Interaction>,
on_mention: Vec<Arc<dyn Fn(&str) + Send + Sync>>,
read_only: bool,
disabled: bool,
full_width: bool,
fluid: bool,
id: Option<Arc<str>>,
}
impl Mentions {
pub fn new(value: Signal<String>, controller: &MentionsController) -> Self {
Self {
input: TokenInput::new(value).rows(2, 8),
controller: controller.clone(),
triggers: Vec::new(),
states: Vec::new(),
rules: Recipe::new(),
forced: None,
on_mention: Vec::new(),
read_only: false,
disabled: false,
full_width: false,
fluid: false,
id: None,
}
}
pub fn trigger(mut self, trigger: char, options: impl Into<MentionSource>) -> Self {
self.triggers.retain(|held| held.character != trigger);
self.triggers.push(Trigger {
character: trigger,
source: options.into(),
});
self
}
pub fn on_mention(mut self, handler: impl Fn(&str) + Send + Sync + 'static) -> Self {
self.on_mention.push(Arc::new(handler));
self
}
pub fn find_tokens(mut self, find: impl Fn(&str) -> Vec<Token> + Send + Sync + 'static) -> Self {
self.input = self.input.find_tokens(find);
self
}
pub fn rows(mut self, min_rows: usize, max_rows: usize) -> Self {
self.input = self.input.rows(min_rows, max_rows);
self
}
pub fn full_width(mut self, full_width: bool) -> Self {
self.full_width = full_width;
self.input = self.input.full_width(full_width);
self
}
pub fn placeholder(mut self, placeholder: &str) -> Self {
self.input = self.input.placeholder(placeholder);
self
}
pub fn size(mut self, size: impl Into<Name>) -> Self {
self.input = self.input.size(size);
self
}
pub fn invalid(mut self, invalid: bool) -> Self {
self.input = self.input.invalid(invalid);
self
}
pub fn warning(mut self, warning: bool) -> Self {
self.input = self.input.warning(warning);
self
}
pub fn valid(mut self, valid: bool) -> Self {
self.input = self.input.valid(valid);
self
}
pub fn read_only(mut self, read_only: bool) -> Self {
self.read_only = read_only;
self.input = self.input.read_only(read_only);
self
}
pub fn disabled(mut self, disabled: bool) -> Self {
self.disabled = disabled;
self.input = self.input.disabled(disabled);
self
}
pub fn label(mut self, label: &str) -> Self {
self.input = self.input.label(label);
self
}
pub fn on_input(mut self, handler: impl Fn(&TextInputEvent) + Send + Sync + 'static) -> Self {
self.input = self.input.on_input(handler);
self
}
#[cfg(feature = "form")]
pub fn name(mut self, name: impl Into<Arc<str>>) -> Self {
self.input = self.input.name(name);
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 style(mut self, part: impl Into<Name>, style: impl FnOnce(PartStyle) -> 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 input_rules(mut self, rules: &Recipe) -> Self {
self.input = self.input.rules(rules);
self
}
pub fn force(mut self, interaction: Option<Interaction>) -> Self {
self.forced = interaction;
self.input = self.input.force(interaction);
self
}
pub fn id(mut self, id: impl Into<Arc<str>>) -> Self {
let id = id.into();
self.input = self.input.id(id.clone());
self.id = Some(id);
self
}
pub fn key(mut self, key: impl Into<Arc<str>>) -> Self {
self.input = self.input.key(key);
self
}
pub fn build(self, theme: &Theme) -> Element {
let controller = self.controller.clone();
controller.tick.get();
let focused = controller.input.element_ref().focus_signal().get();
let base = Case {
variant: None,
size: None,
density: None,
breakpoint: super::current_breakpoint(),
states: self.states.clone(),
}
.state(MentionsState::Fluid, self.fluid);
let own = theme.resolve::<Mentions>(&base, Some(&self.rules));
let control = own.part(MentionsPart::Control).rest();
let root = own.part(MentionsPart::Root).rest();
let mut box_rules = Recipe::new().base(TokenInputPart::Control, move |s| s.merged(&control));
if !self.full_width {
box_rules = box_rules.base(TokenInputPart::Root, move |s| s.merged(&root));
}
let chosen = controller.inner.lock().chosen.clone();
let input = self
.input
.controller(controller.input.clone())
.rules(&box_rules)
.view(theme, move |text| mentions_in(text, &chosen));
let text = input.text.clone();
let caret = controller
.input
.selection()
.ok()
.filter(|selection| selection.range().is_empty());
let mut triggers = self.triggers;
let characters: Vec<char> = triggers.iter().map(|trigger| trigger.character).collect();
let pending = caret
.filter(|_| focused && !self.read_only && !self.disabled)
.and_then(|selection| pending_trigger(&text, selection.caret, &characters, &input.tokens));
let mut kept = controller.inner.lock();
if pending.as_ref().map(|(at, ..)| *at) != kept.dismissed {
kept.dismissed = None;
}
let pending = pending.filter(|(at, ..)| kept.dismissed != Some(*at));
let offers = match &pending {
Some((at, character, query)) => {
let index = triggers.iter().position(|trigger| trigger.character == *character);
let source = index.map(|index| triggers.swap_remove(index).source);
let offers = source
.map(|source| source.offers(*character, query))
.unwrap_or_default();
if kept.query.as_ref() != Some(&(*at, query.clone())) {
kept.query = Some((*at, query.clone()));
kept.active = 0;
}
offers
}
None => {
kept.query = None;
Vec::new()
}
};
let active = settle_active(&offers, kept.active.min(offers.len().saturating_sub(1)));
kept.active = active;
drop(kept);
let open = !offers.is_empty();
let trigger = pending.as_ref().map(|(at, character, _)| (*at, *character));
let case = base.state(MentionsState::Open, open);
let view = MentionsView {
input,
offers,
active,
trigger,
open,
recipe: theme
.resolve::<Mentions>(&case, Some(&self.rules))
.owned_by(self.id.as_ref()),
case,
rules: self.rules,
forced: self.forced,
controller,
on_mention: self.on_mention,
};
match theme.renderer::<Mentions>() {
Some(renderer) => renderer(view),
None => view.render(),
}
}
}
fn settle_active(offers: &[Mention], at: usize) -> usize {
(at..offers.len())
.chain((0..at).rev())
.find(|index| !offers[*index].disabled)
.unwrap_or(at)
}
fn step_active(choosable: &[bool], at: usize, forward: bool) -> usize {
let count = choosable.len();
(1..=count)
.map(|step| {
if forward {
(at + step) % count
} else {
(at + count * step - step) % count
}
})
.find(|index| choosable[*index])
.unwrap_or(at)
}
fn mentions_in(text: &str, chosen: &[Arc<str>]) -> Vec<Token> {
let mut tokens = Vec::new();
for mention in chosen {
for (at, found) in text.match_indices(mention.as_ref()) {
let end = at + found.len();
let starts = text[..at].chars().next_back().is_none_or(char::is_whitespace);
let ends = text[end..]
.chars()
.next()
.is_none_or(|next| next.is_whitespace() || next.is_ascii_punctuation());
if starts && ends {
tokens.push(Token::new(at..end).variant(MENTION).removable(false));
}
}
}
tokens
}
fn pending_trigger(text: &str, caret: usize, triggers: &[char], tokens: &[Token]) -> Option<(usize, char, String)> {
let before = text.get(..caret)?;
let start = before
.char_indices()
.rev()
.find(|(_, character)| character.is_whitespace())
.map_or(0, |(at, character)| at + character.len_utf8());
let word = &before[start..];
let character = word.chars().next()?;
if !triggers.contains(&character) {
return None;
}
if tokens
.iter()
.any(|token| token.range().start <= start && start < token.range().end)
{
return None;
}
Some((start, character, word[character.len_utf8()..].to_owned()))
}
impl FieldControl for Mentions {
fn in_field(mut self, field: &InField) -> Element {
self.disabled |= field.disabled;
self.fluid |= field.fluid;
self.input = self.input.in_field(field);
self.into()
}
fn has_fluid_form(&self) -> bool {
true
}
}
impl From<Mentions> for Element {
fn from(mentions: Mentions) -> Self {
mentions.build(¤t_theme())
}
}
pub struct MentionsView {
pub input: TokenInputView,
pub offers: Vec<Mention>,
pub active: usize,
pub trigger: Option<(usize, char)>,
pub open: bool,
pub recipe: ResolvedRecipe,
case: Case,
rules: Recipe,
forced: Option<Interaction>,
controller: MentionsController,
on_mention: Vec<Arc<dyn Fn(&str) + Send + Sync>>,
}
impl MentionsView {
pub fn part(&self, part: impl Into<Name>) -> ResolvedPart {
self.recipe.part(part)
}
pub fn theme(&self) -> &Theme {
self.recipe.theme()
}
fn chooser(&self, offer: &Mention) -> Option<Arc<dyn Fn() + Send + Sync>> {
if offer.disabled {
return None;
}
let (at, character) = self.trigger?;
let text = offer.inserted(character);
let (controller, handlers) = (self.controller.clone(), self.on_mention.clone());
Some(Arc::new(move || {
controller.choose(at, &text);
for handler in &handlers {
handler(&text);
}
}))
}
pub fn control(&self) -> crate::components::TextInput {
let controller = self.controller.clone();
let choosers: Vec<_> = self.offers.iter().map(|offer| self.chooser(offer)).collect();
let choosable: Vec<bool> = choosers.iter().map(Option::is_some).collect();
let (open, trigger) = (self.open, self.trigger);
let mut control = self.input.control().on_key_down(move |event: KeyboardEvent| {
if !event.focus_within {
return;
}
let plain = !event.ctrl && !event.alt && !event.meta;
if open && plain && choosable.iter().any(|can| *can) {
let count = choosers.len();
let mut kept = controller.inner.lock();
match event.key.as_str() {
"ArrowDown" if !event.shift => {
event.prevent_default();
kept.active = step_active(&choosable, kept.active.min(count - 1), true);
}
"ArrowUp" if !event.shift => {
event.prevent_default();
kept.active = step_active(&choosable, kept.active.min(count - 1), false);
}
"Enter" | "Tab" if !event.shift => {
event.prevent_default();
let chosen = choosers[kept.active.min(count - 1)].clone();
drop(kept);
if let Some(chosen) = chosen {
chosen();
}
return;
}
"Escape" => {
event.prevent_default();
kept.dismissed = trigger.map(|(at, _)| at);
}
_ => {}
}
}
controller.redraw();
});
if let Some((at, _)) = self.trigger {
control = control.anchor_at(self.controller.anchor.clone(), at);
}
let controller = self.controller.clone();
control = control
.on_mouse_down(move |_| controller.redraw())
.describe("a11y_haspopup", "listbox")
.describe("a11y_expanded", if self.open { "true" } else { "false" });
control
}
pub fn item(&self, index: usize, offer: Mention) -> Element {
let active = index == self.active && !offer.disabled;
let choose = self.chooser(&offer);
let case = self
.case
.clone()
.state(MentionsState::Highlighted, active)
.state(MentionsState::Disabled, offer.disabled);
let recipe = self
.theme()
.resolve::<Mentions>(&case, Some(&self.rules))
.owned_like(&self.recipe);
let recipe = match (&offer.id, &offer.key) {
(None, Some(key)) => recipe.keyed_item(key, MentionsPart::Item),
(id, _) => recipe.item(id.as_ref(), MentionsPart::Item),
};
let part = recipe.part(MentionsPart::Item).forced(self.forced.filter(|_| active));
let mut row = Row::new()
.align_items(Alignment::Center)
.focusable(false)
.describe("a11y_role", "option")
.describe("a11y_name", offer.label.clone())
.describe("a11y_selected", if active { "true" } else { "false" })
.part(&part);
if offer.disabled {
row = row.disabled(true);
}
if let Some(id) = &offer.id {
row = row.id(id.clone());
}
if let Some(key) = &offer.key {
row = row.key(key.clone());
}
if let Some(avatar) = offer.avatar {
row = row.child(
Row::new()
.part(&recipe.part(MentionsPart::ItemAvatar).unnamed())
.child(
avatar
.size(AvatarSize::Sm)
.rules(&recipe.lend(MentionsPart::ItemAvatar))
.build(self.theme()),
),
);
} else if let Some(name) = offer.icon {
let icon = recipe.part(MentionsPart::ItemIcon);
let side = icon.rest().width.unwrap_or(Length::Icon(IconSize::Md));
row = row.child(
Row::new()
.part(&icon)
.child(Icon::new(name).size(side).build(self.theme())),
);
}
let label = recipe.part(MentionsPart::ItemLabel);
row = row.child(Row::new().part(&label).child(label.text(&offer.label).nowrap()));
if let Some(choose) = choose {
row = row.on_click(move |_| choose());
}
if offer.disabled {
return row.into();
}
let controller = self.controller.clone();
row
.on_mouse_enter(move || {
let mut kept = controller.inner.lock();
if kept.active != index {
kept.active = index;
drop(kept);
controller.redraw();
}
})
.into()
}
pub fn panel(&mut self) -> Element {
let offers = std::mem::take(&mut self.offers);
let mut panel = Column::new()
.align_items(Alignment::Stretch)
.part(&self.part(MentionsPart::Panel))
.describe("a11y_role", "listbox");
for (index, offer) in offers.into_iter().enumerate() {
panel = panel.child(self.item(index, offer));
}
Popup::new(self.controller.anchor.clone(), panel)
.open_when(self.open)
.placement(Placement::BottomStart)
.offset(0.0, 4.0)
.takes_focus(false)
.dismiss_on_outside_click(false)
.dismiss_on_escape(false)
.switch_on_anchor_press(false)
.into()
}
pub fn render(mut self) -> Element {
let control = self.control();
let panel = self.panel();
self.input.root(control).overflow_visible().child(panel).into()
}
}
impl crate::ui::Styled for Mentions {
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 Mentions {
const NAME: &'static str = "mentions";
type Renderer = MentionsRenderer;
fn parts() -> crate::ui::Declared {
MentionsPart::declared()
}
fn states() -> crate::ui::Declared {
MentionsState::declared()
}
fn recipe() -> Recipe {
use MentionsPart::{Control, Item, ItemAvatar, ItemIcon, ItemLabel, Panel, Root};
use PaletteColor::{Foreground, Highlight, MutedForeground, Popover, PopoverForeground};
Recipe::new()
.base(Root, |s| s.width(280.0).max_width(Length::Fill))
.state(MentionsState::Fluid, Root, |s| s.width(Length::Fill))
.base(Control, |s| {
s.padding_x(12.0).padding_y(8.0).min_height(64.0).line_height(1.5)
})
.base(Panel, |s| {
s.width(220.0)
.padding_x(4.0)
.padding_y(4.0)
.radius(RadiusSize::Lg)
.background(Popover)
.foreground(PopoverForeground)
.border(Border::inside(BorderSize::Sm, PaletteColor::Border))
.shadow(ShadowStyle::Md)
})
.base(Item, |s| {
s.height(36.0)
.padding_x(8.0)
.gap(8.0)
.radius(RadiusSize::Sm)
.cursor(CursorIcon::Pointer)
})
.base(ItemAvatar, |s| s.square(24.0))
.base(ItemIcon, |s| s.square(IconSize::Md).foreground(MutedForeground))
.base(ItemLabel, |s| {
s.typography(TypographyStyle::Body)
.foreground(Foreground)
.width(Length::Fill)
})
.hovered(Item, |s| s.background(Highlight))
.state(MentionsState::Highlighted, Item, |s| s.background(Highlight))
.state(MentionsState::Disabled, Item, |s| {
s.opacity(OpacityLevel::Disabled).cursor(CursorIcon::Default)
})
}
}