feat: fluid type for the gpu and cache cards

The big value moves to the right of the heading, on the same baseline,
so the card's width carries it instead of leaving the right half empty.
Type now scales to fill the cell: card.fit_unit measures the rows and
returns the largest size that fits the width, and the widget takes the
smaller of that and its height budget, shrinking only where a row would
collide.

2 files changed, 88 insertions, 33 deletions

diff --git a/widgets/cache.lua b/widgets/cache.lua
index 0209f1a..40025eb 100644
--- a/widgets/cache.lua
+++ b/widgets/cache.lua
@@ -14,32 +14,68 @@ local M = {}
 function M.draw(cr, rect, colors)
   local inner = card.card(cr, rect, colors)
   local function clamp(v, lo, hi) return math.max(lo, math.min(hi, v)) end
-  local label_size = clamp(inner.w * 0.036, 10, 16)
-  local big_size   = clamp(inner.w * 0.095, 22, 46)
-
-  card.font(cr, card.FONT_MONO, label_size, false)
-  card.rgba(cr, colors.label)
-  card.text(cr, inner.x, inner.y + label_size, 'CACHE')
+  -- Fluid type. One base size S drives every element. The height budget makes
+  -- the content fill the cell; the measured width fit pulls S down only where
+  -- the header or a row would overrun the card. A tall cell gets larger type
+  -- instead of empty space, and nothing collides.
+  local LABEL_F, ROW_F = 0.30, 0.32
 
   local c = data.du_parse(data.slurp(CACHE) or '')
   if not c then
+    local S = clamp(inner.h * 0.94 / (1.78 + 2 * 0.72), 10, 72)
+    S = math.min(S, card.fit_unit(cr, inner.w * 0.96, {
+      { { 'CACHE', card.FONT_MONO, LABEL_F } },
+      { { 'no cache data', card.FONT_UI, 0.36 } },
+      { { 'bin/cache-sample.sh', card.FONT_MONO, ROW_F } },
+    }, 100))
+    card.font(cr, card.FONT_MONO, S * LABEL_F, false)
     card.rgba(cr, colors.label)
-    card.font(cr, card.FONT_UI, label_size * 1.2, true)
-    card.text(cr, inner.x, inner.y + label_size * 3.4, 'no cache data')
-    card.font(cr, card.FONT_MONO, label_size, false)
-    card.text(cr, inner.x, inner.y + label_size * 5, 'bin/cache-sample.sh')
+    card.text(cr, inner.x, inner.y + S, 'CACHE')
+    card.font(cr, card.FONT_UI, S * 0.36, true)
+    card.text(cr, inner.x, inner.y + S + S * LABEL_F * 2.6, 'no cache data')
+    card.font(cr, card.FONT_MONO, S * ROW_F, false)
+    card.text(cr, inner.x, inner.y + S + S * LABEL_F * 2.6 + S * 0.72,
+      'bin/cache-sample.sh')
     return
   end
 
-  card.font(cr, card.FONT_HEAVY, big_size, false)
-  card.rgba(cr, colors.body)
-  card.text(cr, inner.x, inner.y + label_size + big_size, c.total.label)
+  local items = c.items or {}
+  local names = {}
+  for i, e in ipairs(items) do
+    local name = e.name
+    if #name > 18 then name = name:sub(1, 17) .. '\u{2026}' end
+    names[i] = name
+  end
 
-  local ey = inner.y + label_size + big_size + label_size * 2
-  local step = label_size * 2.6
+  local row_n = #items
+  local S_h = inner.h * 0.94 / (1.78 + row_n * 0.64)
+  local groups = {
+    { { 'CACHE', card.FONT_MONO, LABEL_F }, { c.total.label, card.FONT_HEAVY, 1.0 } },
+  }
+  for i = 1, row_n do
+    groups[#groups + 1] = { { names[i], card.FONT_MONO, ROW_F },
+                            { items[i].label, card.FONT_MONO, ROW_F } }
+  end
+  local S = clamp(math.min(S_h, card.fit_unit(cr, inner.w * 0.96, groups, 100)), 10, 72)
+  local label_size = S * LABEL_F
+  local row_size   = S * ROW_F
 
   card.font(cr, card.FONT_MONO, label_size, false)
-  for i, e in ipairs(c.items) do
+  card.rgba(cr, colors.label)
+  card.text(cr, inner.x, inner.y + S, 'CACHE')
+
+  -- The total shares the header line with the label, set on the same baseline
+  -- and right-aligned: the width carries the number instead of an otherwise
+  -- empty row beneath it.
+  card.font(cr, card.FONT_HEAVY, S, false)
+  card.rgba(cr, colors.body)
+  card.text_right(cr, inner.x + inner.w, inner.y + S, c.total.label)
+
+  local ey = inner.y + S + label_size * 2.6
+  local step = row_size * 2.0
+
+  card.font(cr, card.FONT_MONO, row_size, false)
+  for i, e in ipairs(items) do
     if ey + step > inner.y + inner.h then break end
     -- The biggest offender is the point of the card, so it carries colour:
     -- critical when it is over half the total, warning otherwise. The rest
@@ -50,10 +86,7 @@ function M.draw(cr, rect, colors)
       colour = share > 0.5 and colors.critical or colors.warning
     end
     card.rgba(cr, colors.label)
-    -- Long names are truncated rather than allowed to collide with the size.
-    local name = e.name
-    if #name > 18 then name = name:sub(1, 17) .. '\u{2026}' end
-    card.text(cr, inner.x, ey, name)
+    card.text(cr, inner.x, ey, names[i])
     card.rgba(cr, colour)
     card.text_right(cr, inner.x + inner.w, ey, e.label)
     ey = ey + step
diff --git a/widgets/gpu.lua b/widgets/gpu.lua
index 87e22f3..7933e3b 100644
--- a/widgets/gpu.lua
+++ b/widgets/gpu.lua
@@ -24,26 +24,48 @@ function M.draw(cr, rect, colors)
   local inner = card.card(cr, rect, colors)
   local function clamp(v, lo, hi) return math.max(lo, math.min(hi, v)) end
 
-  local label_size = clamp(inner.w * 0.030, 11, 18)
-  local big_size   = clamp(inner.w * 0.085, 26, 56)
-  local row_size   = clamp(inner.w * 0.030, 11, 17)
+  local pkg = data.sensor('xe', 'temp2_input')
+  local big_txt = pkg and string.format('%d\u{00B0}', pkg) or '--'
+
+  -- Fluid type. One base size S drives every element. The cell's height sets
+  -- how large the content grows; the measured width fit pulls S back down
+  -- only where the header or a row would overrun the card. So a tall cell
+  -- gets larger type instead of empty space, and nothing ever collides.
+  local LABEL_F, ROW_F = 0.32, 0.34
+  local row_n = #TEMPS + 1                            -- VRAM + FAN
+  local S_h = inner.h * 0.94 / (2.088 + row_n * 0.646)
+  local groups = {
+    { { 'GPU', card.FONT_MONO, LABEL_F }, { big_txt, card.FONT_HEAVY, 1.0 } },
+    { { 'ARC B580', card.FONT_MONO, LABEL_F } },
+  }
+  for _, t in ipairs(TEMPS) do
+    groups[#groups + 1] = { { t[3], card.FONT_MONO, ROW_F },
+                            { '888\u{00B0}', card.FONT_MONO, ROW_F } }
+  end
+  groups[#groups + 1] = { { 'FAN', card.FONT_MONO, ROW_F },
+                          { '8888 RPM', card.FONT_MONO, ROW_F } }
+  local S = clamp(math.min(S_h, card.fit_unit(cr, inner.w * 0.96, groups, 100)), 10, 72)
+  local label_size = S * LABEL_F
+  local row_size   = S * ROW_F
 
   local y = inner.y
 
+  -- The package temperature is the headline, since there is no load to show.
+  -- It shares the header line with the label, set on the same baseline and
+  -- right-aligned, so the card's width carries the number rather than leaving
+  -- the right half empty under a left-set value.
+  card.font(cr, card.FONT_HEAVY, S, false)
+  card.rgba(cr, pkg and card.threshold(pkg, 75, 85, colors) or colors.label)
+  card.text_right(cr, inner.x + inner.w, y + S, big_txt)
+
   card.font(cr, card.FONT_MONO, label_size, false)
   card.rgba(cr, colors.label)
-  card.text(cr, inner.x, y + label_size, 'GPU')
-  card.rgba(cr, colors.value)
-  card.text_right(cr, inner.x + inner.w, y + label_size, 'ARC B580')
+  card.text(cr, inner.x, y + S, 'GPU')
 
-  -- The package temperature is the headline, since there is no load to show.
-  local pkg = data.sensor('xe', 'temp2_input')
-  card.font(cr, card.FONT_HEAVY, big_size, false)
-  card.rgba(cr, pkg and card.threshold(pkg, 75, 85, colors) or colors.label)
-  card.text(cr, inner.x, y + label_size + big_size,
-    pkg and string.format('%d\u{00B0}', pkg) or '--')
+  card.rgba(cr, colors.value)
+  card.text(cr, inner.x, y + S + label_size * 1.7, 'ARC B580')
 
-  local ey = y + label_size + big_size + 18
+  local ey = y + S + label_size * 3.4
   local step = row_size * 1.9
 
   card.font(cr, card.FONT_MONO, row_size, false)