1use crate::{Node, Orientation, Property, 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#[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 pub fn split_pane_count(&self) -> usize {
85 self.children
86 .iter()
87 .position(|node| node.kind == "SplitHandle")
88 .unwrap_or(self.children.len())
89 }
90
91 pub fn split_panes(&self) -> impl Iterator<Item = (usize, &Node)> {
92 self.children[..self.split_pane_count()]
93 .iter()
94 .enumerate()
95 .filter(|(_, pane)| {
96 pane.is_visible()
97 && !is_window_overlay(pane.kind)
98 && !matches!(pane.kind, "Menu" | "Tooltip" | "Shortcut")
99 })
100 }
101
102 #[doc(hidden)]
103 pub fn add_split_handles(&mut self) {
104 let orientation = self.orientation();
105 let color = self.color("handle-color");
106 let count = self.children.len().saturating_sub(1);
107 self.children.extend((0..count).map(|_| {
108 let mut handle = Node::new("SplitHandle", None);
109 handle
110 .properties
111 .insert("orientation", Value::Orientation(orientation));
112 if let Some(color) = color {
113 handle.properties.insert("color", Value::Color(color));
114 }
115 handle
116 }));
117 }
118
119 #[doc(hidden)]
120 pub fn resized_split_weights(&self, weights: &[(usize, f32)]) -> Option<Arc<[Option<f32>]>> {
121 if self.split_fill_pane.is_some()
122 || self
123 .split_panes()
124 .map(|(index, _)| index)
125 .ne(weights.iter().map(|(index, _)| *index))
126 {
127 return None;
128 }
129 self.resized_split_values(weights, self.split_weights.as_deref())
130 }
131
132 #[doc(hidden)]
133 pub fn resized_split_sizes(&self, sizes: &[(usize, f32)]) -> Option<Arc<[Option<f32>]>> {
134 self.split_fill_pane?;
135 if self
136 .split_panes()
137 .map(|(index, _)| index)
138 .ne(sizes.iter().map(|(index, _)| *index))
139 {
140 let [before, after] = sizes else {
141 return None;
142 };
143 if self
144 .split_panes()
145 .map(|(index, _)| index)
146 .skip_while(|&index| index != before.0)
147 .nth(1)
148 != Some(after.0)
149 {
150 return None;
151 }
152 }
153 self.resized_split_values(sizes, self.split_sizes.as_deref())
154 }
155
156 fn resized_split_values(
157 &self,
158 values: &[(usize, f32)],
159 previous: Option<&[Option<f32>]>,
160 ) -> Option<Arc<[Option<f32>]>> {
161 if self.kind != "SplitView"
162 || values.len() < 2
163 || values
164 .iter()
165 .any(|(_, value)| !value.is_finite() || *value < 0.0)
166 {
167 return None;
168 }
169 let sum: f64 = values.iter().map(|(_, value)| f64::from(*value)).sum();
170 if sum <= 0.0 {
171 return None;
172 }
173 let mut next = previous.map_or_else(Vec::new, <[_]>::to_vec);
174 next.resize(self.split_pane_count(), None);
175 for &(index, value) in values {
176 next[index] = Some(value);
177 }
178 (previous != Some(next.as_slice())).then(|| Arc::from(next))
179 }
180}
181
182const SPLIT_STATE_VERSION: &str = "xrack-split/1";
183const SPLIT_SIZES_VERSION: &str = "xrack-split/2";
184
185#[doc(hidden)]
186pub fn encode_split_state(panes: &[&str], weights: Option<&[Option<f32>]>) -> String {
187 encode_split_values(SPLIT_STATE_VERSION, panes, weights)
188}
189
190#[doc(hidden)]
191pub fn encode_split_sizes(panes: &[&str], sizes: Option<&[Option<f32>]>) -> String {
192 encode_split_values(SPLIT_SIZES_VERSION, panes, sizes)
193}
194
195fn encode_split_values(version: &str, panes: &[&str], weights: Option<&[Option<f32>]>) -> String {
196 let mut state = version.to_owned();
197 for (index, pane) in panes.iter().enumerate() {
198 let value = weights
199 .and_then(|weights| weights.get(index))
200 .copied()
201 .flatten();
202 if let Some(value) = value {
203 write!(state, ";{pane}={value}").expect("writing to a String");
204 } else {
205 write!(state, ";{pane}=-").expect("writing to a String");
206 }
207 }
208 state
209}
210
211#[doc(hidden)]
212pub fn decode_split_state(panes: &[&str], state: &str) -> Option<Arc<[Option<f32>]>> {
213 decode_split_values(SPLIT_STATE_VERSION, panes, state)
214}
215
216#[doc(hidden)]
217pub fn decode_split_sizes(panes: &[&str], state: &str) -> Option<Arc<[Option<f32>]>> {
218 decode_split_values(SPLIT_SIZES_VERSION, panes, state)
219}
220
221fn decode_split_values(version: &str, panes: &[&str], state: &str) -> Option<Arc<[Option<f32>]>> {
222 let mut entries = state.split(';');
223 if entries.next()? != version {
224 return None;
225 }
226 let mut values = BTreeMap::new();
227 for entry in entries {
228 let (pane, encoded) = entry.split_once('=')?;
229 if values.len() == panes.len() || !panes.contains(&pane) {
230 return None;
231 }
232 let weight = if encoded == "-" {
233 None
234 } else {
235 let value = encoded.parse::<f32>().ok()?;
236 if !value.is_finite() || value < 0.0 {
237 return None;
238 }
239 Some(value)
240 };
241 if values.insert(pane, weight).is_some() {
242 return None;
243 }
244 }
245 let weights = panes
246 .iter()
247 .map(|pane| values.get(pane).copied())
248 .collect::<Option<Vec<_>>>()?;
249 if weights.iter().any(Option::is_some) && !weights.iter().flatten().any(|weight| *weight > 0.0)
250 {
251 return None;
252 }
253 Some(weights.into())
254}
255
256#[cfg(test)]
257mod tests {
258 use super::*;
259 use std::cell::Cell;
260
261 #[test]
262 fn divider_templates_only_recompute_for_changed_inputs() {
263 let state = SplitResizeHandle::default();
264 let calls = Cell::new([0; 3]);
265 let render = || {
266 let mut view = Node::new("SplitView", None);
267 view.children = (0..4).map(|_| Node::new("Rectangle", None)).collect();
268 view.add_split_handles();
269 state.decorate(&mut view, |input| {
270 let mut next = calls.get();
271 next[input.index as usize] += 1;
272 calls.set(next);
273 let mut node = Node::new("Rectangle", None);
274 node.properties.insert("visible", (!input.pressed).into());
275 node
276 });
277 view
278 };
279 render();
280 assert_eq!(calls.get(), [1, 1, 1]);
281 state.publish_hovered(Some(4));
282 render();
283 assert_eq!(calls.get(), [2, 1, 1]);
284 state.publish_hovered(Some(5));
285 render();
286 assert_eq!(calls.get(), [3, 2, 1]);
287 state.publish_pressed(Some((5, 2)));
288 let view = render();
289 assert_eq!(calls.get(), [3, 3, 1]);
290 assert!(view.children[4].children[0].is_visible());
291 assert!(!view.children[5].children[0].is_visible());
292 }
293
294 #[test]
295 fn state_restores_by_pane_id_and_rejects_an_invalid_record_set() {
296 let panes = ["source", "preview", "@2"];
297 let weights = [Some(0.2), None, Some(0.8)];
298 let saved = encode_split_state(&panes, Some(&weights));
299 assert_eq!(
300 decode_split_state(&["preview", "source", "@2"], &saved)
301 .unwrap()
302 .as_ref(),
303 [None, Some(0.2), Some(0.8)],
304 );
305 assert_eq!(
306 decode_split_state(&panes, &encode_split_state(&panes, None))
307 .unwrap()
308 .as_ref(),
309 [None; 3]
310 );
311 for invalid in [
312 "xrack-split/2;source=0.2;preview=-;@2=0.8",
313 "xrack-split/1;source=0.2;source=-;@2=0.8",
314 "xrack-split/1;source=0.2;@2=0.8",
315 "xrack-split/1;source=NaN;preview=-;@2=0.8",
316 "xrack-split/1;source=-0.1;preview=-;@2=0.8",
317 "xrack-split/1;source=0;preview=-;@2=0",
318 ] {
319 assert!(decode_split_state(&panes, invalid).is_none(), "{invalid}");
320 }
321 }
322}