Skip to main content

xrack_runtime/
split.rs

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/// Reactive pane state shared by compiled and interpreted SplitViews.
5#[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    /// Return whether the layout changed, or None if the state is invalid.
39    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/// The reactive drag state of a SplitView instance.
91#[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    /// Keep a failed handle binding eligible for reevaluation on the next render.
128    #[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    /// Resolve a resize only if the pane configuration still matches the input scene.
165    #[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            let _ = write!(state, ";{pane}={value}");
321        } else {
322            let _ = write!(state, ";{pane}=-");
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}