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#[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
219pub 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#[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}