Skip to content

A treemap for finding and removing what fills your disk, for Omarchy. Rust + GPUI.

Rust

app: colour that means something, a side panel, the whole disk

Tobi Lutke75d657d57a22
diff --git a/crates/disktree-app/src/git.rs b/crates/disktree-app/src/git.rs
new file mode 100644
index 0000000..5c52eb6
--- /dev/null
+++ b/crates/disktree-app/src/git.rs
@@ -0,0 +1,137 @@
+//! What git knows about a checkout, for the selection panel.
+//!
+//! Before deleting an agent worktree the question is "would anything be
+//! lost": uncommitted changes, stashes, commits nobody pushed. That is three
+//! cheap git calls, run off the UI thread when a checkout is selected and
+//! remembered per path.
+
+use std::path::Path;
+use std::process::{Command, Stdio};
+
+/// A checkout's state, as far as losing work is concerned.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct GitState {
+ /// Paths `git status --porcelain` lists: changed, staged or untracked.
+ pub changed: usize,
+ pub stashes: usize,
+ /// Commits ahead of the upstream; `None` when there is no upstream.
+ pub unpushed: Option<usize>,
+}
+
+impl GitState {
+ /// Nothing would be lost by deleting it.
+ pub const fn is_clean(&self) -> bool {
+ self.changed == 0
+ && self.stashes == 0
+ && matches!(self.unpushed, Some(0))
+ }
+
+ /// One short line: `clean, no stash`, `3 changed, 1 stash, 2 unpushed`.
+ pub fn summary(&self) -> String {
+ let mut parts = Vec::new();
+ parts.push(if self.changed == 0 {
+ "clean".to_string()
+ } else {
+ format!("{} changed", self.changed)
+ });
+ parts.push(match self.stashes {
+ 0 => "no stash".to_string(),
+ 1 => "1 stash".to_string(),
+ count => format!("{count} stashes"),
+ });
+ match self.unpushed {
+ Some(0) => {}
+ Some(count) => parts.push(format!("{count} unpushed")),
+ None => parts.push("no upstream".to_string()),
+ }
+ parts.join(", ")
+ }
+}
+
+/// Whether `path` is the top of a checkout: it has a `.git` directory, or the
+/// `.git` file a worktree gets.
+pub fn is_checkout(path: &Path) -> bool {
+ std::fs::symlink_metadata(path.join(".git")).is_ok()
+}
+
+/// Ask git. `None` when `path` is not a checkout or git is not installed.
+pub fn state(path: &Path) -> Option<GitState> {
+ if !is_checkout(path) {
+ return None;
+ }
+ let status = run(path, &["status", "--porcelain=v1", "-z"])?;
+ let changed = status.split('\0').filter(|line| !line.is_empty()).count();
+ let stashes =
+ run(path, &["stash", "list"]).map_or(0, |list| list.lines().count());
+ let unpushed = run(path, &["rev-list", "--count", "@{upstream}..HEAD"])
+ .and_then(|count| count.trim().parse().ok());
+ Some(GitState {
+ changed,
+ stashes,
+ unpushed,
+ })
+}
+
+fn run(path: &Path, args: &[&str]) -> Option<String> {
+ let output = Command::new("git")
+ .arg("-C")
+ .arg(path)
+ .args(args)
+ // Never prompt, never page, never take a lock for the index refresh.
+ .env("GIT_TERMINAL_PROMPT", "0")
+ .env("GIT_OPTIONAL_LOCKS", "0")
+ .stdin(Stdio::null())
+ .stderr(Stdio::null())
+ .output()
+ .ok()?;
+ output
+ .status
+ .success()
+ .then(|| String::from_utf8_lossy(&output.stdout).into_owned())
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn summaries_say_what_would_be_lost() {
+ let clean = GitState {
+ unpushed: Some(0),
+ ..GitState::default()
+ };
+ assert!(clean.is_clean());
+ assert_eq!(clean.summary(), "clean, no stash");
+ let busy = GitState {
+ changed: 3,
+ stashes: 1,
+ unpushed: Some(2),
+ };
+ assert!(!busy.is_clean());
+ assert_eq!(busy.summary(), "3 changed, 1 stash, 2 unpushed");
+ let local = GitState::default();
+ assert_eq!(local.summary(), "clean, no stash, no upstream");
+ assert!(!local.is_clean(), "unpushed history could be lost");
+ }
+
+ #[test]
+ fn reads_a_real_checkout() {
+ let dir = tempfile::tempdir().expect("tempdir");
+ assert_eq!(state(dir.path()), None, "not a checkout");
+ let git = |args: &[&str]| {
+ Command::new("git")
+ .arg("-C")
+ .arg(dir.path())
+ .args(args)
+ .output()
+ .is_ok_and(|output| output.status.success())
+ };
+ if !git(&["init", "-q"]) {
+ return; // no git on this machine
+ }
+ std::fs::write(dir.path().join("a.txt"), "hi").expect("write");
+ let state = state(dir.path()).expect("a checkout");
+ assert_eq!(state.changed, 1, "one untracked file");
+ assert_eq!(state.stashes, 0);
+ }
+}
diff --git a/crates/disktree-app/src/main.rs b/crates/disktree-app/src/main.rs
index 8dbbaf5..e26653a 100644
--- a/crates/disktree-app/src/main.rs
+++ b/crates/disktree-app/src/main.rs
@@ -5,6 +5,7 @@
//! live free-space meter. Marking is non-destructive until the review screen
//! is confirmed.
+mod git;
mod marks;
mod palette;
mod state;
@@ -45,7 +46,10 @@ options:
-a, --apparent-size measure apparent length instead of allocated blocks
-l, --follow-links follow symlinks
-H, --no-hidden skip dotfiles and dot-directories
- -x, --one-filesystem do not cross filesystem boundaries
+ -D, --disk scan the whole disk the home directory is on
+ -X, --cross-filesystems
+ also measure other disks, network shares and pseudo
+ filesystems mounted below PATH (off by default)
-d, --depth N how many levels to draw at once (1-6, default 3)
--metric files rank by file count instead of bytes
-h, --help show this help
@@ -120,6 +124,7 @@ fn parse_args() -> Result<Args> {
let mut root: Option<PathBuf> = None;
let mut options = ScanOptions::default();
let mut depth = 3_u32;
+ let mut disk = false;
let mut args = std::env::args().skip(1);
while let Some(arg) = args.next() {
@@ -131,7 +136,11 @@ fn parse_args() -> Result<Args> {
"-a" | "--apparent-size" => options.apparent_size = true,
"-l" | "--follow-links" => options.follow_links = true,
"-H" | "--no-hidden" => options.include_hidden = false,
+ // Staying on one volume is the default; the flag is kept so
+ // old invocations still work.
"-x" | "--one-filesystem" => options.one_filesystem = true,
+ "-X" | "--cross-filesystems" => options.one_filesystem = false,
+ "-D" | "--disk" => disk = true,
"-d" | "--depth" => {
let value = args.next().context("--depth needs a number")?;
depth = value.parse().context("--depth needs a number")?;
@@ -160,7 +169,16 @@ fn parse_args() -> Result<Args> {
}
}
+ anyhow::ensure!(
+ !(disk && root.is_some()),
+ "--disk and a PATH cannot be combined"
+ );
+ let home = std::env::var_os("HOME").map(PathBuf::from);
let root = match root {
+ _ if disk => home
+ .as_deref()
+ .and_then(disktree_core::space::volume_root_for)
+ .unwrap_or_else(|| PathBuf::from("/")),
Some(root) => root,
None => std::env::var_os("HOME")
.map(PathBuf::from)
diff --git a/crates/disktree-app/src/palette.rs b/crates/disktree-app/src/palette.rs
index 93f91a5..1f5ad7e 100644
--- a/crates/disktree-app/src/palette.rs
+++ b/crates/disktree-app/src/palette.rs
@@ -1,82 +1,176 @@
-//! Colours derived from the Omarchy theme.
+//! Colour that means something.
//!
-//! Nothing here invents a palette: every colour is the active theme's, shifted
-//! in hue, lightness or alpha. That keeps the app inside Omarchy's visual
-//! language across themes, and light and dark alike.
+//! A tile's hue says what kind of data it is ([`Category`]); every hue sits
+//! at the same muted saturation and lightness, so no block stands out by
+//! accident, and deeper tiles lift slightly so nesting reads without borders.
+//! Reclaimable space is a hatch, not a colour, so "what is it" and "can it go"
+//! are read independently.
+//!
+//! One strong colour is kept apart: the highlight, the theme's warning amber.
+//! It marks the selection, the main action, reclaimable totals and the free
+//! space after a removal, and nothing else, so the eye goes straight to it.
+//!
+//! Lightness, saturation and the surface every fill is pulled toward come
+//! from the active Omarchy theme, so the mosaic sits inside it, light or dark.
-use gpui_kit::Hsla;
+use disktree_core::classify::Category;
use gpui_kit::base::ThemeAppearance;
+use gpui_kit::{Hsla, Rgba};
use gpui_omarchy::Theme;
-/// Hue for a tile: nesting walks the wheel so levels are readable without
-/// borders, and hidden entries get a hue of their own instead of a shade.
-///
-/// Hidden directories under a home directory are usually the largest thing
-/// there — `~/.cache`, `~/.cargo`, `~/.local/share/Trash` — so they are marked
-/// by colour rather than hidden away.
-pub fn tile_hue(theme: &Theme, depth: u32, hidden: bool) -> f32 {
- let base = if hidden {
- theme.warning.h
+/// The hue a category is drawn in, and how much colour it carries. The
+/// neutral kinds (documents, unknown) carry almost none.
+const fn hue(category: Category) -> (f32, f32) {
+ match category {
+ Category::Code => (0.605, 1.0),
+ Category::AgentScratch => (0.065, 1.0),
+ Category::Toolchain => (0.415, 1.0),
+ Category::Synced => (0.535, 1.0),
+ Category::Git => (0.955, 1.0),
+ Category::Media => (0.745, 1.0),
+ Category::Cache => (0.125, 0.95),
+ Category::Documents => (0.6, 0.18),
+ Category::Other => (0.6, 0.08),
+ }
+}
+
+const fn dark(theme: &Theme) -> bool {
+ matches!(theme.appearance, ThemeAppearance::Dark)
+}
+
+/// The fill for a tile of `category`, `depth` levels into the view.
+pub fn category_fill(theme: &Theme, category: Category, depth: u32) -> Hsla {
+ let (h, chroma) = hue(category);
+ let step = depth.min(4) as f32;
+ let (s, l) = if dark(theme) {
+ (0.26 * chroma, step.mul_add(0.028, 0.215))
} else {
- theme.accent.h
+ (0.30 * chroma, step.mul_add(-0.03, 0.84))
};
- wrap_hue((depth as f32).mul_add(0.075, base))
+ // Pulled a little toward the theme surface, so each theme tints it.
+ mix(Hsla { h, s, l, a: 1.0 }, theme.inset, 0.12)
}
-fn wrap_hue(hue: f32) -> f32 {
- let hue = hue % 1.0;
- if hue < 0.0 { hue + 1.0 } else { hue }
+/// The saturated version of a category's hue: the strip over a top-level
+/// directory and the legend swatch.
+pub fn category_accent(theme: &Theme, category: Category) -> Hsla {
+ let (h, chroma) = hue(category);
+ let (s, l) = if dark(theme) {
+ (0.42 * chroma, 0.52)
+ } else {
+ (0.45 * chroma, 0.46)
+ };
+ Hsla { h, s, l, a: 1.0 }
}
-/// Fill for a tile at `depth`, as an opaque colour the mosaic can paint.
-pub fn tile_fill(
- theme: &Theme,
- depth: u32,
- hidden: bool,
- marked: bool,
-) -> Hsla {
- let dark = theme.appearance == ThemeAppearance::Dark;
- // Deeper levels lift slightly so nested tiles separate from their parent
- // without needing a border on every one of them.
- let lightness = if dark {
- (depth.min(4) as f32).mul_add(0.055, 0.20)
+/// The age ramp, newest first: this week, this month, this half-year, this
+/// year, older.
+pub const AGE_BUCKETS: [(i64, &str); 5] = [
+ (7, "This week"),
+ (30, "This month"),
+ (182, "Six months"),
+ (365, "This year"),
+ (i64::MAX, "Older"),
+];
+
+/// Which [`AGE_BUCKETS`] entry an age in days falls in.
+pub fn age_bucket(days: i64) -> usize {
+ AGE_BUCKETS
+ .iter()
+ .position(|(limit, _)| days <= *limit)
+ .unwrap_or(AGE_BUCKETS.len() - 1)
+}
+
+/// The fill for age mode: recent writes carry the theme accent, and colour
+/// drains out of a tile as it goes untouched.
+pub fn age_fill(theme: &Theme, bucket: usize, depth: u32) -> Hsla {
+ let fade = bucket.min(AGE_BUCKETS.len() - 1) as f32 / 4.0;
+ let step = depth.min(4) as f32;
+ let (s, l) = if dark(theme) {
+ (
+ (1.0 - fade).mul_add(0.34, 0.03),
+ step.mul_add(0.028, 0.29 - fade * 0.09),
+ )
} else {
- (depth.min(4) as f32).mul_add(-0.055, 0.86)
+ (
+ (1.0 - fade).mul_add(0.36, 0.04),
+ step.mul_add(-0.03, 0.74 + fade * 0.1),
+ )
};
- let saturation = if hidden { 0.55 } else { 0.42 };
- let fill = Hsla {
- h: tile_hue(theme, depth, hidden),
- s: saturation,
- l: lightness,
- a: 1.0,
+ mix(
+ Hsla {
+ h: theme.accent.h,
+ s,
+ l,
+ a: 1.0,
+ },
+ theme.inset,
+ 0.1,
+ )
+}
+
+/// The age swatch for the legend.
+pub fn age_accent(theme: &Theme, bucket: usize) -> Hsla {
+ let fade = bucket.min(AGE_BUCKETS.len() - 1) as f32 / 4.0;
+ let l = if dark(theme) {
+ 0.55 - fade * 0.25
+ } else {
+ 0.45 + fade * 0.25
};
- // Keep the mosaic calm: pull it toward the theme background so the tile
- // colours read as tinted surfaces rather than a rainbow.
- let flattened = mix(fill, theme.background, 0.34);
- if marked {
- mix(flattened, theme.danger, 0.30)
+ Hsla {
+ h: theme.accent.h,
+ s: (1.0 - fade).mul_add(0.45, 0.04),
+ l,
+ a: 1.0,
+ }
+}
+
+/// The one strong colour: selection, the main action, what can be had back.
+pub const fn highlight(theme: &Theme) -> Hsla {
+ theme.warning
+}
+
+/// Text on a filled highlight.
+pub const fn on_highlight(theme: &Theme) -> Hsla {
+ if dark(theme) {
+ theme.background
+ } else {
+ theme.bright
+ }
+}
+
+/// The diagonal hatch over reclaimable space: quiet enough to leave the hue
+/// readable, visible on every fill.
+pub fn hatch(theme: &Theme) -> Hsla {
+ if dark(theme) {
+ theme.bright.opacity(0.16)
} else {
- flattened
+ theme.foreground.opacity(0.18)
}
}
-/// Linear interpolation between two colours in HSLA.
+/// Linear interpolation between two colours, in RGB: interpolating hue
+/// would drag a colour around the wheel on its way to a grey.
pub fn mix(from: Hsla, to: Hsla, t: f32) -> Hsla {
let t = t.clamp(0.0, 1.0);
let lerp = |a: f32, b: f32| (b - a).mul_add(t, a);
- Hsla {
- h: lerp(from.h, to.h),
- s: lerp(from.s, to.s),
- l: lerp(from.l, to.l),
- a: lerp(from.a, to.a),
- }
+ let (a, b) = (from.to_rgb(), to.to_rgb());
+ Hsla::from(Rgba {
+ r: lerp(a.r, b.r),
+ g: lerp(a.g, b.g),
+ b: lerp(a.b, b.b),
+ a: lerp(a.a, b.a),
+ })
}
-/// The colour of a tile's label on top of its fill.
+/// A tile's name on top of its fill.
pub fn label_color(theme: &Theme, depth: u32) -> Hsla {
- let dark = theme.appearance == ThemeAppearance::Dark;
- let base = if dark { theme.bright } else { theme.background };
- if depth == 0 { base } else { base.opacity(0.86) }
+ let base = if dark(theme) {
+ theme.bright
+ } else {
+ theme.foreground
+ };
+ if depth == 0 { base } else { base.opacity(0.88) }
}
#[cfg(test)]
@@ -84,52 +178,84 @@ mod tests {
use super::*;
fn theme(appearance: ThemeAppearance) -> Theme {
- let mut theme = Theme::tokyo_night();
- theme.appearance = appearance;
- theme
+ match appearance {
+ ThemeAppearance::Dark => Theme::tokyo_night(),
+ ThemeAppearance::Light => Theme::flexoki_light(),
+ }
}
#[test]
- fn hidden_tiles_are_a_different_hue_from_visible_ones() {
+ fn every_legend_category_has_its_own_hue() {
let theme = theme(ThemeAppearance::Dark);
- let visible = tile_fill(&theme, 0, false, false);
- let hidden = tile_fill(&theme, 0, true, false);
- assert!((visible.h - hidden.h).abs() > 0.02);
- assert!(visible.s > 0.0);
+ let fills: Vec<Hsla> = Category::LEGEND
+ .iter()
+ .map(|&category| category_accent(&theme, category))
+ .collect();
+ for (index, left) in fills.iter().enumerate() {
+ for right in &fills[index + 1..] {
+ let apart = (left.h - right.h).abs() > 0.03
+ || (left.s - right.s).abs() > 0.1;
+ assert!(apart, "{left:?} and {right:?} read as one colour");
+ }
+ }
}
#[test]
- fn marking_shifts_a_tile_toward_the_danger_colour() {
+ fn colourful_categories_share_one_level() {
let theme = theme(ThemeAppearance::Dark);
- let plain = tile_fill(&theme, 1, false, false);
- let marked = tile_fill(&theme, 1, false, true);
- let plain_distance = (plain.h - theme.danger.h).abs();
- let marked_distance = (marked.h - theme.danger.h).abs();
- assert!(marked_distance < plain_distance);
+ let code = category_fill(&theme, Category::Code, 0);
+ let git = category_fill(&theme, Category::Git, 0);
+ assert!((code.l - git.l).abs() < 0.02);
+ assert!((code.s - git.s).abs() < 0.03);
}
#[test]
- fn light_and_dark_appearances_differ_in_lightness() {
- let dark = tile_fill(&theme(ThemeAppearance::Dark), 0, false, false);
- let light = tile_fill(&theme(ThemeAppearance::Light), 0, false, false);
- assert!(light.l > dark.l);
+ fn deeper_tiles_lift_away_from_the_background() {
+ for appearance in [ThemeAppearance::Dark, ThemeAppearance::Light] {
+ let theme = theme(appearance);
+ let top = category_fill(&theme, Category::Code, 0);
+ let deep = category_fill(&theme, Category::Code, 3);
+ // Away from the background: lighter on dark, darker on light.
+ let distance = |fill: Hsla| (fill.l - theme.background.l).abs();
+ assert!(distance(deep) > distance(top) + 0.05, "{appearance:?}");
+ }
}
#[test]
- fn hue_stays_in_range_at_every_depth() {
+ fn the_highlight_is_not_a_category_colour() {
let theme = theme(ThemeAppearance::Dark);
- for depth in 0..12 {
- let hue = tile_hue(&theme, depth, false);
- assert!((0.0..1.0).contains(&hue), "depth {depth} gave {hue}");
+ let highlight = highlight(&theme);
+ for category in Category::LEGEND {
+ let fill = category_fill(&theme, category, 0);
+ assert!(highlight.s - fill.s > 0.2, "{category:?} competes");
}
}
+ #[test]
+ fn age_buckets_cover_every_age_in_order() {
+ assert_eq!(age_bucket(0), 0);
+ assert_eq!(age_bucket(8), 1);
+ assert_eq!(age_bucket(100), 2);
+ assert_eq!(age_bucket(300), 3);
+ assert_eq!(age_bucket(5000), 4);
+ let theme = theme(ThemeAppearance::Dark);
+ assert!(age_fill(&theme, 0, 0).s > age_fill(&theme, 4, 0).s);
+ }
+
+ #[test]
+ fn mixing_toward_a_grey_keeps_the_hue() {
+ let theme = theme(ThemeAppearance::Dark);
+ let orange = category_accent(&theme, Category::AgentScratch);
+ let mixed = mix(orange, theme.inset, 0.3);
+ assert!((mixed.h - orange.h).abs() < 0.02, "{mixed:?}");
+ }
+
#[test]
fn mix_clamps_its_parameter() {
let theme = theme(ThemeAppearance::Dark);
let clamped_low = mix(theme.background, theme.accent, -1.0).l;
let clamped_high = mix(theme.background, theme.accent, 2.0).l;
- assert!((clamped_low - theme.background.l).abs() < f32::EPSILON);
- assert!((clamped_high - theme.accent.l).abs() < f32::EPSILON);
+ assert!((clamped_low - theme.background.l).abs() < 1e-3);
+ assert!((clamped_high - theme.accent.l).abs() < 1e-3);
}
}
diff --git a/crates/disktree-app/src/state.rs b/crates/disktree-app/src/state.rs
index 7bc9332..1844944 100644
--- a/crates/disktree-app/src/state.rs
+++ b/crates/disktree-app/src/state.rs
@@ -9,13 +9,16 @@ use std::path::{Path, PathBuf};
use std::rc::Rc;
use std::time::{Duration, Instant};
+use disktree_core::insights::{Candidate, worth_a_look};
use disktree_core::removal::{
Plan, RemovalEvent, RemovalHandle, RemovalMode, Target, TrashBackend,
detect_trash_backend, plan,
};
use disktree_core::scan::{ScanHandle, ScanOptions, ScanSnapshot};
-use disktree_core::space::{SpaceInfo, space_info};
-use disktree_core::tree::{Node, path_of};
+use disktree_core::space::{
+ SpaceInfo, device_for, space_info, volume_root_for,
+};
+use disktree_core::tree::{Metric, Node, path_of};
use disktree_core::treemap::{
LayoutOptions, Rect, Tile, TileKind, hit, layout,
};
@@ -25,11 +28,51 @@ use gpui_kit::{
Window, px, size,
};
use gpui_omarchy::Status;
-use rustc_hash::FxHashSet;
+use rustc_hash::{FxHashMap, FxHashSet};
+
+use crate::git::GitState;
use crate::marks::{Marks, display_path, is_hidden};
use crate::treemap_view::{Mosaic, TileDeco};
+/// What a tile's colour says.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum ColorMode {
+ /// The kind of data it is.
+ #[default]
+ Kind,
+ /// How long since anything in it was written.
+ Age,
+}
+
+/// What is scanned, as the trail's switch names it.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Scope {
+ /// The home directory.
+ Home,
+ /// The whole disk the home directory lives on.
+ Disk,
+}
+
+/// The side panel's width in rem: default and limits. In rem, so interface
+/// zoom scales it with everything it holds.
+pub const PANEL_REMS: f32 = 23.0;
+pub const PANEL_MIN_REMS: f32 = 17.0;
+pub const PANEL_MAX_REMS: f32 = 44.0;
+
+/// The panel width, in rem, for its left edge at `pointer_x` in a window
+/// `viewport` pixels wide: between its limits, and never so wide that the
+/// mosaic is squeezed below the panel's own minimum.
+pub fn panel_width(pointer_x: f32, viewport: f32, rem: f32) -> f32 {
+ let width = (viewport - pointer_x) / rem;
+ let max =
+ (viewport / rem - PANEL_MIN_REMS).clamp(PANEL_MIN_REMS, PANEL_MAX_REMS);
+ width.clamp(PANEL_MIN_REMS, max)
+}
+
+/// How many "worth a look" findings the panel lists.
+const INSIGHT_LIMIT: usize = 6;
+
/// Which screen the app is showing.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Screen {
@@ -296,6 +339,25 @@ pub struct Disktree {
pub show_help: bool,
pub show_selection: bool,
pub focus: FocusHandle,
+
+ pub color_mode: ColorMode,
+ /// The largest things worth clearing, recomputed when a scan lands.
+ pub insights: Vec<Candidate>,
+ /// What git knows about each checkout that has been selected; `None`
+ /// once asked and found not to be one.
+ pub git: FxHashMap<PathBuf, Option<GitState>>,
+ git_pending: FxHashSet<PathBuf>,
+ /// The device the scanned volume is mounted from.
+ pub device: Option<String>,
+ /// The top of the disk the home directory lives on: what "Whole disk"
+ /// scans.
+ pub disk_root: Option<PathBuf>,
+ /// The side panel's width, in rem; dragged from its left edge.
+ pub panel_rems: f32,
+ pub scan_started: Option<Instant>,
+ pub scan_elapsed: Option<Duration>,
+ /// Unix seconds when the tree landed: the "now" ages are measured from.
+ pub scanned_at: i64,
}
impl Disktree {
@@ -357,7 +419,23 @@ impl Disktree {
show_help: false,
show_selection: true,
focus: cx.focus_handle(),
+ color_mode: ColorMode::Kind,
+ insights: Vec::new(),
+ git: FxHashMap::default(),
+ git_pending: FxHashSet::default(),
+ device: None,
+ disk_root: None,
+ panel_rems: PANEL_REMS,
+ scan_started: None,
+ scan_elapsed: None,
+ scanned_at: now_seconds(),
};
+ tree.device = device_for(&tree.root_path);
+ tree.disk_root = tree
+ .home
+ .as_deref()
+ .or(Some(tree.root_path.as_path()))
+ .and_then(volume_root_for);
tree.start_scan(cx);
Self::start_space_ticker(cx);
tree
@@ -380,10 +458,77 @@ impl Disktree {
app.marks.refresh(&app.root_path, &tree, app.options.metric);
app.tree = Some(Rc::new(tree));
app.cache = None;
+ app.refresh_insights();
app.select_largest(cx);
app
}
+ /// Which scope the current root is, if it is one of the two.
+ pub fn scope(&self) -> Option<Scope> {
+ if self.home.as_deref() == Some(self.root_path.as_path()) {
+ Some(Scope::Home)
+ } else if self.disk_root.as_deref() == Some(self.root_path.as_path()) {
+ Some(Scope::Disk)
+ } else {
+ None
+ }
+ }
+
+ /// Scan a different root: the home directory, the whole disk, or any
+ /// directory. Marks are kept; a mark outside the new root is shown as
+ /// kept back, never removed.
+ pub fn set_root(&mut self, root: PathBuf, cx: &mut Context<'_, Self>) {
+ if root == self.root_path && self.tree.is_some() {
+ return;
+ }
+ self.space = space_info(&root).ok();
+ self.device = device_for(&root);
+ self.root_path = root;
+ self.screen = Screen::Explore;
+ self.start_scan(cx);
+ }
+
+ /// Switch to a scope.
+ pub fn set_scope(&mut self, scope: Scope, cx: &mut Context<'_, Self>) {
+ let root = match scope {
+ Scope::Home => self.home.clone(),
+ Scope::Disk => self.disk_root.clone(),
+ };
+ if let Some(root) = root {
+ self.set_root(root, cx);
+ }
+ }
+
+ /// Recompute "worth a look" from the tree on screen.
+ fn refresh_insights(&mut self) {
+ self.scanned_at = now_seconds();
+ self.insights = self.tree.as_deref().map_or_else(Vec::new, |tree| {
+ worth_a_look(tree, self.scanned_at, INSIGHT_LIMIT)
+ });
+ }
+
+ /// Ask git about `path` once, off the UI thread, if it is a checkout.
+ pub fn ensure_git(&mut self, path: &Path, cx: &Context<'_, Self>) {
+ if self.git.contains_key(path) || self.git_pending.contains(path) {
+ return;
+ }
+ let path = path.to_path_buf();
+ self.git_pending.insert(path.clone());
+ let task = cx.background_executor().spawn({
+ let path = path.clone();
+ async move { crate::git::state(&path) }
+ });
+ cx.spawn(async move |this, cx| {
+ let state = task.await;
+ let _ = this.update(cx, |this, cx| {
+ this.git_pending.remove(&path);
+ this.git.insert(path, state);
+ cx.notify();
+ });
+ })
+ .detach();
+ }
+
/// Select the largest entry of the current root, so the selection line, the
/// tooltip and the mark key all have something to act on from the first
/// frame. The largest entry is also the answer to "what is eating my disk"
@@ -415,6 +560,10 @@ impl Disktree {
self.hovered = None;
self.view = View::default();
self.cache = None;
+ self.insights.clear();
+ self.git.clear();
+ self.scan_started = Some(Instant::now());
+ self.scan_elapsed = None;
self.scan = Some(ScanHandle::spawn(
self.root_path.clone(),
self.options.clone(),
@@ -465,6 +614,9 @@ impl Disktree {
self.marks.refresh(&self.root_path, &node, metric);
self.tree = Some(Rc::new(node));
self.cache = None;
+ self.refresh_insights();
+ self.scan_elapsed =
+ self.scan_started.map(|started| started.elapsed());
self.keep_selection_valid();
self.select_largest(cx);
}
@@ -719,6 +871,16 @@ impl Disktree {
cx.notify();
}
+ /// Show `crumbs` in its directory, selected: what a "worth a look" row
+ /// or a found name does.
+ pub fn reveal(&mut self, crumbs: Vec<usize>, cx: &mut Context<'_, Self>) {
+ let parent = crumbs[..crumbs.len().saturating_sub(1)].to_vec();
+ self.go_to(parent, cx);
+ self.selected = Some(crumbs);
+ self.pointer_active = false;
+ cx.notify();
+ }
+
/// Select the tile at `crumbs` without changing the root.
pub fn select(
&mut self,
@@ -976,24 +1138,34 @@ impl Disktree {
};
};
- // Colours are keyed to depth-from-the-scanned-root, not depth-from-this
- // view: the layout root is re-based every time the view descends, so a
- // view-relative key would recolour every tile as you walk in. The view
- // root's own absolute depth is the breadcrumb count.
- let base_depth = u32::try_from(self.crumbs.len()).unwrap_or(u32::MAX);
+ // Hue comes from the node's kind; lightness from its depth in this
+ // view, so the first level always reads as the first level.
+ let age = self.color_mode == ColorMode::Age;
+ let now = self.scanned_at;
let mut decorations = Vec::with_capacity(tiles.len());
let mut labels = Vec::new();
for tile in &tiles {
let crumbs = tile.crumbs();
- let hidden = self.crumbs_are_hidden(crumbs);
+ let node = match &tile.kind {
+ TileKind::Node { crumbs } => self.node_at(crumbs),
+ TileKind::Others { .. } => None,
+ };
+ let category = node.map_or_else(Default::default, |n| n.category);
+ let age_bucket = (age && node.is_some_and(|n| n.modified > 0))
+ .then(|| {
+ let days =
+ (now - node.map_or(now, |n| n.modified)) / 86_400;
+ crate::palette::age_bucket(days)
+ });
let is_marked = marked.contains(crumbs);
let is_covered = covered.contains(crumbs);
decorations.push(TileDeco {
rect: self.animated_rect(tile.rect),
- header: tile.header.map(|header| self.animated_rect(header)),
depth: tile.depth,
- color_depth: base_depth.saturating_add(tile.depth),
- hidden,
+ category,
+ age_bucket,
+ reclaimable: node.is_some_and(|n| n.reclaim.is_some()),
+ unreadable: node.is_some_and(|n| n.read_error),
marked: is_marked,
covered: is_covered,
hovered: hovered.as_deref() == Some(crumbs),
@@ -1023,7 +1195,7 @@ impl Disktree {
header: tile
.header
.map(|header| self.animated_rect(header)),
- color_depth: base_depth.saturating_add(tile.depth),
+ depth: tile.depth,
marked: is_marked || is_covered,
size_text: crate::widgets::short_value(node, metric),
});
@@ -1032,7 +1204,7 @@ impl Disktree {
text: format!("+{count} more"),
rect: self.animated_rect(tile.rect),
header: None,
- color_depth: base_depth.saturating_add(tile.depth),
+ depth: tile.depth,
marked: false,
size_text: String::new(),
}),
@@ -1077,21 +1249,12 @@ impl Disktree {
Some(crumbs)
}
- /// Whether any component of the path to `crumbs` is a dotfile.
- fn crumbs_are_hidden(&self, crumbs: &[usize]) -> bool {
- let Some(tree) = &self.tree else {
- return false;
- };
- tree.resolve_chain(crumbs)
- .iter()
- .any(|node| node.name.starts_with('.'))
- }
-
/// Tiles for the current root and viewport size, computed once per change.
pub fn layout(&mut self) -> Option<&[Tile]> {
// A 17 px band at the default rem, scaled so zoom keeps the band's
// relationship to the label inside it.
self.layout_options.header = HEADER_REMS * self.rem;
+ self.layout_options.header_inner = HEADER_INNER_REMS * self.rem;
let area = self.treemap_size.get();
let key = LayoutKey {
crumbs: self.crumbs.clone(),
@@ -1217,10 +1380,36 @@ impl Disktree {
metric,
);
}
+ // Children are ordered by the metric, so every crumb moved.
+ self.refresh_insights();
self.cache = None;
cx.notify();
}
+ /// The Size | Files | Age choice: what areas measure, and what colour
+ /// says. Age keeps areas by size, since age has no area of its own.
+ pub fn set_mode(&mut self, index: usize, cx: &mut Context<'_, Self>) {
+ let (metric, color) = match index {
+ 1 => (Metric::Files, ColorMode::Kind),
+ 2 => (Metric::Bytes, ColorMode::Age),
+ _ => (Metric::Bytes, ColorMode::Kind),
+ };
+ self.color_mode = color;
+ if self.options.metric != metric {
+ self.toggle_metric(cx);
+ }
+ cx.notify();
+ }
+
+ /// The Size | Files | Age choice currently on.
+ pub const fn mode_index(&self) -> usize {
+ match (self.color_mode, self.options.metric) {
+ (ColorMode::Age, _) => 2,
+ (ColorMode::Kind, Metric::Files) => 1,
+ (ColorMode::Kind, Metric::Bytes) => 0,
+ }
+ }
+
// ── removal ─────────────────────────────────────────────────────────
/// The review screen's commit: move to the trash at once, or ask first for
@@ -1404,11 +1593,8 @@ impl Disktree {
cx.notify();
return;
};
- let parent = crumbs[..crumbs.len().saturating_sub(1)].to_vec();
- self.go_to(parent, cx);
- self.selected = Some(crumbs);
+ self.reveal(crumbs, cx);
self.notice = None;
- cx.notify();
}
// ── input ───────────────────────────────────────────────────────────
@@ -1595,8 +1781,18 @@ impl Disktree {
);
}
"0" => self.reset_view(cx),
- "t" if !control => self.toggle_metric(cx),
+ "t" if !control => {
+ self.set_mode((self.mode_index() + 1) % 3, cx);
+ }
"r" if !control => self.start_scan(cx),
+ "g" if !control => {
+ let next = if self.scope() == Some(Scope::Disk) {
+ Scope::Home
+ } else {
+ Scope::Disk
+ };
+ self.set_scope(next, cx);
+ }
"i" if !control => {
self.options.include_hidden = !self.options.include_hidden;
self.start_scan(cx);
@@ -1661,6 +1857,21 @@ impl Disktree {
event.position.x - origin.x,
event.position.y - origin.y,
);
+ // Moves are delivered here even when the pointer is elsewhere in the
+ // window. Outside the mosaic there is nothing to hover, and a stale
+ // tooltip would cover whatever the pointer went to — the panel's
+ // resize handle, for one.
+ let area = self.treemap_size.get();
+ let inside = local.x >= px(0.)
+ && local.y >= px(0.)
+ && local.x < area.width
+ && local.y < area.height;
+ if !inside {
+ if self.pointer.is_some() || self.hovered.is_some() {
+ self.on_mouse_leave(cx);
+ }
+ return;
+ }
self.pointer = Some(local);
self.pointer_active = true;
let previous = self.hovered.clone();
@@ -1844,9 +2055,8 @@ pub struct Label {
/// The band this label belongs in, when its tile reserved one. A parent's
/// name goes in its own band, never over its children.
pub header: Option<Rect>,
- /// Depth from the scanned root, used for the colour so it does not shift
- /// when the view descends.
- pub color_depth: u32,
+ /// Nesting depth in this view: the first level is set in bold.
+ pub depth: u32,
pub marked: bool,
pub size_text: String,
}
@@ -1854,8 +2064,20 @@ pub struct Label {
/// How many labels one frame will shape.
const MAX_LABELS: usize = 150;
-/// Height of a directory's name band, in rem.
-const HEADER_REMS: f32 = 1.0625;
+/// Height of a top-level directory's name band, in rem.
+const HEADER_REMS: f32 = 1.375;
+
+/// Height of the slim label row a deeper open directory keeps, in rem.
+const HEADER_INNER_REMS: f32 = 1.0;
+
+/// Now, in Unix seconds.
+pub fn now_seconds() -> i64 {
+ std::time::SystemTime::now()
+ .duration_since(std::time::UNIX_EPOCH)
+ .map_or(0, |since| {
+ i64::try_from(since.as_secs()).unwrap_or(i64::MAX)
+ })
+}
/// Smallest tile, in rem, that gets a label: below this a name cannot be read.
const LABEL_MIN_W_REMS: f32 = 3.375;
diff --git a/crates/disktree-app/src/tests.rs b/crates/disktree-app/src/tests.rs
index f923027..bcaf16a 100644
--- a/crates/disktree-app/src/tests.rs
+++ b/crates/disktree-app/src/tests.rs
@@ -814,3 +814,100 @@ fn after_descending_every_tile_is_inside_the_directory_drawn(
});
assert_eq!(hatched, 1, "exactly the marked tile is hatched");
}
+
+/// Drive the scan the view started until its tree lands.
+fn finish_scan(view: &Entity<Disktree>, cx: &mut Window) {
+ let epoch = read(view, cx, |app| app.scan_epoch);
+ for _ in 0..600 {
+ std::thread::sleep(std::time::Duration::from_millis(5));
+ let ready = update(view, cx, |app, cx| {
+ app.poll_scan_once(epoch, cx);
+ app.tree().is_some()
+ });
+ if ready {
+ return;
+ }
+ }
+ panic!("the scan never landed");
+}
+
+#[gpui_kit::test]
+fn dragging_the_panel_edge_resizes_it_within_its_limits(
+ cx: &mut TestAppContext,
+) {
+ use crate::state::{PANEL_MAX_REMS, PANEL_MIN_REMS, panel_width};
+ use gpui_kit::{Modifiers, MouseButton};
+
+ cx.update(gpui_omarchy::init);
+ let temp = fixture();
+ let (view, cx) = view_over(temp.path(), cx);
+ cx.simulate_resize(gpui_kit::size(px(1400.), px(900.)));
+ draw(cx);
+ let handle = cx.debug_bounds("panel-handle").expect("the panel is shown");
+ let start = handle.center();
+ let before = read(&view, cx, |app| app.panel_rems);
+
+ // A drag starts on the first move and reports moves after it, as a real
+ // pointer does in many small steps.
+ let drag = |cx: &mut Window, from: Point<Pixels>, to: Point<Pixels>| {
+ cx.simulate_mouse_down(from, MouseButton::Left, Modifiers::none());
+ for step in 1..=4 {
+ let t = step as f32 / 4.0;
+ let at = Point::new(from.x + (to.x - from.x) * t, to.y);
+ cx.simulate_mouse_move(
+ at,
+ Some(MouseButton::Left),
+ Modifiers::none(),
+ );
+ }
+ cx.simulate_mouse_up(to, MouseButton::Left, Modifiers::none());
+ draw(cx);
+ };
+
+ // Wider: drag the edge 160 px to the left.
+ let wider = Point::new(start.x - px(160.), start.y);
+ drag(cx, start, wider);
+ let after = read(&view, cx, |app| app.panel_rems);
+ assert!(
+ (after - before - 10.0).abs() < 0.5,
+ "160 px is 10 rem: {before} -> {after}"
+ );
+
+ // The limits, for any edge position: a minimum, a maximum, and never
+ // so wide that the mosaic gets less room than the panel's own minimum.
+ assert!((panel_width(1390., 1400., 16.) - PANEL_MIN_REMS).abs() < 1e-3);
+ assert!((panel_width(0., 3000., 16.) - PANEL_MAX_REMS).abs() < 1e-3);
+ let squeezed = panel_width(0., 800., 16.);
+ assert!((squeezed - (800. / 16. - PANEL_MIN_REMS)).abs() < 1e-3);
+ assert!((panel_width(0., 300., 16.) - PANEL_MIN_REMS).abs() < 1e-3);
+}
+
+#[gpui_kit::test]
+fn g_switches_between_the_home_directory_and_the_whole_disk(
+ cx: &mut TestAppContext,
+) {
+ use crate::state::Scope;
+
+ cx.update(gpui_omarchy::init);
+ let temp = fixture();
+ let (view, cx) = view_over(temp.path(), cx);
+ // Stand-ins: the fixture is "home", a directory in it is "the disk".
+ let disk = temp.path().join("junk");
+ update(&view, cx, |app, _| {
+ app.home = Some(temp.path().to_path_buf());
+ app.disk_root = Some(disk.clone());
+ });
+ assert_eq!(read(&view, cx, Disktree::scope), Some(Scope::Home));
+
+ press(cx, "g");
+ assert_eq!(read(&view, cx, |app| app.root_path.clone()), disk);
+ assert!(read(&view, cx, |app| app.scan.is_some()), "a new scan runs");
+ finish_scan(&view, cx);
+ assert_eq!(read(&view, cx, Disktree::scope), Some(Scope::Disk));
+ let top = read(&view, cx, |app| app.tree().map(|tree| tree.bytes));
+ assert!(top.is_some_and(|bytes| bytes > 0));
+
+ press(cx, "g");
+ finish_scan(&view, cx);
+ assert_eq!(read(&view, cx, Disktree::scope), Some(Scope::Home));
+}
diff --git a/crates/disktree-app/src/treemap_view.rs b/crates/disktree-app/src/treemap_view.rs
index 01a5704..093ee70 100644
--- a/crates/disktree-app/src/treemap_view.rs
+++ b/crates/disktree-app/src/treemap_view.rs
@@ -13,7 +13,7 @@ use std::rc::Rc;
use disktree_core::treemap::Rect;
use gpui_kit::{
- App, Bounds, ContentMask, Context, Corners, Edges, Font, Hsla,
+ App, Bounds, ContentMask, Context, Corners, Edges, Font, FontWeight, Hsla,
InteractiveElement as _, IntoElement, MouseButton, MouseDownEvent,
MouseMoveEvent, ParentElement as _, Pixels, Point, ScrollWheelEvent,
SharedString, Size, StatefulInteractiveElement as _, Styled, TextAlign,
@@ -21,6 +21,8 @@ use gpui_kit::{
};
use gpui_omarchy::{ActiveTheme, Theme};
+use disktree_core::classify::Category;
+
use crate::palette;
use crate::state::{Disktree, Label, View};
@@ -30,13 +32,16 @@ use crate::state::{Disktree, Label, View};
pub struct TileDeco {
/// Base-space rectangle: the view transform is applied while painting.
pub rect: Rect,
- /// The band this directory reserved for its name, when it is subdivided.
- pub header: Option<Rect>,
+ /// Nesting depth in this view; `0` is the first level.
pub depth: u32,
- /// Depth from the scanned root, used for the fill so descending does not
- /// recolour the mosaic; `depth` stays view-relative for geometry.
- pub color_depth: u32,
- pub hidden: bool,
+ /// What kind of data it is: the hue.
+ pub category: Category,
+ /// In age mode, which [`palette::AGE_BUCKETS`] entry it falls in.
+ pub age_bucket: Option<usize>,
+ /// Its space can be had back: hatched.
+ pub reclaimable: bool,
+ /// Part of it could not be read: flagged in its corner.
+ pub unreadable: bool,
pub marked: bool,
/// Inside another marked directory, so it goes with its parent.
pub covered: bool,
@@ -138,71 +143,99 @@ pub fn mosaic(
/// Theme colours resolved once per frame.
struct Colors {
- label: Vec<Hsla>,
+ label: [Hsla; 2],
label_dim: Hsla,
- border: Hsla,
hover_border: Hsla,
selected_border: Hsla,
marked_border: Hsla,
- marked_hatch: Hsla,
marked_label: Hsla,
covered_border: Hsla,
- header_tint: Hsla,
- header_rule: Hsla,
- fill: Vec<Hsla>,
- fill_hidden: Vec<Hsla>,
- fill_marked: Vec<Hsla>,
+ warning: Hsla,
+ hatch: Hsla,
+ /// Fills per category, then per depth.
+ fill: Vec<[Hsla; DEPTHS]>,
+ /// The strip over a top-level directory, per category.
+ strip: Vec<Hsla>,
+ /// Fills per age bucket, then per depth.
+ age: Vec<[Hsla; DEPTHS]>,
+ marked_fill: Hsla,
+}
+
+/// Depth steps a fill distinguishes; deeper clamps.
+const DEPTHS: usize = 5;
+
+/// Every category, in the order [`category_index`] numbers them.
+const CATEGORIES: [Category; 9] = [
+ Category::Code,
+ Category::AgentScratch,
+ Category::Toolchain,
+ Category::Synced,
+ Category::Git,
+ Category::Media,
+ Category::Documents,
+ Category::Cache,
+ Category::Other,
+];
+
+fn category_index(category: Category) -> usize {
+ CATEGORIES
+ .iter()
+ .position(|&known| known == category)
+ .unwrap_or(CATEGORIES.len() - 1)
}
impl Colors {
fn new(theme: &Theme) -> Self {
- // Absolute depth runs past the visible nesting (each descent adds to
- // it), so the ladder is longer than `max_depth` and clamps at the end.
- let depth_range = 0..=12;
+ let ladder = |fill: &dyn Fn(u32) -> Hsla| {
+ std::array::from_fn(|depth| fill(depth as u32))
+ };
Self {
- label: depth_range
- .clone()
- .map(|d| palette::label_color(theme, d))
- .collect(),
- label_dim: theme.bright.opacity(0.55),
- border: theme.background.opacity(0.55),
- hover_border: theme.bright.opacity(0.7),
- selected_border: theme.bright,
+ label: [
+ palette::label_color(theme, 0),
+ palette::label_color(theme, 1),
+ ],
+ label_dim: palette::label_color(theme, 1).opacity(0.5),
+ hover_border: theme.bright.opacity(0.55),
+ selected_border: palette::highlight(theme),
marked_border: theme.danger,
- marked_hatch: theme.danger.opacity(0.4),
- marked_label: theme.bright,
- covered_border: theme.danger.opacity(0.45),
- // A band reads as a label strip because it is lifted a little and
- // closed with a rule, not because it is another colour.
- header_tint: theme.bright.opacity(0.09),
- header_rule: theme.background.opacity(0.75),
- fill: depth_range
- .clone()
- .map(|d| palette::tile_fill(theme, d, false, false))
+ marked_label: theme.danger,
+ covered_border: theme.danger.opacity(0.4),
+ warning: theme.warning,
+ hatch: palette::hatch(theme),
+ fill: CATEGORIES
+ .iter()
+ .map(|&category| {
+ ladder(&|depth| {
+ palette::category_fill(theme, category, depth)
+ })
+ })
.collect(),
- fill_hidden: depth_range
- .clone()
- .map(|d| palette::tile_fill(theme, d, true, false))
+ strip: CATEGORIES
+ .iter()
+ .map(|&category| palette::category_accent(theme, category))
.collect(),
- fill_marked: depth_range
- .map(|d| palette::tile_fill(theme, d, false, true))
+ age: (0..palette::AGE_BUCKETS.len())
+ .map(|bucket| {
+ ladder(&|depth| palette::age_fill(theme, bucket, depth))
+ })
.collect(),
+ marked_fill: palette::mix(theme.inset, theme.danger, 0.16),
}
}
fn fill(&self, tile: &TileDeco) -> Hsla {
- let index = (tile.color_depth as usize).min(self.fill.len() - 1);
if tile.marked {
- self.fill_marked[index]
- } else if tile.hidden {
- self.fill_hidden[index]
- } else {
- self.fill[index]
+ return self.marked_fill;
+ }
+ let depth = (tile.depth as usize).min(DEPTHS - 1);
+ match tile.age_bucket {
+ Some(bucket) => self.age[bucket.min(self.age.len() - 1)][depth],
+ None => self.fill[category_index(tile.category)][depth],
}
}
- fn label(&self, depth: u32) -> Hsla {
- self.label[(depth as usize).min(self.label.len() - 1)]
+ const fn label(&self, depth: u32) -> Hsla {
+ self.label[if depth == 0 { 0 } else { 1 }]
}
}
@@ -213,76 +246,129 @@ fn paint_tiles(
colors: &Colors,
window: &mut Window,
) {
+ let none = Edges::all(px(0.));
+ let solid = gpui_kit::BorderStyle::Solid;
+ let scale = window.scale_factor();
+ // Outlines are drawn after every fill: a directory's children paint over
+ // its body, and would otherwise cover its selection ring, leaving only
+ // slivers of it showing in the gaps between them.
+ let mut outlines: Vec<(u8, Bounds<Pixels>, f32, Hsla)> = Vec::new();
for tile in tiles {
let rect = view.project(tile.rect);
if rect.w <= 0.5 || rect.h <= 0.5 {
continue;
}
- let quad_bounds = to_window(&rect, bounds);
-
- // Every tile gets a hairline of background rather than a bright border:
- // that is what separates nested levels without turning the mosaic into
- // a wireframe.
- let mut width = if tile.depth == 0 { 1.0 } else { 0.5 };
- let mut border = colors.border;
- if tile.marked {
- width = 2.0;
- border = colors.marked_border;
- } else if tile.covered {
- width = 1.0;
- border = colors.covered_border;
- }
- if tile.hovered {
- width = 2.0;
- border = colors.hover_border;
- }
- if tile.selected {
- width = 2.0;
- border = colors.selected_border;
- }
+ let quad_bounds = snap(to_window(&rect, bounds), scale);
+ // No border by default: the gaps between tiles, wider between the
+ // top-level directories, are what separate them.
window.paint_quad(quad(
quad_bounds,
Corners::default(),
colors.fill(tile),
- Edges::all(px(width)),
- border,
- gpui_kit::BorderStyle::Solid,
+ none,
+ colors.hover_border,
+ solid,
));
- // The band a subdivided directory keeps for its name: lifted, and
- // closed with a rule, so the group reads as a group and the space
- // inside it belongs to the children.
- if let Some(header) = tile.header {
- let header = view.project(header);
- if header.w > 1.0 && header.h > 1.0 {
- let band = to_window(&header, bounds);
- window.paint_quad(quad(
- band,
- Corners::default(),
- colors.header_tint,
- Edges::all(px(0.)),
- colors.header_rule,
- gpui_kit::BorderStyle::Solid,
- ));
- }
+ // Reclaimable space is hatched, over any hue: the hatch answers
+ // "can it go", the colour "what is it". Everything inside a
+ // reclaimable directory is reclaimable too, so only the outermost
+ // one needs painting; its children repaint their own fill and hatch.
+ if tile.reclaimable && !tile.marked {
+ window.paint_quad(quad(
+ quad_bounds,
+ Corners::default(),
+ pattern_slash(colors.hatch, 1.0, 6.0),
+ none,
+ colors.hatch,
+ solid,
+ ));
}
- // A hatched overlay is the conventional "this one is going away" mark,
- // and it survives on top of any tile colour the theme produces.
- if tile.marked {
+ // A top-level directory carries a thin strip of its colour, so the
+ // first level of structure reads before any detail.
+ if tile.depth == 0 && tile.age_bucket.is_none() {
+ let strip = Bounds::new(
+ quad_bounds.origin,
+ Size::new(
+ quad_bounds.size.width,
+ px(2.0_f32.min(quad_bounds.size.height.as_f32())),
+ ),
+ );
+ window.paint_quad(quad(
+ strip,
+ Corners::default(),
+ colors.strip[category_index(tile.category)],
+ none,
+ colors.hover_border,
+ solid,
+ ));
+ }
+
+ if tile.unreadable && rect.w > 12.0 && rect.h > 12.0 {
+ // A small warning corner: part of this was never measured.
+ let mark = Bounds::new(
+ Point::new(
+ quad_bounds.origin.x + quad_bounds.size.width - px(6.),
+ quad_bounds.origin.y + px(2.),
+ ),
+ Size::new(px(4.), px(4.)),
+ );
window.paint_quad(quad(
- inset(quad_bounds, px(2.)),
+ mark,
Corners::default(),
- pattern_slash(colors.marked_hatch, 2.0, 9.0),
- Edges::all(px(0.)),
- colors.marked_border,
- gpui_kit::BorderStyle::Solid,
+ colors.warning,
+ none,
+ colors.warning,
+ solid,
));
}
+
+ // Ranked so the most important ring is painted last, on top.
+ let outline = if tile.selected {
+ Some((3, 2.0, colors.selected_border))
+ } else if tile.hovered {
+ Some((2, 1.0, colors.hover_border))
+ } else if tile.marked {
+ Some((1, 2.0, colors.marked_border))
+ } else if tile.covered {
+ Some((0, 1.0, colors.covered_border))
+ } else {
+ None
+ };
+ if let Some((rank, width, color)) = outline {
+ outlines.push((rank, quad_bounds, width, color));
+ }
+ }
+ outlines.sort_by_key(|(rank, ..)| *rank);
+ for (_, ring, width, color) in outlines {
+ window.paint_quad(quad(
+ ring,
+ Corners::default(),
+ gpui_kit::transparent_black(),
+ Edges::all(px(width)),
+ color,
+ solid,
+ ));
}
}
+/// Round a rectangle's edges to device pixels. Tiles land on fractional
+/// positions, and a 2 px strip or ring there smears across a pixel row and
+/// leaves a seam; rounding each edge, not the size, keeps neighbours flush.
+fn snap(bounds: Bounds<Pixels>, scale: f32) -> Bounds<Pixels> {
+ let round = |value: Pixels| px((value.as_f32() * scale).round() / scale);
+ let left = round(bounds.origin.x);
+ let top = round(bounds.origin.y);
+ let right = round(bounds.origin.x + bounds.size.width);
+ let bottom = round(bounds.origin.y + bounds.size.height);
+ Bounds::new(
+ Point::new(left, top),
+ Size::new((right - left).max(px(0.)), (bottom - top).max(px(0.))),
+ )
+}
+
#[expect(
clippy::too_many_arguments,
reason = "the paint pass threads window state; a struct would only move
@@ -330,12 +416,21 @@ fn paint_labels(
let color = if label.marked {
colors.marked_label
} else {
- colors.label(label.color_depth)
+ colors.label(label.depth)
+ };
+ // The first level is set in bold in its band: it names a region.
+ let weight = if label.depth == 0 && label.header.is_some() {
+ FontWeight::BOLD
+ } else {
+ FontWeight::NORMAL
};
let run = TextRun {
len: label.text.len(),
- font: font.clone(),
+ font: Font {
+ weight,
+ ..font.clone()
+ },
color,
..TextRun::default()
};
@@ -381,9 +476,27 @@ fn paint_labels(
+ ((line.ascent - line.descent)
- (size_line.ascent - size_line.descent))
* 0.5;
- // In a band the size sits at the far end, where it reads as a
- // column; without one it follows the name when there is room.
- let size_origin = if label.header.is_some() {
+ // A first-level band puts the size at the far end, where the
+ // sizes read as a column; a deeper band follows the name. A
+ // closed tile stacks it under the name when it is tall enough.
+ let stacked = label.header.is_none()
+ && mask.size.height >= name_line_height * 2.0 + text_inset;
+ if stacked {
+ let _ = size_line.paint(
+ Point::new(
+ origin.x,
+ origin.y + name_line_height * 0.92,
+ ),
+ name_line_height,
+ TextAlign::Left,
+ None,
+ window,
+ cx,
+ );
+ return;
+ }
+ let size_origin = if label.header.is_some() && label.depth == 0
+ {
Point::new(
mask.origin.x + mask.size.width
- size_line.width()
@@ -418,16 +531,6 @@ fn to_window(rect: &Rect, bounds: Bounds<Pixels>) -> Bounds<Pixels> {
)
}
-fn inset(bounds: Bounds<Pixels>, amount: Pixels) -> Bounds<Pixels> {
- Bounds::new(
- Point::new(bounds.origin.x + amount, bounds.origin.y + amount),
- Size::new(
- (bounds.size.width - amount * 2.).max(px(0.)),
- (bounds.size.height - amount * 2.).max(px(0.)),
- ),
- )
-}
-
fn rem_px(rems: f32, rem_size: Pixels) -> Pixels {
px(rems * rem_size.as_f32())
}
diff --git a/crates/disktree-app/src/ui.rs b/crates/disktree-app/src/ui.rs
index 4644f67..c024022 100644
--- a/crates/disktree-app/src/ui.rs
+++ b/crates/disktree-app/src/ui.rs
@@ -47,6 +47,12 @@ pub mod text {
pub const BODY: Rems = Rems(0.75);
/// Window, section and dialog titles.
pub const TITLE: Rems = Rems(0.875);
+ /// The app name and the selection's name.
+ pub const HEADING: Rems = Rems(1.125);
+ /// A figure worth reading from across the room: the free space.
+ pub const FIGURE: Rems = Rems(1.625);
+ /// The selection's size: the one number the panel exists to show.
+ pub const DISPLAY: Rems = Rems(2.5);
}
/// Icon slots, sized with the text they sit beside.
@@ -63,14 +69,16 @@ pub mod icon {
pub mod size {
use super::Rems;
- /// The volume meter in the status bar.
- pub const SPACE_METER: Rems = Rems(20.0);
- /// The scan meter in the status bar.
- pub const SCAN_METER: Rems = Rems(15.0);
+ /// A list row's share bar.
+ pub const ROW_BAR: Rems = Rems(5.5);
+ /// A legend or identity swatch.
+ pub const SWATCH: Rems = Rems(0.625);
+ /// A thin meter: share of the scan, the disk.
+ pub const METER: Rems = Rems(0.3125);
/// The meter on the scanning panel.
pub const SCANNING_METER: Rems = Rems(26.25);
- /// The Size | Files choice in the settings row.
- pub const RANKING_CHOICE: Rems = Rems(8.5);
+ /// The Size | Files | Age choice in the settings row.
+ pub const RANKING_CHOICE: Rems = Rems(11.0);
/// The review screen's summary column.
pub const REVIEW_SUMMARY: Rems = Rems(22.5);
/// The review list's share-bar lane.
diff --git a/crates/disktree-app/src/views.rs b/crates/disktree-app/src/views.rs
index e0dcf6d..fff8804 100644
--- a/crates/disktree-app/src/views.rs
+++ b/crates/disktree-app/src/views.rs
@@ -4,30 +4,38 @@
//! always exactly what the state says — there is no second copy of anything to
//! keep in sync.
+use disktree_core::classify::Category;
+use disktree_core::insights::{Candidate, Finding, STALE_DAYS};
use disktree_core::removal::{RemovalMode, Target};
use disktree_core::size::human_bytes;
use disktree_core::tree::Metric;
+use gpui_kit::base::CheckboxState;
use gpui_kit::{
- App, Context, Div, ElementId, FontWeight, InteractiveElement as _,
- IntoElement, KeyDownEvent, ParentElement, SharedString, Stateful,
- StatefulInteractiveElement as _, Styled, Window, div, px,
+ App, AppContext as _, ClickEvent, Context, Div, DragMoveEvent, ElementId,
+ FontWeight, InteractiveElement as _, IntoElement, KeyDownEvent,
+ ParentElement, Rems, SharedString, Stateful,
+ StatefulInteractiveElement as _, Styled, Window, div, pattern_slash, px,
+ relative,
};
use gpui_omarchy::{
ActiveTheme, ButtonVariant, ChoiceItem, Theme, alert_dialog, button,
- button_group, dialog_button, dialog_description, dialog_popup,
- dialog_title, separator, toggle, with_tooltip,
+ button_group, checkbox, dialog_button, dialog_description, dialog_popup,
+ dialog_title, separator, with_tooltip,
};
use gpui_kit::prelude::FluentBuilder as _;
-use crate::state::{Disktree, Screen};
+use crate::palette;
+use crate::state::{
+ ColorMode, Disktree, PANEL_REMS, Scope, Screen, panel_width,
+};
use crate::treemap_view::{self, Mosaic};
use crate::ui::{icon, size, space, text};
use crate::widgets;
/// Width, in rem, at which the header holds title, settings and totals on one
/// line. Narrower, the totals move into the status bar.
-const HEADER_WIDE_REMS: f32 = 62.0;
+const HEADER_WIDE_REMS: f32 = 86.0;
/// How many marks the review screen lists. Everything above the cap is still
/// removed; the list only stops being exhaustive, which it says out loud.
@@ -173,117 +181,107 @@ fn explore(
) -> Div {
let theme = cx.omarchy().clone();
let mosaic: Mosaic = app.prepare();
- let selection = app.show_selection;
- // Below this width the header cannot hold title, settings and totals on
- // one line; the totals move to the status bar rather than wrapping.
- let wide =
- window.viewport_size().width.as_f32() / app.rem >= HEADER_WIDE_REMS;
- let header = explore_header(app, &theme, wide, window, cx);
- let trail = breadcrumbs(app, &theme, cx);
+ let width_rems = window.viewport_size().width.as_f32() / app.rem;
+ let wide = width_rems >= HEADER_WIDE_REMS;
+ // The panel is where the selection, the marks and the disk live; it
+ // only gives way when the mosaic would be too narrow to read.
+ let panel = app.show_selection && width_rems >= PANEL_SHOWN_REMS;
+ if panel && let Some(path) = selection_checkout(app) {
+ app.ensure_git(&path, cx);
+ }
- div()
- .flex()
- .flex_col()
- .flex_1()
- .min_h_0()
- .child(header)
- .child(trail)
- .child(div().flex().flex_row().flex_1().min_h_0().child(
- if app.tree().is_none() {
- // The first walk of a home directory takes long enough that
- // an empty viewport would look broken; count the work
- // instead of pretending there is nothing to see.
- scanning_panel(app, &theme, cx).into_any_element()
- } else {
- treemap_view::mosaic(mosaic, app, window, cx).into_any_element()
- },
- ))
- .children(selection.then(|| selection_bar(app, &theme, cx)))
- .child(status_bar(app, &theme, !wide, cx))
- .child(hint_bar(app, &theme, cx))
-}
+ let viewport = if app.tree().is_none() {
+ // The first walk of a home directory takes long enough that an
+ // empty viewport would look broken; count the work instead.
+ scanning_panel(app, &theme, cx).into_any_element()
+ } else {
+ treemap_view::mosaic(mosaic, app, window, cx).into_any_element()
+ };
-/// What the viewport shows while the first scan is running.
-fn scanning_panel(app: &Disktree, theme: &Theme, cx: &gpui_kit::App) -> Div {
- let progress = &app.progress;
- let mut panel = div()
+ div()
.flex()
.flex_col()
.flex_1()
.min_h_0()
- .items_center()
- .justify_center()
- .gap(space::LG)
- .bg(theme.inset)
- .child(
- gpui_omarchy::icon(gpui_omarchy::IconName::Loader)
- .size(icon::LG)
- .text_color(theme.accent),
- )
- .child(
- div()
- .text_size(text::TITLE)
- .font_weight(FontWeight::SEMIBOLD)
- .text_color(theme.bright)
- .child(format!("Reading {}", widgets::display_root(app))),
- )
+ .child(top_bar(app, &theme, wide, window, cx))
.child(
div()
+ .id("explore-body")
.flex()
.flex_row()
- .gap(space::XL)
- .child(widgets::stat(
- "files",
- widgets::human_count(progress.files),
- cx,
- ))
- .child(widgets::stat("directories", widgets::human_count(progress.dirs), cx))
- .child(widgets::stat("measured", human_bytes(progress.bytes), cx))
- .child(widgets::stat_colored(
- "unreadable",
- widgets::human_count(progress.errors),
- if progress.errors > 0 {
- theme.warning
- } else {
- theme.secondary
+ .flex_1()
+ .min_h_0()
+ // The panel's handle starts the drag; the width follows the
+ // pointer from here, wherever it goes in the window.
+ .on_drag_move(cx.listener(
+ |this, event: &DragMoveEvent<PanelDrag>, window, cx| {
+ this.panel_rems = panel_width(
+ event.event.position.x.as_f32(),
+ window.viewport_size().width.as_f32(),
+ this.rem,
+ );
+ cx.notify();
},
- cx,
- )),
- )
- .child(
- div()
- .w(size::SCANNING_METER)
- .child(widgets::meter_row(
- "",
- "",
- progress_estimate(progress.files),
- theme.accent,
- cx,
- )),
+ ))
+ .child(
+ div()
+ .flex()
+ .flex_col()
+ .flex_1()
+ .min_w_0()
+ .min_h_0()
+ .child(trail_and_legend(app, &theme, cx))
+ .child(
+ div()
+ .flex()
+ .flex_1()
+ .min_h_0()
+ .px(space::LG)
+ .pb(space::SM)
+ .child(viewport),
+ ),
+ )
+ .children(panel.then(|| side_panel(app, &theme, cx))),
)
- .child(
- div()
- .text_size(text::BODY)
- .text_color(theme.secondary)
- .child("Marking, zooming and the free-space meter all work as soon as it lands."),
- );
+ .child(key_bar(app, &theme, cx))
+}
- if let Some(error) = &app.scan_error {
- panel = panel.child(
- div()
- .max_w(size::HELP)
- .p(space::MD)
- .border_1()
- .border_color(theme.danger)
- .text_color(theme.danger)
- .text_size(text::BODY)
- .child(error.clone()),
- );
+/// The selection, when it is a checkout git can say something about.
+fn selection_checkout(app: &Disktree) -> Option<std::path::PathBuf> {
+ let target = app.action_target()?;
+ let node = app.node_at(&target)?;
+ if !node.is_dir() {
+ return None;
+ }
+ let path = app.path_at(&target)?;
+ crate::git::is_checkout(&path).then_some(path)
+}
+
+/// Width, in rem, below which the side panel gives the mosaic its room.
+const PANEL_SHOWN_REMS: f32 = 52.0;
+
+/// What the panel handle drags. The width itself lives in the app state.
+#[derive(Clone, Copy, Debug)]
+struct PanelDrag;
+
+/// A drag needs a view to draw under the pointer; resizing draws nothing.
+struct NoGhost;
+
+impl gpui_kit::Render for NoGhost {
+ fn render(
+ &mut self,
+ _: &mut Window,
+ _: &mut Context<'_, Self>,
+ ) -> impl IntoElement {
+ div()
}
- panel
}
-fn explore_header(
+// ── top bar ─────────────────────────────────────────────────────────────
+
+/// The app, what the whole scan found, and the controls that decide what
+/// is measured, on the edge they own.
+fn top_bar(
app: &Disktree,
theme: &Theme,
wide: bool,
@@ -291,111 +289,96 @@ fn explore_header(
cx: &mut Context<'_, Disktree>,
) -> Div {
let tree = app.tree();
- let scanned = tree.map_or(0, |node| node.bytes);
- let files = tree.map_or(0, |node| node.files);
- let dirs = tree.map_or(0, |node| node.dirs);
+ let scanned = tree.map_or(app.progress.bytes, |node| node.bytes);
+ let files = tree.map_or(app.progress.files, |node| node.files);
+ let dirs = tree.map_or(app.progress.dirs, |node| node.dirs);
+ let errors = app.progress.errors;
let mut row = div()
.flex()
.flex_row()
.items_center()
- .gap(space::MD)
+ .gap(space::LG)
.px(space::LG)
.py(space::MD)
- // Leading: the app and what the whole scan found. Trailing: the
- // controls that decide what is measured, on the edge they own. The
- // breadcrumb below names only the place.
- .child(
- div()
- .flex_shrink_0()
- .text_size(text::TITLE)
- .font_weight(FontWeight::BOLD)
- .text_color(theme.bright)
- .child("disktree"),
- );
+ .border_b_1()
+ .border_color(theme.divider())
+ .child(logo(theme))
+ // What is scanned sits with the name: the totals beside it are
+ // totals of this choice.
+ .child(scope_switch(app, window, cx));
if wide {
+ let value = |text: String| text;
row = row
- .child(div().w(space::MD))
- .child(widgets::stat("Scanned", human_bytes(scanned), cx))
- .child(widgets::stat("Files", widgets::human_count(files), cx))
- .child(widgets::stat(
- "Directories",
+ .child(widgets::figure(
+ "Scanned",
+ value(human_bytes(scanned)),
+ theme.bright,
+ cx,
+ ))
+ .child(widgets::figure(
+ "Files",
+ widgets::human_count(files),
+ theme.bright,
+ cx,
+ ))
+ .child(widgets::figure(
+ "Dirs",
widgets::human_count(dirs),
+ theme.bright,
+ cx,
+ ))
+ .child(widgets::figure(
+ "Unreadable",
+ widgets::human_count(errors),
+ if errors > 0 {
+ theme.warning
+ } else {
+ theme.secondary
+ },
cx,
));
}
- row = row.child(div().flex_1());
- if app.find_open || !app.find.is_empty() {
- row = row.child(find_field(app, theme));
- }
- row.child(view_settings(app, window, cx))
+ row.child(div().flex_1())
+ .child(view_settings(app, window, cx))
}
-fn find_field(app: &Disktree, theme: &Theme) -> Div {
+/// Four tiles in category colours, and the name.
+fn logo(theme: &Theme) -> Div {
+ let tile = |category| {
+ div()
+ .size(space::SM)
+ .bg(palette::category_accent(theme, category))
+ };
+ let column = |top, bottom| {
+ div()
+ .flex()
+ .flex_col()
+ .gap(space::XXS)
+ .child(tile(top))
+ .child(tile(bottom))
+ };
div()
.flex()
.flex_row()
.items_center()
.gap(space::SM)
- .px(space::SM)
- .py(space::XS)
- .border_1()
- .border_color(if app.find_open {
- theme.accent
- } else {
- theme.control_border()
- })
- .bg(theme.normal_fill())
- .text_size(text::BODY)
+ .flex_shrink_0()
.child(
- gpui_omarchy::icon(gpui_omarchy::IconName::Search)
- .size(icon::SM)
- .text_color(theme.secondary),
+ div()
+ .flex()
+ .flex_row()
+ .gap(space::XXS)
+ .child(column(Category::Code, Category::Synced))
+ .child(column(Category::AgentScratch, Category::Toolchain)),
)
- .child(if app.find.is_empty() {
+ .child(
div()
- .text_color(theme.secondary.opacity(0.7))
- .child("Find by name")
- } else {
- div().text_color(theme.bright).child(app.find.clone())
- })
-}
-
-fn breadcrumbs(
- app: &Disktree,
- theme: &Theme,
- cx: &Context<'_, Disktree>,
-) -> Div {
- let trail = app.breadcrumbs();
- let last = trail.len().saturating_sub(1);
- let mut row = div()
- .flex()
- .flex_row()
- .items_center()
- .gap(space::XXS)
- .px(space::LG)
- .py(space::SM)
- .min_h_0()
- .border_b_1()
- .border_color(theme.divider());
-
- for (index, (label, crumbs)) in trail.into_iter().enumerate() {
- if index > 0 {
- row = row.child(
- div()
- .text_color(theme.secondary.opacity(0.6))
- .text_size(text::CAPTION)
- .child("/"),
- );
- }
- let active = index == last;
- let id = ElementId::Name(SharedString::from(format!("crumb-{index}")));
- row = row.child(widgets::crumb(id, label, active, cx).on_click(
- cx.listener(move |this, _, _, cx| this.go_to(crumbs.clone(), cx)),
- ));
- }
-
- row
+ .text_size(text::HEADING)
+ .font_weight(FontWeight::BOLD)
+ .text_color(theme.bright)
+ .child("disktree"),
+ )
}
/// How the mosaic is measured and drawn, as real controls with visible state.
@@ -411,27 +394,19 @@ fn view_settings(
let focus = app.focus.clone();
let entity = cx.entity().downgrade();
- let ranking = {
+ let mode = {
let entity = entity.clone();
let focus = focus.clone();
button_group(
- "ranking",
+ "mode",
vec![
- ChoiceItem::new("bytes", "Size"),
+ ChoiceItem::new("size", "Size"),
ChoiceItem::new("files", "Files"),
+ ChoiceItem::new("age", "Age"),
],
- Some(usize::from(app.options.metric == Metric::Files)),
+ Some(app.mode_index()),
move |index, window, cx| {
- let _ = entity.update(cx, |this, cx| {
- let wanted = if index == 0 {
- Metric::Bytes
- } else {
- Metric::Files
- };
- if this.options.metric != wanted {
- this.toggle_metric(cx);
- }
- });
+ let _ = entity.update(cx, |this, cx| this.set_mode(index, cx));
window.focus(&focus, cx);
},
window,
@@ -439,56 +414,83 @@ fn view_settings(
)
.w(size::RANKING_CHOICE)
// Tighter than a standalone group, so the segmented control shares
- // the toggles' height and centre line in this toolbar row.
+ // the checkboxes' height and centre line.
.p(space::XXS)
};
+ let check = |on: bool| {
+ if on {
+ CheckboxState::Checked
+ } else {
+ CheckboxState::Unchecked
+ }
+ };
let hidden = {
let entity = entity.clone();
let focus = focus.clone();
- toggle("hidden", "Hidden files", app.options.include_hidden, cx)
- .tab_stop(false)
- .on_change(move |_, _, window, cx| {
- let _ = entity.update(cx, |this, cx| {
- this.options.include_hidden = !this.options.include_hidden;
- this.start_scan(cx);
- });
- window.focus(&focus, cx);
- })
+ checkbox(
+ "hidden",
+ "Hidden files",
+ check(app.options.include_hidden),
+ cx,
+ )
+ .tab_stop(false)
+ .on_change(move |_, _, window, cx| {
+ let _ = entity.update(cx, |this, cx| {
+ this.options.include_hidden = !this.options.include_hidden;
+ this.start_scan(cx);
+ });
+ window.focus(&focus, cx);
+ })
};
-
let apparent = {
- toggle("apparent", "Apparent size", app.options.apparent_size, cx)
- .tab_stop(false)
- .on_change(move |_, _, window, cx| {
- let _ = entity.update(cx, |this, cx| {
- this.options.apparent_size = !this.options.apparent_size;
- this.start_scan(cx);
- });
- window.focus(&focus, cx);
- })
- };
-
- let depth = app.layout_options.max_depth;
- let levels = with_tooltip(
- button(
- "levels",
- format!("{depth} levels"),
- // Outline, like the toggles beside it: bare text reads as a label.
- ButtonVariant::Outline,
+ checkbox(
+ "apparent",
+ "Apparent size",
+ check(app.options.apparent_size),
cx,
)
.tab_stop(false)
- .on_click(cx.listener(|this, _, window, cx| {
- // Cycles, so the pointer can reach every depth; the keys step.
- let step = if this.layout_options.max_depth >= 6 {
- -5
- } else {
- 1
- };
- this.adjust_depth(step, cx);
- window.focus(&this.focus, cx);
- })),
+ .on_change(move |_, _, window, cx| {
+ let _ = entity.update(cx, |this, cx| {
+ this.options.apparent_size = !this.options.apparent_size;
+ this.start_scan(cx);
+ });
+ window.focus(&focus, cx);
+ })
+ };
+
+ let theme = cx.omarchy().clone();
+ let depth = app.layout_options.max_depth;
+ let stepper = |id: &'static str,
+ label: &'static str,
+ step: i32,
+ cx: &mut Context<'_, Disktree>| {
+ button(id, label, ButtonVariant::Secondary, cx)
+ .tab_stop(false)
+ .disabled(if step < 0 { depth <= 1 } else { depth >= 6 })
+ .on_click(cx.listener(move |this, _, window, cx| {
+ this.adjust_depth(step, cx);
+ window.focus(&this.focus, cx);
+ }))
+ };
+ let depth_control = with_tooltip(
+ div()
+ .id("depth")
+ .flex()
+ .flex_row()
+ .items_center()
+ .border_1()
+ .border_color(theme.control_border())
+ .child(
+ div()
+ .px(space::SM)
+ .text_size(text::BODY)
+ .text_color(theme.foreground)
+ .child(format!("Depth {depth}")),
+ )
+ .child(stepper("depth-less", "\u{2212}", -1, cx))
+ .child(stepper("depth-more", "+", 1, cx)),
"Levels drawn at once \u{00b7} [ and ]",
);
@@ -497,391 +499,903 @@ fn view_settings(
.flex_row()
.items_center()
.gap(space::SM)
- .child(ranking)
+ .flex_shrink_0()
+ .child(mode)
.child(hidden)
.child(apparent)
- .child(levels)
+ .child(depth_control)
}
-/// What the keys act on, as one line above the status bar: name and path,
-/// size and share, and the two actions that apply to it. The mosaic keeps the
-/// full width of the window.
-fn selection_bar(
+// ── trail and legend ────────────────────────────────────────────────────
+
+/// Where you are, as a clickable trail, and what the colours mean, on one
+/// row over the mosaic.
+fn trail_and_legend(
app: &Disktree,
theme: &Theme,
cx: &Context<'_, Disktree>,
) -> Div {
- let target = app.action_target().unwrap_or_else(|| app.crumbs.clone());
- let row = div()
+ let trail = app.breadcrumbs();
+ let last = trail.len().saturating_sub(1);
+ let mut crumbs = div()
.flex()
.flex_row()
.items_center()
- .gap(space::XL)
- .px(space::LG)
- .py(space::SM)
- .border_t_1()
- .border_color(theme.divider())
- .bg(theme.surface);
-
- let Some(node) = app.node_at(&target) else {
- return row.child(
- div()
- .text_color(theme.secondary)
- .child("Point at a tile or select one with the arrows"),
- );
+ .gap(space::XXS)
+ .flex_shrink_0();
+ for (index, (label, path)) in trail.into_iter().enumerate() {
+ if index > 0 {
+ crumbs = crumbs.child(
+ div()
+ .text_color(theme.secondary.opacity(0.5))
+ .text_size(text::BODY)
+ .child("/"),
+ );
+ }
+ let id = ElementId::Name(SharedString::from(format!("crumb-{index}")));
+ crumbs = crumbs.child(
+ widgets::crumb(id, label, index == last, cx).on_click(
+ cx.listener(move |this, _, _, cx| this.go_to(path.clone(), cx)),
+ ),
+ );
+ }
+
+ let mut row = div()
+ .flex()
+ .flex_row()
+ .items_center()
+ .gap(space::LG)
+ .px(space::LG)
+ .py(space::SM)
+ .child(crumbs);
+ if app.find_open || !app.find.is_empty() {
+ row = row.child(find_field(app, theme));
+ }
+ row.child(div().flex_1()).child(legend(app, theme, cx))
+}
+
+/// What is scanned: the home directory or the whole disk it lives on. A
+/// root given on the command line is neither, and selects nothing.
+fn scope_switch(
+ app: &Disktree,
+ window: &mut Window,
+ cx: &mut Context<'_, Disktree>,
+) -> impl IntoElement {
+ let entity = cx.entity().downgrade();
+ let focus = app.focus.clone();
+ let disk = app.disk_root.as_deref().map_or_else(
+ || "/ Whole disk".to_string(),
+ |root| format!("{} Whole disk", root.display()),
+ );
+ with_tooltip(
+ button_group(
+ "scope",
+ vec![
+ ChoiceItem::new("home", "~ Home"),
+ ChoiceItem::new("disk", disk),
+ ],
+ app.scope().map(|scope| usize::from(scope == Scope::Disk)),
+ move |index, window, cx| {
+ let _ = entity.update(cx, |this, cx| {
+ this.set_scope(
+ if index == 1 { Scope::Disk } else { Scope::Home },
+ cx,
+ );
+ });
+ window.focus(&focus, cx);
+ },
+ window,
+ cx,
+ )
+ .flex_shrink_0()
+ .p(space::XXS),
+ "What to scan · g switches",
+ )
+}
+
+/// The key to the colours: the categories, or the age ramp in age mode.
+/// Clipped from the trailing end when the row runs out of room.
+fn legend(app: &Disktree, theme: &Theme, cx: &App) -> Div {
+ let item = |swatch: Div, label: &'static str| {
+ div()
+ .flex()
+ .flex_row()
+ .items_center()
+ .gap(space::XS)
+ .flex_shrink_0()
+ .child(swatch)
+ .child(
+ div()
+ .text_size(text::CAPTION)
+ .text_color(theme.secondary)
+ .child(label),
+ )
+ };
+ let mut lane = div()
+ .flex()
+ .flex_row()
+ .items_center()
+ .gap(space::MD)
+ .min_w_0()
+ .overflow_hidden();
+ if app.color_mode == ColorMode::Age {
+ for (bucket, (_, label)) in palette::AGE_BUCKETS.iter().enumerate() {
+ lane = lane.child(item(
+ widgets::swatch(palette::age_accent(theme, bucket)),
+ label,
+ ));
+ }
+ } else {
+ for category in Category::LEGEND {
+ lane = lane.child(item(
+ widgets::swatch(palette::category_accent(theme, category)),
+ category.label(),
+ ));
+ }
+ }
+ let ground = palette::category_fill(theme, Category::Other, 0);
+ let hatch = cx.omarchy().bright.opacity(0.5);
+ div()
+ .flex()
+ .flex_row()
+ .items_center()
+ .gap(space::MD)
+ .min_w_0()
+ .overflow_hidden()
+ .child(item(widgets::hatch_swatch(hatch, ground), "Reclaimable"))
+ .child(lane)
+}
+
+// ── side panel ──────────────────────────────────────────────────────────
+
+/// Selection, worth a look, marked, and the disk: everything a decision
+/// needs, next to the mosaic rather than under it.
+fn side_panel(
+ app: &Disktree,
+ theme: &Theme,
+ cx: &Context<'_, Disktree>,
+) -> Div {
+ let rule = || div().h(px(1.)).bg(theme.divider());
+ // A hairline to look at, a wider strip to grab; double-click resets.
+ let handle = div()
+ .id("panel-handle")
+ .debug_selector(|| "panel-handle".into())
+ .absolute()
+ .top_0()
+ .bottom_0()
+ .left(px(-3.))
+ .w(px(6.))
+ .cursor_col_resize()
+ .hover(|style| style.bg(theme.accent.opacity(0.35)))
+ .on_drag(PanelDrag, |_, _, _, cx| cx.new(|_| NoGhost))
+ .on_click(cx.listener(|this, event: &ClickEvent, _, cx| {
+ if event.click_count() >= 2 {
+ this.panel_rems = PANEL_REMS;
+ cx.notify();
+ }
+ }));
+ div()
+ .relative()
+ .flex()
+ .flex_col()
+ .gap(space::LG)
+ .w(Rems(app.panel_rems))
+ .flex_shrink_0()
+ .min_h_0()
+ .px(space::LG)
+ .py(space::LG)
+ .border_l_1()
+ .border_color(theme.divider())
+ .bg(theme.surface)
+ .child(handle)
+ .child(selection_section(app, theme, cx))
+ .child(rule())
+ // The lists scroll; the selection above and the disk below stay put,
+ // so the two numbers that matter never leave the screen.
+ .child(
+ div()
+ .id("panel-lists")
+ .flex()
+ .flex_col()
+ .gap(space::LG)
+ .flex_1()
+ .min_h_0()
+ .overflow_y_scroll()
+ .child(worth_section(app, theme, cx))
+ .child(rule())
+ .child(marked_section(app, theme, cx)),
+ )
+ .children(notice_line(app, theme, cx))
+ .child(disk_section(app, theme, cx))
+}
+
+/// What the keys act on: its name and place, its size set large with its
+/// share of the scan, when it was last written, what git says, and the two
+/// things to do with it.
+fn selection_section(
+ app: &Disktree,
+ theme: &Theme,
+ cx: &Context<'_, Disktree>,
+) -> Div {
+ let section = div()
+ .flex()
+ .flex_col()
+ .gap(space::MD)
+ .child(widgets::eyebrow("Selection", cx));
+ let target = app.action_target().unwrap_or_else(|| app.crumbs.clone());
+ let Some(node) = app.node_at(&target) else {
+ return section.child(
+ div()
+ .text_color(theme.secondary)
+ .child("Point at a tile or select one with the arrows"),
+ );
};
let path = app.path_at(&target);
- let parent = target[..target.len().saturating_sub(1)].to_vec();
- let parent_value = app.node_at(&parent).map_or(0, |node| node.bytes);
let root_value = app.tree().map_or(0, |tree| tree.bytes);
let marked = path.as_deref().is_some_and(|path| app.marks.contains(path));
let covered_by = marks_ancestor(app, path.as_deref());
let is_current_root = target == app.crumbs;
+ let highlight = palette::highlight(theme);
- // Identity: the lane that shrinks, so a long path truncates instead of
- // pushing the actions off the edge.
let identity = div()
.flex()
- .flex_row()
- .items_center()
- .gap(space::SM)
- .flex_1()
+ .flex_col()
+ .gap(space::XS)
.min_w_0()
- .child(
- gpui_omarchy::icon(if node.is_dir() {
- gpui_omarchy::IconName::FolderOpen
- } else {
- gpui_omarchy::IconName::File
- })
- .size(icon::MD)
- .flex_shrink_0()
- .text_color(theme.secondary),
- )
.child(
div()
.flex()
- .flex_col()
- .gap(space::XXS)
+ .flex_row()
+ .items_center()
+ .gap(space::SM)
.min_w_0()
- .overflow_hidden()
.child(
div()
- .text_size(text::TITLE)
- .font_weight(FontWeight::SEMIBOLD)
- .text_color(theme.bright)
- .whitespace_nowrap()
- .child(node.name.to_string()),
+ .flex_shrink_0()
+ .w(space::XS)
+ .h(text::HEADING)
+ .bg(palette::category_accent(theme, node.category)),
)
.child(
div()
- .text_size(text::CAPTION)
- .text_color(theme.secondary)
+ .text_size(text::HEADING)
+ .font_weight(FontWeight::BOLD)
+ .text_color(theme.bright)
.whitespace_nowrap()
- .child(path.as_deref().map_or_else(
- String::new,
- |path| {
- crate::marks::display_path(
- path,
- app.home.as_deref(),
- )
- },
- )),
+ .overflow_hidden()
+ .text_ellipsis()
+ .child(node.name.to_string()),
),
+ )
+ .child(
+ div()
+ .text_size(text::CAPTION)
+ .text_color(theme.secondary)
+ .whitespace_nowrap()
+ .overflow_hidden()
+ .text_ellipsis()
+ .child(path.as_deref().map_or_else(String::new, |path| {
+ crate::marks::display_path(path, app.home.as_deref())
+ })),
);
- // Badges stay neutral unless the state is a real deletion or warning.
- let mut badges = div().flex().flex_row().gap(space::XS).flex_shrink_0();
- if node.name.starts_with('.') {
- badges = badges.child(widgets::chip("Hidden", theme.secondary, cx));
- }
- if marked {
- badges = badges.child(widgets::chip("Marked", theme.danger, cx));
- }
- if let Some(ancestor) = &covered_by {
- badges = badges.child(widgets::chip(
- format!("Inside marked {ancestor}"),
- theme.secondary,
+ let (number, unit) = match app.options.metric {
+ Metric::Bytes => widgets::split_size(&human_bytes(node.bytes)),
+ Metric::Files => (widgets::human_count(node.files), "files".into()),
+ };
+ let share = node.bytes as f32 / root_value.max(1) as f32;
+ let measure = div()
+ .flex()
+ .flex_col()
+ .gap(space::SM)
+ .child(widgets::measure(
+ number,
+ text::DISPLAY,
+ unit,
+ text::TITLE,
cx,
- ));
- }
- if node.read_error {
- badges = badges.child(widgets::chip("Unreadable", theme.warning, cx));
- }
+ ))
+ .child(widgets::bar(share, highlight, cx));
- // Measure: the size, then its share, then what it holds.
- let measure = div()
+ let fourth = if node.is_dir()
+ && let Some(path) = &path
+ && crate::git::is_checkout(path)
+ {
+ let value = match app.git.get(path) {
+ Some(Some(state)) => state.summary(),
+ Some(None) => "not readable".to_string(),
+ None => "asking\u{2026}".to_string(),
+ };
+ let clean =
+ matches!(app.git.get(path), Some(Some(state)) if state.is_clean());
+ widgets::figure(
+ "Git",
+ value,
+ if clean { theme.success } else { theme.bright },
+ cx,
+ )
+ } else {
+ let kind = node.reclaim.map_or_else(
+ || node.category.label().to_string(),
+ |reason| {
+ format!("{} \u{00b7} {}", node.category.label(), reason.label())
+ },
+ );
+ widgets::figure("Kind", kind, theme.bright, cx)
+ };
+ let grid = div()
.flex()
.flex_col()
- .gap(space::XXS)
- .flex_shrink_0()
- .items_end()
+ .gap(space::MD)
.child(
div()
- .text_size(text::TITLE)
- .font_weight(FontWeight::BOLD)
- .text_color(theme.bright)
- .child(widgets::value(node, app.options.metric)),
+ .flex()
+ .flex_row()
+ .child(div().flex_1().min_w_0().child(widgets::figure(
+ "Of scan",
+ widgets::percent(node.bytes, root_value),
+ theme.bright,
+ cx,
+ )))
+ .child(div().flex_1().min_w_0().child(widgets::figure(
+ "Files",
+ widgets::human_count(node.files),
+ theme.bright,
+ cx,
+ ))),
)
.child(
div()
- .text_size(text::CAPTION)
- .text_color(theme.secondary)
- .child(format!(
- "{} of its directory \u{00b7} {} of the scan \u{00b7} {} files",
- widgets::percent(node.bytes, parent_value),
- widgets::percent(node.bytes, root_value),
- widgets::human_count(node.files),
- )),
+ .flex()
+ .flex_row()
+ .child(div().flex_1().min_w_0().child(widgets::figure(
+ "Last write",
+ widgets::ago(crate::state::now_seconds(), node.modified),
+ theme.bright,
+ cx,
+ )))
+ .child(div().flex_1().min_w_0().child(fourth)),
);
- // One primary, only where it is what Enter does. Marking is reversible,
- // so it is framed but neither primary nor danger. Both hand the keyboard
- // back to the treemap.
- let mut actions = div().flex().flex_row().gap(space::SM).flex_shrink_0();
- if !is_current_root && node.is_dir() {
- let crumbs = target.clone();
- actions = actions.child(
- button("open", "Open", ButtonVariant::Primary, cx)
- .tab_stop(false)
- .on_click(cx.listener(move |this, _, window, cx| {
- this.go_to(crumbs.clone(), cx);
- window.focus(&this.focus, cx);
- })),
- );
+ // Only states that change the decision earn a badge.
+ let mut chips = Vec::new();
+ if marked {
+ chips.push(widgets::chip("Marked", theme.danger, cx));
+ }
+ if let Some(ancestor) = &covered_by {
+ chips.push(widgets::chip(
+ format!("Inside marked {ancestor}"),
+ theme.secondary,
+ cx,
+ ));
}
+ if node.read_error {
+ chips.push(widgets::chip("Partly unreadable", theme.warning, cx));
+ }
+ let badges = (!chips.is_empty()).then(|| {
+ div()
+ .flex()
+ .flex_row()
+ .flex_wrap()
+ .gap(space::XS)
+ .children(chips)
+ });
+
+ // Open is secondary: Enter already does it. Marking is the action this
+ // tool exists for, so it takes the highlight.
+ let mut actions = div().flex().flex_row().gap(space::SM);
if !is_current_root {
+ if node.is_dir() {
+ let crumbs = target.clone();
+ actions = actions.child(
+ button("open", "Open", ButtonVariant::Outline, cx)
+ .tab_stop(false)
+ .flex_1()
+ .justify_center()
+ .on_click(cx.listener(move |this, _, window, cx| {
+ this.go_to(crumbs.clone(), cx);
+ window.focus(&this.focus, cx);
+ })),
+ );
+ }
let crumbs = target;
- actions = actions.child(
- button(
- "mark",
- if marked { "Unmark" } else { "Mark for removal" },
- ButtonVariant::Outline,
- cx,
- )
- .tab_stop(false)
- .on_click(cx.listener(move |this, _, window, cx| {
- this.toggle_mark(&crumbs.clone(), cx);
- window.focus(&this.focus, cx);
- })),
- );
+ let mark = button(
+ "mark",
+ if marked { "Unmark" } else { "Mark for removal" },
+ ButtonVariant::Primary,
+ cx,
+ )
+ .tab_stop(false)
+ .flex_1()
+ .justify_center()
+ .on_click(cx.listener(move |this, _, window, cx| {
+ this.toggle_mark(&crumbs.clone(), cx);
+ window.focus(&this.focus, cx);
+ }));
+ actions = actions.child(if marked {
+ mark
+ } else {
+ let on = palette::on_highlight(theme);
+ mark.bg(highlight)
+ .border_color(highlight)
+ .text_color(on)
+ .font_weight(FontWeight::SEMIBOLD)
+ .hover(move |style| {
+ style.bg(highlight.opacity(0.85)).border_color(highlight)
+ })
+ });
}
- row.child(identity)
- .child(badges)
+ section
+ .child(identity)
.child(measure)
+ .child(grid)
+ .children(badges)
.child(actions)
}
-fn short_name(path: &std::path::Path) -> String {
- path.file_name().map_or_else(
- || path.display().to_string(),
- |name| name.to_string_lossy().into_owned(),
- )
+/// The biggest things that could plausibly go, with their total.
+fn worth_section(
+ app: &Disktree,
+ theme: &Theme,
+ cx: &Context<'_, Disktree>,
+) -> Div {
+ let total: u64 = app.insights.iter().map(|candidate| candidate.bytes).sum();
+ let largest = app.insights.first().map_or(1, |candidate| candidate.bytes);
+ let highlight = palette::highlight(theme);
+ let mut section = div().flex().flex_col().gap(space::XS).child(
+ div()
+ .flex()
+ .flex_row()
+ .items_center()
+ .justify_between()
+ .pb(space::XS)
+ .child(widgets::eyebrow("Worth a look", cx))
+ .when(total > 0, |this| {
+ this.child(
+ div()
+ .text_size(text::CAPTION)
+ .text_color(highlight)
+ .child(human_bytes(total)),
+ )
+ }),
+ );
+ if app.insights.is_empty() {
+ return section.child(
+ div()
+ .text_size(text::CAPTION)
+ .text_color(theme.secondary)
+ .child(if app.tree().is_some() {
+ "Nothing obviously disposable"
+ } else {
+ "Waiting for the scan"
+ }),
+ );
+ }
+ let selected = app.action_target();
+ for (index, candidate) in app.insights.iter().enumerate() {
+ let Some(node) = app.node_at(&candidate.crumbs) else {
+ continue;
+ };
+ let (title, detail) = insight_text(app, candidate);
+ let accent = palette::category_accent(theme, node.category);
+ let active = selected.as_deref() == Some(candidate.crumbs.as_slice());
+ let crumbs = candidate.crumbs.clone();
+ section = section.child(
+ div()
+ .id(ElementId::Name(format!("insight-{index}").into()))
+ .flex()
+ .flex_row()
+ .items_center()
+ .gap(space::SM)
+ .px(space::SM)
+ .py(space::XS)
+ .when(active, |this| this.bg(theme.hover_fill()))
+ .hover(|style| style.bg(theme.hover_fill()))
+ .on_click(cx.listener(move |this, _, window, cx| {
+ this.reveal(crumbs.clone(), cx);
+ window.focus(&this.focus, cx);
+ }))
+ .child(div().flex_shrink_0().w(px(2.)).h(space::XL).bg(accent))
+ .child(
+ div()
+ .flex()
+ .flex_col()
+ .flex_1()
+ .min_w_0()
+ .child(
+ div()
+ .text_size(text::BODY)
+ .text_color(theme.bright)
+ .whitespace_nowrap()
+ .overflow_hidden()
+ .text_ellipsis()
+ .child(title),
+ )
+ .child(
+ div()
+ .text_size(text::CAPTION)
+ .text_color(theme.secondary.opacity(0.8))
+ .whitespace_nowrap()
+ .overflow_hidden()
+ .text_ellipsis()
+ .child(detail),
+ ),
+ )
+ .child(
+ div()
+ .flex()
+ .flex_col()
+ .items_end()
+ .gap(space::XS)
+ .flex_shrink_0()
+ .w(size::ROW_BAR)
+ .child(
+ div()
+ .text_size(text::BODY)
+ .text_color(theme.bright)
+ .child(human_bytes(candidate.bytes)),
+ )
+ .child(widgets::bar(
+ candidate.bytes as f32 / largest.max(1) as f32,
+ accent,
+ cx,
+ )),
+ ),
+ );
+ }
+ section
}
-/// The marked ancestor of a path, if any, so the UI can explain nesting.
-fn marks_ancestor(
- app: &Disktree,
- path: Option<&std::path::Path>,
-) -> Option<String> {
- let path = path?;
- app.marks
- .items()
- .iter()
- .filter(|item| item.path != path && path.starts_with(&item.path))
- .map(|item| short_name(&item.path))
- .next()
+/// A finding's title, as the last two parts of its path, and why it is on
+/// the list.
+fn insight_text(app: &Disktree, candidate: &Candidate) -> (String, String) {
+ let tree = app.tree();
+ let chain = tree
+ .map_or_else(Vec::new, |tree| tree.resolve_chain(&candidate.crumbs));
+ let names: Vec<&str> =
+ chain.iter().skip(1).map(|node| &*node.name).collect();
+ let tail = names[names.len().saturating_sub(2)..].join("/");
+ match &candidate.finding {
+ Finding::Reclaimable(reason) => (tail, reason.label().to_string()),
+ Finding::Worktrees { count, oldest_days } => (
+ tail,
+ format!(
+ "{count} worktree{} \u{00b7} oldest {oldest_days} d",
+ if *count == 1 { "" } else { "s" }
+ ),
+ ),
+ Finding::StaleExperiments { count } => (
+ format!("{tail} > {STALE_DAYS} days"),
+ format!(
+ "{count} experiment{} untouched",
+ if *count == 1 { "" } else { "s" }
+ ),
+ ),
+ }
}
-/// The volume and the marks: what was found, what it will free, and the
-/// command that acts on the marks, next to the marks it acts on.
-fn status_bar(
+/// What is queued for removal, each with a way off the list.
+fn marked_section(
app: &Disktree,
theme: &Theme,
- show_totals: bool,
cx: &Context<'_, Disktree>,
) -> Div {
let plan = app.plan();
- let reclaiming = plan.bytes();
- let marked = app.marks.len();
- let mut row = div()
+ let count = app.marks.len();
+ let header = div()
.flex()
.flex_row()
.items_center()
- .gap(space::LG)
- .px(space::LG)
- .py(space::SM)
- .border_t_1()
- .border_color(theme.divider())
- .bg(theme.surface);
-
- row =
- row.child(div().w(size::SPACE_METER).flex_shrink_0().when_some(
- app.space,
- |this, space| {
- this.child(widgets::space_meter(space, reclaiming, cx))
+ .justify_between()
+ .child(widgets::eyebrow(
+ if count == 0 {
+ "Marked".to_string()
+ } else {
+ format!("Marked · {count}")
},
- ));
+ cx,
+ ))
+ .when(count > 0, |this| {
+ this.child(
+ div()
+ .text_size(text::CAPTION)
+ .text_color(theme.secondary)
+ .child(human_bytes(plan.bytes())),
+ )
+ });
+ let mut section = div().flex().flex_col().gap(space::XS).child(header);
+ if count == 0 {
+ return section.child(
+ div()
+ .text_size(text::CAPTION)
+ .text_color(theme.secondary)
+ .child("Space marks the tile you point at"),
+ );
+ }
+ for (index, item) in app.marks.items().iter().take(MARKED_ROWS).enumerate()
+ {
+ let category = app
+ .crumbs_for_path(&item.path)
+ .and_then(|crumbs| app.node_at(&crumbs))
+ .map_or(Category::Other, |node| node.category);
+ let path = item.path.clone();
+ section = section.child(
+ div()
+ .flex()
+ .flex_row()
+ .items_center()
+ .gap(space::SM)
+ .text_size(text::CAPTION)
+ .child(
+ div()
+ .flex_shrink_0()
+ .size(space::SM)
+ .rounded_full()
+ .bg(palette::category_accent(theme, category)),
+ )
+ .child(
+ div()
+ .flex_1()
+ .min_w_0()
+ .text_color(theme.foreground)
+ .whitespace_nowrap()
+ .overflow_hidden()
+ .text_ellipsis()
+ .child(crate::marks::display_path(
+ &item.path,
+ app.home.as_deref(),
+ )),
+ )
+ .child(
+ div()
+ .flex_shrink_0()
+ .text_color(theme.secondary)
+ .child(human_bytes(item.bytes)),
+ )
+ .child(
+ div()
+ .id(ElementId::Name(format!("unmark-{index}").into()))
+ .flex_shrink_0()
+ .px(space::XS)
+ .text_color(theme.secondary.opacity(0.7))
+ .hover(|style| style.text_color(theme.danger))
+ .on_click(cx.listener(move |this, _, window, cx| {
+ this.unmark(&path, cx);
+ window.focus(&this.focus, cx);
+ }))
+ .child("\u{00d7}"),
+ ),
+ );
+ }
+ if count > MARKED_ROWS {
+ section = section.child(
+ div()
+ .text_size(text::CAPTION)
+ .text_color(theme.secondary)
+ .child(format!(
+ "+{} more on the review screen",
+ count - MARKED_ROWS
+ )),
+ );
+ }
+ if !plan.covered.is_empty() || !plan.blocked.is_empty() {
+ section = section.child(
+ div()
+ .text_size(text::CAPTION)
+ .text_color(theme.secondary)
+ .child(format!(
+ "{} nested \u{00b7} {} kept back",
+ plan.covered.len(),
+ plan.blocked.len()
+ )),
+ );
+ }
+ section
+}
+
+/// Marked rows the panel lists before pointing at the review screen.
+const MARKED_ROWS: usize = 6;
- row = row.child(
+/// The last thing that happened, or a scan error, above the disk.
+fn notice_line(app: &Disktree, theme: &Theme, cx: &App) -> Option<Div> {
+ let (message, color) = if let Some(error) = &app.scan_error {
+ (error.clone(), theme.danger)
+ } else {
+ let (message, status) = app.notice.as_ref()?;
+ (message.clone(), widgets::alert_color(*status, cx))
+ };
+ Some(
+ div()
+ .px(space::SM)
+ .py(space::XS)
+ .border_1()
+ .border_color(color.opacity(0.5))
+ .text_color(color)
+ .text_size(text::CAPTION)
+ .child(message),
+ )
+}
+
+/// Free space on the volume now, and after the marks go.
+fn disk_section(
+ app: &Disktree,
+ theme: &Theme,
+ cx: &Context<'_, Disktree>,
+) -> Div {
+ let device = app.device.clone().unwrap_or_default();
+ let mut section = div().flex().flex_col().gap(space::SM).child(
div()
.flex()
- .flex_col()
- .gap(space::XXS)
- .child(widgets::stat_colored(
- "Marked for removal",
- if marked == 0 {
- "Nothing marked".to_string()
- } else {
- format!(
- "{marked} items \u{00b7} {}",
- human_bytes(reclaiming)
- )
- },
- if marked > 0 {
- theme.danger
- } else {
- theme.secondary
- },
- cx,
- ))
+ .flex_row()
+ .gap(space::SM)
+ .child(widgets::eyebrow("Disk", cx))
.child(
div()
.text_size(text::CAPTION)
- .text_color(theme.secondary)
- .child(if marked == 0 {
- "Space marks the tile you point at".to_string()
- } else if !plan.covered.is_empty()
- || !plan.blocked.is_empty()
- {
- format!(
- "{} nested \u{00b7} {} kept back",
- plan.covered.len(),
- plan.blocked.len()
- )
- } else if app.removal_mode == RemovalMode::Trash {
- "Will move to the trash".to_string()
- } else {
- "Will delete permanently".to_string()
- }),
+ .text_color(theme.secondary.opacity(0.6))
+ .child(device),
),
);
-
- if marked > 0 {
- row = row.child(
- button("review", "Review\u{2026}", ButtonVariant::Secondary, cx)
- .tab_stop(false)
- .on_click(cx.listener(|this, _, window, cx| {
- this.screen = Screen::Review;
- cx.notify();
- window.focus(&this.focus, cx);
- })),
- );
- }
-
- row = row.child(div().flex_1());
-
- if app.scan.is_some() {
- let progress = &app.progress;
- row = row.child(
+ let Some(space_info) = app.space else {
+ return section.child(
div()
- .flex()
- .flex_col()
- .gap(space::XS)
- .w(size::SCAN_METER)
- .child(
+ .text_size(text::CAPTION)
+ .text_color(theme.secondary)
+ .child("Free space is not available here"),
+ );
+ };
+ let reclaiming = app.plan().bytes();
+ let after = space_info.after_removing(reclaiming);
+ let highlight = palette::highlight(theme);
+ let (number, unit) =
+ widgets::split_size(&human_bytes(space_info.available));
+ let total = space_info.total.max(1) as f32;
+ let used_now = (space_info.used() as f32 / total).clamp(0.0, 1.0);
+ let used_after = (after.used() as f32 / total).clamp(0.0, used_now);
+
+ section = section.child(
+ div()
+ .flex()
+ .flex_row()
+ .items_end()
+ .child(widgets::measure(
+ number,
+ text::FIGURE,
+ format!("{unit} free"),
+ text::BODY,
+ cx,
+ ))
+ .child(div().flex_1())
+ .when(reclaiming > 0, |this| {
+ // Lifted like the unit beside the figure, onto its baseline.
+ this.child(
div()
- .text_size(text::CAPTION)
- .text_color(theme.secondary)
+ .text_size(text::TITLE)
+ .line_height(text::TITLE)
+ .pb(gpui_kit::Rems(
+ (text::FIGURE.0 - text::TITLE.0) * 0.2,
+ ))
+ .text_color(highlight)
.child(format!(
- "Scanning \u{00b7} {} files \u{00b7} {}",
- widgets::human_count(progress.files),
- human_bytes(progress.bytes)
+ "→ {} free",
+ human_bytes(after.available)
)),
)
- .child(widgets::meter_row(
- "",
- "",
- progress_estimate(progress.files),
- theme.accent,
- cx,
- )),
- );
- } else {
- if show_totals && let Some(tree) = app.tree() {
- row = row.child(widgets::stat(
- "Scanned",
- human_bytes(tree.bytes),
- cx,
- ));
- }
- row = row.child(widgets::stat(
- "Entries read",
- widgets::human_count(app.progress.files),
- cx,
- ));
- if app.progress.errors > 0 {
- row = row.child(widgets::stat_colored(
- "Unreadable",
- format!("{} paths", app.progress.errors),
- theme.warning,
- cx,
- ));
- }
- }
-
- if let Some((message, status)) = &app.notice {
- row = row.child(
+ }),
+ );
+ // Used space from the left; the slice the marks give back is the hatched
+ // end of it, so the gap it leaves is exactly what comes back.
+ section = section.child(
+ div()
+ .relative()
+ .w_full()
+ .h(space::SM)
+ .bg(theme.foreground.opacity(0.08))
+ .child(
+ div()
+ .absolute()
+ .left_0()
+ .top_0()
+ .h_full()
+ .w(relative(used_after))
+ .bg(theme.foreground.opacity(0.28)),
+ )
+ .child(
+ div()
+ .absolute()
+ .left(relative(used_after))
+ .top_0()
+ .h_full()
+ .w(relative(used_now - used_after))
+ .bg(highlight.opacity(0.25))
+ .child(
+ div()
+ .size_full()
+ .bg(pattern_slash(highlight, 1.0, 3.0)),
+ ),
+ ),
+ );
+ section
+ .child(
div()
.flex()
.flex_row()
- .items_center()
- .gap(space::SM)
- .px(space::SM)
- .py(space::XS)
- .border_1()
- .border_color(widgets::alert_color(*status, cx).opacity(0.5))
- .text_color(widgets::alert_color(*status, cx))
- .text_size(text::CAPTION)
- .child(message.clone()),
- );
- }
- if let Some(error) = &app.scan_error {
- row = row.child(
- div()
- .text_color(theme.danger)
.text_size(text::CAPTION)
- .child(error.clone()),
- );
- }
-
- row
+ .text_color(theme.secondary)
+ .child(format!("{} used", human_bytes(space_info.used())))
+ .child(div().flex_1())
+ .child(format!("{} total", human_bytes(space_info.total))),
+ )
+ .children(
+ (!app.marks.is_empty())
+ .then(|| review_button(app, reclaiming, theme, cx)),
+ )
}
-/// A scan has no total to measure against, so the meter shows the work done
-/// rather than pretending to know how far along it is.
-fn progress_estimate(files: u64) -> f32 {
- if files == 0 {
- 0.06
- } else {
- // Asymptotic: the bar keeps moving while the walk continues.
- let scaled = files as f32 / (files as f32 + 20_000.0);
- (0.1 + scaled * 0.85).min(0.99)
- }
+/// The way to the review screen, where the saving is: it says what is
+/// marked and what it frees, so the number that matters is the thing to
+/// press. Outlined in the highlight, so it does not compete with the filled
+/// "Mark for removal" above it.
+fn review_button(
+ app: &Disktree,
+ reclaiming: u64,
+ theme: &Theme,
+ cx: &Context<'_, Disktree>,
+) -> impl IntoElement {
+ let highlight = palette::highlight(theme);
+ let count = app.marks.len();
+ div()
+ .id("review")
+ .flex()
+ .flex_row()
+ .items_center()
+ .gap(space::SM)
+ .mt(space::XS)
+ .px(space::MD)
+ .py(space::SM)
+ .border_1()
+ .border_color(highlight)
+ .bg(highlight.opacity(0.1))
+ .hover(move |style| style.bg(highlight.opacity(0.18)))
+ .active(move |style| style.bg(highlight.opacity(0.26)))
+ .on_click(cx.listener(|this, _, window, cx| {
+ this.screen = Screen::Review;
+ cx.notify();
+ window.focus(&this.focus, cx);
+ }))
+ .child(
+ div()
+ .flex_1()
+ .min_w_0()
+ .text_size(text::BODY)
+ .text_color(highlight)
+ .whitespace_nowrap()
+ .overflow_hidden()
+ .text_ellipsis()
+ .child(format!(
+ "Review {count} marked · frees {}…",
+ human_bytes(reclaiming)
+ )),
+ )
+ .child(gpui_omarchy::keycap("c", cx))
}
-fn hint_bar(app: &Disktree, theme: &Theme, cx: &App) -> Div {
- // Most useful first, so a narrow window clips the least useful. The key
- // to every other key is pinned to the trailing edge and never clipped.
+// ── key bar ─────────────────────────────────────────────────────────────
+
+/// The keys, quietly: outlines and light labels, there when needed. The key
+/// to every other key and the scan's own numbers hold the trailing edge.
+fn key_bar(app: &Disktree, theme: &Theme, cx: &App) -> Div {
+ // Most useful first, so a narrow window clips the least useful.
let hints: [(&str, &str); 10] = [
("space", "mark"),
("enter", "open"),
("\u{232b}", "up"),
("c", "review"),
- ("\u{2190}\u{2191}\u{2193}\u{2192}", "move"),
+ ("hjkl", "move"),
("/", "find"),
- ("scroll", "zoom"),
- ("[ ]", "levels"),
+ ("[ ]", "depth"),
+ ("t", "mode"),
("0", "reset"),
("r", "rescan"),
];
@@ -903,12 +1417,10 @@ fn hint_bar(app: &Disktree, theme: &Theme, cx: &App) -> Div {
.items_center()
.gap(space::LG)
.px(space::LG)
- .py(space::SM)
+ .py(space::XS)
.border_t_1()
.border_color(theme.divider())
- .bg(theme.background)
.child(lane);
- // The magnification only earns space when it is not the default.
if (app.view.scale - 1.0).abs() > 0.01 {
row = row.child(
div()
@@ -918,7 +1430,172 @@ fn hint_bar(app: &Disktree, theme: &Theme, cx: &App) -> Div {
.child(format!("{:.1}\u{00d7}", app.view.scale)),
);
}
+ let scan = if app.scan.is_some() {
+ format!(
+ "scanning \u{00b7} {} entries \u{00b7} {}",
+ widgets::human_count(app.progress.files),
+ human_bytes(app.progress.bytes)
+ )
+ } else {
+ let elapsed = app.scan_elapsed.map_or_else(String::new, |time| {
+ format!(" \u{00b7} {:.1} s", time.as_secs_f32())
+ });
+ format!(
+ "scan {} entries{elapsed}",
+ widgets::human_count(app.progress.files)
+ )
+ };
row.child(widgets::hint("?", "all keys", cx).flex_shrink_0())
+ .child(
+ div()
+ .flex_shrink_0()
+ .text_size(text::CAPTION)
+ .text_color(theme.secondary.opacity(0.7))
+ .child(scan),
+ )
+}
+
+/// What the viewport shows while the first scan is running.
+fn scanning_panel(app: &Disktree, theme: &Theme, cx: &gpui_kit::App) -> Div {
+ let progress = &app.progress;
+ let mut panel = div()
+ .flex()
+ .flex_col()
+ .flex_1()
+ .min_h_0()
+ .items_center()
+ .justify_center()
+ .gap(space::LG)
+ .bg(theme.inset)
+ .child(
+ gpui_omarchy::icon(gpui_omarchy::IconName::Loader)
+ .size(icon::LG)
+ .text_color(theme.accent),
+ )
+ .child(
+ div()
+ .text_size(text::TITLE)
+ .font_weight(FontWeight::SEMIBOLD)
+ .text_color(theme.bright)
+ .child(format!("Reading {}", widgets::display_root(app))),
+ )
+ .child(
+ div()
+ .flex()
+ .flex_row()
+ .gap(space::XL)
+ .child(widgets::stat(
+ "files",
+ widgets::human_count(progress.files),
+ cx,
+ ))
+ .child(widgets::stat("directories", widgets::human_count(progress.dirs), cx))
+ .child(widgets::stat("measured", human_bytes(progress.bytes), cx))
+ .child(widgets::stat_colored(
+ "unreadable",
+ widgets::human_count(progress.errors),
+ if progress.errors > 0 {
+ theme.warning
+ } else {
+ theme.secondary
+ },
+ cx,
+ )),
+ )
+ .child(
+ div()
+ .w(size::SCANNING_METER)
+ .child(widgets::meter_row(
+ "",
+ "",
+ progress_estimate(progress.files),
+ theme.accent,
+ cx,
+ )),
+ )
+ .child(
+ div()
+ .text_size(text::BODY)
+ .text_color(theme.secondary)
+ .child("Marking, zooming and the free-space meter all work as soon as it lands."),
+ );
+
+ if let Some(error) = &app.scan_error {
+ panel = panel.child(
+ div()
+ .max_w(size::HELP)
+ .p(space::MD)
+ .border_1()
+ .border_color(theme.danger)
+ .text_color(theme.danger)
+ .text_size(text::BODY)
+ .child(error.clone()),
+ );
+ }
+ panel
+}
+
+fn find_field(app: &Disktree, theme: &Theme) -> Div {
+ div()
+ .flex()
+ .flex_row()
+ .items_center()
+ .gap(space::SM)
+ .px(space::SM)
+ .py(space::XS)
+ .border_1()
+ .border_color(if app.find_open {
+ theme.accent
+ } else {
+ theme.control_border()
+ })
+ .bg(theme.normal_fill())
+ .text_size(text::BODY)
+ .child(
+ gpui_omarchy::icon(gpui_omarchy::IconName::Search)
+ .size(icon::SM)
+ .text_color(theme.secondary),
+ )
+ .child(if app.find.is_empty() {
+ div()
+ .text_color(theme.secondary.opacity(0.7))
+ .child("Find by name")
+ } else {
+ div().text_color(theme.bright).child(app.find.clone())
+ })
+}
+
+fn short_name(path: &std::path::Path) -> String {
+ path.file_name().map_or_else(
+ || path.display().to_string(),
+ |name| name.to_string_lossy().into_owned(),
+ )
+}
+
+/// The marked ancestor of a path, if any, so the UI can explain nesting.
+fn marks_ancestor(
+ app: &Disktree,
+ path: Option<&std::path::Path>,
+) -> Option<String> {
+ let path = path?;
+ app.marks
+ .items()
+ .iter()
+ .filter(|item| item.path != path && path.starts_with(&item.path))
+ .map(|item| short_name(&item.path))
+ .next()
+}
+
+/// A scan has no total to measure against, so the meter shows the work done
+/// rather than pretending to know how far along it is.
+fn progress_estimate(files: u64) -> f32 {
+ if files == 0 {
+ 0.06
+ } else {
+ // Asymptotic: the bar keeps moving while the walk continues.
+ let scaled = files as f32 / (files as f32 + 20_000.0);
+ (0.1 + scaled * 0.85).min(0.99)
+ }
}
// ── review ──────────────────────────────────────────────────────────────
@@ -1803,7 +2480,7 @@ fn help_overlay(app: &Disktree, cx: &gpui_kit::App) -> Div {
let theme = cx.omarchy();
// Sentence case, and the tile a key acts on is always the one under the
// pointer if the pointer moved last, else the keyboard selection.
- let rows: [(&str, &str); 23] = [
+ let rows: [(&str, &str); 24] = [
("space / x", "Mark or unmark the tile you point at"),
("ctrl-click", "Mark without moving the selection"),
("enter", "Open that directory, at any depth"),
@@ -1820,8 +2497,9 @@ fn help_overlay(app: &Disktree, cx: &gpui_kit::App) -> Div {
("ctrl = / - / 0", "Interface zoom"),
("/", "Find an entry by name"),
("c", "Review the marked list"),
- ("t", "Rank by size or by file count"),
+ ("t", "Size, files or age: what areas and colours say"),
("r", "Scan again from the same root"),
+ ("g", "Scan the home directory or the whole disk"),
("d", "Disk usage or apparent size"),
("i", "Include or skip hidden entries"),
("p", "Show or hide the selection line"),
diff --git a/crates/disktree-app/src/widgets.rs b/crates/disktree-app/src/widgets.rs
index 5849eb5..3ba4137 100644
--- a/crates/disktree-app/src/widgets.rs
+++ b/crates/disktree-app/src/widgets.rs
@@ -35,14 +35,6 @@ pub fn short_value(node: &Node, metric: Metric) -> String {
}
}
-/// The value to show in tables and headers.
-pub fn value(node: &Node, metric: Metric) -> String {
- match metric {
- Metric::Bytes => human_bytes(node.bytes),
- Metric::Files => format!("{} files", human_count(node.files)),
- }
-}
-
/// A dim label above a number, for the header strip.
pub fn stat(
label: impl Into<SharedString>,
@@ -345,3 +337,174 @@ pub fn crumb(
})
.child(label.into())
}
+
+/// A small uppercase label over a region or a figure.
+pub fn eyebrow(label: impl Into<SharedString>, cx: &App) -> Div {
+ let theme = cx.omarchy();
+ let label: SharedString = label.into();
+ div()
+ .text_size(text::CAPTION)
+ .text_color(theme.secondary.opacity(0.7))
+ .whitespace_nowrap()
+ .child(SharedString::from(label.to_uppercase()))
+}
+
+/// An eyebrow over a value, for the top bar and the selection grid.
+pub fn figure(
+ label: impl Into<SharedString>,
+ value: impl Into<SharedString>,
+ color: Hsla,
+ cx: &App,
+) -> Div {
+ div()
+ .flex()
+ .flex_col()
+ .gap(space::XXS)
+ .min_w_0()
+ .child(eyebrow(label, cx))
+ .child(
+ div()
+ .text_size(text::TITLE)
+ .text_color(color)
+ .whitespace_nowrap()
+ .overflow_hidden()
+ .child(value.into()),
+ )
+}
+
+/// A size split into number and unit, so the number can be set large:
+/// `90.1 GiB` is `("90.1", "GiB")`.
+pub fn split_size(text: &str) -> (String, String) {
+ text.split_once(' ').map_or_else(
+ || (text.to_string(), String::new()),
+ |(number, unit)| (number.to_string(), unit.to_string()),
+ )
+}
+
+/// How long ago a Unix time was, in the unit a person would use.
+pub fn ago(now: i64, then: i64) -> String {
+ if then <= 0 {
+ return "unknown".to_string();
+ }
+ let seconds = (now - then).max(0);
+ let plural = |count: i64, unit: &str| {
+ if count == 1 {
+ format!("1 {unit} ago")
+ } else {
+ format!("{count} {unit}s ago")
+ }
+ };
+ match seconds {
+ 0..60 => "just now".to_string(),
+ 60..3_600 => plural(seconds / 60, "minute"),
+ 3_600..86_400 => plural(seconds / 3_600, "hour"),
+ 86_400..5_184_000 => plural(seconds / 86_400, "day"),
+ 5_184_000..63_072_000 => plural(seconds / 2_592_000, "month"),
+ _ => plural(seconds / 31_536_000, "year"),
+ }
+}
+
+/// A thin bar: `fraction` of a track, in `color`.
+pub fn bar(fraction: f32, color: Hsla, cx: &App) -> Div {
+ let theme = cx.omarchy();
+ div()
+ .relative()
+ .w_full()
+ .h(crate::ui::size::METER)
+ .bg(theme.foreground.opacity(0.08))
+ .child(
+ div()
+ .absolute()
+ .left_0()
+ .top_0()
+ .h_full()
+ .w(relative(fraction.clamp(0.0, 1.0)))
+ .bg(color),
+ )
+}
+
+/// A square of colour, for a legend or an identity.
+pub fn swatch(color: Hsla) -> Div {
+ div()
+ .flex_shrink_0()
+ .size(crate::ui::size::SWATCH)
+ .bg(color)
+}
+
+/// The hatch swatch that stands for reclaimable space in the legend.
+pub fn hatch_swatch(color: Hsla, ground: Hsla) -> Div {
+ div()
+ .flex_shrink_0()
+ .size(crate::ui::size::SWATCH)
+ .bg(ground)
+ .child(
+ div()
+ .size_full()
+ .bg(gpui_kit::pattern_slash(color, 1.0, 3.0)),
+ )
+}
+
+/// A large number followed by its small unit, sharing one baseline.
+///
+/// Flex baseline alignment does not line up text of different sizes here,
+/// so both are set on bottom-aligned boxes exactly one line tall, and the
+/// unit is lifted by the difference in their descents: a font's descent is
+/// close to a fifth of its size.
+pub fn measure(
+ number: impl Into<SharedString>,
+ number_size: gpui_kit::Rems,
+ unit: impl Into<SharedString>,
+ unit_size: gpui_kit::Rems,
+ cx: &App,
+) -> Div {
+ let theme = cx.omarchy();
+ let lift = gpui_kit::Rems((number_size.0 - unit_size.0) * DESCENT);
+ div()
+ .flex()
+ .flex_row()
+ .items_end()
+ .gap(space::SM)
+ .child(
+ div()
+ .text_size(number_size)
+ .line_height(number_size)
+ .font_weight(FontWeight::BOLD)
+ .text_color(theme.bright)
+ .child(number.into()),
+ )
+ .child(
+ div()
+ .text_size(unit_size)
+ .line_height(unit_size)
+ .pb(lift)
+ .text_color(theme.secondary)
+ .whitespace_nowrap()
+ .child(unit.into()),
+ )
+}
+
+/// A font's descent as a share of its size, for lining up baselines.
+const DESCENT: f32 = 0.2;
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn ages_read_in_the_unit_a_person_would_use() {
+ let now = 1_800_000_000;
+ assert_eq!(ago(now, now - 5), "just now");
+ assert_eq!(ago(now, now - 120), "2 minutes ago");
+ assert_eq!(ago(now, now - 3_600), "1 hour ago");
+ assert_eq!(ago(now, now - 19 * 86_400), "19 days ago");
+ assert_eq!(ago(now, now - 90 * 86_400), "3 months ago");
+ assert_eq!(ago(now, now - 800 * 86_400), "2 years ago");
+ assert_eq!(ago(now, 0), "unknown");
+ }
+
+ #[test]
+ fn sizes_split_into_number_and_unit() {
+ assert_eq!(split_size("90.1 GiB"), ("90.1".into(), "GiB".into()));
+ assert_eq!(split_size("0"), ("0".into(), String::new()));
+ }
+}