Round dashboards: shape and ring, the ring drawn and turned in every look, Knob preset and face guide in the editor

This commit is contained in:
Melvin Strobl
2026-10-14 14:23:55 +02:00
parent 9bed078c41
commit be3446cb16
21 changed files with 1447 additions and 57 deletions
@@ -13,6 +13,7 @@ import { useUi } from "./ui"
import { scrolls, showTitle } from "./ui/core/config"
import { LookProvider, useCanvasRoot, useLook } from "./ui/core/look"
import { gridStagger, LOOK } from "./ui/core/motion"
import { RING_INSET } from "./ui/core/ring"
import { WidgetBody, widgetIssue } from "./widgets"
export type Dashboard = DashboardDef_Output
@@ -21,7 +22,7 @@ export type Dashboard = DashboardDef_Output
export const DEFAULT_COLUMNS = 12
/** What a grid size setting may be set to; a panel is matched to one of these. */
export const COLUMN_CHOICES = [6, 8, 12, 16, 24]
export const COLUMN_CHOICES = [4, 6, 8, 12, 16, 24]
/** The panel a dashboard is drawn for, if the document does not say. */
export const DEFAULT_CANVAS = { width: 1920, height: 1080 }
@@ -40,6 +41,9 @@ export const CANVAS_PRESETS = [
{ label: "Full HD", width: 1920, height: 1080 },
{ label: '10" tablet, portrait', width: 800, height: 1280 },
{ label: "Full HD, portrait", width: 1080, height: 1920 },
// A rotary knob's round screen. The only round one: a circle needs nothing
// but its diameter, so any other is a custom width.
{ label: "Knob", width: 360, height: 360, shape: "round" as const },
]
/** The gap between widgets, in pixels. Matches the `gap-3` view mode uses. */
@@ -75,10 +79,32 @@ export const widgetsOf = (dashboard: DashboardDef_Output) =>
export const columnsOf = (dashboard: Dashboard) =>
dashboard.columns || DEFAULT_COLUMNS
export const canvasOf = (dashboard: Dashboard) => ({
width: dashboard.canvas_width || DEFAULT_CANVAS.width,
height: dashboard.canvas_height || DEFAULT_CANVAS.height,
})
/** Drawn in the circle its canvas inscribes, for a round screen. */
export const isRound = (dashboard: Dashboard) => dashboard.shape === "round"
/** Widget types a round dashboard may draw on its ring. Mirrors the server's
* `RING_WIDGETS` (`flow/dashboards.py`). */
export const RING_WIDGETS = new Set(["slider", "dropdown", "color", "gauge"])
/** The widget a round dashboard draws along its edge, if it has one. */
export const ringOf = (dashboard: Dashboard): WidgetDef | null =>
(isRound(dashboard) &&
widgetsOf(dashboard).find(
(widget) => widget.id === dashboard.ring && RING_WIDGETS.has(widget.type),
)) ||
null
/** A round canvas is square whatever its stored height says: a circle has one
* size. The server squares it on save; this covers a draft not saved yet. */
export const canvasOf = (dashboard: Dashboard) => {
const width = dashboard.canvas_width || DEFAULT_CANVAS.width
return {
width,
height: isRound(dashboard)
? width
: dashboard.canvas_height || DEFAULT_CANVAS.height,
}
}
/** One grid row, in pixels, on the canvas the grid was first drawn for. */
const DEFAULT_ROW_HEIGHT = 80
@@ -107,15 +133,23 @@ const CELL_ASPECT = DEFAULT_COLUMN_WIDTH / DEFAULT_ROW_HEIGHT
* 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.
*
* A round dashboard has no rail — a panel shows page dots in the ring's gap
* instead — and is inset evenly, by the ring's band as well when it has one.
* The cells are the same maths in that square; what a circle cuts off of it
* is the editor's to warn about (`offFace`).
*/
export const areaOf = (dashboard: Dashboard, rail = false) => {
const { width, height } = canvasOf(dashboard)
const left = GRID_INSET + (rail ? RAIL_INSET : 0)
const round = isRound(dashboard)
const inset = GRID_INSET + (ringOf(dashboard) ? RING_INSET : 0)
const left = round ? inset : GRID_INSET + (rail ? RAIL_INSET : 0)
const top = round ? inset : GRID_INSET
return {
left,
top: GRID_INSET,
width: Math.max(1, width - left - GRID_INSET),
height: Math.max(1, height - 2 * GRID_INSET),
top,
width: Math.max(1, width - left - (round ? inset : GRID_INSET)),
height: Math.max(1, height - 2 * top),
}
}
@@ -156,14 +190,18 @@ export function CanvasSurface({
dashboard,
dots,
rail,
face,
touch,
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. */
/** The dashboard-switching rail, drawn on the panel rather than beside it.
* On a round dashboard, the page dots in the ring's gap. */
rail?: React.ReactNode
/** What a round dashboard draws over the whole face: its ring. */
face?: React.ReactNode
/** Whether the panel this canvas hangs on is touched rather than pointed at. */
touch?: boolean
children: (scale: number) => React.ReactNode
@@ -187,6 +225,7 @@ export function CanvasSurface({
const { width, height } = canvasOf(dashboard)
const scale = Math.min(box.width / width, box.height / height)
const root = useCanvasRoot(dashboard, touch)
const round = isRound(dashboard)
const area = areaOf(dashboard, Boolean(rail))
// The arrangement, held across the renders that are not about it. This
// component reads the dashboard's own settings, so a bound one wakes it on
@@ -208,6 +247,8 @@ export function CanvasSurface({
data-look={root["data-look"]}
data-touch={root["data-touch"]}
data-palette={root["data-palette"]}
data-shape={round ? "round" : undefined}
data-arranging={dots ? "" : undefined}
className={cn(
"absolute overflow-hidden bg-background text-foreground",
root.className,
@@ -218,6 +259,10 @@ export function CanvasSurface({
...root.style,
width,
height,
// Round, nothing outside the circle is drawn — except while it
// is being arranged, where a tile reaching past the edge has to
// stay in reach to be moved back (`FaceGuide` shades it).
clipPath: round && !dots ? "circle(50%)" : undefined,
left: (box.width - width * scale) / 2,
top: (box.height - height * scale) / 2,
transform: `scale(${scale})`,
@@ -249,6 +294,10 @@ export function CanvasSurface({
) : null}
{content}
</div>
{round ? face : null}
{round && dots ? (
<FaceGuide size={width} ring={Boolean(ringOf(dashboard))} />
) : null}
</div>
</LookProvider>
) : null}
@@ -256,6 +305,83 @@ export function CanvasSurface({
)
}
/**
* The circle, while a round dashboard is being arranged.
*
* The canvas is not clipped then, so what lies outside the face is shaded
* rather than hidden, and the edge the grid's tiles must keep inside — the
* ring's inner edge, when there is one — is drawn dashed.
*/
function FaceGuide({ size, ring }: { size: number; ring: boolean }) {
const half = size / 2
const safe = half - (ring ? RING_INSET : 0)
return (
<svg
role="presentation"
width={size}
height={size}
className="pointer-events-none absolute inset-0 z-[5]"
data-testid="face-guide"
>
<path
fillRule="evenodd"
className="fill-background opacity-70"
d={`M0 0H${size}V${size}H0Z M${half} 0a${half} ${half} 0 1 0 0.01 0Z`}
/>
<circle
cx={half}
cy={half}
r={half - 0.5}
fill="none"
className="stroke-border"
/>
{ring ? (
<circle
cx={half}
cy={half}
r={safe}
fill="none"
strokeDasharray="4 4"
className="stroke-muted-foreground opacity-50"
/>
) : null}
</svg>
)
}
/**
* Which tiles reach past a round dashboard's face: any corner outside the
* circle the grid has to keep inside, which is the ring's inner edge when
* there is a ring. A device clips them, so the editor says so.
*/
export function offFace(
dashboard: Dashboard,
items: readonly { i: string; x: number; y: number; w: number; h: number }[],
): string[] {
if (!isRound(dashboard)) return []
const { width } = canvasOf(dashboard)
const area = areaOf(dashboard)
const column = (area.width + GRID_GAP) / columnsOf(dashboard)
const row = rowPitchOf(dashboard)
const reach = width / 2 - (ringOf(dashboard) ? RING_INSET : 0)
const out = (x: number, y: number) =>
Math.hypot(x - width / 2, y - width / 2) > reach
return items
.filter((item) => {
const left = area.left + item.x * column
const top = area.top + item.y * row
const right = left + item.w * column - GRID_GAP
const bottom = top + item.h * row - GRID_GAP
return (
out(left, top) ||
out(right, top) ||
out(left, bottom) ||
out(right, bottom)
)
})
.map((item) => item.i)
}
/**
* What the widgets sit on.
*
@@ -346,15 +472,18 @@ export function DashboardView({
)
}
// The ring is drawn along the face's edge (`RoundFace`), not in a cell.
const ring = ringOf(dashboard)
const placed = ring ? all.filter((widget) => widget !== ring) : all
// Stacked, the arrangement becomes a reading order, so it follows the rows
// the panel shows rather than the order widgets happened to be added in.
const widgets = stacked
? [...all].sort((a, b) => {
? [...placed].sort((a, b) => {
const left = placement(a)
const right = placement(b)
return (left.y ?? 0) - (right.y ?? 0) || (left.x ?? 0) - (right.x ?? 0)
})
: all
: placed
const columns = columnsOf(dashboard)
const grid = (