use crate::{DialogRole, InputRoute, Length, Node, Property};
use std::cell::{Cell, RefCell};
const SESSION: &str = "__picker-session";
const DRAFT_REVISION: &str = "__picker-draft-revision";
impl Node {
#[doc(hidden)]
pub fn picker_session_id(&self) -> Option<i64> {
self.int(SESSION)
}
}
thread_local! {
static NEXT_SESSION: Cell<i64> = const { Cell::new(1) };
}
pub(crate) struct PickerSession<T> {
initial: RefCell<Option<(i64, T)>>,
draft: Property<Option<T>>,
draft_revision: Cell<i64>,
}
impl<T> Default for PickerSession<T> {
fn default() -> Self {
Self {
initial: RefCell::new(None),
draft: Property::default(),
draft_revision: Cell::new(0),
}
}
}
impl<T: Clone> PickerSession<T> {
pub(crate) fn close(&self) {
self.initial.take();
self.draft_revision.set(0);
self.draft.reset();
}
pub(crate) fn try_begin<E>(
&self,
dialog: &mut Node,
initial: impl FnOnce() -> Result<T, E>,
) -> Result<Option<T>, E> {
if !dialog.is_visible() {
self.close();
return Ok(None);
}
let session = self.initial.borrow().clone();
let (revision, initial) = if let Some(session) = session {
session
} else {
#[expect(
clippy::expect_used,
reason = "picker sessions cannot reuse IDs while older scene inputs may still arrive"
)]
let revision = NEXT_SESSION.with(|next| {
let current = next.get();
next.set(current.checked_add(1).expect("picker sessions exhausted"));
current
});
let session = (revision, initial()?);
self.initial.replace(Some(session.clone()));
session
};
dialog.properties.insert(SESSION, revision.into());
dialog
.properties
.insert(DRAFT_REVISION, self.draft_revision.get().into());
Ok(Some(self.draft.get(|| None).unwrap_or(initial)))
}
pub(crate) fn stamp(&self, child: &mut Node) {
if let Some((revision, _)) = self.initial.borrow().as_ref() {
child.properties.insert(SESSION, (*revision).into());
}
}
pub(crate) fn current(&self, scene: &Node) -> Option<T> {
let initial = self.initial.borrow();
let (revision, value) = initial.as_ref()?;
(scene.picker_session_id() == Some(*revision))
.then(|| self.draft.get(|| None).unwrap_or_else(|| value.clone()))
}
pub(crate) fn accepts_input(&self, scene: &Node, input: InputRoute<'_>) -> bool {
input.is_current()
&& self
.initial
.borrow()
.as_ref()
.is_some_and(|(revision, _)| scene.picker_session_id() == Some(*revision))
}
#[expect(
clippy::expect_used,
reason = "a new picker draft must invalidate input from older revisions"
)]
pub(crate) fn set(&self, draft: T) {
self.draft_revision.set(
self.draft_revision
.get()
.checked_add(1)
.expect("picker draft revisions exhausted"),
);
self.draft.set(Some(draft));
}
pub(crate) fn try_finish_input<E>(
&self,
dialog: &Node,
role: DialogRole,
input: InputRoute<'_>,
accept: impl FnOnce(T) -> Result<Option<T>, E>,
) -> Result<Option<T>, E> {
if !self.accepts_input(dialog, input) {
return Ok(None);
}
if role == DialogRole::Reject {
return Ok(self.finish(dialog, role));
}
if dialog.int(DRAFT_REVISION) != Some(self.draft_revision.get()) {
return Ok(None);
}
let Some(draft) = self.current(dialog) else {
return Ok(None);
};
let Some(value) = accept(draft)? else {
return Ok(None);
};
if !self.accepts_input(dialog, input)
|| dialog.int(DRAFT_REVISION) != Some(self.draft_revision.get())
{
return Ok(None);
}
self.close();
Ok(Some(value))
}
pub(crate) fn finish(&self, dialog: &Node, role: DialogRole) -> Option<T> {
if role == DialogRole::Accept
&& dialog.int(DRAFT_REVISION) != Some(self.draft_revision.get())
{
return None;
}
let value = self.current(dialog)?;
self.close();
Some(value)
}
}
pub(crate) fn append_picker_dialog(dialog: &mut Node, picker: Node, can_accept: bool) {
let mut footer = Node::new("DialogButtonBox", None);
let date_or_time = matches!(picker.kind, "Calendar" | "TimePicker");
footer.properties.insert("__picker-actions", true.into());
for (role, property) in [
(DialogRole::Reject, "cancel-text"),
(DialogRole::Accept, "accept-text"),
] {
let mut button = Node::new("DialogButton", None);
button.properties.insert("role", role.into());
button.properties.insert("min-width", Length(44.0).into());
button.properties.insert("min-height", Length(44.0).into());
if role == DialogRole::Accept && !can_accept {
button.properties.insert("enabled", false.into());
}
if let Some(text) = dialog.text(property) {
button.properties.insert("text", text.to_owned().into());
}
footer.children.push(button);
}
let picker = if date_or_time {
picker
} else {
let mut viewport = Node::new("ScrollView", None);
viewport.properties.insert("__picker-viewport", true.into());
viewport
.properties
.insert("reserve-scroll-bar-space", true.into());
viewport.children.push(picker);
viewport
};
dialog.children.extend([picker, footer]);
}