Skip to main content

xrack_runtime/
combo.rs

1use crate::{ChangeSignal, Node, RowKey, Value, VecModel};
2use std::{borrow::Cow, fmt, ops::Range, rc::Rc};
3
4trait Rows {
5    fn structure(&self) -> (u64, u64);
6    fn len(&self) -> usize;
7    fn label(&self, index: usize) -> Option<String>;
8    fn value(&self, index: usize) -> Option<Value>;
9    fn enabled(&self, index: usize) -> bool;
10    fn key(&self, index: usize) -> Option<RowKey>;
11    fn index(&self, key: RowKey) -> Option<usize>;
12    fn find_label(
13        &self,
14        range: Range<usize>,
15        enabled_only: bool,
16        predicate: &mut dyn FnMut(&str) -> bool,
17    ) -> Option<usize>;
18    fn find_value(&self, value: &Value) -> Option<usize>;
19}
20
21struct RecordRows<T> {
22    model: VecModel<T>,
23    label: fn(&T) -> &str,
24    value: fn(&T) -> Value,
25    enabled: fn(&T) -> bool,
26}
27
28impl<T> Rows for RecordRows<T> {
29    fn structure(&self) -> (u64, u64) {
30        self.model.structure_stamp()
31    }
32    fn len(&self) -> usize {
33        self.model.len()
34    }
35    fn label(&self, index: usize) -> Option<String> {
36        self.model
37            .project_row_untracked(index, |row| (self.label)(row).to_owned())
38    }
39    fn value(&self, index: usize) -> Option<Value> {
40        self.model.project_row_untracked(index, self.value)
41    }
42    fn enabled(&self, index: usize) -> bool {
43        self.model
44            .project_row_untracked(index, self.enabled)
45            .unwrap_or(false)
46    }
47    fn key(&self, index: usize) -> Option<RowKey> {
48        self.model.row_key(index)
49    }
50    fn index(&self, key: RowKey) -> Option<usize> {
51        self.model.row_index(key)
52    }
53    fn find_label(
54        &self,
55        range: Range<usize>,
56        enabled_only: bool,
57        predicate: &mut dyn FnMut(&str) -> bool,
58    ) -> Option<usize> {
59        self.model.position_untracked(range, |row| {
60            (!enabled_only || (self.enabled)(row)) && predicate((self.label)(row))
61        })
62    }
63    fn find_value(&self, value: &Value) -> Option<usize> {
64        self.model
65            .position_untracked(0..self.model.len(), |row| (self.value)(row) == *value)
66    }
67}
68
69/// A typed record projection shared by snapshots of a ComboBox.
70#[doc(hidden)]
71#[derive(Clone)]
72pub struct ComboItems {
73    rows: Rc<dyn Rows>,
74    changes: Rc<ChangeSignal>,
75}
76
77impl ComboItems {
78    pub fn new<T: 'static>(
79        model: VecModel<T>,
80        label: fn(&T) -> &str,
81        value: fn(&T) -> Value,
82    ) -> Self {
83        Self::with_enabled(model, label, value, |_| true)
84    }
85
86    pub fn with_enabled<T: 'static>(
87        model: VecModel<T>,
88        label: fn(&T) -> &str,
89        value: fn(&T) -> Value,
90        enabled: fn(&T) -> bool,
91    ) -> Self {
92        let changes = model.observe_projection_changes(usize::MAX, move |_, before, after| {
93            enabled(before) != enabled(after)
94                || label(before) != label(after)
95                || value(before) != value(after)
96        });
97        Self {
98            rows: Rc::new(RecordRows {
99                model,
100                label,
101                value,
102                enabled,
103            }),
104            changes,
105        }
106    }
107
108    pub fn snapshot(&self, index: i64, value: Option<&Value>) -> ComboModel {
109        self.changes.track();
110        let structure = self.rows.structure();
111        let index = match value {
112            Some(value) => self.rows.find_value(value),
113            None => usize::try_from(index).ok(),
114        };
115        let selected = index.and_then(|index| Some((index, self.rows.label(index)?)));
116        ComboModel {
117            items: self.clone(),
118            structure,
119            selected,
120        }
121    }
122}
123
124#[doc(hidden)]
125#[derive(Clone)]
126pub struct ComboModel {
127    items: ComboItems,
128    structure: (u64, u64),
129    selected: Option<(usize, String)>,
130}
131
132impl fmt::Debug for ComboModel {
133    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
134        f.debug_struct("ComboModel")
135            .field("structure", &self.structure)
136            .field("selected", &self.selected)
137            .finish()
138    }
139}
140
141impl PartialEq for ComboModel {
142    fn eq(&self, other: &Self) -> bool {
143        Rc::ptr_eq(&self.items.rows, &other.items.rows)
144            && self.structure == other.structure
145            && self.selected == other.selected
146    }
147}
148
149fn model(node: &Node) -> Option<&ComboModel> {
150    match node.properties.get("model") {
151        Some(Value::ComboModel(model)) => Some(model),
152        _ => None,
153    }
154}
155
156pub fn combo_index(node: &Node) -> Option<usize> {
157    if let Some(model) = model(node) {
158        return model.selected.as_ref().map(|(index, _)| *index);
159    }
160    let model = node.strings("model");
161    if let Some(value) = node.text("current-value") {
162        model.iter().position(|item| item == value)
163    } else {
164        let index = usize::try_from(node.int("current-index").unwrap_or(0)).ok()?;
165        (index < model.len()).then_some(index)
166    }
167}
168
169pub fn combo_text(node: &Node) -> &str {
170    if let Some(model) = model(node) {
171        return model.selected.as_ref().map_or("", |(_, label)| label);
172    }
173    combo_index(node).map_or("", |index| node.strings("model")[index].as_str())
174}
175
176pub fn combo_count(node: &Node) -> usize {
177    model(node).map_or_else(
178        || node.strings("model").len(),
179        |model| model.items.rows.len(),
180    )
181}
182
183pub fn combo_label(node: &Node, index: usize) -> Option<Cow<'_, str>> {
184    match model(node) {
185        Some(model) => model.items.rows.label(index).map(Cow::Owned),
186        None => node
187            .strings("model")
188            .get(index)
189            .map(|label| Cow::Borrowed(label.as_str())),
190    }
191}
192
193pub fn combo_labels(node: &Node, range: Range<usize>) -> Cow<'_, [String]> {
194    match model(node) {
195        Some(model) => Cow::Owned(
196            range
197                .filter_map(|index| model.items.rows.label(index))
198                .collect(),
199        ),
200        None => Cow::Borrowed(&node.strings("model")[range]),
201    }
202}
203
204pub fn combo_find_label(node: &Node, mut predicate: impl FnMut(&str) -> bool) -> Option<usize> {
205    match model(node) {
206        Some(model) => {
207            model
208                .items
209                .rows
210                .find_label(0..model.items.rows.len(), false, &mut predicate)
211        }
212        None => node
213            .strings("model")
214            .iter()
215            .position(|text| predicate(text)),
216    }
217}
218
219/// Search enabled rows from a model index, wrapping to the beginning once.
220pub fn combo_find_enabled_label(
221    node: &Node,
222    start: usize,
223    mut predicate: impl FnMut(&str) -> bool,
224) -> Option<usize> {
225    let len = combo_count(node);
226    let start = start.min(len);
227    [start..len, 0..start].into_iter().find_map(|range| {
228        if let Some(model) = model(node) {
229            model.items.rows.find_label(range, true, &mut predicate)
230        } else {
231            let start = range.start;
232            node.strings("model")[range]
233                .iter()
234                .position(|text| predicate(text))
235                .map(|offset| start + offset)
236        }
237    })
238}
239
240pub fn choice_enabled(node: &Node, index: usize) -> bool {
241    if node.kind == "SearchField" {
242        return crate::search_suggestion(node, index).is_some();
243    }
244    model(node).map_or_else(
245        || index < node.strings("model").len(),
246        |model| model.items.rows.enabled(index),
247    )
248}
249
250#[doc(hidden)]
251pub fn combo_model_is_current<T>(node: &Node, source: &VecModel<T>) -> bool {
252    model(node).is_some_and(|model| model.structure == source.structure_stamp())
253}
254
255#[doc(hidden)]
256pub fn combo_value(node: &Node, index: usize) -> Option<Value> {
257    model(node)?.items.rows.value(index)
258}
259
260pub fn combo_row_key(node: &Node, index: usize) -> Option<RowKey> {
261    model(node)?.items.rows.key(index)
262}
263
264pub fn combo_row_index(node: &Node, key: RowKey) -> Option<usize> {
265    model(node)?.items.rows.index(key)
266}
267
268/// A pressed or projected option must still identify the same record and business value.
269#[derive(Clone, Debug, PartialEq)]
270pub struct ChoiceIdentity {
271    pub label: String,
272    pub record: Option<(RowKey, Value)>,
273}
274
275pub fn choice_identity(node: &Node, index: usize) -> Option<ChoiceIdentity> {
276    if node.kind == "SearchField" {
277        return Some(ChoiceIdentity {
278            label: crate::search_suggestion(node, index)?.to_owned(),
279            record: None,
280        });
281    }
282    let label = combo_label(node, index)?.into_owned();
283    let record = match model(node) {
284        Some(model) => Some((model.items.rows.key(index)?, model.items.rows.value(index)?)),
285        None => None,
286    };
287    Some(ChoiceIdentity { label, record })
288}