Skip to main content

xrack_runtime/
time_picker.rs

1use crate::{
2    ControlAction, Node, Tumbler, TumblerItems, VecModel,
3    picker::{PickerSession, append_picker_dialog},
4};
5use std::fmt;
6
7/// A time of day with second precision.
8#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
9pub struct Time {
10    pub hour: i64,
11    pub minute: i64,
12    pub second: i64,
13}
14
15impl Time {
16    pub fn new(hour: i64, minute: i64, second: i64) -> Option<Self> {
17        let value = Self {
18            hour,
19            minute,
20            second,
21        };
22        (value == value.normalized()).then_some(value)
23    }
24
25    pub fn normalized(self) -> Self {
26        Self {
27            hour: self.hour.clamp(0, 23),
28            minute: self.minute.clamp(0, 59),
29            second: self.second.clamp(0, 59),
30        }
31    }
32}
33
34impl fmt::Display for Time {
35    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
36        write!(f, "{:02}:{:02}:{:02}", self.hour, self.minute, self.second)
37    }
38}
39
40thread_local! {
41    static HOURS_24: TumblerItems = numbers(0..24);
42    static HOURS_12: TumblerItems = numbers(std::iter::once(12).chain(1..12));
43    static MINUTES_SECONDS: TumblerItems = numbers(0..60);
44    static PERIODS: TumblerItems = TumblerItems::new(VecModel::from(vec!["AM".into(), "PM".into()]));
45}
46
47fn numbers(values: impl Iterator<Item = i64>) -> TumblerItems {
48    TumblerItems::new(VecModel::from(
49        values
50            .map(|value| format!("{value:02}"))
51            .collect::<Vec<_>>(),
52    ))
53}
54
55#[doc(hidden)]
56#[derive(Clone, Copy)]
57pub struct TimePickerOptions {
58    use_24_hours: bool,
59    show_seconds: bool,
60}
61
62impl TimePickerOptions {
63    pub fn new(use_24_hours: bool, show_seconds: bool) -> Self {
64        Self {
65            use_24_hours,
66            show_seconds,
67        }
68    }
69
70    pub fn from_node(node: &Node) -> Self {
71        Self::new(
72            node.boolean("use-24-hour-format", true),
73            node.boolean("show-seconds", false),
74        )
75    }
76
77    fn wheel(self, time: Time, slot: usize) -> Option<(&'static str, TumblerItems, i64)> {
78        Some(match slot {
79            0 if self.use_24_hours => ("Hour", HOURS_24.with(Clone::clone), time.hour),
80            0 => ("Hour", HOURS_12.with(Clone::clone), time.hour % 12),
81            1 => ("Minute", MINUTES_SECONDS.with(Clone::clone), time.minute),
82            2 if self.show_seconds => ("Second", MINUTES_SECONDS.with(Clone::clone), time.second),
83            3 if !self.use_24_hours => ("AM/PM", PERIODS.with(Clone::clone), time.hour / 12),
84            _ => return None,
85        })
86    }
87
88    pub fn populate(self, picker: &mut Node, time: Time) {
89        let time = time.normalized();
90        for slot in 0..4 {
91            let wheel = if let Some((label, model, index)) = self.wheel(time, slot) {
92                let mut wheel = Node::new("Tumbler", None);
93                wheel.tumbler_items = Some(model);
94                wheel
95                    .properties
96                    .insert("accessible-name", label.to_owned().into());
97                wheel.properties.insert("current-index", index.into());
98                wheel
99            } else {
100                Node::hidden()
101            };
102            picker.children.push(wheel);
103        }
104    }
105
106    pub fn select(
107        self,
108        time: Time,
109        slot: usize,
110        node: &Node,
111        action: ControlAction,
112    ) -> Option<Time> {
113        let ControlAction::PickTumbler { index, row } = action else {
114            return None;
115        };
116        let time = time.normalized();
117        let (_, model, current) = self.wheel(time, slot)?;
118        let index_value = i64::try_from(index).ok()?;
119        if node.kind != "Tumbler"
120            || node.tumbler_items.as_ref() != Some(&model)
121            || node.int("current-index") != Some(current)
122            || Tumbler::from_node(node).row_key(index) != Some(row)
123            || index_value == current
124        {
125            return None;
126        }
127        Some(match slot {
128            0 => Time {
129                hour: index_value
130                    + if self.use_24_hours {
131                        0
132                    } else {
133                        time.hour / 12 * 12
134                    },
135                ..time
136            },
137            1 => Time {
138                minute: index_value,
139                ..time
140            },
141            2 => Time {
142                second: index_value,
143                ..time
144            },
145            3 => Time {
146                hour: time.hour % 12 + index_value * 12,
147                ..time
148            },
149            _ => unreachable!(),
150        })
151    }
152}
153
154#[doc(hidden)]
155#[derive(Default)]
156pub struct TimePopupState(PickerSession<Time>);
157
158impl TimePopupState {
159    pub fn close(&self) {
160        self.0.close();
161    }
162
163    pub fn populate(&self, dialog: &mut Node, time: impl FnOnce() -> Time) {
164        let Some(draft) = self.0.begin(dialog, || time().normalized()) else {
165            return;
166        };
167        let mut picker = Node::new("TimePicker", None);
168        TimePickerOptions::from_node(dialog).populate(&mut picker, draft);
169        for wheel in &mut picker.children {
170            self.0.stamp(wheel);
171        }
172        append_picker_dialog(dialog, picker);
173    }
174
175    pub fn edit(
176        &self,
177        options: TimePickerOptions,
178        slot: usize,
179        node: &Node,
180        action: ControlAction,
181    ) -> bool {
182        let Some(next) = self
183            .0
184            .current(node)
185            .and_then(|time| options.select(time, slot, node, action))
186        else {
187            return false;
188        };
189        self.0.set(next);
190        true
191    }
192
193    pub fn finish(&self, dialog: &Node) -> Option<Time> {
194        self.0.finish(dialog)
195    }
196}