1use crate::{InputRoute, Node, Orientation, Property, RoutedEvent, Value, is_window_overlay};
2use std::{cell::RefCell, collections::BTreeMap, fmt, fmt::Write, rc::Rc, sync::Arc};
3
4#[doc(hidden)]
6#[derive(Default)]
7pub struct SplitState {
8 values: Property<Option<Arc<[Option<f32>]>>>,
9 handle: SplitResizeHandle,
10}
11
12impl SplitState {
13 pub fn handle(&self) -> &SplitResizeHandle {
14 &self.handle
15 }
16
17 pub fn populate(&self, node: &mut Node, fill: Option<usize>) {
18 let values = self.values.get(|| None);
19 if fill.is_some() {
20 node.split_fill_index = fill;
21 node.split_sizes = values;
22 } else {
23 node.split_weights = values;
24 }
25 node.split_resize_handle = Some(self.handle.clone());
26 node.add_split_handles();
27 }
28
29 pub fn save(&self, panes: &[&str], fixed_sizes: bool) -> String {
30 let values = self.values.get(|| None);
31 if fixed_sizes {
32 encode_split_sizes(panes, values.as_deref())
33 } else {
34 encode_split_state(panes, values.as_deref())
35 }
36 }
37
38 pub fn restore(&self, panes: &[&str], fixed_sizes: bool, state: &str) -> Option<bool> {
40 let values = if fixed_sizes {
41 decode_split_sizes(panes, state)
42 } else {
43 decode_split_state(panes, state)
44 }?;
45 let next = values.iter().any(Option::is_some).then_some(values);
46 Some(self.update(self.values.get(|| None), next))
47 }
48
49 pub fn resize(&self, node: &Node, input: InputRoute<'_>) -> bool {
50 let current = self.values.get(|| None);
51 node.prepare_split_resize(input, current.as_deref())
52 .is_some_and(|next| self.update(current, Some(next)))
53 }
54
55 fn update(
56 &self,
57 current: Option<Arc<[Option<f32>]>>,
58 next: Option<Arc<[Option<f32>]>>,
59 ) -> bool {
60 if current == next {
61 return false;
62 }
63 self.values.set(next);
64 true
65 }
66}
67
68#[doc(hidden)]
69#[derive(Clone, Copy, Debug, PartialEq, Eq)]
70pub struct SplitHandleInput {
71 pub index: i64,
72 pub orientation: Orientation,
73 pub hovered: bool,
74 pub pressed: bool,
75}
76
77#[derive(Default)]
78struct SplitHandleVisual {
79 input: Property<SplitHandleInput>,
80 scene: Property<Node>,
81}
82
83#[derive(Default)]
84struct SplitSignals {
85 pressed: Property<Option<(usize, usize)>>,
86 hovered: Property<Option<usize>>,
87 visuals: RefCell<BTreeMap<usize, SplitHandleVisual>>,
88}
89
90#[doc(hidden)]
92#[derive(Clone, Default)]
93pub struct SplitResizeHandle(Rc<SplitSignals>);
94
95impl fmt::Debug for SplitResizeHandle {
96 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
97 f.debug_struct("SplitResizeHandle").finish_non_exhaustive()
98 }
99}
100
101impl PartialEq for SplitResizeHandle {
102 fn eq(&self, other: &Self) -> bool {
103 Rc::ptr_eq(&self.0, &other.0)
104 }
105}
106
107impl SplitResizeHandle {
108 pub fn resizing(&self) -> bool {
109 self.0.pressed.get(|| None).is_some()
110 }
111
112 pub fn publish_pressed(&self, divider: Option<(usize, usize)>) {
113 self.0.pressed.set_if_changed(divider);
114 }
115
116 pub fn publish_hovered(&self, slot: Option<usize>) {
117 self.0.hovered.set_if_changed(slot);
118 }
119
120 pub fn decorate(&self, view: &mut Node, render: impl Fn(SplitHandleInput) -> Node) {
121 self.try_decorate(view, |input| {
122 Ok::<_, std::convert::Infallible>(render(input))
123 })
124 .unwrap_or_else(|error| match error {})
125 }
126
127 #[doc(hidden)]
129 pub fn try_decorate<E>(
130 &self,
131 view: &mut Node,
132 render: impl Fn(SplitHandleInput) -> Result<Node, E>,
133 ) -> Result<(), E> {
134 if !view.is_visible() {
135 return Ok(());
136 }
137 let first = view.split_pane_count();
138 let orientation = view.orientation();
139 let panes: Vec<_> = view.split_panes().map(|(index, _)| index).collect();
140 let hovered = self.0.hovered.get(|| None);
141 let pressed = self.0.pressed.get(|| None);
142 let mut visuals = self.0.visuals.borrow_mut();
143 for pair in panes.windows(2) {
144 let index = pair[0];
145 let slot = first + index;
146 let visual = visuals.entry(index).or_default();
147 let input = SplitHandleInput {
148 index: index as i64,
149 orientation,
150 hovered: hovered == Some(slot),
151 pressed: pressed == Some((slot, pair[1])),
152 };
153 visual.input.set_if_changed(input);
154 let decoration = visual
155 .scene
156 .try_get(|| render(visual.input.get(|| input)))?;
157 view.children[slot].children.push(decoration);
158 }
159 Ok(())
160 }
161}
162
163impl Node {
164 #[doc(hidden)]
166 pub fn prepare_split_resize(
167 &self,
168 input: InputRoute<'_>,
169 current: Option<&[Option<f32>]>,
170 ) -> Option<Arc<[Option<f32>]>> {
171 if !input.is_current() {
172 return None;
173 }
174 match input.event() {
175 RoutedEvent::ResizeSplit(weights) if current == self.split_weights.as_deref() => {
176 self.resized_split_weights(weights)
177 }
178 RoutedEvent::ResizeSplitSizes(sizes) if current == self.split_sizes.as_deref() => {
179 self.resized_split_sizes(sizes)
180 }
181 _ => None,
182 }
183 }
184
185 pub fn has_split_fill(&self) -> bool {
186 self.split_fill_index.is_some() || self.split_fill_pane.is_some()
187 }
188
189 #[doc(hidden)]
190 pub fn split_fill_slot(&self) -> Option<usize> {
191 self.split_fill_index.or_else(|| {
192 let target = self.split_fill_pane?;
193 self.children[..self.split_pane_count()]
194 .iter()
195 .position(|pane| pane.element_id() == Some(target))
196 })
197 }
198
199 pub fn split_pane_count(&self) -> usize {
200 self.children
201 .iter()
202 .position(|node| node.kind == "SplitHandle")
203 .unwrap_or(self.children.len())
204 }
205
206 pub fn split_panes(&self) -> impl Iterator<Item = (usize, &Node)> {
207 self.children[..self.split_pane_count()]
208 .iter()
209 .enumerate()
210 .filter(|(_, pane)| {
211 pane.is_visible()
212 && !is_window_overlay(pane.kind)
213 && !matches!(pane.kind, "Menu" | "Tooltip" | "Shortcut")
214 })
215 }
216
217 #[doc(hidden)]
218 pub fn add_split_handles(&mut self) {
219 let orientation = self.orientation();
220 let color = self.color("handle-color");
221 let count = self.children.len().saturating_sub(1);
222 self.children.extend((0..count).map(|_| {
223 let mut handle = Node::new("SplitHandle", None);
224 handle
225 .properties
226 .insert("orientation", Value::Orientation(orientation));
227 if let Some(color) = color {
228 handle.properties.insert("color", Value::Color(color));
229 }
230 handle
231 }));
232 }
233
234 #[doc(hidden)]
235 pub fn resized_split_weights(&self, weights: &[(usize, f32)]) -> Option<Arc<[Option<f32>]>> {
236 if self.has_split_fill()
237 || self
238 .split_panes()
239 .map(|(index, _)| index)
240 .ne(weights.iter().map(|(index, _)| *index))
241 {
242 return None;
243 }
244 self.resized_split_values(weights, self.split_weights.as_deref())
245 }
246
247 #[doc(hidden)]
248 pub fn resized_split_sizes(&self, sizes: &[(usize, f32)]) -> Option<Arc<[Option<f32>]>> {
249 if !self.has_split_fill() {
250 return None;
251 }
252 if self
253 .split_panes()
254 .map(|(index, _)| index)
255 .ne(sizes.iter().map(|(index, _)| *index))
256 {
257 let [before, after] = sizes else {
258 return None;
259 };
260 if self
261 .split_panes()
262 .map(|(index, _)| index)
263 .skip_while(|&index| index != before.0)
264 .nth(1)
265 != Some(after.0)
266 {
267 return None;
268 }
269 }
270 self.resized_split_values(sizes, self.split_sizes.as_deref())
271 }
272
273 fn resized_split_values(
274 &self,
275 values: &[(usize, f32)],
276 previous: Option<&[Option<f32>]>,
277 ) -> Option<Arc<[Option<f32>]>> {
278 if self.kind != "SplitView"
279 || values.len() < 2
280 || values
281 .iter()
282 .any(|(_, value)| !value.is_finite() || *value < 0.0)
283 {
284 return None;
285 }
286 let sum: f64 = values.iter().map(|(_, value)| f64::from(*value)).sum();
287 if sum <= 0.0 {
288 return None;
289 }
290 let mut next = previous.map_or_else(Vec::new, <[_]>::to_vec);
291 next.resize(self.split_pane_count(), None);
292 for &(index, value) in values {
293 next[index] = Some(value);
294 }
295 (previous != Some(next.as_slice())).then(|| Arc::from(next))
296 }
297}
298
299const SPLIT_STATE_VERSION: &str = "xrack-split/1";
300const SPLIT_SIZES_VERSION: &str = "xrack-split/2";
301
302#[doc(hidden)]
303pub fn encode_split_state(panes: &[&str], weights: Option<&[Option<f32>]>) -> String {
304 encode_split_values(SPLIT_STATE_VERSION, panes, weights)
305}
306
307#[doc(hidden)]
308pub fn encode_split_sizes(panes: &[&str], sizes: Option<&[Option<f32>]>) -> String {
309 encode_split_values(SPLIT_SIZES_VERSION, panes, sizes)
310}
311
312fn encode_split_values(version: &str, panes: &[&str], weights: Option<&[Option<f32>]>) -> String {
313 let mut state = version.to_owned();
314 for (index, pane) in panes.iter().enumerate() {
315 let value = weights
316 .and_then(|weights| weights.get(index))
317 .copied()
318 .flatten();
319 if let Some(value) = value {
320 write!(state, ";{pane}={value}").expect("writing to a String");
321 } else {
322 write!(state, ";{pane}=-").expect("writing to a String");
323 }
324 }
325 state
326}
327
328#[doc(hidden)]
329pub fn decode_split_state(panes: &[&str], state: &str) -> Option<Arc<[Option<f32>]>> {
330 decode_split_values(SPLIT_STATE_VERSION, panes, state)
331}
332
333#[doc(hidden)]
334pub fn decode_split_sizes(panes: &[&str], state: &str) -> Option<Arc<[Option<f32>]>> {
335 decode_split_values(SPLIT_SIZES_VERSION, panes, state)
336}
337
338fn decode_split_values(version: &str, panes: &[&str], state: &str) -> Option<Arc<[Option<f32>]>> {
339 let mut entries = state.split(';');
340 if entries.next()? != version {
341 return None;
342 }
343 let mut values = BTreeMap::new();
344 for entry in entries {
345 let (pane, encoded) = entry.split_once('=')?;
346 if values.len() == panes.len() || !panes.contains(&pane) {
347 return None;
348 }
349 let weight = if encoded == "-" {
350 None
351 } else {
352 let value = encoded.parse::<f32>().ok()?;
353 if !value.is_finite() || value < 0.0 {
354 return None;
355 }
356 Some(value)
357 };
358 if values.insert(pane, weight).is_some() {
359 return None;
360 }
361 }
362 let weights = panes
363 .iter()
364 .map(|pane| values.get(pane).copied())
365 .collect::<Option<Vec<_>>>()?;
366 if weights.iter().any(Option::is_some) && !weights.iter().flatten().any(|weight| *weight > 0.0)
367 {
368 return None;
369 }
370 Some(weights.into())
371}
372
373#[cfg(test)]
374mod tests {
375 use super::*;
376 use std::cell::Cell;
377
378 #[test]
379 fn divider_templates_only_recompute_for_changed_inputs() {
380 let state = SplitResizeHandle::default();
381 let calls = Cell::new([0; 3]);
382 let render = || {
383 let mut view = Node::new("SplitView", None);
384 view.children = (0..4).map(|_| Node::new("Rectangle", None)).collect();
385 view.add_split_handles();
386 state.decorate(&mut view, |input| {
387 let mut next = calls.get();
388 next[input.index as usize] += 1;
389 calls.set(next);
390 let mut node = Node::new("Rectangle", None);
391 node.properties.insert("visible", (!input.pressed).into());
392 node
393 });
394 view
395 };
396 render();
397 assert_eq!(calls.get(), [1, 1, 1]);
398 state.publish_hovered(Some(4));
399 render();
400 assert_eq!(calls.get(), [2, 1, 1]);
401 state.publish_hovered(Some(5));
402 render();
403 assert_eq!(calls.get(), [3, 2, 1]);
404 state.publish_pressed(Some((5, 2)));
405 let view = render();
406 assert_eq!(calls.get(), [3, 3, 1]);
407 assert!(view.children[4].children[0].is_visible());
408 assert!(!view.children[5].children[0].is_visible());
409 }
410
411 #[test]
412 fn state_restores_by_pane_id_and_rejects_an_invalid_record_set() {
413 let panes = ["source", "preview", "@2"];
414 let weights = [Some(0.2), None, Some(0.8)];
415 let saved = encode_split_state(&panes, Some(&weights));
416 assert_eq!(
417 decode_split_state(&["preview", "source", "@2"], &saved)
418 .unwrap()
419 .as_ref(),
420 [None, Some(0.2), Some(0.8)],
421 );
422 assert_eq!(
423 decode_split_state(&panes, &encode_split_state(&panes, None))
424 .unwrap()
425 .as_ref(),
426 [None; 3]
427 );
428 for invalid in [
429 "xrack-split/2;source=0.2;preview=-;@2=0.8",
430 "xrack-split/1;source=0.2;source=-;@2=0.8",
431 "xrack-split/1;source=0.2;@2=0.8",
432 "xrack-split/1;source=NaN;preview=-;@2=0.8",
433 "xrack-split/1;source=-0.1;preview=-;@2=0.8",
434 "xrack-split/1;source=0;preview=-;@2=0",
435 ] {
436 assert!(decode_split_state(&panes, invalid).is_none(), "{invalid}");
437 }
438 }
439}