use std::sync::{
Arc,
atomic::{AtomicBool, Ordering},
};
use super::{
button::{Button, ButtonPart, ButtonSize, ButtonVariant},
icons,
input::{Input, InputPart, InputSize},
names,
part_style::{Length, PartStyle},
recipe::{Case, Interaction, Name, Recipe, ResolvedPart, ResolvedRecipe},
shared::{fading, glyph, one_line, pressable},
theme::{Themed, current_theme},
};
use crate::{
app::{
component::Component,
ctx::Ctx,
events::KeyboardEvent,
theme::{OpacityLevel, PaletteColor, RadiusSize, Theme, TypographyStyle},
},
components::{Row, TextInputController},
core::{ElementRef, Signal},
layout::{Alignment, text_style::FontWeight},
node::{CursorIcon, Element, NodeUpdate},
};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum EditablePart {
Root,
Label,
Placeholder,
Icon,
Editing,
Field,
Confirm,
Cancel,
}
names!(EditablePart {
Root => "root",
Label => "label",
Placeholder => "placeholder",
Icon => "icon",
Editing => "editing",
Field => "field",
Confirm => "confirm",
Cancel => "cancel",
});
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum EditableState {
Editing,
Empty,
Invalid,
ReadOnly,
Disabled,
FullWidth,
}
names!(EditableState {
Editing => "editing",
Empty => "empty",
Invalid => "invalid",
ReadOnly => "read_only",
Disabled => "disabled",
FullWidth => "full_width",
});
pub type EditableRenderer = Arc<dyn Fn(EditableView) -> Element + Send + Sync>;
type Run = Arc<dyn Fn() + Send + Sync>;
type TextHandler = Arc<dyn Fn(&str) + Send + Sync>;
type FlagHandler = Arc<dyn Fn(bool) + Send + Sync>;
#[derive(Clone)]
enum Held {
Bound(Signal<String>),
Controlled(Arc<str>),
}
#[derive(Clone)]
pub struct Editable {
value: Held,
on_change: Vec<TextHandler>,
on_cancel: Vec<Run>,
editing: Option<Signal<bool>>,
default_editing: bool,
on_editing_change: Vec<FlagHandler>,
placeholder: Option<Arc<str>>,
label: Option<Arc<str>>,
actions: bool,
submit_on_blur: bool,
invalid: bool,
read_only: bool,
disabled: bool,
full_width: bool,
confirm_label: Arc<str>,
cancel_label: Arc<str>,
states: Vec<Name>,
rules: Recipe,
forced: Option<Interaction>,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl Editable {
fn of(value: Held) -> Self {
Self {
value,
on_change: Vec::new(),
on_cancel: Vec::new(),
editing: None,
default_editing: false,
on_editing_change: Vec::new(),
placeholder: None,
label: None,
actions: true,
submit_on_blur: true,
invalid: false,
read_only: false,
disabled: false,
full_width: false,
confirm_label: super::current_locale().common.save.clone(),
cancel_label: super::current_locale().common.cancel.clone(),
states: Vec::new(),
rules: Recipe::new(),
forced: None,
id: None,
key: None,
}
}
pub fn new(value: Signal<String>) -> Self {
Self::of(Held::Bound(value))
}
pub fn controlled(value: &str, on_change: impl Fn(&str) + Send + Sync + 'static) -> Self {
Self::of(Held::Controlled(Arc::from(value))).on_change(on_change)
}
pub fn on_change(mut self, handler: impl Fn(&str) + Send + Sync + 'static) -> Self {
self.on_change.push(Arc::new(handler));
self
}
pub fn on_cancel(mut self, handler: impl Fn() + Send + Sync + 'static) -> Self {
self.on_cancel.push(Arc::new(handler));
self
}
pub fn editing(mut self, editing: Signal<bool>) -> Self {
self.editing = Some(editing);
self
}
pub fn default_editing(mut self, editing: bool) -> Self {
self.default_editing = editing;
self
}
pub fn on_editing_change(mut self, handler: impl Fn(bool) + Send + Sync + 'static) -> Self {
self.on_editing_change.push(Arc::new(handler));
self
}
pub fn placeholder(mut self, placeholder: &str) -> Self {
self.placeholder = Some(Arc::from(placeholder));
self
}
pub fn label(mut self, label: &str) -> Self {
self.label = Some(Arc::from(label));
self
}
pub fn actions(mut self, actions: bool) -> Self {
self.actions = actions;
self
}
pub fn submit_on_blur(mut self, submit: bool) -> Self {
self.submit_on_blur = submit;
self
}
pub fn invalid(mut self, invalid: bool) -> Self {
self.invalid = invalid;
self
}
pub fn read_only(mut self, read_only: bool) -> Self {
self.read_only = read_only;
self
}
pub fn disabled(mut self, disabled: bool) -> Self {
self.disabled = disabled;
self
}
pub fn full_width(mut self, full_width: bool) -> Self {
self.full_width = full_width;
self
}
pub fn confirm_label(mut self, label: &str) -> Self {
self.confirm_label = Arc::from(label);
self
}
pub fn cancel_label(mut self, label: &str) -> Self {
self.cancel_label = Arc::from(label);
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 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
}
fn text(&self) -> Arc<str> {
match &self.value {
Held::Bound(signal) => Arc::from(signal.get()),
Held::Controlled(value) => value.clone(),
}
}
pub fn mount(self, ctx: &mut Ctx) -> Element {
let key = self.key.clone();
let mut element = ctx.mount::<EditableHost>(EditableProps { editable: self });
if let Some(key) = key {
element = element.key(key);
}
element
}
pub fn build(self, theme: &Theme) -> Element {
let kept = Kept {
editing: self
.editing
.clone()
.unwrap_or_else(|| Signal::new(self.default_editing)),
draft: Signal::new(self.text().to_string()),
reading: ElementRef::new(),
field: TextInputController::new(),
return_focus: Arc::default(),
started: Arc::default(),
};
self.view(theme, kept)
}
fn view(self, theme: &Theme, kept: Kept) -> Element {
let text = self.text();
let editing = kept.editing.get() && !self.read_only && !self.disabled;
let mut case = Case::new()
.breakpoint(super::current_breakpoint())
.state(EditableState::Editing, editing)
.state(EditableState::Empty, text.is_empty())
.state(EditableState::Invalid, self.invalid)
.state(EditableState::ReadOnly, self.read_only)
.state(EditableState::Disabled, self.disabled)
.state(EditableState::FullWidth, self.full_width);
for state in &self.states {
case = case.state(state.clone(), true);
}
let view = EditableView {
text,
placeholder: self.placeholder,
label: self.label,
editing,
actions: self.actions,
invalid: self.invalid,
read_only: self.read_only,
disabled: self.disabled,
full_width: self.full_width,
recipe: theme
.resolve::<Editable>(&case, Some(&self.rules))
.owned_by(self.id.as_ref()),
held: self.value,
on_change: self.on_change,
on_cancel: self.on_cancel,
on_editing_change: self.on_editing_change,
submit_on_blur: self.submit_on_blur,
confirm_label: self.confirm_label,
cancel_label: self.cancel_label,
forced: self.forced,
kept,
id: self.id,
key: self.key,
};
match theme.renderer::<Editable>() {
Some(renderer) => renderer(view),
None => view.render(),
}
}
}
impl From<Editable> for Element {
fn from(editable: Editable) -> Self {
editable.build(¤t_theme())
}
}
#[derive(Clone)]
struct Kept {
editing: Signal<bool>,
draft: Signal<String>,
reading: ElementRef,
field: TextInputController,
return_focus: Arc<AtomicBool>,
started: Arc<AtomicBool>,
}
#[derive(Clone)]
struct EditableProps {
editable: Editable,
}
impl PartialEq for EditableProps {
fn eq(&self, _: &Self) -> bool {
false
}
}
impl crate::app::component::DevtoolsInspectable for EditableProps {}
struct EditableHost {
editing: Signal<bool>,
draft: Signal<String>,
reading: ElementRef,
field: TextInputController,
return_focus: Arc<AtomicBool>,
started: Arc<AtomicBool>,
was_editing: AtomicBool,
rendered: AtomicBool,
}
impl Component for EditableHost {
type Props = EditableProps;
fn create(_: &mut Ctx) -> Self {
Self {
editing: Signal::new(false),
draft: Signal::new(String::new()),
reading: ElementRef::new(),
field: TextInputController::new(),
return_focus: Arc::default(),
started: Arc::default(),
was_editing: AtomicBool::new(false),
rendered: AtomicBool::new(false),
}
}
fn render(&self, ctx: &mut Ctx) -> impl Into<Element> {
let EditableProps { editable } = ctx.props::<EditableProps>().clone();
let first = !self.rendered.swap(true, Ordering::Relaxed);
if first && editable.editing.is_none() && editable.default_editing {
self.editing.set(true);
}
let editing = editable.editing.clone().unwrap_or_else(|| self.editing.clone());
let now = editing.get() && !editable.read_only && !editable.disabled;
let was = self.was_editing.swap(now, Ordering::Relaxed);
if now && !was {
if !self.started.swap(false, Ordering::Relaxed) {
self.draft.set(editable.text().to_string());
}
if !first || editable.editing.is_none() {
ctx.focus(&self.field.element_ref());
}
} else if !now && was && self.return_focus.swap(false, Ordering::Relaxed) {
ctx.focus(&self.reading);
}
let kept = Kept {
editing,
draft: self.draft.clone(),
reading: self.reading.clone(),
field: self.field.clone(),
return_focus: self.return_focus.clone(),
started: self.started.clone(),
};
editable.view(¤t_theme(), kept)
}
}
pub struct EditableView {
pub text: Arc<str>,
pub placeholder: Option<Arc<str>>,
pub label: Option<Arc<str>>,
pub editing: bool,
pub actions: bool,
pub invalid: bool,
pub read_only: bool,
pub disabled: bool,
pub full_width: bool,
pub recipe: ResolvedRecipe,
held: Held,
on_change: Vec<TextHandler>,
on_cancel: Vec<Run>,
on_editing_change: Vec<FlagHandler>,
submit_on_blur: bool,
confirm_label: Arc<str>,
cancel_label: Arc<str>,
forced: Option<Interaction>,
kept: Kept,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl EditableView {
pub fn part(&self, part: impl Into<Name>) -> ResolvedPart {
self.recipe.part(part)
}
pub fn theme(&self) -> &Theme {
self.recipe.theme()
}
fn sub_id(&self, suffix: &str) -> Option<String> {
self.id.as_ref().map(|id| format!("{id}-{suffix}"))
}
fn start(&self) -> Run {
let (kept, text, handlers) = (self.kept.clone(), self.text.clone(), self.on_editing_change.clone());
Arc::new(move || {
if kept.editing.get_untracked() {
return;
}
kept.return_focus.store(false, Ordering::Relaxed);
kept.started.store(true, Ordering::Relaxed);
kept.draft.set(text.to_string());
kept.editing.set(true);
for handler in &handlers {
handler(true);
}
})
}
fn end(&self) -> Arc<dyn Fn(bool, bool) + Send + Sync> {
let (kept, held, text) = (self.kept.clone(), self.held.clone(), self.text.clone());
let (changed, cancelled, turned) = (
self.on_change.clone(),
self.on_cancel.clone(),
self.on_editing_change.clone(),
);
Arc::new(move |keep, by_person| {
if !kept.editing.get_untracked() {
return;
}
if by_person {
kept.return_focus.store(true, Ordering::Relaxed);
}
kept.editing.set(false);
if keep {
let typed = kept.draft.get_untracked();
if typed.as_str() != text.as_ref() {
if let Held::Bound(signal) = &held {
signal.set(typed.clone());
}
for handler in &changed {
handler(&typed);
}
}
} else {
for handler in &cancelled {
handler();
}
}
for handler in &turned {
handler(false);
}
})
}
pub fn reading(&self) -> Element {
let root = self.part(EditablePart::Root).forced(self.forced);
let shown = if self.text.is_empty() {
self.placeholder.clone().unwrap_or_default()
} else {
self.text.clone()
};
let label = if self.text.is_empty() {
self.part(EditablePart::Placeholder)
} else {
self.part(EditablePart::Label)
};
let name = self.label.clone().unwrap_or_else(|| shown.clone());
if self.read_only {
let mut row = Row::new()
.part(&root)
.align_items(Alignment::Center)
.describe("a11y_name", name)
.child(one_line(&label, &shown));
if let Some(id) = &self.id {
row = row.id(id.clone());
}
if let Some(key) = &self.key {
row = row.key(key.clone());
}
return row.into();
}
let (start, on_key) = (self.start(), self.start());
let mut button = pressable(&root, self.disabled)
.justify(crate::layout::layout_kind::Justify::Start)
.align_items(Alignment::Center)
.ref_element(self.kept.reading.clone())
.describe("a11y_name", name)
.describe("a11y_description", self.text.clone())
.on_click(move |_| start())
.on_key_down(move |event: KeyboardEvent| {
if event.focus_within && event.key == "F2" && !(event.ctrl || event.alt || event.meta || event.shift) {
event.prevent_default();
on_key();
}
})
.child(one_line(&label, &shown))
.child(glyph(&self.part(EditablePart::Icon), Name::from(icons::PENCIL), false));
if let Some(id) = &self.id {
button = button.id(id.clone());
}
if let Some(key) = &self.key {
button = button.key(key.clone());
}
button.into()
}
fn action(
&self,
part: EditablePart,
label: &str,
icon: &str,
variant: ButtonVariant,
suffix: &str,
run: Run,
) -> Element {
let mut button = Button::new(label)
.icon(icon)
.icon_only(true)
.variant(variant)
.size(ButtonSize::Sm)
.rules(&self.recipe.rules_for(part, ButtonPart::Root))
.focuses(&self.kept.field.element_ref())
.on_click(move |_| run());
if let Some(id) = self.sub_id(suffix) {
button = button.id(id);
}
let mut element = button.build(self.theme());
NodeUpdate::tab_index(&mut *element.node, -1);
element
}
pub fn editor(&self) -> Element {
let kept = &self.kept;
let rules = self
.recipe
.rules_for(EditablePart::Field, InputPart::Root)
.extend(&self.recipe.rules_for(EditablePart::Field, InputPart::Control));
let mut input = Input::new(kept.draft.clone())
.size(InputSize::Sm)
.invalid(self.invalid)
.rules(&rules);
if let Some(placeholder) = &self.placeholder {
input = input.placeholder(placeholder);
}
if let Some(label) = self.label.as_ref().or(self.placeholder.as_ref()) {
input = input.label(label);
}
if let Some(id) = self.sub_id("field") {
input = input.id(id);
}
let view = input.view(self.theme());
let (on_key, on_blur) = (self.end(), self.end());
let submit_on_blur = self.submit_on_blur;
let control = view
.control()
.controller(kept.field.clone())
.select_on_focus(true)
.on_blur(move || on_blur(submit_on_blur, false))
.on_key_down(move |event: KeyboardEvent| {
if !event.focus_within || event.composing || event.ctrl || event.alt || event.meta {
return;
}
match event.key.as_str() {
"Enter" => {
event.prevent_default();
on_key(true, true);
}
"Escape" => {
event.prevent_default();
on_key(false, true);
}
_ => {}
}
});
let mut row = Row::new()
.part(&self.part(EditablePart::Editing))
.align_items(Alignment::Center)
.child(
Row::new()
.flex_full(if self.full_width { 1.0 } else { 0.0 }, 1.0, None)
.min_width(0.0)
.child(view.render_with_end(control, None)),
);
if self.actions {
let (confirm, cancel) = (self.end(), self.end());
row = row
.child(self.action(
EditablePart::Confirm,
&self.confirm_label,
icons::CHECK,
ButtonVariant::Outline,
"confirm",
Arc::new(move || confirm(true, true)),
))
.child(self.action(
EditablePart::Cancel,
&self.cancel_label,
icons::CLOSE,
ButtonVariant::Ghost,
"cancel",
Arc::new(move || cancel(false, true)),
));
}
row.into()
}
pub fn render(self) -> Element {
if self.editing { self.editor() } else { self.reading() }
}
}
impl crate::ui::Styled for Editable {
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 Editable {
const NAME: &'static str = "editable";
type Renderer = EditableRenderer;
fn parts() -> crate::ui::Declared {
EditablePart::declared()
}
fn states() -> crate::ui::Declared {
EditableState::declared()
}
fn recipe() -> Recipe {
use EditablePart::*;
use PaletteColor::{Foreground, MutedForeground};
Recipe::new()
.base(Root, |s| {
fading(
s.height(32.0)
.gap(8.0)
.max_width(Length::Fill)
.radius(RadiusSize::Sm)
.foreground(Foreground)
.cursor(CursorIcon::Pointer),
)
})
.state(EditableState::FullWidth, Root, |s| s.width(Length::Fill))
.base(Label, |s| {
s.typography(TypographyStyle::Body)
.font_size(16.0)
.weight(FontWeight::SemiBold)
.foreground(Foreground)
})
.base(Placeholder, |s| {
s.typography(TypographyStyle::Body)
.font_size(16.0)
.weight(FontWeight::SemiBold)
.foreground(MutedForeground)
})
.base(Icon, |s| fading(s.square(14.0).foreground(MutedForeground)))
.focus_visible(Root, |s| s.focus_ring())
.state(EditableState::ReadOnly, Root, |s| s.cursor(CursorIcon::Default))
.state(EditableState::Disabled, Root, |s| {
s.opacity(OpacityLevel::Disabled).cursor(CursorIcon::Default)
})
.base(Editing, |s| s.gap(6.0).max_width(Length::Fill))
.state(EditableState::FullWidth, Editing, |s| s.width(Length::Fill))
.base(Field, |s| s.width(160.0).height(32.0).font_size(14.0))
.state(EditableState::FullWidth, Field, |s| s.width(Length::Fill))
.base(Confirm, |s| s.square(32.0))
.base(Cancel, |s| s.square(32.0))
}
}