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