diff --git a/crates/data/src/tree.rs b/crates/data/src/tree.rs index e0d446c..7a67a12 100644 --- a/crates/data/src/tree.rs +++ b/crates/data/src/tree.rs @@ -47,7 +47,7 @@ impl TreeItem { } } - /// Shows an icon leading the label. + /// Shows a custom icon leading the label. pub fn icon(mut self, icon: I) -> Self where I: Into, @@ -189,6 +189,22 @@ impl Tree { } } } + + /// The nearest row above `index` with a smaller depth. + fn parent_of(items: &[TreeItem], index: usize) -> Option { + let depth = items.get(index)?.depth; + items[..index] + .iter() + .rposition(|candidate| candidate.depth < depth) + } + + /// The first selectable row deeper than `index`, when its branch is open. + fn first_descendant(items: &[TreeItem], selectable: &[usize], index: usize) -> Option { + let depth = items.get(index)?.depth; + selectable.iter().copied().find(|candidate| { + *candidate > index && items.get(*candidate).is_some_and(|row| row.depth > depth) + }) + } } impl RenderOnce for Tree { @@ -248,6 +264,7 @@ impl RenderOnce for Tree { let selected = self.selected; let on_change = self.on_change.clone(); let on_disclosure = self.on_disclosure.clone(); + move |event: &KeyDownEvent, window, cx| { if nav_key(&selectable, selected, &event.keystroke.key, |next| { if let Some(on_change) = &on_change { @@ -260,14 +277,31 @@ impl RenderOnce for Tree { match event.keystroke.key.as_str() { "left" | "right" => { let expanding = event.keystroke.key == "right"; + let mut disclose = None; + let mut target = None; + if let Some(index) = selected && let Some(item) = items.get(index) - && item.expandable && !item.disabled - && item.expanded != expanding + { + if item.expandable && item.expanded != expanding { + disclose = Some(index); + } else if expanding { + target = Self::first_descendant(&items, &selectable, index); + } else { + target = Self::parent_of(&items, index) + .filter(|parent| selectable.contains(parent)); + } + } + + if let Some(index) = disclose && let Some(on_disclosure) = &on_disclosure { on_disclosure(index, window, cx); + } else if let Some(next) = target + && let Some(on_change) = &on_change + { + on_change(Some(next), window, cx); } } _ => return, @@ -295,13 +329,13 @@ impl TreeItem { let theme = cx.theme(); let label_color = selectable_label_color(cx, selected, self.disabled); let disabled = self.disabled; - // usize can exceed f32's exact integer range; bound it via u32 before casting. + let depth = u32::try_from(self.depth).unwrap_or(u32::MAX) as f32; - // One indent step per depth level, on the theme's horizontal padding. - let indent = theme.sizes.medium.padding_x * (depth + 1.0); + let indent = theme.sizes.medium.padding_x * if self.depth == 0 { 0.5 } else { depth + 1.0 }; div() .id((self.key.clone(), "tree-item")) + .relative() .flex() .items_center() .gap_2() @@ -319,19 +353,39 @@ impl TreeItem { .when(!disabled, |row| { row.cursor_pointer().on_click({ let on_change = on_change.clone(); + let on_disclosure = on_disclosure.clone(); + let expandable = self.expandable; let focus = focus.clone(); + move |_, window, cx| { window.focus(&focus, cx); if let Some(on_change) = &on_change { on_change(Some(index), window, cx); } + // A folder row toggles with its own click, not just its chevron. + if expandable && let Some(on_disclosure) = &on_disclosure { + on_disclosure(index, window, cx); + } } }) }) - .child(self.render_disclosure(cx, index, selected, on_disclosure)) - .when_some(self.icon.clone(), |row, icon| { - row.child(icon.size(theme.sizes.medium.icon_size).color(label_color)) - }) + .children((0..self.depth).map(|level| { + let step = u32::try_from(level).unwrap_or(u32::MAX) as f32; + div() + .absolute() + .left(theme.sizes.medium.padding_x * (step + 0.5)) + .top_0() + .bottom_0() + .border_l_1() + .border_color(theme.colors.border) + })) + .child(self.render_disclosure(cx, selected)) + .when_some( + self.icon + .clone() + .or_else(|| (!self.expandable).then(|| icon(IconRole::File))), + |row, icon| row.child(icon.size(theme.sizes.medium.icon_size).color(label_color)), + ) .child( div() .flex_1() @@ -341,13 +395,7 @@ impl TreeItem { .into_any_element() } - fn render_disclosure( - &self, - cx: &App, - index: usize, - selected: bool, - on_disclosure: &Option, - ) -> AnyElement { + fn render_disclosure(&self, cx: &App, selected: bool) -> AnyElement { let theme = cx.theme(); let glyph_color = if self.disabled || !selected { theme.colors.muted_foreground @@ -355,39 +403,25 @@ impl TreeItem { theme.colors.primary_foreground }; - let cell = div() + // Only expandable rows draw a chevron; the empty cell keeps labels aligned with folders. + div() .flex_none() .size(theme.sizes.medium.icon_size) .flex() .items_center() .justify_center() - .child( - icon(if self.expanded { - IconRole::ChevronDown - } else { - IconRole::ChevronRight - }) - .size(theme.sizes.medium.dense_icon_size) - .color(glyph_color), - ); - - if self.expandable && !self.disabled { - cell.id((self.key.clone(), "tree-disclosure")) - .cursor_pointer() - .on_click({ - let on_disclosure = on_disclosure.clone(); - move |_, window, cx| { - if let Some(on_disclosure) = &on_disclosure { - on_disclosure(index, window, cx); - } - // The toggle is not a selection: keep it off the row. - cx.stop_propagation(); - } - }) - .into_any_element() - } else { - cell.into_any_element() - } + .when(self.expandable, |cell| { + cell.child( + icon(if self.expanded { + IconRole::ChevronDown + } else { + IconRole::ChevronRight + }) + .size(theme.sizes.medium.dense_icon_size) + .color(glyph_color), + ) + }) + .into_any_element() } } @@ -410,4 +444,20 @@ mod tests { let sets = Tree::sibling_sets(&[item(0), item(1), item(2), item(1), item(0)]); assert_eq!(sets, vec![(1, 2), (1, 2), (1, 1), (2, 2), (2, 2)]); } + + #[test] + fn parent_skips_the_subtree_above() { + let rows = [item(0), item(1), item(2), item(1), item(0)]; + assert_eq!(Tree::parent_of(&rows, 3), Some(0)); + assert_eq!(Tree::parent_of(&rows, 2), Some(1)); + assert_eq!(Tree::parent_of(&rows, 0), None); + } + + #[test] + fn first_descendant_skips_disabled_rows() { + let rows = [item(0), item(1), item(1), item(0)]; + let selectable = vec![0, 2, 3]; + assert_eq!(Tree::first_descendant(&rows, &selectable, 0), Some(2)); + assert_eq!(Tree::first_descendant(&rows, &selectable, 2), None); + } }