Draw the panel as a panel

Five things a wall panel showed that a wall panel should not.

**A tile's body no longer clips.** It scrolled, and a box that scrolls
also cuts whatever crosses its edge — which took the glow off a lit
button at exactly the width where the button filled its tile, and off a
gauge's arc at exactly the height where the dial filled its own. Only
what is written or listed asks for a scroller now; everything else is a
picture drawn to fit, and what overflows is left to the frame, which
clips at the tile's edge where a shadow has already faded out. The
slider's phantom scrollbar goes with it.

**The selector is a selector.** Named for what it does rather than what
it is, and the choice it is holding is held in the dashboard's own
primary — a pill that slides between the options rather than a grey one
that had to be looked for. The stored type is untouched, so no document
changes meaning.

**The arrangement is held off the panel's edges**, by the same distance
it holds between two widgets. The ground is not held off with it: a
background covers the whole panel, and only what is arranged on it has
a margin. No stored panel loses a row to it.

**The rail is drawn on the panel.** It was chrome bolted to the edge of
the screen beside the canvas — in the app's own design rather than the
dashboard's, and on a scaled canvas not even lined up with it. It now
takes a column out of the canvas the way the margin does, scaled with
it and wearing its look. Which cell each widget sits in is unchanged;
only how big a cell is.

Two of these were the same mistake twice: an unlayered rule stating
`position` for everything wearing a class — `.gl-surface` on a rail
placed by a utility, and a blanket lift over every child of a pressable
on a pill placed by `layoutId`. Both now say it one element at a time.
This commit is contained in:
2026-08-24 10:44:53 +02:00
parent 86ceccdf7f
commit 73870d5f6f
18 changed files with 389 additions and 173 deletions
@@ -16,7 +16,7 @@ import {
useDashboardBackground,
} from "./settings"
import { useUi } from "./ui"
import { showTitle } from "./ui/core/config"
import { scrolls, showTitle } from "./ui/core/config"
import { LookProvider, useCanvasRoot, useLook } from "./ui/core/look"
import { gridStagger, LOOK } from "./ui/core/motion"
import { WidgetBody, widgetIssue } from "./widgets"
@@ -44,6 +44,26 @@ export const CANVAS_PRESETS = [
/** The gap between widgets, in pixels. Matches the `gap-3` view mode uses. */
export const GRID_GAP = 12
/**
* How far the arrangement keeps from the panel's own edges.
*
* The same as the gap between two widgets, so a tile sits as far from the edge
* of the screen as it does from its neighbour. The ground is not inset with it
* — a background covers the whole panel, and only what is arranged on it is
* held off the edge.
*/
export const GRID_INSET = GRID_GAP
/**
* The column a dashboard-switching rail takes out of the canvas, in canvas
* pixels.
*
* The rail is drawn on the panel rather than beside it — it is part of what
* the screen shows — so it is inside the canvas, scaled with it, wearing the
* dashboard's own look.
*/
export const RAIL_INSET = 72
/**
* The generated client marks every list optional, because the server fills
* them in. These three keep that from spreading through the components.
@@ -80,22 +100,43 @@ const DEFAULT_COLUMN_WIDTH =
*/
const CELL_ASPECT = DEFAULT_COLUMN_WIDTH / DEFAULT_ROW_HEIGHT
const columnWidthOf = (dashboard: Dashboard) =>
(canvasOf(dashboard).width + GRID_GAP) / columnsOf(dashboard) - GRID_GAP
/**
* The part of the canvas an arrangement is laid out in.
*
* The margin off every edge, plus the rail's column when the panel carries
* one: a rail is part of the screen rather than something beside it, so the
* room it takes comes out of the canvas the same way the margin does. Which
* cell each widget sits in never changes — only how big a cell is.
*/
export const areaOf = (dashboard: Dashboard, rail = false) => {
const { width, height } = canvasOf(dashboard)
const left = GRID_INSET + (rail ? RAIL_INSET : 0)
return {
left,
top: GRID_INSET,
width: Math.max(1, width - left - GRID_INSET),
height: Math.max(1, height - 2 * GRID_INSET),
}
}
const columnWidthOf = (dashboard: Dashboard, rail = false) =>
(areaOf(dashboard, rail).width + GRID_GAP) / columnsOf(dashboard) - GRID_GAP
/** One grid row, in pixels — the unit widget heights are multiples of. */
export const rowHeightOf = (dashboard: Dashboard) =>
Math.round(columnWidthOf(dashboard) / CELL_ASPECT)
export const rowHeightOf = (dashboard: Dashboard, rail = false) =>
Math.round(columnWidthOf(dashboard, rail) / CELL_ASPECT)
/** Distance between two row origins — what a widget's `y` is counted in. */
export const rowPitchOf = (dashboard: Dashboard) =>
rowHeightOf(dashboard) + GRID_GAP
export const rowPitchOf = (dashboard: Dashboard, rail = false) =>
rowHeightOf(dashboard, rail) + GRID_GAP
/** How many rows of the grid fit in the canvas; the rest is off the panel. */
export const rowsOf = (dashboard: Dashboard) =>
export const rowsOf = (dashboard: Dashboard, rail = false) =>
Math.max(
1,
Math.floor((canvasOf(dashboard).height + GRID_GAP) / rowPitchOf(dashboard)),
Math.floor(
(areaOf(dashboard, rail).height + GRID_GAP) / rowPitchOf(dashboard, rail),
),
)
/**
@@ -114,11 +155,14 @@ export const rowsOf = (dashboard: Dashboard) =>
export function CanvasSurface({
dashboard,
dots,
rail,
children,
}: {
dashboard: Dashboard
/** Draw the placement grid. A wall panel is not being arranged, so: no. */
dots?: boolean
/** The dashboard-switching rail, drawn on the panel rather than beside it. */
rail?: React.ReactNode
children: (scale: number) => React.ReactNode
}) {
const ref = useRef<HTMLDivElement>(null)
@@ -140,6 +184,7 @@ export function CanvasSurface({
const { width, height } = canvasOf(dashboard)
const scale = Math.min(box.width / width, box.height / height)
const root = useCanvasRoot(dashboard)
const area = areaOf(dashboard, Boolean(rail))
return (
<div ref={ref} className="relative size-full overflow-hidden">
@@ -165,20 +210,33 @@ export function CanvasSurface({
top: (box.height - height * scale) / 2,
transform: `scale(${scale})`,
transformOrigin: "top left",
// One dot per cell corner. The column pitch the grid snaps to
// is (width + gap) / columns; a row is one row plus the gap.
"--dot-x": `${(width + GRID_GAP) / columnsOf(dashboard)}px`,
"--dot-y": `${rowPitchOf(dashboard)}px`,
// One dot per cell corner, counted across the arranged area
// rather than the whole panel: the margin is not a cell.
"--dot-x": `${(area.width + GRID_GAP) / columnsOf(dashboard)}px`,
"--dot-y": `${rowPitchOf(dashboard, Boolean(rail))}px`,
} as React.CSSProperties
}
>
{/* Full bleed, and under everything: a background covers the
panel, margin included. */}
<CanvasGround dashboard={dashboard} />
{/* Over the ground rather than under it: the dots are what is
being arranged against, and a wallpaper must not hide them. */}
{dots ? (
<div className="dot-canvas pointer-events-none absolute inset-0" />
) : null}
{children(scale)}
{rail}
<div
className="absolute"
style={{
left: area.left,
top: area.top,
width: area.width,
height: area.height,
}}
>
{/* Over the ground rather than under it: the dots are what is
being arranged against, and a wallpaper must not hide them. */}
{dots ? (
<div className="dot-canvas pointer-events-none absolute inset-0" />
) : null}
{children(scale)}
</div>
</div>
</LookProvider>
) : null}
@@ -293,11 +351,14 @@ export function DashboardView({
dashboard,
renderWidget,
stacked,
rail,
}: {
dashboard: Dashboard
renderWidget?: (widget: WidgetDef) => React.ReactNode
/** One column at the viewport's width, for a phone. */
stacked?: boolean
/** Whether the panel carries a rail, which takes a column of the canvas. */
rail?: boolean
}) {
// ponytail: the first page only. A panel carries several whole dashboards
// — that is what the rail is for — so nothing writes a second page.
@@ -343,6 +404,7 @@ export function DashboardView({
widgets={widgets}
columns={columns}
stacked={stacked}
rail={rail}
renderWidget={renderWidget}
/>
</PaletteProvider>
@@ -363,12 +425,14 @@ function WidgetGrid({
widgets,
columns,
stacked,
rail,
renderWidget,
}: {
dashboard: Dashboard
widgets: WidgetDef[]
columns: number
stacked?: boolean
rail?: boolean
renderWidget?: (widget: WidgetDef) => React.ReactNode
}) {
const { Frame } = useUi()
@@ -385,7 +449,7 @@ function WidgetGrid({
"--widget-cols": columns,
// The row height follows the canvas, so the CSS grid and the
// editor's grid library cannot drift apart.
"--row-height": `${rowHeightOf(dashboard)}px`,
"--row-height": `${rowHeightOf(dashboard, rail)}px`,
} as React.CSSProperties
}
>
@@ -403,6 +467,7 @@ function WidgetGrid({
<Frame
title={showTitle(widget) ? widget.title : undefined}
issue={widgetIssue(widget)}
scroll={scrolls(widget)}
>
<WidgetBody widget={widget} dashboard={dashboard.name} />
</Frame>