ledger_parts library

Helpers for customizing components copied from ledger_ui.

Import this library in the copied widget to use its theme and component helpers.

import 'package:ledger_ui/ledger_parts.dart';

Outside semver: this library may change in any version, a patch included; the CHANGELOG says how to move.

Classes

AnimatedLedgerTheme
Animates to a new data over duration (200 ms, Material's AnimatedTheme default), as AnimatedTheme does: colours, type and shadows blend through LedgerThemeData.lerp.
ChromeGroundScope
Publishes the ChromeGround of the page it wraps. ChromeRoutes.page mounts one inside a pushed page and inside a branch root (from its NavTab.ground); a system's chrome inside the page reads it.
DefaultDesignLocalizations
The words in English, with no localizations package.
DesignAdaptiveShell
An app's frame: destinations in a bar, a rail or a sidebar by the shell's width (DesignNavigationMode.fromWidth, or mode), and the app's body beside it (above a bar). The look paints each destination (destinationBuilder) and the navigation round them (navigationBuilder); the shell gives them their keys, their meaning to a screen reader and their place.
DesignAnchoredOverlay
A surface anchored to anchorBuilder's widget: a popover (DesignOverlayTrigger.press, focusOnOpen), a hover card (DesignOverlayTrigger.hover) or a menu (arrowKeyNavigation on).
DesignBandScale
Categories side by side (bars): count bands from start to end, paddingInner of each step between bands and paddingOuter at the ends. A value is a band's index; map gives its centre.
DesignBottomSheetController
Drives an open DesignBottomSheetRoute's size from outside it, as DraggableScrollableController drives a sheet, on the route's spring. The caller makes it, gives it to one route at a time, and disposes it.
DesignBottomSheetDetails
What a DesignBottomSheetRoute's panel paints from.
DesignBottomSheetDragHandle
A bottom sheet's drag handle, painted by builder: a button that moves the sheet to its next size (from the largest back to the smallest; a sheet of one size closes), Up and Down to a larger or smaller size when focused, and a screen reader's increase and decrease. Put it in a DesignBottomSheetRoute's panel.
DesignBottomSheetRoute<T>
A modal bottom sheet. Push it with Navigator.push; its panel is builder's, the screen's width, rising from the bottom edge.
DesignCalendar
One or more month grids over a DesignCalendarController.
DesignCalendarController
A calendar's state: the shown month, the keyboard's day and the selection.
DesignCalendarDay
One day as the grid paints it.
DesignCalendarHeader
A month's header, as DesignCalendar.headerBuilder gets it.
DesignCapCenter
Draws a one-line label or text entry so that the middle of its capitals is the middle of its own box, as Baseline puts a baseline where it is told.
DesignCarousel
Slides itemBuilder builds, itemCount of them.
DesignCarouselControls
What a carousel's controls act on.
DesignChart
A cartesian chart (line, area, bars, a sparkline): the look draws series from the scales and ticks in builder's details; the chart picks points, says them, and springs from one set of data to the next.
DesignChartDetails
A DesignChart as its look draws it.
DesignChartPoint
A point of a DesignChartSeries: x and y, or a gap where y is null.
DesignChartPointRef
A point of a chart: the indexth point of the seriesth series.
DesignChartSeries
A named run of points, in order along x.
DesignChartTable
A chart's data as a table, the alternative an app shows instead of the chart (a screen reader's "Show data table"): a row per x value, a column per series (DesignChartTable.new), or a row per slice with its value and share (DesignChartTable.slices). A screen reader reads a table, its column headers and cells, a missing value as "Empty"; cellBuilder paints each cell, and the columns are as wide as their widest cell.
DesignChartTableCellDetails
A cell of a DesignChartTable.
DesignColorArea
A saturation (across) and brightness (up) area for controller's hue.
DesignColorAreaDetails
What the look paints the area from.
DesignColorController
A colour being picked, as hue, saturation, brightness and alpha.
DesignColorPicker
An area over a hue slider (and an alpha slider), on one controller.
DesignColorSlider
A slider for one channel of controller's colour.
DesignCombobox<T extends Object>
A text field that suggests options as you type.
DesignComboboxField
The field, as DesignCombobox.fieldBuilder gets it: wire controller and focusNode to the look's text input, and submit to its onEditingComplete (and give it no onSubmitted; see submit).
DesignCommand
A command in a palette.
DesignCommandPalette
The palette's body: the field over the results. Put it in a route with showDesignCommandPalette, or anywhere (a sidebar's search).
DesignCommandShortcut
Opens a palette from anywhere under it on activators (Ctrl+K and Cmd+K).
DesignContextMenu
A menu of menuChildren that opens over child, where the user asks for it.
DesignControlBox
A control's box: at least minHeight tall, as wide as its child (or as the width it is told to be), with child placed by alignment and its text given even leading (TextLeadingDistribution.even).
DesignDataTable<R>
The rows of a DesignTableController's page under a header row, with one tab stop for the rows. The look paints the header cells, the cells, and each row around its cells.
DesignDateField
A date typed in segments, in the reader's order: value is a calendar day (its time ignored), null when empty; onChanged gets the day once every segment holds one, and null when one is cleared.
DesignDateRange
A range of days, start to end inclusive; end is null while only the start is chosen.
DesignDateSegmentDetails
One segment of a DesignDateField or DesignTimeField, as the look paints it.
DesignDensity
How compact a look's controls stand, as Material's VisualDensity: each step of vertical takes heightStep from a control's height and each step of horizontal paddingStep from its padding at either side, from -4 (tightest) to 4 (roomiest).
DesignDestinationDetails
What a look paints a destination from.
DesignDialog
An alert's or a simple dialog's layout: title and content scroll together over actions, which stay put. The actions sit side by side, sharing the row on a compact screen and aligned at the end on a larger screen. When their labels do not fit, including at a large text size, they stack, one to a line, the last given (the confirm) on top and the first (the dismissive one) at the bottom, as Material and iOS stack them.
DesignDialogAction
An action at the foot of a DesignDialog.
DesignDialogActionDetails
What the look paints a DesignDialogAction from.
DesignDialogDetails
What a DesignDialogRoute's builder paints from.
DesignDialogFrameDetails
What the look paints a DesignDialog's frame and action bar from.
DesignDialogRoute<T>
A modal dialog or alert. Push it with Navigator.push; its page is builder's, over a barrier.
DesignField
A control with its label, help and error.
DesignFieldParts
What a DesignField's builder lays out.
DesignForm
A Form that, on a submit that fails, shows every error, moves focus to the first field that is wrong (scrolling it into view) and tells a screen reader how many fields need attention; after that, errors update as the reader edits.
DesignFormField<T>
A FormField whose control DesignForm can focus: give focusNode to the control.
DesignFormState
The state of a DesignForm: submit and reset it.
DesignHaptics
The haptics ui_core's behaviours play: one callback per moment; a null callback plays nothing.
DesignHapticsScope
Puts haptics in force for child: the table every ui_core behaviour below reads with DesignHaptics.of.
DesignInputGroup
A field and its add-ons as one control.
DesignInventory
A look's inventory: one entry per DesignInventoryRow.
DesignInventoryEntry
A look's answer to one row: a live specimen (builder) or the reason the look leaves it out (absentReason).
DesignInventoryGallery
Lists an inventory, group by group in DesignInventoryRow.groups' order: each row's live specimen, or Deliberately absent: <reason> for a gap, or "Missing" for a row the inventory does not answer. Lazy: a row builds when it scrolls in.
DesignInventoryRow
One row of the inventory: a component every look either carries or leaves out with a reason.
DesignKeylineFace
Marks child as one face for the checks in package:ui_core_test: a control's face or a well (a field's, a list's, a table's) whose pixels may not show it, or a picture with things placed on it.
DesignKeylineRegion
Marks child as a card or a section whose contents share keylines: a keyline is the line that what starts a row (or ends one) sits on, so a card's title, its rows' words, its fields and its dividers start on one line, and its switches, chevrons and selects end on another.
DesignLinearScale
A number line: min at start, max at end.
DesignListDetail<T extends Object>
A list (listBuilder) and the detail of selectedItem (detailBuilder), as Compose's ListDetailPaneScaffold.
DesignLocalizations
The words a design system says on its own. The behaviours' words: the names a screen reader hears for a part with no text of its own (a carousel, a sheet's barrier, a split view's handle) and the messages they announce (a slide turned, a row moved, the results found), each also a parameter on its behaviour, which a null leaves to this. And the general words a look shows or says by itself (Cancel, Close, Today, Next month, "2 of 5"), under MaterialLocalizations' names where Flutter has the word, so a look built on any app (MaterialApp, CupertinoApp, WidgetsApp) has them.
DesignMenuBar
A row of menus.
DesignMenuEntry
An item of a menubar: a command, a submenu (children), or a divider.
DesignMotionPolicy
The Reduce Motion policy: which spring a component actually runs.
DesignNavigationDestination
A destination: its name and glyphs, as Material's NavigationDestination.
DesignNavigationDetails
What a look lays the navigation out from.
DesignNumberField
A number typed or stepped: value the number, null when empty; onChanged gets it as it is taken (Enter, the focus leaving, a step), not on each key typed.
DesignNumberFieldButtonDetails
One of a number field's step buttons, as the look paints it.
DesignNumberFieldDetails
The field, as DesignNumberField.fieldBuilder gets it: wire controller, focusNode, keyboardType, inputFormatters and onEditingComplete to the look's text input.
DesignOtpController
Holds a code: its text, its length, whether it is whole.
DesignOtpField
A one-time code drawn as boxes over one input.
DesignOtpSlot
One box, as DesignOtpField.slotBuilder gets it.
DesignOverlayAnchor
The anchor, as DesignAnchoredOverlay.anchorBuilder gets it.
DesignOverlayInfo
What DesignAnchoredOverlay.overlayBuilder paints the surface from.
DesignOverlayPadding
The edges a surface opened under it keeps clear of, beyond the screen's safe area and the on-screen keyboard: a look's own chrome over its pages, such as a desktop side bar a page's overlay runs under.
DesignOverlayPlacement
Where a surface goes relative to its anchor.
DesignPasswordController
Whether a password shows: true while it is hidden.
DesignPasswordDetails
What a DesignPasswordReveal's builder paints from.
DesignPasswordReveal
Holds whether a password shows and gives the field and its toggle what they need. The field keeps its focus and caret as it flips; with hideOnBlur a shown password hides again when focus leaves the field.
DesignPieChart
A pie or donut: the look draws slices from the angles in builder's details; the chart picks a slice, says it, and springs from one set of values to the next.
DesignPieChartDetails
A DesignPieChart as its look draws it.
DesignPieSlice
A slice of a DesignPieChart: a label and its value.
DesignPieSliceDetails
A slice as drawn.
DesignPressable
Makes any widget a control (press, focus, hover and what a screen reader hears), with no look of its own.
DesignPressableState
The state of a DesignPressable: states is what its builder was last given.
DesignPullToRefresh
child, a scroll view, refreshed by onRefresh on a pull.
DesignPullToRefreshState
The refresher's state: refresh runs one (a keyboard shortcut, a menu's "Refresh").
DesignRangeSlider
A slider of values between min and max.
DesignRangeTrack
The track's state, for the look to paint its rail and the filled part.
DesignRangeValues
A range's two ends.
DesignRating
A rating of itemCount items filled up to value (0, none, to itemCount): onChanged gets the value a tap, a drag, a key or a screen reader sets.
DesignRatingItemDetails
One item of a DesignRating, as the look paints it.
DesignRefreshDetails
What the look paints the indicator from.
DesignReorderableList<T extends Object>
A list of items the reader puts in order; onReorder gets an item's place from and its new place to (counted after it left).
DesignReorderItem
An item's place and moves, as DesignReorderableList.itemBuilder gets them.
DesignScale
Values to positions and back.
DesignScaleTick
A tick on a scale: a value, its position, its label.
DesignScrollArea
child, a scroll view on controller, with a scrollbar from thumbBuilder (and trackBuilder) on its end edge (or bottom).
DesignScrollThumb
A scrollbar's geometry and state, for the look to paint.
DesignSearchError
A search that failed, as a combobox's or a tag input's errorBuilder gets it: paint a message and a "Try again" (DesignLocalizations.retryButtonLabel) that calls retry, lit while focused.
DesignSheetInfo
What a side sheet's panel gets to paint with.
DesignSheetPageRoute<T>
A full-screen sheet presented as an opaque page of the navigator. The whole page rises on a spring and returns along the same path. With Reduce Motion it fades. Escape and Back respect the page's PopScope.
DesignSideSheetRoute<T>
A modal side sheet. Push it with Navigator.push; its panel is builder's, sized to width (at most the screen less minGap) and the full height.
DesignSpacing
The step a look's spacing stands on: every padding, gap and spacing token a multiple of grid.
DesignSpacingScope
Declares the spacing a look's parts stand on for the subtree, as a theme does; DesignSpacing.of reads it.
DesignSplitAction
An action in a split button's menu.
DesignSplitButton
A main action with a menu of actions beside it.
DesignSplitView
first and second side by side (or stacked, axis vertical), split at fraction of the room (the first pane's share).
DesignStyle
How one part of a look looks, as Material's ButtonStyle is: every slot resolves for the part's states (WidgetState.disabled, WidgetState.hovered, WidgetState.focused, WidgetState.pressed, WidgetState.selected, WidgetState.error).
DesignStyleOf
A part's style layers read at its states: its own style:, then its component theme (first wins). Each getter is the first layer's value for states, or null, so the part goes on to the theme-wide knobs and its own default.
DesignSwipeAction
An action behind a row.
DesignSwipeActionDetails
What the look paints an action from.
DesignSwipeActions
child with startActions behind its start edge and endActions behind its end edge.
DesignSwipeActionsController
Opens and closes a DesignSwipeActions row from outside, and says whether it is open, as flutter_slidable's controller does. The caller makes it, gives it to one row, and disposes it; with no row it does nothing.
DesignSwipeBackPageTransitionsBuilder
builder's page transition with iOS's swipe back from the screen's leading edge round it.
DesignTab
A tab: its name, and what a look paints it with.
DesignTabBar
A bar of tabs, controller choosing among them; the look paints each tab (tabBuilder) and the indicator under them (indicatorBuilder), or over them (indicatorPosition).
DesignTabController
Which tab is selected, and where a swipe or a change has got to: Material's TabController without Material. A DesignTabBar and a DesignTabView given the same one follow each other. The caller makes it, with a TickerProvider (TickerProviderStateMixin), and disposes it.
DesignTabDetails
What a look paints a tab from.
DesignTabIndicatorDetails
Where a look paints the indicator, and the selected tab's states.
DesignTableColumn<R>
A column of a DesignTableController.
DesignTableController<R>
A table's data and its view of it: the filter, the sort, the selection and the page.
DesignTableRow<R>
One row, as DesignDataTable.rowBuilder gets it.
DesignTabView
The pages of controller's tabs, one per tab, swiped between: Material's TabBarView without Material. Swiping moves the controller's DesignTabController.animation, so a bar's indicator follows the finger; let go, the pages spring to the nearer page (or the next, flung) on the controller's spring. A change from the bar springs the pages the same way. Each page is its tab's panel to a screen reader; pages off screen are not built, unless a page keeps itself alive.
DesignTagDetails
One tag, as DesignTagInput.tagBuilder gets it.
DesignTagInput<T extends Object>
Values chosen as tags, with a field that suggests and makes more.
DesignTapTarget
Lays child out at least minSize (the floor for what reaches the controls, DesignTapTargets.of, when null), placed by alignment, and sends a tap anywhere in that area to the child's centre: the control's layout, the area a tap reaches and the box a screen reader outlines are one.
DesignTapTargets
The least area a tap must reach on a control, by what reaches it: 44 by 44 for a finger (Apple's Human Interface Guidelines), 24 by 24 for a pointer (WCAG 2.2, success criterion 2.5.8, level AA).
DesignTapTargetScope
Declares the targets a look's controls stand at for the subtree, as a theme does; DesignTapTargets.of reads them.
DesignTextEntryBox
A text entry's box: at least minHeight tall, holding child, an editable as wide as the box, with one line centred in it and hint on the typed text's baseline while controller is empty.
DesignTimeField
A time of day typed in segments, on the reader's clock: value the time, null when empty; onChanged gets it once every segment holds one, and null when one is cleared.
DesignTimeOfDay
A time of day with no date: an hour (0–23), a minute and a second.
DesignTimeScale
Time, in local dates: min at start, max at end. Its values are milliseconds since the epoch (DateTime.millisecondsSinceEpoch); its ticks fall on calendar steps (seconds to years) and read as the reader's times and dates.
DesignToast
What a toast says and does. The look reads the fields it paints; data carries anything else it needs (a tone, an icon).
DesignToastDetails
What the look's DesignToaster.toastBuilder paints one toast from.
DesignToaster
Hosts toasts over child: put it above the app's navigator (WidgetsApp.builder), then call DesignToaster.of and DesignToasterState.show from anywhere below.
DesignToasterState
The state of a DesignToaster: show and dismiss toasts through it.
DesignToastHandle
A shown or waiting toast, as DesignToasterState.show returns it.
DesignToggleGroup<T>
A row (or column) of toggles over options.
DesignTooltip
A tooltip of message for child, painted by tooltipBuilder.
DesignTree<T extends Object>
The open rows of controller, one tab stop for all of them.
DesignTreeController<T extends Object>
A tree's nodes and which are open and selected.
DesignTreeItem<T extends Object>
A row's paint state.
DesignTreeRow<T extends Object>
A shown row of a tree.
DesignValueHandle
A focusable value between min and max.
DesignWheelColumn
One column of a DesignWheelPicker: its rows, their names and which of them can be chosen.
DesignWheelColumnDetails
One column of a DesignWheelPicker, as the look frames it: its lens, a band behind the centre row, a focus ring.
DesignWheelItemDetails
One row of a DesignWheelPicker, as the look paints it.
DesignWheelPicker
A wheel picker of linked columns: selection holds a row per column, columns gives the columns for a selection, and onChanged gets every pick as a whole, valid selection.
DisplayFormat
English display formats for amounts, counts and dates.
LedgerAccount
Who the app belongs to, as its chrome shows them: the initials in the avatar, the name and the quiet meta line ("Member since 2023") at the sidebar's foot, the unread count the bell wears, and where the avatar (onProfilePressed) and the bell (onNotificationsPressed) lead. The app mounts one LedgerAccountScope above its router; the top bars and the sidebar read it, so no page passes the person around. profileLocation is the profile page's path: the sidebar's foot is current there (a :name segment stands for any one, so '/:root/profile' is the profile pushed on any root). notificationsLocation is the bell's page, where the sidebar marks nothing current, as the source's notifications do. searchHint and onSearchPressed are the app's search, which the desktop's masthead offers beside the bell.
LedgerAccountMarks
The bell, then the avatar, of account: what the phone's top bar wears at its end on a tab's page, 4 apart. The desktop's masthead wears the bell alone (ringed), the avatar standing at the sidebar's foot.
LedgerAccountScope
Publishes the app's LedgerAccount to its chrome: mount one above the router (around the host's child), rebuilt when the person or the unread count changes.
LedgerActionBar
A page's commit strip: what is about to happen on the leading side (a total in the engraved serif, over its line in the mono) and the page's one act on the trailing side, the green button. Stood as a LedgerScreen(footer:) it leaves the band's hairline and room to the screen; anywhere else it stands its own band on the paper (a hairline over it, the gutter at its sides, the device's inset under), and with floating it is a card of the raised paper that keeps a body's edges. Without a summary the act takes the whole width. At large text, or in a room narrower than stackBelow, the summary stacks over the act rather than squeezing it. A busy act shows busyLabel and takes no press.
LedgerActionSheet<T>
The acts of an action sheet (what to do with a receipt: Replace the photo, Download, Delete), drawn in place: message in the second ink over them, then each act a line 52 tall under a hairline, its glyph and its words in the medium, the vermilion for one that cannot be taken back, the darker paper under a pointer or a press. onSelected gets the act's value. showLedgerActionSheet raises them on a sheet with Cancel at its foot.
LedgerAllocationRow
One kind of an allocation (.alloc-row): its hatched swatch (the tone its part wears in the LedgerStackBar over it), its name on the leader to its amount, and its share of the whole in the quiet mono, 11 above and below. Stand them in LedgerRows under the bar.
LedgerAmount
The ledger amount, as the source sets money in its rows (.amt): the mono at 14 on 20, its sign and dollars in the tone's ink, its cents receding (regular, in the tone's quieter ink): money out in the ink, LedgerTone.moneyIn green, LedgerTone.over vermilion, a LedgerTone.move between the owner's own accounts quiet and regular. showSign puts the plus on a positive amount. Read aloud as one amount.
LedgerAvatar
The owner's avatar: their initials in the italic serif on a 36 ink disc, saying label (Profile and settings). A null onTap draws it unpressable (the sidebar's foot presses as a whole).
LedgerAvatarStack
Several people as one line of marks: ink discs bearing their initials in the italic serif, side by side a little apart as signatures stand on a form (one never laid over another), then the rest as a count in the mono ("+3"). Up to max show; total says how many there are when names lists only the first few. It is one node for a screen reader: the first names and how many more.
LedgerBack
The way back off a pushed page, or the close of a cover or a sheet, as the route's bar draws it: on a phone the 36 ringed button with the chevron (the cross to close) saying "Back to label"; at desktop width, and beside a tablet's rail (where no phone bar stands), the crumb over the title, the 15 chevron and label in the mono capitals, hung 4 into the gutter; on a sheet's card the ringed close. label names where back goes (Home, Activity); unset, the bar's backLabel names it.
LedgerBadge
A count on a control's corner (notes unread, entries to file): the figure in the mono on a disc of the green centred on child's top end corner (clear of what the control shows inside it), the vermilion when urgent, 99+ past 99; with no count, the green dot alone. A count of 0 takes the mark away in Ledger's one motion. A screen reader hears the count after the control's own name.
LedgerBanner
A notice in the page's flow (a statement ready, a card declined): the raised paper in the rule with a stroke of its tone down its reading start, the tone's glyph, title in the medium and text in the second ink; actionLabel a text button under them (pressing it calls onAction), onDismiss the ringed close at its end. A screen reader hears it as it appears when it is LedgerBannerTone.wrong or LedgerBannerTone.mind.
LedgerBarSlotScope
Tells a LedgerTopBar which part of it a screen stands here. Plumbing of the screen and the bar.
LedgerBeforeRow
The row that sums what came before the rows shown (.row-before): a dashed box with its icon (40 by 44, the faint ink), the title in the second ink on the dot leader to its value, and its subtitle (how many) under them; 14 above and below, as a ledger row.
LedgerBell
The bell: the owner's notifications, its green dot while any are unread, saying "Notifications, unread unread". Bare in the phone's top bar; LedgerBell.outlined ringed on the desktop's masthead.
LedgerBillList
The bills' list (.ledger.bills): its rows with the hairline between, on the desktop under the column heads (due, payee, account, status, amount).
LedgerBillRow
A bill (.billrow): its due date as a date tab, the payee on the dot leader to the amount, the account under the payee and its status under the amount (green on autopay); on the desktop a statement line with the account and the status in their columns. One link, read as the payee, the amount and the date.
LedgerBottomStand
Marks what a screen or a sheet stands over its bottom edge (the footer's band, a floating bar), so a toast raised on that route rises above it rather than over its buttons. Plumbing of the components; pages never place one.
LedgerBrandMark
The brand mark: a ruled globe, its lower half engraved in 45° hatching, drawn in the green as the source's brand_mark draws it on its 24 grid (the ring 10.6 round at 1.3, the rule across at 1.3, the hatch 2.3 apart at .8 inside 8.6, under the rule). Scales with size; color inks it otherwise (a card's face prints it in its own green).
LedgerBreadcrumb
Where a page stands (Accounts / Everyday / October): each step in the mono capitals, the ways back in the second ink and the page itself in the ink, a slash between them in the faint ink. A way back underlines under a pointer and takes the double rule with focus; each is laid out at the tap floor. A long trail wraps rather than cuts a word, and a screen reader hears it as one navigation, the last step as the current page.
LedgerBudgetRule
A budget on a dollar rule (art.budget_rule), on its 432 by 30 grid scaled to its width: the month's spent hatched to the budget's ink tick (vermilion past it), the suggested budget as a dashed green tick on the paper. Read as its label and the three sums.
LedgerButton
A round button: its label and an optional icon (before the words, or after with iconAfter; a left or right chevron or arrow turns the other way in a right-to-left page). expand stretches it across its room: its column on a phone; from 600 up to 320 (LedgerLayout.fieldMeasure), wider only for longer words, at the start of its slot.
LedgerButtonEnds
Sets how far the buttons under it keep their words from their ends: a row of buttons sharing its width pads each 16 (.form-actions-row .btn, .card-acts .btn: padding 0 16px) where a button alone keeps 22. The row wraps its buttons in it; LedgerButtonEnds.of tells a button its pad. A quiet button keeps its own 13. Plumbing of the components; pages never place one.
LedgerButtonRow
Two acts side by side (.form-actions-row): each children item half the row, 12 apart (a sent transfer's Back to Home and View transfer). Give it LedgerButtons with expand: true.
LedgerCardActsScope
Lifts the measure for the acts under it: in a sheet's or a dialog's foot the card is the measure, so one act takes the card's width and two share it evenly, as on a phone (LedgerLayout.keepsMeasure reads false under it). Without it a desktop sheet's two acts each hugged their words at the start of their half, off the card's middle. Plumbing of the parts.
LedgerCardChip
A card's chip, engraved (art.chip_art) on its 40 by 30 grid fitted in its box: the rounded plate, its contact lines and a hatched pad, in color.
LedgerCardDetails
A card's details shown on its ink (.card-details): under the label its number in four groups spread across in the mono at 21, then under a faint rule its expiry, its cvc and the name on it, each under its label. Printed as the card is (the ink stock's light from its top end corner), 12 round. The card details sheet's body; 12 under the sheet's head.
LedgerCardFace
A payment card's face, printed like a banknote (.card-face): its stock, a guilloche rosette off its corner, the brand mark and brand in the serif with the card's kind, the engraved chip and the contactless mark, the number masked to its last group, the holder and the account at its foot. frozen lays a frost of hatched paper over it, drops the account and presses the seal (the ink's Frozen) across its corner. Read as its kind and last four.
LedgerCarousel
Slides turned one at a time (this month's highlights, a goal's milestones): each slide in the slip's small corners, height tall at the standard text size and growing with the reader's, a swipe, the arrow keys or the ringed arrows at its foot turning it in Ledger's one motion, and the page dots between the arrows saying where it stands (each a press to that slide). viewportFraction under 1 shows a sliver of its neighbours. A screen reader hears it as semanticLabel and each slide as its place of the count.
LedgerCategoryLine
A category's month (.cat): its name on the leader to what it spent, the gauge under them (its budget at 250 of 300, the month's pace across it), then its subtitle and trailingSubtitle; over its budget the name, the amount and the end note vermilion. On the desktop one line: the name over its note in a 236 column, the gauge, the amount in 104. One link to the category.
LedgerCategoryMini
A category's month in a record's margin (.cat-mini): its name on the leader to what it spent, the gauge to its budget under them with the month's pace, then its subtitle and trailingSubtitle (the end vermilion over budget). With no budget (a month gone by) the gauge is left out and only the sub line follows. Unlike LedgerCategoryLine it keeps one shape at every width. Stand it 16 under its head; onTap makes it one link to the category.
LedgerCategoryTile
A category as a tile (.cat-tile): its glyph, its name and what it spent this month, vermilion when overBudget its budget, on the raised paper in a fine rule. One link to the category. Stand them two by two in LedgerCategoryTiles.
LedgerCategoryTiles
Category tiles two to a line on a phone (.cat-tiles), sharing the column; from 600 each tile wide (its glyph, its name and its sum whole, never a word broken), as many to a line as the column holds up to four, from the column's start: a wide column never stretches them. 8 apart each way, the tiles of a line as tall as its tallest. No tile is left alone on its line: three stand one per line on a phone and on one line from 600.
LedgerChartBracket
The bracket over a run of LedgerMonthBars and its words.
LedgerChartKey
A chart's key (.legend): each swatch 6 before its words in the third ink's mono, wrapping 16 apart (6 between lines).
LedgerChartMark
A day ringed on a month's plot and labelled (.mark): a payday above its point, a card's payment below it.
LedgerChartNote
A note hung on a plot's point on a leader lift above it (.anno): the rent's jump on day 1, a large bill's step; its **strong** run in the ink. deskLift stands it on the desktop's plot, and deskText words it there (a phone's note may break where the desktop's runs on).
LedgerCheck
The mark that fills when a thing is done: a ring of the rule that the green fills and a tick, pressed a few degrees off square like the seal, draws across. A task, a habit, a line ticked off a list. onChanged null makes it a MARK, not a control (as a null callback holds any Flutter control): a finished line's tick, undimmed, that lets taps through. Give a check that stands without words a label, spoken and never printed. It lays out at the tap floor round its ring (44 for a finger, 24 for a pointer), and a tap anywhere in that room reaches it.
LedgerCheckbox
A checkbox: a 20 square ringed in the ink, filled with the ink and ticked in the paper when value is true, a dash when it is null (with tristate). With a label the words stand after it on its line (two or more when they wrap), and the line is the target. isError rings it in the danger red; a null onChanged disables it.
LedgerCheque
A transfer drawn as a cheque (.cheque), printed on a LedgerSlip: the guilloche band, its kind and date, its lines (the pick lines, the amount, the note), the tear line and the micr line at its foot in the spaced mono. A sent cheque carries its stamp, pressed across it at the stamp's size (.seal-stamp: 132 down and 14 in from its end; 136 and 40 from 1024, clear of the amount's box); at a large text size, under its lines at their end.
LedgerChequeAmount
A cheque's amount (.amount-row): its label, then in a box ruled in the ink the sum in the serif after its $ (typed live with a controller, else read back as the engraved amount), and under it the sum in words on the cheque's line with its unit (DOLLARS). The typed line stands as Chrome holds an input's, at least its font's normal line: 1.3 of the serif's size to the pixel (the transfer's box 95 tall at 56, 116 at 72), its label on the body's line (21.75). typed reads the amount back as the input holds it ("500.00" after its $), a sum shown that no one types here (the form's).
LedgerChip
A choice token: a pill ringed in the rule on the raised paper, 32 tall (4 off each density step, as the controls beside it step), its label in the mono medium; the chosen one is set in the ink with the paper's words. An icon stands before the words and a count (how many things it matches) after them, in the mono. A null onTap shows it without letting it change. Says its label, its count and whether it is chosen. Set several in a LedgerChipRow.
LedgerChipRow
Chips set in a row that wraps rather than overflows, 6 apart each way, naming the set to a screen reader by label. Each chip keeps its own press and lays out at the tap floor; the row only lays them out and holds them together.
LedgerChromeMetrics
The chrome's measures, by the part that draws them.
LedgerCodeField
A one-time code (a bank's six figures, a card's PIN): each figure in the serif on its own short rule, the code's halves parted by a wider gap, its label in the small capitals over them and its helper or error under, as every Ledger field. The slot the next figure goes in rules the accountant's double rule while the field has focus, drawn in from the reading start as a pen draws it, with the caret standing on it; an error rules every slot in the vermilion. One input under the slots, so a pasted code or an offered one fills them all, the figures read left to right in either direction, and a screen reader hears one field. onCompleted runs when the last slot fills. obscureText writes a bead for each figure (a PIN).
LedgerCombobox<T extends Object>
A payee, a category or a shop typed in and taken from what it suggests: a Ledger field on its rule, the chevron at its end, and under it, as soon as it has focus, the matching options on the select's raised paper, 48 a line, a hairline between, the value on the menu's paper, its words semibold and ticked in the accent. A pointer underlines a line's words and the keyboard's line doubles the rule under them, on that line alone. Up and down walk the list, Enter takes the line, Escape closes it; with nothing matching the paper says so. labelOf words each option (its toString otherwise) and noteOf puts a note at its end (a count, a balance). requireSelection holds the field to an option, giving back the chosen words on blur. With a search in place of options (a payee looked up as it is typed), the paper says it is looking while the search runs, and when it fails says so with a "Try again" line the keys reach with Down, as ui_core's combobox runs it; debounceDuration waits for the typing to rest.
LedgerCommandPalette
Every act of the app found by typing (New entry, Export October, Go to Budgets): a field on its rule with the search glyph, and under it the acts matching what is typed on the select's raised paper, gathered under their groups' small capitals, each 48 a line with its shortcut's keys at its end. Up and down walk the list, Enter runs the line, Escape closes it; with nothing matching the paper says so, and a screen reader hears how many match. Open it over a page with showLedgerCommandPalette, or stand it on a page (a desk's side search).
LedgerComponentThemes
Every component theme in one, as ThemeData holds Material's: what LedgerThemeData.components carries and lerps. Each is null until an app sets it, and a null one leaves its parts as the book draws them.
LedgerComposer
The message input that docks at the foot of a conversation: a ringed round of the raised paper holding the field, onAttachPressed before it, and at its end the green send once there are words to send, onVoicePressed while there are none, and the ink stop while sending runs (onStopPressed ends it). Enter sends from a hardware keyboard on a single line field; the field grows with its words. Stand it as a LedgerScreen(footer:) or in a sheet's foot, where the band owns the room round it. LedgerComposerStyle.assistant is the larger slip for an ask to an assistant, with a toolbar under the words. Says its semanticLabel (the hint by default), and each act its own name.
LedgerCorners
Corner radii: the scale behind the shape roles of LedgerThemeData. The source's language is paper at 6 (a memo slip, a sheet, a menu, a toast, a date tab), plastic at 12 to 16 (a card face) and round for everything held in the hand (buttons, chips, pills, the tab's disc).
LedgerCounter
A number set anew when it changes, as a clerk re-inks a figure: engraved in the serif, and only the characters that changed are rewritten, each fading out where it stands as its successor inks in over it, in LedgerMotion.slow; nothing rolls or slides. Characters are aligned from the end, so the units stay put when a new leading digit is written in, and every digit takes the width of the widest one so the figure never shivers. It lands on exactly the value it was given and, with reduced motion on, swaps. It reads as the figure printed (format renders it: 12 days, 1,284). style defaults to the engraved medium figure.
LedgerCrumb
One step of a LedgerBreadcrumb: its label and where a tap goes (onTap; null on the page itself).
LedgerCumulativeChart
A month's spending summed day by day against its budget (art.cumulative): the engraved area under the inked line, the budget as a double rule with its label, the budget's pace as a dashed green line from nothing to the budget at the month's end, the days ahead shaded, today's point and its dotted drop, the rent day's note, and the day ruler under it. 342 by 248 on a phone, 712 by 392 from 1024.
LedgerDashedFrame
A frame of the faint ink's dashes round its child (border: 1px dashed var(--ink-4), 6 round): what is not yet there. A new goal's tile, the blank goal a form previews, the empty mark of a row before it is saved. Dashed as Chrome dashes a border, 3 on about 2 off, fitted round its corners. It says nothing; its child speaks.
LedgerDashedOutline
A dashed outline 1 wide inside a rounded box, as Chrome draws CSS's border: 1px dashed in the captures: dashes of 3 about 2 apart round the corners, the gap fitted so the dashes go evenly round. A ghost tile's, a new goal's and a preview's edge. Plumbing of the components.
LedgerDataTable<R>
A ruled table of records (a month's entries, a statement): the headings in the small capitals over the ink rule, each a press that sorts by it (its arrow saying which way), the rows ruled under in the body face with numeric columns in the figures' face at their end. A row is a press that selects it when selectable (its box drawn at its start, filled when chosen; the box over the headings chooses the page), else opens it with onActivate. When columns cannot fit whole words, the other fields appear below the first text field with their column labels. The arrow keys move along the rows, one tab stop for all of them. controller holds the rows, the sort and the selection.
LedgerDatePicker
A day and a time of day chosen from a calendar or from wheels, in the ledger's hand. LedgerDatePickerPresentation.compact prints the label on the dot leader to the value in mono pills (Nov 4, 2026, 7:40 PM), each raising its own picker in a sheet that commits on Done; LedgerDatePickerPresentation.inline is the month itself: its name in the serif with the two ringed arrows, the weekdays in the small capitals, the days in 44 point cells with the chosen one struck on the ink and today ringed, closed on the accountant's double rule; LedgerDatePickerPresentation.wheel is the day, or the hour, the minute and AM or PM, as flat columns of figures that settle between two ink rules, as a ledger's column stands (never curved away like a drum). From 600 the month and the wheels stand at most 416 across (a desktop sheet's width), at the start of their slot; on a sheet's card they span the card. A day outside firstDate and lastDate is faint and takes no press, and every change is kept inside them. Weeks start on Monday. In English it writes as above; in another language, the days, months, clock and figures are that language's, in its order and its digits, from ui_core's DesignLocalizations (٢٠ نوفمبر ٢٠٢٦, ٠٩:٣٠, 20. Nov. 2026). Nothing here reads the clock: pass today to have it ringed. A null onChanged dims the whole picker and holds it. Each wheel is an adjustable value for a screen reader, and each day a button named by its full date.
LedgerDateRangePicker
A span of days (a statement's period, a trip's nights) chosen on the month grid: over it the span read as a ledger heads a period, FROM and TO in the small capitals over each date in the serif, the nights between in the mono; then the month in the bar's title with its two ways on the reading end, the weekdays in the mono's capitals and the days in their 44 cells. The first press sets the start, the next the end: each end a disc of the ink, the days between on a band of the darker paper running from one to the other, today ringed; a pointer over a day draws where the span would end in the band's lighter tint. The keyboard walks the days (arrows, Page Up and Down for months, Home and End for the week), Enter takes one. months shows two side by side on a desk. A screen reader hears each day whole, chosen or in the span.
LedgerDateTab
A day as a date tab (.when): the month in tracked mono capitals over the day in the serif, on a small slip of the light paper, 40 by 44. It names nothing to a screen reader; its row says the date.
LedgerDayBars
A month's spending by day as hatched bars (art.day_bars): one bar per day so far, as tall as the money spent that day, on the month's ruler; a bar past cap broken the way an engraver breaks an axis and labelled with its amount from capLabels; marks ring the paydays along the top on a dotted drop; the rest of the month shaded, nothing spent there yet; the grid dotted with its amounts (phoneGrid on a phone, its top line alone by default). 342 by 132 on a phone, 712 by 236 from 1024 (height for another).
LedgerDayGroup
A day of the register (.daygroup): its head (the day in the capitals, its date note for Today and Yesterday, its net at the end: what was spent and received, moves between the owner's accounts left out) over its rows, denser than a page's rows (36 marks, 10 above and below).
LedgerDayRulerLabels
The day ruler under a month's plot (.xruler): 4 under it, 14 tall, each label centred on its day. Plumbing of the engravings.
LedgerDelta
A figure's change under it (.delta): an optional rise in the green after its arrow, then each of words (their **strong** runs in the ink), then a pill, wrapping 10 apart, in the second ink at 15.
LedgerDensity
How tightly Ledger sets its controls and rows: the one size setting the look has, in Flutter's words for density. standard is the touch size the look is drawn at (a 48 button, a 48 field, a 52 row); comfortable takes 4 off each, compact 8. Every part that takes a line height reads its height here, so a field, a select and a button that share a line keep one height at every density.
LedgerDestinationFaces
What a bar paints the shell's destinations with, set round them.
LedgerDialog
A decision put on a slip of paper, centred over the scrim: the title in the serif over the ink rule, the body under it (and any children after the body: a field, a note), then the acts, two sharing the width or one across it. type picks them: a LedgerDialogType.confirm has Cancel and the green confirmLabel, a LedgerDialogType.destructive the vermilion one (only for what cannot be undone), an LedgerDialogType.acknowledge a lone "Got it". Its card is 360 at most, the raised paper on the dialog's shadow, and it scrolls once its words outgrow the screen. Raise it with show, which completes with true for the confirm, false for Cancel and null when the scrim, Escape or the system back dismisses it: ui_core's DesignDialogRoute fades it in on its spring (a short fade under Reduce Motion), keeps Tab inside it, opens with the focus on the safe act (Cancel beside a destructive confirm, the confirm otherwise) and gives the focus back to what opened it. A phone's choice among options is a LedgerSheet; a dialog is for one question.
LedgerDialogLead
A dialog's lead (.dialog-lead): what the act does, said plainly in the serif at 22 before what it does in detail; 12 above, 4 under. Each line of text (split at \n) its own paragraph.
LedgerDisclosure
Detail folded under a line (a fee's breakdown, the terms of a transfer): the title in the medium on a line 48 tall with a hairline under it and the chevron at its end, pointing down while open; a press opens or folds it, the child unrolling under the line in Ledger's one motion (at once with reduced motion). A pointer over the line darkens its words; the keyboard's focus rules the double rule under it. A screen reader hears the line as a button that is expanded or collapsed. note stands in the mono at the line's end before the chevron (a sum, a count).
LedgerDivider
A rule between parts of a page: the hairline between rows, strong the ink rule under a head, total the accountant's double rule over a sum. With a label the rule breaks for it at the reading start, the words in the mono capitals (OCTOBER, EARLIER), and a screen reader hears them as a heading; without, it says nothing. vertical stands it upright between columns, as tall as its row.
LedgerDoneHead
A done page's head (.done-head): what happened and when in the green mono (meta), then the title in the serif at 32 (44 from 1024) ending in its emphasis in the green italic, kept on the title's last line by a no-break space. The page's heading.
LedgerEase
A value on its way to value, moving in Ledger's one motion (as LedgerFace moves a whole face): a press's sink, a rule drawn in. A change mid-way turns from where it is; with reduced motion on, it lands at once. Plumbing of the controls.
LedgerEffect
What an act does, one line of it (.effect): a glyph (the ink's ring for what stops), its title in the semibold over its words in the second ink at 14; 12 above and below.
LedgerEffects
What an act does, all of it (.effects): its LedgerEffects one under another, a hairline between each and the next (.effect's rule, none under the last); 6 under what leads it. A freeze dialog's body under its lead, and the frozen card's notice (ruled: a hairline above the effects, under the 6, as .frozen-banner .effects has it).
LedgerEmptyState
What a page shows when it has nothing, as the source's empty search draws it: a blank page of ledger paper (ruled every 32, its double green margin rule down its start) stamped with the seal at its end, the title in the serif at 32 (titleItalic after it in the italic), the body in the second ink and the one act (actionLabel, ringed in the ink) that gets the person somewhere. From 1024 the page is the desktop's: padded 36 36 32 56, ruled every 36, its margin rules at 28 and 32, the title at 44 on 46.
LedgerEndGlyph
A Lucide glyph at the end of a line with its ink, not its box, on the line's end. Lucide draws on a 24 grid inside a margin, so a 16 chevron's box runs 5.3 past its ink, and a row ending in one would end short of the rule and the switch above it. Laid out at its box; painted moved toward the end by the glyph's margin (its tap box, the row, is unchanged). In a right-to-left page a left or right chevron or arrow turns the other way (ledgerDirectional). Plumbing of the parts.
LedgerErrorState
What a page shows when its records could not be had: the blank ledger page with the title in the serif, the message under it and Try again (onRetryPressed). DERIVED: the source draws no failure; it is the empty page's paper without its seal, its margin ruled in the vermilion (a state is written).
LedgerEvenActs
The acts at a card's foot: each takes an even share of the row, gap apart, the first at the reading start. When one act's words would not fit its share (a card narrower than a phone's sheet, the words at twice their size), they stand one above another across the whole width instead, the last (the confirm) on top, or the first when lastOnTop is false (a row that leads with its main act): an act is never cut short to an ellipsis. Plumbing of the parts.
LedgerFace
Ledger's one motion for a change of state. A face resolves its LedgerFaceStyle for its states and hands it here; when the states change, the face goes from the style it shows to the new one whole (the fill, the rim, the drop and the ink together), as ink fades in on paper, in duration on LedgerMotion.out. A change that comes mid-way turns from where the face is, never jumping back; with the platform's reduced motion on, it switches at once. builder draws the face in the style of the moment. Plumbing of the controls; pages never place one.
LedgerFaceStyle
What a face is in one set of states, whole: its ground (the fill, the rim and the drop as one decoration), the ink of its words and glyphs, the quiet ink beside them (a count's) and the rule under its words (an underline's ink; null for none). Plumbing of the controls; pages never make one.
LedgerFact
One fact of a LedgerFacts: its label in the capitals, its value in the serif (money with its cents set smaller), and its note.
LedgerFacts
A record's facts at a glance (.facts): each a label, a figure in the serif and a note, ruled in a grid of columns on a phone (the ink rule over them when ruled: no head stands above them), one under another in the desktop's margin (a LedgerFactColumns.pair two across there too, under the ink rule when ruled). Read fact by fact.
LedgerField
A form's field (.field): its label in the small capitals, then on the ink rule the words typed (the medium at 16; the hint in the third ink) after an optional serif prefix ($), its note under it. 16 above it. Says its label. A child stands in the typed line's place, a control rather than words (a cheque's When and its chips: 4 above it, 6 under it, at its start, no rule). A value stands there read only: the words as typed, which no one here types (a transfer's note shown on its cheque). On a cheque the rule is the faint ink (.cheque .field-box), the ink off one.
LedgerFieldFrame
A Ledger field as a ledger rules it: its label in the small capitals, then the line it is written on, ruled under in the ink (the accountant's double rule while it has focus, the danger red when wrong, the light rule when it cannot be used), then its help or its error. The rule is painted over the line's foot, so focus and error never move a pixel of the page. Its ink changes in Ledger's one motion, and focus draws the second line in from the reading start as a pen does. Plumbing of the text field and the select; pages never place one.
LedgerFieldRuled
Marks the field whose frame rules focus on node: a LedgerPressable on the same node (the select's line) leaves its own focus rule out, so the field's line is the one doubled. Plumbing; pages never place one.
LedgerFigure
The engraved figure, a page's one amount as the source sets it in the serif (.fig): its $ (and its sign) hung at the cap height at .34 of the size in the second ink, the dollars, and the cents raised to the same height and underlined like a cheque's. tone inks it; showSign puts the plus on money received; showCents false drops the cents (a goal's whole dollars). Read aloud as one amount.
LedgerFile
One attached file: its name, its bytes, how far it has gone up (progress, 0 to 1; null once it is in) and what went wrong (error).
LedgerFileUpload
Files attached to an entry: a slip ruled round in the dashed rule, a paperclip and hint on it, that opens the app's picker (onPick) when pressed (its rule turns to the ink under a pointer, the stamp's sink while held, the double rule with focus); then each of files on a line of its own, its name in the medium and its size in the mono, a rule filling under it in the ink as it goes up, its error in the vermilion, and the cross that takes it off (onRemove). Its label in the small capitals over the slip. onPick null holds the slip in the third ink.
LedgerFilters<T>
Filter pills (.filters): each its own ring of the light paper, the chosen one in the ink, wrapping 6 apart; value null chooses none. label names the set. onChanged null shows them without letting them change. optionKeys keys each pill by its value. The options are any values: labelOf words each (its toString() when null).
LedgerFlag
A flag under a section (.flag): a vermilion bead, the words with their **strong** part in the vermilion (Dining out is over by $36.40), and a chevron at the end; the whole line one link.
LedgerFocusRing
The focus mark a Ledger control wears: the accountant's double rule, two lines of LedgerChromeMetrics.focusRing in color, LedgerChromeMetrics.focusGap apart and twice that under the face standing insets inside child's box, clear of the face's drop. It is centred under the face and as long as the face less one corner of radius, never shorter than three quarters of the face. It is drawn in from the reading start as a pen draws it, in LedgerMotion.base, and drawn back out when focus leaves. Painted over the child, it takes no room and no taps. Plumbing of the controls; pages never place one.
LedgerFooterBand
Marks the band a screen or a sheet stands its footer in, so a bar that also asks for a band of its own there is caught: the two would draw two hairlines and inset the bar twice. Plumbing of the components; pages never place one.
LedgerFormat
Ledger's display formatting: the money, days, clock times and counts a finance screen prints, in the shapes the Keel pilot writes them ("−$1,326.44", "Mon, Oct 26", "8:12 AM", "In 4 days").
LedgerFrozenBanner
The frozen card's notice on its slip (.frozen-banner): the ringed icon beside its title in the serif and its text, then what being frozen does (effects, under a hairline) and the act that undoes it (actionLabel, the primary button across the slip). From 1024 the act stands beside the head and the effects side by side.
LedgerGap
A fixed spacer of one LedgerSpacing step.
LedgerGauge
The hatched gauge (art.gauge), drawn on its 300 by 16 grid scaled to its width: a faint frame to the budget, the part spent hatched and edged in its ink to its mark, past the budget vermilion on its wash; the budget's tick across it; the month's pace as a green line on the paper. budgetAt places the budget along it (a category's stands at 250 of 300, room left for going over). Its paceLabel stands over the pace's line, its startLabel and endLabel under its ends, its budgetLabel under the budget. Spending past its end stops at its end, clipped to its box as the source's svg is. In right to left it runs from the right, its labels mirrored with it. Read as its label and the share spent.
LedgerGlyph
A round mark wearing one Lucide glyph (.glyph): an account's, a category's, a goal's, a move's (dashed). It names nothing to a screen reader; the row it leads says what it is.
LedgerGoalCard
A goal's card (.goal-card): its LedgerGoalLine's parts 18 above and below, then its status pill (green on track, the ink behind) and its note; on the desktop the note stands in a 264 column beside them, 44 off. A target of 0 reads 0% on an empty gauge, as on LedgerGoalLine. One link to the goal.
LedgerGoalChart
A goal's saving over time (art.goal_chart): the months saved engraved in the green under the inked line, each ringed, today green with its halo; the target as a double rule with its label; the projection on as a dashed green line to a ring at the goal's date over the shaded months ahead, its endLabel at the foot; or, with no projection, the gapLabel's dimension line from today up to the target. months keys the months under it. 342 by 196 on a phone, 712 by 300 from 1024, or height / deskHeight.
LedgerGoalLine
A goal's line (.goal): its glyph and name on the leader to the share saved, the green gauge under them, then what is saved of the target and by when (by May 2027, reaches May 2027); 16 above and below. The share ends at the line's end, the leader filling what the name leaves. A target of 0 (a goal with none set yet) reads 0% on an empty gauge, as the new goal's preview stands before its target is typed ("0%", gauge(0)); the words keep the sums given ("$0 of $0"). One link to the goal, read as its name, share and date.
LedgerGrabber
The grip at the top of a phone sheet (.grip): a 36 by 4 bar in the faint ink, 8 under the sheet's top. The desktop's dialog has none. Plumbing of the sheet.
LedgerGridLine
A line across a plot at value, its label at the plot's end above it (.ylab: $2k, 60k).
LedgerGuilloche
The guilloche rosette (art.guilloche), a banknote's turned ornament on its 400 grid scaled to its box: eighteen waved rings (r 150 ± 24, ten waves) at .45 and twelve inside (r 100 ± 9, sixteen waves) at .4, in color (the green by default). Drawn behind a card's face and as a page's watermark; it says nothing to a screen reader.
LedgerGuillocheBand
A banknote's border (art.guilloche_band): ten interlaced sine waves (eighteen across) on a 600 by 14 strip stretched to its width, in color at .45: the head of a receipt, a cheque and a form. Says nothing to a screen reader.
LedgerHead
A section's head (.head): the ink rule across the column, 11 under it the label in the tracked capitals, a footnote mark beside it, and at its end a mono note (Balance, Day 28 of 31), the note as a green link with its chevron when onTap is set (All bills, View all), or a trailing control (the range chips). LedgerHead.hero, a page's first head, centres its parts 10 under the rule; a faintRule head draws its rule in the hairline's ink. The label is read as a heading.
LedgerHitSlop
Takes taps over at least a target square round its child while laying out at the child's own size. Ledger's parts reach their floor through ui_core's DesignTapTarget since 0.2.0, whose screen-reader box is the reach a tap has; this forwards to it, for a component copied from 0.1.
LedgerHoldingRow
One fund of a portfolio (.holding): its monogram, its name over its symbol and shares, its value over what it moved today (green when it rose). From 1024 one line: name, symbol, kind, shares, value and today in their columns under LedgerHoldings' heads. Stand them in LedgerHoldings.
LedgerHoldings
A portfolio's funds (.holdings): from 1024 the column heads over them (Fund, Symbol, Kind, Shares, Value, Today, the last two at their ends) on a rule; then its rows, the hairline between each.
LedgerHost
The one mount of Ledger. Picks the theme for the brightness in force, publishes it as a LedgerTheme, gives the platform primitives beneath the thin Material ThemeData they read, paints the ground behind the app, sets the body type as the default text style, carries status-bar polarity, and lets the reader's text size reach maxTextScale (200%): rows grow and wrap to it, and past it a page stands at 200% rather than break. Day to night (or one theme to another) the paper and the ink fade across in LedgerMotion.slow (AnimatedLedgerTheme); with reduced motion on they change at once. It hosts the toasts (LedgerToaster). Every render host mounts it once above its Navigator: the app in its router builder, a page preview in its own.
LedgerIconButton
A round button of one glyph in the ink, saying semanticLabel: bare, or with LedgerIconButton.outlined ringed in the rule (the way back, a sheet's close, the desktop's bell). showBadge marks it with the green dot ringed in the paper (unread notes). A null onPressed disables it: its glyph in pencil, the third ink. It lays out at the tap floor round its face at every size (44 for a finger, 24 for a pointer). A left or right chevron or arrow turns the other way in a right-to-left page, so a way back points to the reading start.
LedgerIconChoice
One glyph a LedgerIconPicker offers, and the name it is read by.
LedgerIconPicker
A form's choice of one glyph (.icon-grid): its choices in rounds of 48, five to a line spread across it on a phone (16 apart from its start from 600), 10 between lines; the selectedIndex one green on its wash, ringed out in the green past the paper. Read as a group (semanticLabel), each glyph a button named "Icon: plane" that says whether it is chosen.
LedgerIconSize
Glyph sizes: a section link's chevron (14), a crumb's, a toast's and a quiet button's (15), a menu's check and the sidebar's chevron (16), a button's, a nav link's and a ringed button's (18), the body glyph (20) and a tab's (22).
LedgerInputGroup
A field and its add-ons as one control (a web address's https:// and .ledger.app, a weight's kg, a code's copy button): each add-on in a column of its own on the field's one rule, a hairline between it and the words, as a ledger rules its columns. The add-on words stand in the mono in the second ink, the third while the field cannot be used; action (a Ledger icon button, say) closes the line at the reading end. A tap on the frame or a word add-on puts the caret in the words. Its label, its help or error, its focus rule as every Ledger field's.
LedgerInsets
The paddings Ledger's parts use, on the spacing scale.
LedgerInventoryGallery
Every row of inventory, group by group: a group's head counts the parts Ledger carries, each row names its Ledger part over its specimen, and a row a ledger leaves out reads its reason.
LedgerKbd
The keys of a shortcut, each printed as a ledger prints a mark: its name in the mono capitals on the light paper, ringed in the rule, with the heavier ink rule of the key's edge at its foot, 4 apart (⌘ K, Shift Enter). It is read, never pressed: a screen reader hears the keys joined, or semanticLabel (Command K) when the marks are symbols.
LedgerKeyEntry
One entry of a LedgerChartKey: its swatch and its words.
LedgerKeyFocus
Keyboard reach for an adjustable control (the switch, the sliders, the stepper, the segmented strip): it takes focus, answers keys, and rules the double rule in the ink under it (LedgerFocusRing) while the keyboard, not a pointer, holds focus. Plumbing of the controls; pages never place one.
LedgerKeyValue
A record's key and its value on the dot leader (.kv): the key in the second ink, the value medium (in the mono when monospace: a mask), and an action 10 beside it (Change), 11 above and below. The key and the value read as one line; the action is its own button beside it. Stand them in LedgerRows.
LedgerLayout
Responsive layout invariants shared by Ledger apps.
LedgerLeaderFill
The dot leader alone, filling its width, centred on its line (a goal's line, where the parts stand centred). Plumbing of the rows.
LedgerLeaderLine
A line of a name and its value on one baseline, the dot leader between them (.leader): dots of the faint ink (the full ink while the row above is hovered or pressed) every 5, 3 tall, standing on the baseline 8 clear of each, at least 16 long. The line fills its width; the end keeps its own, and the start gives way first. Where the start cannot keep its longest word, or (at the reader's larger text) cannot stand whole, the line turns over: the start on a line of its own, the leader under it running to the end, so neither is cut. A setting's line stands its leader 6 clear and lets it shrink to 8 (inset, minLength). centred stands the parts and the leader centred on the line instead (a goal's line, .goal .line: align-items center, the leader align-self center).
LedgerLeaderPainter
The dot leader as Chrome draws the source's .leader: a strip 3 tall tiled every 5 from its start with one dot, centred 1.5 into the tile, solid to .85 and faded out by 1.15 (radial-gradient(circle at 1.5px 1.5px, ink-4 .85px, transparent 1.15px) repeated along x), the last tile cut at the strip's end. Plumbing of the leader and the rows.
LedgerLoadingState
What a page shows while its records come: its message in the mono capitals, then a dot leader that draws itself in, dot by dot, like a line waiting for its figure (standing whole when motion is reduced), on its room's start where the first record will stand, as the error's and the empty page's words stand on theirs. DERIVED: the source draws no wait.
LedgerMedia
A picture in Ledger's frame (a receipt's photo, a payee's storefront): the image laid in the slip's small corners under a fine rule, cropped to aspectRatio. While it loads, when there is none and when it fails, the darker paper stands in its place, engraved with fine hatching, a glyph in its middle. caption stands under it in the mono capitals. A screen reader hears semanticLabel as an image; without one the picture says nothing (the words round it say what it shows).
LedgerMediaGround
Stands child on the media ground: the host's dark tokens under a light status bar, for chrome drawn over a full-bleed photograph or video (the shell's bar on a media tab). Nothing in it blurs.
LedgerMemberCard
The account holder's certificate (.member), printed on a LedgerSlip: the guilloche band, its kind and since in the mono, then the holder's initials inked on a disc beside the seal (from 1024 the name between them), the name in the serif 40 over its subtitle, an ink rule, and the details (key and value lines). The profile's head.
LedgerMemo
A memo on its slip (.memo): a short verdict in the serif at 28 (its text, then its over words in the vermilion italic, then textAfter) beside its seal (pressed at the memo's 92; under the words at a large text size), and under a hairline its foot: a leading (a monogram), the note (its noteAmount in the semibold mono ink, then noteAfter) and a chevron. With onTap the foot is one link. Line breaks in the words are the caller's (\n).
LedgerMemoSlip
A memo slip (.goal-memo): a goal's standing as its label (in the second ink), the owner's own note in the serif at 22, and the actions it offers (buttons, 10 apart, wrapping), on the light paper.
LedgerMenu
A menu (.menu): a slip of the raised paper 300 wide, lifted on the menu's shadow, a mono head over its items, one choice of a set (the months Spending can show): each 46 tall, the chosen one checked in the green on the paper. Stand it 10 under the control that opens it (centred under it on a phone, at its start from 1024). One item at a time is marked under its words, the pointer's underline or the keyboard's double rule, whichever moved last; with the keys in it, the pointer moves their place too. Read as its semanticLabel, each item a button that says whether it is chosen.
LedgerMenuItem
One item of a LedgerMenu: its label, an amount at its end, and whether it is the one selected (checked, on the paper, semibold).
LedgerMenuMarks
An open menu's rows with one current row among them: the row the pointer or the keys moved to last, marked as that one moved it (the pointer's underline, the keyboard's double rule, LedgerMenuRow) and no other, so a pointer resting on one row and the keys on another never read as two. A pointer moving onto a row moves the keys there too while they are in the menu. A menu a pointer opened lights none until the pointer or the keys move: Down, Enter or Space then lights the row the keys hold (the first) rather than pass or press it unseen.
LedgerMenuRow
A row of a LedgerMenuMarks menu: builder gets the pressable's states with its hover and focus replaced by the one current row's mark (hovered while the pointer lit it, focused while the keys did). Under no LedgerMenuMarks, states as they are.
LedgerMonogram
A merchant's or a person's initials in the italic serif inside a fine ring (.mg): "BF" for Blue Fern Café, green on its wash for who paid the owner, the paper's letters on the ink for the account holder (LedgerMonogramTone.inked). selected rings a chosen person in the green, the paper between. It names nothing to a screen reader; the row says who.
LedgerMonthBars
Months as bars (art.month_bars): one hatched bar per month, the latest solid, on a double rule; a bracket over a run of them with its words, marks labelling a bar's top (the latest's ending on its right side). Green by default. 342 by 164 on a phone (its bars 58 under the top), 712 by 240 from 1024 (64).
LedgerMonthKeys
The keys under a plot of months (.xlabs): 8 under it, one per month centred in its column, a gutter at the end left empty (the scale's column); the now month green, the end month in the ink. Plumbing of the engravings.
LedgerMonthLine
A month as a line (art.month_line): an account's balance or a portfolio by the end of each day from its start, engraved under the inked line on the month's ruler, its marks ringed (a payday above, a card's payment below), today ringed green with its endLabel (above its ring with endAbove), the days ahead shaded, the grid dotted. 342 by 196 on a phone, 712 by 300 from 1024, or height / deskHeight.
LedgerMonthRule
Where a register runs back into an earlier month (.month-rule): the ink rule, 12 under it the month in the capitals and a mono note at the end (Last month).
A link standing on its own under what it closes (a.head-link.more: "See all 13 visits"): its words in the green mono capitals (500 11 on 16, tracked .04em), the 14 chevron 2 after them; the link a head's note draws, outside a head. label names it when its words say too little; its key sits on its hit target.
LedgerMotion
Motion: durations and curves. DERIVED: the source is static pages and moves nothing but its overlays' open and close. Where the reader asks for reduced motion (Android's Remove animations, the web's prefers-reduced-motion or iOS's Reduce Motion: ui_core's designReduceMotionOf), every change lands at once (of).
LedgerMultiSelect<T extends Object>
Several values (the categories a rule files under, the people a bill is split with) chosen as tags on one Ledger field: each tag a ringed pill of the mono capitals with its cross, the words typed after the last on the same rule, and the matching options on the select's raised paper as they are typed. Enter, a comma or a tab takes the highlighted line (or, with onCreate, makes a tag of the words); Backspace in the empty field walks onto the last tag and takes it off, the arrows walk the tags. Each cross is laid out at the tap floor, and a tag the keyboard is on is ringed in the ink. maxTags stops it taking more.
LedgerNarrowScope
Sets the parts under it in their phone form on any window: a part laid in a slot too narrow for its desktop form (a receipt in a column beside a form) reads LedgerLayout.isWide as false under it. Plumbing of the parts.
LedgerNavBar
The phone's tab bar, as the source's .tabbar draws it: raised paper 84 tall with a rule over it, five columns of a 22 glyph over its name in the third ink (the current one in the ink, the green tick under it), the middle destination drawn as the green disc ringed in the paper (Move). The columns stand in one row hung from under the rule, as tall as its tallest column and never shorter than the bar's room over its 22 foot, each column at the row's foot: the disc's column fills the bar from its rule and the tabs end 7 over the bar's foot, where the browser's grid sets them. A ShellAction given to the shell stands as the disc instead, between the tabs. accessory rides 8 over the bar. It is paper, opaque: the source frosts it, but a page scrolled under glass smears through (no glass, no glow).
LedgerNavigationFrame
An app's frame: the current destination's body with the navigation the window earns. Under railFrom (600) the tab bar stands at the foot (LedgerNavBar); from it the rail stands at the start (LedgerSideBar with extended: false); from LedgerLayout.wide (1024) the full side bar with the brand's wordmark. The page stands above the tab bar or beside the rail or side bar; beside either, its masthead heads it (the phone's strip is the tab bar's partner only).
LedgerNavItem
One destination of the app's root, as generated apps declare a tab: its glyph, the label the tab bar and the sidebar print (and speak) and the walkthrough key set on its hit target, positionally. While current it wears its selectedIcon (null keeps icon); its page stands on its ground (the design kit's surface or media). As the bar's green disc (the app's main act), the sidebar's green act says its actLabel (LedgerNavItem.act).
LedgerNetWorthChart
The net worth over a year of month ends (art.net_worth): an engraved area under the inked line, each month ringed, today's point green with its halo and a dotted drop, the grid dotted across with its scale, and today's endLabel beside its point; months keys each month under it (the last green), each key centred under its point and whole however narrow its slot (an empty key draws nothing, so a day's or a year's range can key only some points). Sized by its width: the source's 342 by 168 on a phone, 712 by 330 from 1024, or height. Read as its label and end.
LedgerNoOption
The paper's line when nothing matches: the words in the third ink.
LedgerNote
One footnote of a LedgerNotes: its mark and its words.
LedgerNoteRow
A notification's row (.note-row): its glyph, its title on the dot leader to when (the time today, else the date) and its body under it, the title free to wrap. An unread one stands on the green wash fading across (14 by 12 inside, 6 round), its glyph green, its title semibold and tagged, its time green. One link, read as its title (and unread).
LedgerNotes
A page's footnotes (.notes): each mark in the green mono hung in its 10 wide column, its words in the second ink, 8 apart: marginalia on the desktop, under the section on a phone.
LedgerOnCheque
Marks the lines under it as standing on a cheque (.cheque), where a field's rule is the faint ink (.cheque .field-box { border-bottom-color: var(--ink-4) }) rather than the ink it is off one. The cheque wraps its lines in it; LedgerOnCheque.of tells a field which rule to draw. Plumbing of the components; pages never place one.
LedgerOption
One option of a choice (.opt): its glyph, its label and a round check at its end, 10 above and below; the selected one green (its glyph ringed and washed, the check filled). Stand them in LedgerRows for the hairlines between (a sheet's categories). Each is a button that says whether it is chosen.
LedgerOptionRow
One suggestion on the paper, 48 tall: its words in the medium, a hairline over it after the first. The one that is the value stands on the menu's paper, its words semibold, the green tick at its end; the pointer's or the keyboard's marks run under its words alone (LedgerOptionWords).
LedgerOptionWords
An option's words in an open list (a select's, a menu's, a combobox's or a tag field's), marked for its states on its own row: semibold when it is the chosen one (its row on the menu's paper, the green tick at its end); under a pointer or a finger they take the ink underline, as a frameless act's words do; while the keyboard is on the option they stand on the accountant's double rule, Ledger's focus. Both marks run under the words alone, inside their row, so neither reads as a rule between options or as a second choice, and each comes and goes in Ledger's one motion. Plumbing of the lists.
LedgerPage<T>
The go_router Page for a route pushed off a root: its route is laid down in Ledger's page motion (LedgerPageTransitions, which the host sets on every platform), standing on the theme's ground.
LedgerPageDots
Which of a few pages shows (a welcome's cards, a carousel's slips): a short rule for each page in the light rule, the page shown a longer one in the ink that runs to the next in Ledger's one motion, as a ruler marks its place. With onChanged each mark is a key laid out at the tap floor that turns to its page, darkening under a pointer; without, the marks only show the place. A screen reader hears "Page 2 of 5".
LedgerPageTransitions
Ledger's page motion, for a PageTransitionsTheme: a pushed page is a leaf laid down on the ledger. It fades in as it rises the last rise onto the page, in LedgerMotion.base on LedgerMotion.out; a pop lifts it off the same way, and the page under it stays where it is. Under reduced motion it lands at once. A destination chosen from the side bar, the rail or the tab bar is no push: it changes in place.
LedgerPagination
The pages of a long register: the way back and the way on as ringed keys at the ends, between them the page figures in the mono, the page shown underlined in the accountant's double rule and set in the ink, the rest in the second ink, darkening under a pointer; a run of pages too long to show folds into an ellipsis round the page shown. Where the figures do not fit (a phone at a large text size) it reads PAGE 2 OF 9 between its keys. page counts from 1. Each figure is laid out at the tap floor; a screen reader hears each as "Page 3", the shown one as selected.
LedgerPasswordField
A password written on the rule, as LedgerTextField is, its letters hidden as dots, with the eye at its end that shows them and hides them again: the eye says "Show password" or "Hide password" and the field keeps its focus and its caret as it flips. With hideOnBlur a shown password hides when focus leaves the field. autofillHints default to a password's, so a password manager offers to fill it.
LedgerPerforation
A tear line of punched holes (.perf): a hole of the darker paper, shaded by the rule's ink, 2.1 round (fading out by 2.6) every 9 along a strip 6 tall, whole holes only, the spare length split between its ends (a hole cut at an end reads as sliced by a slip's notch); vertical runs it down (.vperf). Says nothing.
LedgerPickLine
A cheque's line (.pick-row): its label in the small capitals, then the account's glyph, its name over its mask in the mono, its balance with its note (Available) at the end and, live (onTap), a chevron to choose another; read back (no onTap) it is no control. A choice shown that opens nothing keeps the chevron with showChevron (the form's From and To), still no control.
LedgerPieChart
Shares of a whole (October's spending by category): a ring cut into its shares, each in one of Ledger's inks (the ink, the green, the vermilion, the second ink, the light rule), parted by a hair of the paper, the whole in the serif in its middle; beside or under it a key, each share's swatch, its words, its amount in the mono and its part of the whole. Five shares at most; fold the rest into one ("Other"). A screen reader hears the whole and each share with its part. The figures and parts are in the reader's digits; the word under the whole is totalLabel.
LedgerPill
A figure's change or a record's state in the mono on its wash, round (.pill): +3.86%, −6% vs September, Autopay on. It never acts.
LedgerPlot
A plot sized by its constraints: as wide as it may be, as tall as height or the source's aspect for its width class (phoneAspect up to 1024, deskAspect from it), its engraving drawn by draw at that size in the source's own units (one unit a pixel), and its labels over it. Plumbing of the engravings.
LedgerPlotLabel
One label of a plot, placed as the source places its HTML over the SVG (style="left:…%;top:…%" in the plot's own units): its box's start at left (or its end at right from the plot's end), its top at top, then moved by shift of its own size (CSS's translate(-100%, -50%) is Offset(-1, -.5)). Plumbing of the engravings.
LedgerPopover
A slip of detail anchored to a control (how a figure was reached, a payee's details beside its name): the raised paper in the rule, at most width wide, its title in the medium over the child, below the anchor (above it when there is no room), lining up with its reading start. anchor builds the control from its DesignOverlayAnchor: its press calls toggle, and its isOpen is the control's expanded state. The slip fades and settles in on Ledger's spring (at once with reduced motion); a tap outside, Escape or the anchor again closes it, focus going back to the anchor.
LedgerPressable
The one press machine every Ledger control rides, on ui_core's DesignPressable: the tap, the pointer's click cursor, keyboard focus with Enter and Space, and the semantics of the control it makes (a button or a link, enabled or not, selected, checked or toggled). Ledger says each state in its rules and its ink, never in a wash: a press sinks the face LedgerChromeMetrics.pressSink into the paper, like a stamp; keyboard focus rules the accountant's double rule in the ink under the face (LedgerFocusRing), only while the keyboard moved focus; a hover or a press inks a row's dot leader in (LedgerPressStates carries them to the face). Each change moves in Ledger's one motion (LedgerEase, LedgerFace): the face sinks and rises, the rule is drawn in as a pen draws it, and a change mid-way turns from where it is. Plumbing of the components; a page places one only to make a row or card it composed by hand one tap target.
LedgerPressStates
The states of the nearest LedgerPressable above (hovered, pressed, focused, selected), for a face that answers them in its own ink: a row's dot leader inks in, a filled button's shadow goes while pressed. Plumbing of the controls; pages never place one.
LedgerPreview
One page's isolated preview: the same host, bar, route and sheet the app gives the page live, without the router, so preview pixels match in-app pixels and the chrome the route derives is the real one: the way back when pushed, the close on a sheet. A pushed or sheet page is raised over a blank stage so its exit renders as it does live; a preview is looked at, not walked out of, so the exit leaves the page standing. A root stands over the tab bar on a phone; at desktop width a root and a pushed page stand beside the sidebar (tabs, activeIndex its current), as the shell stands every page there. Given the page's location, the sidebar marks the account's foot when the page is its profile.
LedgerProgressBar
How far a piece of work has gone along a rule: the light rule its whole length, the ink filling it from the reading start to value in Ledger's one motion. With no value it is under way without a measure: a short stroke of the ink runs the rule's length and starts again (with reduced motion a third of the rule stands inked). A screen reader hears its label and how far it is ("60%").
LedgerProgressRing
How far a piece of work has gone round a ring: the light ring whole, the ink closing it clockwise from the top to value; the figure in the mono inside it when showValue. With no value a quarter of the ink turns round the ring (still, with reduced motion). size is its across. A screen reader hears its label and how far it is.
LedgerPullToRefresh
A list fetched again by a pull from its top (the register's bank feed): as it is pulled, a rule of the ink draws out from the middle in the room opened above the list, reaching the width when a letting go would fetch, and the words under it change from Pull to fetch to Let go to fetch; while onRefresh runs the ring turns there with Fetching, then the list settles back. A screen reader offers the fetch as an action and hears when it starts and ends. child is the scroll view.
LedgerQuickAction
One way of a LedgerQuickActions: its glyph, its words, where it goes, and the walkthrough key its link carries (the source's .action links).
LedgerQuickActions
The ways to move money (.actions): on a phone a strip ruled above and below, each way a 44 ink ring over its words, hairlines between; in the desktop's margin a list, each a 36 ring, its words and a chevron, the hairline under each. Every way is a link.
LedgerRadio<T>
A radio: a 20 ring in the ink, an ink dot in it when value is the groupValue. With a label the words stand after it on one line, and the line is the target. A null onChanged disables it; with toggleable a press on the chosen one clears the choice (null).
LedgerRangeSlider
A span between two values (an amount from and to, a range of dates by day) set along the slider's ruled track: the ink rule between the two knobs, the dot leader outside them, each knob a ring of the ink holding the paper, flat on the rule. Over it the label in the small capitals and the span in the mono, its unit after it. Drag a knob, or tap the track to bring the nearer one; the arrow keys step the focused knob, which takes the accountant's double rule under it; a knob a pointer is over darkens its paper, a held one sinks a pixel. The knobs keep minGap apart; divisions snaps them and ticks the track. Each knob's target is the tap floor; a screen reader hears each knob by its own label and value. A null onChanged dims it.
LedgerReceipt
A transaction's receipt (.receipt), printed on a LedgerSlip: the guilloche band, its kind and number, the leading beside the name in the serif and its subtitle, the engraved figure with the seal pressed at its end (both sized for a receipt), the tear line, then its details (key and value lines).
LedgerRecordHead
A record's head (.rec-head): its leading (a LedgerGlyph or a LedgerMonogram at record size) and beside it the record's name in the serif, 30 (40 on the desktop), its subtitle under it with a mono part (the mask). The name is read as a heading.
LedgerRegister
The register (.register): the transactions as a statement, its day groups 20 apart (28 on the desktop), a month rule where it runs back into an earlier month. On the desktop its rows stand in columns (time, mark, merchant, category, account, amount, as columns keeps them) under the column heads (their words, the mark's column left blank); searchResults narrows the columns to the search's main column; showDay widens the first for rows that carry their day (Home's recent activity, with no day groups).
LedgerReorderableList<T extends Object>
A list the reader puts in order (the accounts on Home, a budget's categories): each line ruled under, itemBuilder's content beside a grip at its end. A press on the grip, or a long press anywhere on the line, lifts it on paper with the menu's shadow, the others making room in Ledger's one motion as it is dragged. A screen reader offers Move up and Move down on each line and hears where it landed. The list is only as tall as its lines: put it in the page's scroll.
LedgerReportHeight
Reports its child's laid-out height to onHeight after the frame that changed it (the shell's measured allowance). Plumbing of the shell and the preview.
LedgerRow
The ledger row (.row): a leading (a monogram, a glyph or a date tab), the title joined to its value by the dot leader, and under them two sub lines, subtitle and trailingSubtitle (in the mono, or green, as their tones say), 14 above and below. onTap makes the whole row one link; semanticLabel names it when its words say too little. Stand rows in LedgerRows for the hairlines between them.
LedgerRows
A ledger's rows (.ledger): one under another, the hairline between each, none after the last. divided false stands them with no rules (a list of lit rows).
LedgerSavedAfter
What a goal will hold once the money lands (.add-after): the title on the dot leader to the value (the sum and its share), the green gauge filled to ratio, and under it how it adds up (subtitle) and the target (trailingSubtitle); a rule above and below. The add money sheet's line.
LedgerScreen
A page: its body on the paper, under the head its route earns. On a phone the topBar's paper strip is pinned over the page (the wordmark, the bell and the avatar on a tab's page; the way back and what the page is on a pushed one) and the page scrolls under it, its masthead (a tab's date over its title) first; on the desktop the masthead heads every page (a pushed one's with its crumb) beside the sidebar. On a sheet's card the bar is the sheet's head.
LedgerScrollArea
A scrolling region (the terms of a transfer, a long note) whose scrollbar is a fine rule in the margin: the light ink 3 wide, the second ink and 5 wide under a pointer or while dragged, fading after scrolling stops (at once with reduced motion). Its pointer target is 12 across. It is a tab stop the arrow keys scroll; while the keyboard is on it the double rule stands round it. child is the scroll view, on the same controller.
LedgerSeal
The seal: a milled-edge stamp pressed slightly off square, as the source's seal draws it, 112 round: a fine ring, 96 milled ticks, two rings inside (the inner one dotted), a wash of its ink fading to the rim, and three lines stamped in it: the kicker in tracked capitals, the value in the italic serif (a line break allowed), the foot in the mono. Pressed into the paper (multiplied), so the paper's grain shows through. size presses it larger or smaller (its art scales, its lines keep their type). Read aloud as its three lines.
LedgerSearchEntry
The way into a search: the search field drawn as a link, its glyph and hint in a round of the raised paper that opens the search page when pressed (onTap), and with onFilterPressed a square beside it that opens the filters, carrying the green count of those in force (filterCount). It takes no words itself; the page it opens does. One a page, over its first section. Says its semanticLabel (the placeholder by default) as a link, and the filter by filterLabel and how many are in force.
LedgerSearchField
The search field (.search), a round field of the light paper 46 tall: as a link (onTap: Activity's, leading to the search) its glyph and hint; live (no onTap) ringed in the ink, the words typed in the medium, a round clear at its end when onCleared is set and it holds words (clearKey keys it). Says its semanticLabel.
LedgerSection
A section of a page: its head, then 8 under it what it holds.
LedgerSegmentedControl<T>
A segmented set of words (.chips): the range of a chart (1M 3M 1Y All), Today or Later. The chosen one is set in the ink, the rest in the mono's second ink, all in one ring of the light paper; onChanged null shows the set without letting it change. Each says whether it is chosen. The ring is as wide as its chips, at the start of a wider slot. Keyboard focus rules the double rule under the focused chip, as wide as the chip and touching it. The options are any values: labelOf words each (its toString() when null), so a range can be an enum.
LedgerSelect<T>
A choice among items, written on a rule as LedgerTextField is: the chosen item's words on the line (its hint in the third ink while none is), a chevron at the end. A press opens the list under it on the raised paper, ruled between its rows, the chosen one on the menu's paper and ticked in the accent. Enter, Space or Down opens it too; open, the keyboard stands on the chosen option (the first while none is), the arrow keys move at once, round from the last to the first, Home and End go to its ends, a letter to the next option it starts, Enter chooses and closes, and Escape closes, the keyboard back on the field. A null onChanged disables it. From 600 it stands at a short entry's measure (at the start of its slot, at most LedgerLayout.fieldMeasure); on a phone it spans the column. Its list is the field's width, on the field's leading edge, wider only to fit its widest option (at most 320, as ui_core holds every list from a field). The field's words stand on the rule with no inset; the list's rows keep their 16, so its words stand 16 in from the field's.
LedgerSelectItem<T>
One choice of a LedgerSelect: its value and the words it shows.
LedgerSettingRow
A setting's row (.set-row): its glyph, its title on the dot leader (6 clear, 8 at the least) to its value, its subtitle under it, a faint chevron at the end. With onTap it opens its setting. With none it opens nothing and stands in the full ink, read as its words rather than as a control. enabled false holds it in the third ink, a control that cannot be used now (a frozen card's limit). Says its title and value.
LedgerShare
One share of a LedgerPieChart: its label and its value.
LedgerSheet
Present a sheet: show raises a transient one from a control (a category, an amount, a confirm) over the whole app; pageRoute is the route a declared sheet PAGE rides, created on the root navigator by the route code (LedgerSheetPage): that page is a plain LedgerScreen, whose bar becomes the sheet's head with its close.
LedgerSheetAct<T>
One act of a LedgerActionSheet: its label, the value it answers with, a glyph, and whether it cannot be taken back.
LedgerSheetCard
The card a sheet stands on, as the source draws it: the raised paper (on a phone open at its foot, at desktop width a whole dialog with its own deeper shadow), its content clipped to its corners and marked as on a card (LedgerSheetShell.around). Plumbing of the sheets; a page never places one.
LedgerSheetHead
A sheet's head (.sheet-head): its title in the serif, the ringed close at its end hung 6 into the gutter, an ink rule under both; 14 over the title on a phone (under the grip), 26 on the desktop's dialog. leading and actions stand before the title and before the close.
LedgerSheetPage<T>
The go_router Page whose route is Ledger's page sheet, created on the root navigator so it rises over the shell's bar. drawer stands it as tall as its content, confirm as the narrower dialog of a question at desktop width; fullScreen raises a full-screen cover on the ground instead, with no barrier, drawn as a pushed page whose exit is the close. Either publishes RoutePresentation.sheet around its child, so the screen inside derives its close, or with back the way back.
LedgerSheetShell
A modal sheet's card, drawn in place: on a phone it rises off the bottom edge, its top corners at 6 (--r-sheet), the grip over its head; at desktop width it stands centred, 480 wide, every corner at 6 and no grip. Its face is the raised paper with the sheet's shadow. The head (LedgerSheetHead: the title and the ringed close over the ink rule), then the body's children 8 under it, then the foot 20 under that: one button takes the whole width, two share it 12 apart. The card scrolls once its parts outgrow 90% of the screen (84% at desktop width). For a sheet composed in place; LedgerSheet.show presents this same widget, so the two never drift apart.
LedgerShellDestinations
The destinations ui_core's shell built (its navigation builder's), for a Ledger bar to lay out in place of presses of its own: LedgerNavBar and LedgerSideBar under LedgerNavigationFrame. Each paints its face through the bar's LedgerDestinationFaces.
LedgerShellFace
A destination's face in ui_core's shell: whatever the bar it stands in paints for it.
LedgerSideBar
The desktop's sidebar, as the source's .sidebar draws it in its 248 column of sunken paper, a rule down its end: the wordmark at 30, the green act (the tab bar's disc, Move money, or the shell's act), the other destinations as links of 40 (the current one on raised paper, ringed in the hairline, its glyph green), and at its foot over a rule the owner (the avatar, the name, the meta line and a chevron), which opens the profile. On the profile (profileSelected) the foot is the current place; with selectedIndex null (the notifications) no destination is current. solid draws it on the media ground's dark paper.
LedgerSideInset
How far the desktop sidebar stands over the left of the pages under it: a page lays its content out to the right of inset, as the source's grid does. The shell publishes it on the desktop; elsewhere it is none. Plumbing of the shell and the screen; pages never place one.
LedgerSideSheet
A side sheet's panel (a record's details beside its list, the filters of a register): the raised paper the screen's height, a hairline on its inner edge, its title in the serif with the ringed close at the head's end, the child scrolling under a hairline and foot's acts at its foot. showLedgerSideSheet stands it in from a side; drawn in place it is the same panel.
LedgerSkeleton
The paper's placeholder while a page loads: lines bars of the darker paper in the shape of the words to come (the last one short), a slow sheen passing over them, still with reduced motion; avatar puts a disc before them, as a row's initials stand. A screen reader hears "Loading" once for the whole placeholder.
LedgerSlider
A value along a ruled track: the ink rule up to the knob, the dot leader beyond it, the knob a ring of the ink holding the raised paper, flat on the rule (no shadow: only a slip of paper rises). Over it the label in the small capitals and the value in the mono, its unit after it. Tap the track or drag the knob; the arrow keys step it (one division, or a tenth of the range), Home and End jump to the ends, and a screen reader steps it by its increase and decrease. divisions snaps the value and ticks the track like a ruler. format prints a value's figure (20, 70%), for the line and for a screen reader alike; without it a range of 0 to 1 prints as a percent and any other as the value, rounded to a whole number (a tenth on a span under 10). A null onChanged dims it. The touch strip is 44 tall.
LedgerSlip
A slip of the light paper (.sheet): 6 round, lifted off the page by its shadow. What a receipt, a cheque and a memo are printed on.
LedgerSlipBand
A slip's band of guilloche across its head (.receipt-band): 14 tall, the green at .5, its top corners the slip's. It stands first on a LedgerSlip, edge to edge (outside the slip's side room), over a LedgerSlipHead: how a page prints its own slip (a new goal's form, a member's card) as the receipt, the cheque and the statement are printed. It says nothing.
LedgerSlipHead
A slip's head (.receipt-head): what the slip is (start: its kind) and its number, date or class at the far side (end), in the mono capitals at 10; 12 under the LedgerSlipBand (16 from 1024), 18 over what follows (26). Inside the slip's side room.
LedgerSpacing
Design tokens and theme assembly: the only styling vocabulary a Ledger page may use.
LedgerSparkline
A figure's short history (a balance's last 30 days) as one fine line in the ink, its last point a dot, set beside a figure or in a row; with baseline a dotted rule where the figure started. It says its label and its first and last values to a screen reader.
LedgerSplitButton
A main act with the menu of its siblings beside it (Export, and as CSV or as PDF): the two halves in one ring, parted by a rule, the chevron's half opening a slip of paper under it with each act on its own line. filled sets it as the page's one green act. A press stamps a half (its fill takes the impression), the keyboard's focus rules the double rule under the half it holds, Down opens the menu and the arrows walk it; the chevron turns while it is open. The menu marks one act at a time, as the select's list does, under its words: the pointer's underline or the keyboard's double rule, whichever moved last (the pointer moving the keys' place with it). Opened by a click it marks none until the pointer or the keys move; opened by the keys, its first. Beside the desktop's side bar it keeps to the room between the bar and its end, its words wrapping. Each half stands at least the tap floor, so the whole of it answers a tap. onPressed null disables the main half; an act with no onPressed stands in pencil.
LedgerSplitHalf
One half of a LedgerSplitTicket: who (name, their initials when not the name's own), what they did (note) and their share.
LedgerSplitTicket
A purchase split as a ticket torn in two (.ticket), on the light paper: its start (what and when) and end (the total) in the mono over a hairline, then mine and theirs side by side, each a monogram, a name, what they did and their share engraved, the perforation and a notch between; theirs on the green wash, its monogram green.
LedgerStackBar
A ruled bar cut into its parts 3 apart (art.stack_bar), each hatched in its own way (the allocation): drawn on its 600 by 22 grid stretched across its width, 22 tall. Read as its label.
LedgerStackPart
One part of a LedgerStackBar: its value and its hatch.
LedgerStateFace
What LedgerPressable draws round a face, for a face one of ui_core's behaviours presses (a toggle group's pill, a split button's half): the accountant's double rule under it while the keyboard holds it, and the stamp's sink while it is held, each in Ledger's one motion. states also reach the face's own ink through LedgerPressStates.
LedgerStatementSlip
A card's statement printed on a slip (.statement): the guilloche band, its kind and number, the balance engraved under its label against when it is due (the date in the serif, dueNote in the mono under it) over the ink rule, then its details (key and value lines) and the last payment's row under a rule.
LedgerStatementTotal
The statement's total, an accountant's double rule (.double, two rules of the ink 4 apart outside to outside) and 14 under it the title in the semibold on a dot leader to its amount (15 bold).
LedgerStepper
A number stepped down and up by step between min and max; its ring at a bound is off, and onChanged null holds it.
LedgerStepProgress
How far through a run of steps a person is (Payee, Amount, Review): each step a numbered mark on one rule, a step done a disc of the ink with its tick, the step at hand ringed in the ink round its figure, the steps to come ringed in the light rule round theirs; the rule inked up to the step at hand. Each step's name in the mono capitals under its mark (the one at hand in the ink). A screen reader hears it as one line: "Step 2 of 3, Amount". The marks move in Ledger's one motion as current changes. On a phone with more steps than fit, the names under the marks give way to the step at hand's name alone.
LedgerStepTotal
A month of bills summed as they fall due (art.step_total): the running total steps up on each due date, engraved under the inked steps, each step ringed, the large bills' notes hung on leaders, the grid dotted, the month's ruler under it (1, 8, 15, 22, the last day). 342 by 220 on a phone, 712 by 320 from 1024.
LedgerStub
The tear line across a slip (.stub): a half-round notch cut from each edge (9 by 18, the page's paper showing) and the perforation between them, 14 in from each (22 from 1024). It says nothing.
LedgerSuggestion
A suggested figure to take (.suggest): the amount in the green serif, its title (semibold) over the text that says where it comes from, and a round action in the green mono capitals, on the green's faint wash in a green rule. The whole line is one button.
LedgerSwipeAction
One act a LedgerSwipeActions row holds under it: a square the row's full height filled with its tone, its icon over its label in the small capitals. The label is also what a screen reader offers as the row's custom action.
LedgerSwipeActions
A list row that opens on its acts when dragged aside: leading acts wait under its start edge and trailing acts under its end, squares the row's full height, butted edge to edge in their tones with no gap. The row snaps open past a share of its acts' width and shut below it, resists a drag past them, and while open a tap on it closes it rather than opening the record; an act closes the row as it acts. Every act is also offered to a screen reader as a custom action on the row, so nothing here needs the gesture. initiallyOpen starts it open on its trailing acts (its leading ones when it has none): a preview, or a hint that the row swipes. Right to left mirrors the edges. The drag, the snap and the actions are ui_core's DesignSwipeActions; the squares are Ledger's.
LedgerSwitch
The switch (.toggle): 44 by 26, its knob of the light paper on the darker paper, at the end on the ink when on; a null onChanged dims it to .45. It lays out at the tap floor round its face. Says its semanticLabel and whether it is on.
LedgerTabs
In-page sections, peers of one page: a strip 44 tall over the page's hairline, each tabs label set in the sans medium with an optional counts figure after it in the mono, the chosen one in the ink under one ink rule and the rest in the second ink. A strip wider than its room scrolls sideways, keeping the chosen tab in view. The strip is ui_core's DesignTabBar: one tab stop, the arrow keys (mirrored right to left, wrapping) and Home and End move the choice and the focus with it, and the change runs on ui_core's spring, the old tab's rule drawn back out as the new one's is drawn in. padding insets the labels (the page's gutter on a full-bleed strip) while the hairline runs edge to edge. A null onSelected shows the strip without letting it change. A screen reader hears a tab bar, each tab its label, its count and its place ("Entries, 12, Tab 2 of 3"), and whether it is chosen. Supply children to show a named, swipeable tab panel below the strip. Give the widget a bounded height when showing panels.
LedgerTag
A word ringed small after a title in mono capitals (.tag): Pending after a purchase not yet posted, New after an unread notification.
LedgerTextArea
Longer words (a memo on a payment, a note to a budget) written on ruled paper: each line of the words stands on a faint rule a line apart, minLines of them before anything is typed and more as the words run on, up to maxLines before it scrolls; the last rule is the field's ink rule, doubled while it has focus, as on every Ledger field. Its label in the small capitals over the paper, its helper or error under. With a maxLength the count of what is left stands in the paper's foot at the reading end, in the mono, turning vermilion once it is spent. The rules grow with the text size, so large text still writes on them.
LedgerTextField
A field written on a rule, as a ledger is: its label in the small capitals over the line, the words typed in the medium at 16 (its hint in the third ink while it is empty), the ink rule under it (2 thick while it has focus), its helper or its error under the rule. No box: the rule is the field. 48 tall at LedgerDensity.standard, each density step 4 less, the words centred in it on every platform.
LedgerTextInput
A text input in Ledger's type, its placeholder shown while it is empty, one line unless maxLines says it may grow. Plumbing of the fields and the composer; pages never place one.
LedgerTheme
Puts Ledger in scope for everything under it, as Material's Theme does. It is the whole install: put one in any app's builder:, under a MaterialApp, a CupertinoApp or a WidgetsApp alike. Under it, Flutter's own text field wears Ledger's caret, selection and handles with no ink, and every text has Ledger's body style to fall back on. Another one restyles a part of the tree. An InheritedTheme, so what a route or an overlay captures keeps the Ledger it was raised in.
LedgerThemeData
The design tokens: every colour role, shadow, type slot and shape role a Ledger widget draws with, for one preset in one appearance.
LedgerThemeDataTween
A tween between two Ledger themes, through LedgerThemeData.lerp.
LedgerTimeline
What happened to a record, in order (a transfer sent, cleared, posted): a rule down the reading start with a mark at each entry, a disc of the ink for one done, a ring of the ink for the one under way and a ring of the light rule for one to come, the rule inked down to the one under way; beside each mark its time in the mono capitals, its title in the medium and its note in the second ink. A screen reader hears each entry whole, with where it stands.
LedgerTimelineEntry
One entry of a LedgerTimeline: its when in the mono, its title and its note.
LedgerToast
A short confirmation over the page, as the source raises one (Moved to Groceries, Card number copied): the toast rising 12 clear of the tab bar on a tab's page (96 over its foot), 24 over the bottom edge elsewhere, 16 in from either side; at desktop width 380 wide at the window's bottom right, 32 in. It stays a few seconds, longer with its one inline act (Undo), and a new toast replaces the one still showing. Its time stops while a pointer rests on it or the keyboard is in it; F6 takes the keyboard to it, Escape dismisses it, and a screen reader hears it. The behaviour is ui_core's (DesignToaster), installed by LedgerHost (LedgerToaster); Ledger paints it.
LedgerToastCard
The toast's face, drawn in place (a still of a toast on a showcase or a walkthrough frame): the ink slip, 6 at its corners, its deep drop under it; the icon in a 28 ring, the message in the raised paper's ink, and the one act's word (actionLabel) in pale green mono capitals at its end. A page confirms through LedgerToast.show, never by standing this in its body.
LedgerToaster
Hosts Ledger's toasts over child: LedgerHost installs one above the app's navigator, so a page needs nothing of its own. One shows at a time, where LedgerToast.show says (over the tab bar on a phone, at the bottom right from desk width). The behaviour is ui_core's (DesignToaster); Ledger paints each toast as a LedgerToastCard.
LedgerToggleGroup<T>
A row of pills over options (.filters' face), one tab stop for the row: each its own ring of the light paper, a chosen one in the ink. One choice is a radio group to a screen reader and the arrows choose as they move; with multiple each pill toggles on its own (a register's columns shown). The arrows move along it, mirrored right to left, Home and End to its ends, Space and Enter press. A hover takes the ring to the strong rule, a press sinks the pill, the keyboard's focus rules the double rule under it. Each pill lays out at the tap floor round its 32 face (44 for a finger, 24 for a pointer), so a tap anywhere in that room reaches it. labelOf names each option (its words and its spoken name); onChanged null shows the row without letting it change.
LedgerToggleRow
A switch's row (.toggle-row): its glyph, its title and subtitle, the LedgerSwitch at the end; the whole row flips it. A null onChanged dims it (the third ink). Says its title and whether it is on.
LedgerTokenColors
The colours of one appearance of a baked catalog theme: Cody's role names, which is what ThemeTokens v2 records.
LedgerTokens
A ThemeTokens v2 record, baked into constants (internal/themes/<id>.g.dart, drift-gated against the JSON by the catalog's tests): both appearances, the twelve type slots and the shape. LedgerThemeData.fromTokens dresses the system in one.
LedgerTokenShadow
One elevation layer of a baked catalog theme.
LedgerTokenShape
The corner language of a baked catalog theme.
LedgerTokenType
One text slot of a baked catalog theme: the face it names, its size, weight (100..900), line height as a multiple and tracking in points.
LedgerTooltip
A few words on a control (what a glyph does, a figure's full value): the toast's dark slip in the small radius, message in the mono on it, above the control (below it when there is no room), over ui_core's DesignTooltip. It stands after a pointer rests half a second, at once when the keys bring the focus to the control, or on a long press; the pointer may move onto it, Escape hides it, and it goes as the pointer or the focus leaves. A screen reader hears message as the control's tooltip.
LedgerTopBar
The head of a page, in the register its route earns (RoutePresentation.of), as the source's shell draws it. A screen stands the one bar in two places:
LedgerTransactionRow
One transaction in the register (.tx): its mark (the merchant's monogram, green on its wash for money in, a dashed glyph for a move between the owner's accounts), its title (a pending one tagged), under it its category and when, its signed amount at the end; on the desktop in the register's columns, its account among them. One link to its record; read as one line.
LedgerVisitRuler
One merchant's month as a ruler (art.visit_ruler), 34 tall: a hatched bar on each day it was paid, as tall as that day's total there, the record's own current day solid; the days ahead shaded; a tick for every day, long on the weeks. moneyIn inks it green (a payer). startLabel and endLabel stand 4 under it at its two ends (.ruler-labs: Oct 1, Oct 31).
LedgerWatermark
A page's watermark (.watermark): the guilloche rosette in the green at .36, fading out down its lower half (a phone's, 360 round), or at. 42 fading out from its middle (the desktop's, 300 round), placed as the source places it over the page's column (top −10, right −150 on a phone; top 156, left 476 from 1024). Stand it as a screen's backdrop (LedgerScreen(backdrop: const LedgerWatermark())); it says nothing.
LedgerWay
One of LedgerWays: its glyph, its title in the serif and the text under it (what it moves, or what waits).
LedgerWays
The ways to move money, large (.bigs): under an ink rule, two to a line on a phone (each its glyph ringed in the ink beside its title in the serif 24, its words under both, ruled apart), four in a line from 1024 (the glyph over the title over the words); from 600 each at most cell across, from the column's start. Each way is one link.
LedgerWeekStrip
A week at a glance, seven days in a row: each a mark over its letter in the mono capitals, LedgerDayMark.kept a green check, LedgerDayMark.missed a voided ring, LedgerDayMark.today a ring in the ink with its letter firm, LedgerDayMark.upcoming a dot. Read only (a day is changed on the page it summarises). One node for a screen reader: its label and each day's name with how it stands. letters and names start where the week does (Monday by default).
LedgerWholeAspect
An AspectRatio whose height is a whole pixel: the width it is given over aspectRatio, rounded.
LedgerWholeHeight
Its child at its own size, standing in a box of the nearest whole height (the child at its top; a fraction over hangs, unclipped). For a row whose parts of other faces share a baseline.
LedgerWordmark
The wordmark: the brand mark and the app's name in the serif, 10 apart, as the phone's top bar and the sidebar head the app (the sidebar's word at 30, inset 8). Says "name, home"; onTap goes home.
MediaSlot
Where a slot's picture comes from.
MediaSlotImage
Trusted image delivery for one declared media slot, shared by a system's photo and avatar components. fallback stands in while the picture is pending and whenever it misses, so a pending image never delays layout, first paint or publication.
One tab of the shell's navigation: a branch's root, with the glyph and the words it wears. The runtime emits one per StatefulShellBranch, in branch order; the system decides how it looks.
PreviewDevice
The device a platform previews on: its logical size and pixel density. The oracle captures and the gallery's renders use the same numbers.
PreviewFrame
The frame a preview stands in: publishes its platform and brightness to everything inside it, scopes the platform override there, and publishes its box as the screen.
PreviewFrameData
What a PreviewFrame publishes to everything inside it.
PreviewStage
A stage that raises a previewed page on a route over itself once it is on screen, and keeps it raised: how a pushed or sheet page is previewed alone, so its exit renders as it does live and the chrome it derives is the real one (RoutePresentation.pushed or the sheet's).
RenderDesignCapCenter
The render object of DesignCapCenter: keeps its child's size and paints it moved up or down so that its one-line label's capitals sit on the box's middle.
RenderDesignTapTarget
DesignTapTarget's render object: its child laid out as given, itself at least minSize, the child placed by alignment, a hit anywhere in it sent to the child's centre.
RoutePresentationScope
Publishes the RoutePresentation of the route it stands in, overriding what the route's position implies. A system's sheet page wraps its child in one with RoutePresentation.sheet; a preview or a hand-built navigator may publish any presentation.
ShellAction
The app-level act beside the shell's tabs: the one thing reachable from every root — add, compose, capture — with the glyph it wears and what it does. A system draws it in its own way (a floating action button, a disc in the bar, a square at its end).
ShellInsets
The bottom inset the shell's bar asks every branch root to keep clear: published by a system's shell over its branch container (and by a preview that stands the bar under a lone page), spent by the system's screen on its scroll padding and by its toast on its inset.

Enums

ChromeGround
The ground a page stands on, which is what its chrome is drawn against: the system's own surface, or media — a full-bleed feed of video or photographs, over which the chrome is dark and solid.
DesignBranchBackBehavior
Where back goes from a branch at its root page.
DesignCalendarMode
How a calendar selects.
DesignChartXAxis
What a DesignChart's x values are.
DesignColorChannel
A channel a DesignColorSlider sets.
DesignDateSegmentType
The kinds of segment a date or a time field is typed in.
DesignInput
What reaches a look's controls: a finger, or a pointer (a mouse, a trackpad, a stylus that hovers).
DesignMenuLevel
Where a DesignMenuBar's builder paints: the bar, a menu or a submenu.
DesignNavigationMode
How a shell shows its destinations.
DesignOverlayAlign
How a surface lines up with its anchor along the side it sits on.
DesignOverlaySide
Which side of the anchor a surface sits on. start and end follow the text direction.
DesignOverlayTrigger
What opens an anchored surface.
DesignRefreshMode
Where a pull stands.
DesignScrollbarVisibility
When a DesignScrollArea's scrollbar shows.
DesignSelection
A page's selection, for its select-all checkbox.
DesignSheetEdge
Which edge a DesignSideSheetRoute comes from.
DesignSortDirection
Which way a column sorts.
DesignSplitPart
Which part of a split button a builder paints.
DesignToastClosedReason
Why a toast left.
DesignWindowSizeClass
Material's window size classes, by width in logical pixels.
LedgerAmountSize
How large a ledger amount stands.
LedgerBannerTone
What a LedgerBanner says: news, a thing done, a thing to mind, or a thing gone wrong.
LedgerBarSlot
Where a screen stands its authored top bar: the phone's paper strip pinned over the page, or the masthead at the top of the page's scroll. LedgerScreen places the one bar in both; each draws its own part.
LedgerBarTone
How a LedgerDayBars is inked: the ink (spending) or the green.
LedgerButtonSize
How tall a LedgerButton stands, at LedgerDensity.standard (each density step takes 4 off).
LedgerCardSize
How large a LedgerCardFace stands: regular across its column, 216 tall (400 by 252 on the desktop), or small (264 by 166; 280 by 176).
LedgerCardStock
Which stock a LedgerCardFace is printed on: the credit card's ink (its light print on the dark), the debit card's paper.
LedgerComposerStyle
How a LedgerComposer sits.
LedgerDatePickerMode
What a LedgerDatePicker sets: the day, the time of day, or both.
LedgerDatePickerPresentation
How a LedgerDatePicker stands: compact a line on the dot leader whose value pills raise the picker in a sheet; inline the month's calendar on the page (with the time's wheels under it for a date and a time); wheel scrolling columns alone.
LedgerDayMark
How one day of a LedgerWeekStrip stands.
LedgerDialogType
What a LedgerDialog asks of the person.
LedgerFactColumns
How a LedgerFacts stands its facts: two across (one under another on the desktop's margin), three across (likewise), or pair: two across everywhere (.facts-2), under the ink rule only where no head stands over it (LedgerFacts.ruled), as on a phone.
LedgerFigureSize
How large an engraved figure stands, on a phone and on the desktop, as the source sizes .fig where each page sets it. The sizes are the quire preset's; another preset scales them with its figure.
LedgerFigureTone
How an engraved figure is inked: plain in the page ink (its $ in the second ink), moneyIn green throughout (money received), over vermilion (spent past a budget, its $ still in the second ink).
LedgerGaugeTone
How a LedgerGauge is inked: the ink (money spent) or the green (money saved toward a goal).
LedgerGlyphSize
How large a LedgerGlyph stands, and its glyph, as the source sizes .glyph where it stands.
LedgerGlyphTone
How a LedgerGlyph is inked: plain on the light paper in a fine ring, move (a move between the owner's own accounts) dashed and open, moneyIn on the green wash, inked ringed in the ink (a firm state: declined), selected ringed in the green on its wash (the chosen option of a list).
LedgerIconButtonSize
How large a LedgerIconButton stands, at LedgerDensity.standard (each density step takes 4 off).
LedgerKeySwatch
A key's swatch, as the source draws each in a chart's legend.
LedgerMonogramSize
How large a LedgerMonogram stands, and its letters, as the source sizes .mg where it stands.
LedgerMonogramTone
How a LedgerMonogram is inked: plain on the light paper, moneyIn green on the green wash (who paid the owner), inked the paper's letters on a disc of the ink, ringed 3 out in the slip's paper and 1 in the ink (the account holder's, on the member card).
LedgerPillSize
How large a LedgerPill stands: regular 24 tall (a figure's change), small 20 (a goal's status beside its note).
LedgerPillTone
Which wash a LedgerPill stands on: the success (good news, a state on track), the vermilion over (past a budget), the plain (a plain state: behind, on autopay).
LedgerPresentation
How a previewed page stands in the app: as a nav root over the shell's bar, pushed off one, or raised as a page sheet.
LedgerPressRole
What a LedgerPressable is to assistive technology.
LedgerRegisterColumns
Which of the desktop's columns a LedgerRegister keeps: all of them, no account's (one account holds every row), no category's (a category's own register), or neither.
LedgerSealSize
How large a LedgerSeal is pressed, on a phone and on the desktop, as the source sizes .seal where it stands.
LedgerSealTone
Which ink a LedgerSeal is pressed in.
LedgerStackTone
How a part of a LedgerStackBar is hatched: close in the ink, wider in the green, wide and faint (pale).
LedgerStepperSize
How large a LedgerStepper stands.
LedgerSwipeTone
What a LedgerSwipeAction stands for, and so what ground it is struck on.
LedgerTagTone
How a LedgerTag is ringed: plain in the faint ink (Pending), or unread in the green (New).
LedgerTimelineState
Where a LedgerTimelineEntry stands: done, the one under way, or to come.
LedgerTone
How an amount or a figure is inked, as the source tells money apart: plain in the page ink, moneyIn green, over vermilion (spent past a budget, and only then) and move the quiet ink of money moved between the owner's own accounts.
LedgerWordmarkSize
How large a LedgerWordmark stands: regular the phone's top bar's (its name at 28), large the side bar's (30).
PreviewPlatform
The platform a preview is drawn for: its device size and the platform whose behaviour applies inside it. The look is the system's everywhere; behaviour (scroll physics, back gestures, text handling) follows this platform.
RoutePresentation
How a route is presented, which is what a screen derives its bar from: the title on a root, the back affordance on a pushed page, the dismiss affordance on a sheet. A page never authors its own back or close; it reads its presentation (of).

Extensions

DesignSpringDrive on AnimationController
Runs an AnimationController on a spring instead of a duration.
LedgerPlotType on LedgerThemeData
The labels' type, as the source sets each kind over its plots. Plumbing of the engravings.
LedgerStyled on DesignStyleOf
A part's style layers over the face Ledger would draw: what each part reads of a LedgerStyle. Plumbing of the controls; pages never use it.
LedgerTextStyle on TextStyle
Scale-step adjustments that stay on the scale.
LedgerThemeContext on BuildContext
The accessor every Ledger widget reads its tokens through.
PreviewPlatformDevice on PreviewPlatform
The platform's device, as data on the enum.

Constants

designSpringTolerance → const Tolerance
When a spring-driven controller counts as settled, in the controller's own units (a 0–1 progress, or dp for a position):
frostTokens → const LedgerTokens
The frost catalog theme, baked: both appearances, the type slots and the shape, as ThemeTokens v2 records them.
galleryTokens → const LedgerTokens
The gallery catalog theme, baked: both appearances, the type slots and the shape, as ThemeTokens v2 records them.
ledgerCupertinoWords → const LocalizationsDelegate<Object?>
Cupertino's words for any locale: cupertino_ui's translation where it has one, else English. A text field's menu on iOS reads them.
ledgerFontPackage → const String?
The package that bundles Ledger's faces, or null when the app does. Every Ledger text style passes it as TextStyle.package.
ledgerInventoryFills → const Set<String>
Rows whose specimen fills the room it is given (a frame, a rail, a chart): the gallery gives each a height.
ledgerInventoryParts → const Map<String, String>
Each row Ledger answers live and the Ledger part that is it, where the part's name is not the row's.
ledgerMaterialWords → const LocalizationsDelegate<Object?>
Material's words for any locale: material_ui's translation where it has one, else English.
ledgerPageTransitions → const Map<TargetPlatform, PageTransitionsBuilder>
LedgerPageTransitions on every platform: one map for the PageTransitionsTheme of either Material, Flutter's own or the one Ledger is built on. On iOS a swipe from the screen's leading edge still takes a page back (ui_core's DesignSwipeBackPageTransitionsBuilder round the leaf): the page follows the finger as on every iOS screen, and a push or a pop is Ledger's leaf.
paperTokens → const LedgerTokens
The paper catalog theme, baked: both appearances, the type slots and the shape, as ThemeTokens v2 records them.
signalTokens → const LedgerTokens
The signal catalog theme, baked: both appearances, the type slots and the shape, as ThemeTokens v2 records them.

Properties

ledgerInventory → DesignInventory
Ledger in ui_core's shared inventory: each row's specimen is the Ledger part for it (ledgerInventoryParts), built with plain values, and each row a ledger leaves out says why. DesignInventory.verify checks every row is answered; LedgerInventoryGallery shows them all.
final
ledgerPresence → Animatable<double>
A surface's presence on ui_core's springs (an overlay's, a route's) clamped to 0 to 1: a spring can pass 1 before it rests, and an opacity asserts outside 0 to 1.
final

Functions

designMatchScore(String text, String query) → int?
How well query finds text: null not at all, higher better. A prefix beats a word's start, which beats a substring, which beats the letters in order.
designReduceMotionOf(BuildContext context) → bool
Whether the reader asked for reduced motion at context: Android's Remove animations or the web's prefers-reduced-motion (MediaQuery.disableAnimationsOf), or iOS's Reduce Motion (dart:ui's AccessibilityFeatures.reduceMotion, which MediaQuery does not carry).
designShortcutKeys(BuildContext context, MenuSerializableShortcut shortcut, {TargetPlatform? platform, bool appleSymbols = true}) → List<String>
The keys of shortcut (a SingleActivator or a CharacterActivator), one string a key, modifiers first, as Flutter's MenuItemButton labels them:
designShortcutLabel(BuildContext context, MenuSerializableShortcut shortcut, {TargetPlatform? platform, bool appleSymbols = true}) → String
designShortcutKeys joined as a menu row shows them: "⌃ ⇧ N" with Apple's symbols (Flutter's spacing), "Shift+Command+N" in words on macOS and iOS, "Ctrl+Shift+N" elsewhere.
designSpring({required double dampingRatio, required double stiffness}) → SpringDescription
The Flutter spring for the token (ζ = dampingRatio, k = stiffness): SpringDescription.withDampingRatio(mass: 1, stiffness: k, ratio: ζ), so damping = 2ζ√k. Compose's spring(dampingRatio, stiffness) is written against unit mass, so the two run the same curve.
designSpringSimulation(SpringDescription spring, {required double from, required double to, double velocity = 0, Tolerance tolerance = designSpringTolerance}) → SpringSimulation
The simulation of spring from from to to, starting at velocity units per second, that settles at tolerance and lands exactly on to.
designSwipeBack(Map<TargetPlatform, PageTransitionsBuilder> builders, {Set<TargetPlatform> platforms = const {TargetPlatform.iOS}}) → Map<TargetPlatform, PageTransitionsBuilder>
builders with the entries for platforms (iOS, by default) wrapped in DesignSwipeBackPageTransitionsBuilder, so a page there pops with a swipe from the screen's leading edge and otherwise plays the look's push.
ledgerAhead(Canvas canvas, Rect box, Color ink) → void
The days ahead: box shaded faintly (the ink at .035).
ledgerBesideSide({required double inset, required Widget child}) → Widget
Publishes the sidebar's inset over child (LedgerSideInset) and keeps every surface ui_core opens there (a split button's menu, a select's list, a popover, a tooltip) clear of the bar (DesignOverlayPadding at the reading start): a page's overlay runs under the sidebar, which stands over it. No padding at an inset of 0.
ledgerCapCenter(TextStyle? style, Widget label) → Widget
label, a one-line label set in style, drawn with its capitals on its box's middle: every face's label in Ledger's own widgets goes through it, never an icon.
ledgerCapHeight(TextStyle? style) → double
The cap height, over its size, of the face style sets (its family with or without the package's prefix); Inter Tight's when it names none.
ledgerCorners(OutlinedBorder shape) → BorderRadiusGeometry?
The corners of shape as a box's radius: a rounded rectangle's own, a stadium's (every corner round), none for another outline.
ledgerDashed(Path path, List<double> pattern) → Path
path cut into an SVG dash pattern (on, off, ...), the pattern running on along the whole path from its start.
ledgerDirectional(BuildContext context, IconData icon) → IconData
icon as it points at context: a left or right chevron or arrow turns the other way in a right-to-left page, so a disclosure points to the reading end and a back to its start. Any other glyph is drawn as it is.
ledgerDotted(Canvas canvas, double y, double x0, double x1, Color color, {double opacity = .28}) → void
art.dotted: a grid line at y from x0 to x1, dashes of 1 every 4,. 8 wide, the ink at .28.
ledgerDoubleRule(Canvas canvas, double y, double x0, double x1, Color color, {double gap = 3}) → void
art.double_rule: a rule .9 wide at y and a .5 one gap above it.
ledgerDrop(Canvas canvas, Offset from, Offset to, Color color, {double width = 1}) → void
A vertical dotted drop (stroke-dasharray="1.5 2.5") from from to to.
ledgerEngravedArea(List<Offset> points, double top, double yb, double spacing, {bool band = true, double? x0, double? x1}) → ({Path? band, Path fill})
art.engraved_area's two hatches under the line through points: the fill (45°, spacing apart, 2.2 under the line, inked by the fade) and, with band, the engraver's shadow under the line (135°, 1.15 times as far apart, 13 deep). Heavy: computed once per size and kept.
ledgerFade(Color color, double y0, double y1, {double a0 = .62, double a1 = .10}) → Shader
art.fade: the hatch's ink fading from a0 of color at y0 to a1 at y1 (a userSpaceOnUse linear gradient).
ledgerFontFamily(String family) → String
family under the name Flutter registers it by: PlexMono when the app bundles it, packages/ledger_ui/PlexMono from the package. A test that loads the faces itself loads them under this name.
ledgerGlyph(BuildContext context, IconData icon, {double? size, Color? color}) → Widget
icon drawn at size in color as it points at context: a chevron or an arrow turns (ledgerDirectional), and a glyph with a heading of its own (send's paper plane) is drawn mirrored in a right-to-left page, so it flies to the reading end as Continue's arrow points there.
ledgerHatch(bool inside(double x, double y), double x0, double y0, double x1, double y1, double spacing, {double angle = 45, double step = 0.2}) → Path
The source's engraved hatching (art.hatch): parallel strokes at angle degrees rising to the right, spacing apart measured across x, kept where inside holds within the box x0, y0, x1, y1 (walked in steps of step; a run shorter than .6 is dropped). The same walk, so a stroke starts and ends where the source's does. Plumbing of the engravings.
ledgerHatchRect(double x0, double y0, double x1, double y1, double spacing, {double angle = 60}) → Path
The source's engraving primitives, drawn on a canvas in the source's own units: every stroke width, dash and opacity is the one its SVG writes. Plumbing of the engravings. art.hatch_rect: strokes at angle degrees rising to the right, spacing apart across x, clipped exactly to the box x0, y0, x1, y1 (gauges, bars, a card's chip). A box thinner than .4 is left bare.
ledgerInk(Color color, double opacity) → Color
color at opacity of its own alpha (an SVG stroke-opacity).
ledgerInkedLine(Canvas canvas, List<Offset> points, Color color, Color paper, {double width = 1.5, double knock = 5, List<double>? dash}) → void
art.inked_line: the line through points over a paper knock-out knock wide (so the hatching stops short of it), width wide, round joined and capped, dashed by dash when given.
ledgerInterp(List<Offset> points) → double? Function(double x)
art.interp: the polyline through points as a function of x, null outside its span.
ledgerLoadFonts() → Future<void>
Loads the faces Ledger bundles, so the first frame is set in them. Await it before runApp: on the web a bundled face otherwise arrives after the first frames, which flash in a fallback face.
ledgerMarked(String text, TextStyle base, TextStyle strong) → TextSpan
text with its **strong** runs set in strong: how a page's words mark the part the source sets in <b>.
ledgerNowMark(Canvas canvas, Offset at, Color color, Color paper, {bool halo = true}) → void
art.now_mark: today's point, a disc of color ringed in the paper, with its halo at 9.
ledgerOptionPaper(BuildContext context, Widget list) → Widget
The raised paper a suggestion list stands on, as the select's: the surface in the rule, the small radius, the menu's shadow. Plumbing of the combobox and the tag input.
ledgerPaintArea(Canvas canvas, ({Path? band, Path fill}) area, Shader fade, Color color, double width) → void
Paints area: the fill in fade at width, the band in color at .45 and .8 of the width.
ledgerPerLine(int count, int most) → int
How many of count choices stand on a line that holds at most most, so that no line is left with one choice alone while another holds more: every choice on one line when they fit; else the most per line that leaves the last line full or at least two; else one per line. Three choices two to a line on a phone stand one per line; from 600 they share one line.
ledgerPlotText(String text, TextStyle style, Color strong, {TextAlign? align}) → Widget
text with its **strong** runs at 500 in the ink, as a plot's labels set their <b>. Plumbing of the engravings.
ledgerPolyline(List<Offset> points) → Path
The polyline through points.
ledgerRing(Canvas canvas, Offset at, Color color, Color fill, {double radius = 2.4, double width = 1.1}) → void
art.ring: a ring of color width wide round a fill disc.
ledgerRulerTicks(Canvas canvas, double x(int day), double yb, int days, int today, Color ink, {Set<int>? long, int from = 0, double longTick = 7, double shortTick = 3.5, double longWidth = .9, double shortWidth = .6}) → void
art.ruler_ticks: a tick under the baseline yb for each day from.. days, long (7, .9 wide) where the ruler's labels stand (the month's start, the 8th, 15th and 22nd, today and the last day), else 3.5 and .6. A line's day ends at x of it (0 the month's start); a bar chart gives its bars' centres from day 1.
ledgerShadow({required Color color, double x = 0, double y = 0, double blur = 0, double spread = 0}) → BoxShadow
A CSS box-shadow as Flutter draws one: CSS blurs a shadow to a standard deviation of half its blur radius, Flutter's radius maps to 0.57735 r + 0.5. Plumbing of the components; pages never place one.
ledgerSigma(double blur) → double
The Gaussian sigma of a CSS blur of blur (filter: blur(), a shadow's blur radius halved), for a MaskFilter or an image filter.
ledgerStroke(Color color, double width) → Paint
A stroke of color width wide.
ledgerSubLine(BuildContext context, {String? start, String? end, bool startMono = false, LedgerTone startTone = LedgerTone.plain, LedgerTone endTone = LedgerTone.plain}) → Widget?
A row's sub line (.sub, 13 on 18 in the third ink): its start words and its end words at the far side, 12 apart at least; null with neither. Plumbing of the rows.
ledgerTitle(BuildContext context, String title, {Widget? tag, TextStyle? style, int? maxLines}) → Widget
A row's title (.title, 500 15 on 20), a tag 8 after it raised 2, as the rows set it. Plumbing of the rows.
ledgerWatchInput() → void
Starts telling a key from the pointer, app-wide, for the menus' one current row (LedgerMenuMarks): a control that opens a menu calls it as it builds, before the keys that open the menu come.
showDesignCommandPalette({required BuildContext context, required DesignCommandPalette palette(ValueChanged<DesignCommand> run), Widget surfaceBuilder(BuildContext context, Widget palette)?, Color barrierColor = const Color(0x66000000), DesignBarrierBuilder? barrierBuilder, String? barrierLabel, AlignmentGeometry alignment = const Alignment(0, -0.6)}) → Future<void>
Opens palette in a modal route over a barrier; surfaceBuilder paints the panel around it. A command runs after the route has closed and focus is back where it was.
showLedgerActionSheet<T>(BuildContext context, {required String title, required List<LedgerSheetAct<T>> acts, String? message, String? cancelLabel}) → Future<T?>
Raises acts on a sheet titled title (on a phone off the bottom edge, at desktop width as a dialog) with Cancel at its foot. Completes with the value of the act chosen; null when it is cancelled or dismissed.
showLedgerCommandPalette(BuildContext context, {required List<LedgerCommand> commands, String hint = 'Type an act or a place'}) → Future<void>
Opens a LedgerCommandPalette of commands over the page on its raised paper, 560 wide at most; an act runs once the palette has closed.
showLedgerSideSheet<T>(BuildContext context, {required String title, required WidgetBuilder builder, List<Widget> foot(BuildContext context)?, DesignSheetEdge edge = DesignSheetEdge.end, double width = 400}) → Future<T?>
Stands a LedgerSideSheet titled title in from edge (the reading end by default) over the whole app, width wide, leaving at least 56 of the screen beside it on a phone; a tap on the scrim, the system back, the Escape key, the close or a drag toward its edge dismisses it, focus coming back to where it was. Completes with the value it pops with.

Typedefs

DesignBarrierBuilder = Widget Function(BuildContext context, Animation<double> animation)
Paints a modal part's barrier in place of its barrier colour: a look's own screen over the page behind (Ben-Day dots, a blur, a grain).
DesignBottomSheetBuilder = Widget Function(BuildContext context, DesignBottomSheetDetails details)
Builds a bottom sheet's panel from details.
DesignCalendarDayBuilder = Widget Function(BuildContext context, DesignCalendarDay day, Set<WidgetState> states)
Paints one day for its states (WidgetState.selected when chosen, WidgetState.focused while the keyboard is on it, hovered, pressed, disabled).
DesignChartBuilder = Widget Function(BuildContext context, DesignChartDetails details)
Draws a chart from its details.
DesignChartFormat = String Function(double value)
Formats a value for labels, readouts and speech.
DesignChartTableCellBuilder = Widget Function(BuildContext context, DesignChartTableCellDetails cell)
Paints a cell of a DesignChartTable.
DesignComboboxFieldBuilder = Widget Function(BuildContext context, DesignComboboxField field)
Paints the field.
DesignDateFieldFrameBuilder = Widget Function(BuildContext context, Set<WidgetState> states, Widget segments)
Frames a date or time field's laid-out segments (its box, its focus ring); states are the field's: focused (a segment has the focus), hovered, disabled, error.
DesignDateLiteralBuilder = Widget Function(BuildContext context, String literal)
Paints the text between a field's segments ("/", ".", ":", Japanese's year mark U+5E74).
DesignDateSegmentBuilder = Widget Function(BuildContext context, DesignDateSegmentDetails details)
Paints one segment of a date or time field. A segment is a tap target: a look gives its face the floor (DesignTapTarget).
DesignDestinationBuilder = Widget Function(BuildContext context, DesignNavigationDestination destination, DesignDestinationDetails details)
Paints a destination.
DesignDialogActionBuilder = Widget Function(BuildContext context, DesignDialogAction action, DesignDialogActionDetails details)
Paints an action of a DesignDialog.
DesignDialogBuilder = Widget Function(BuildContext context, DesignDialogDetails details)
Builds a dialog route's page: the look's dialog, which details lets it move as the route opens and closes.
DesignDialogPartBuilder = Widget Function(BuildContext context, DesignDialogFrameDetails details, Widget child)
Wraps a part of a DesignDialog (its frame or its action bar) in the look's paint.
DesignDividerBuilder = Widget Function(BuildContext context, Set<WidgetState> states, Axis axis)
Builds a split view's divider for its states (focused while the keyboard is on it, hovered, pressed while dragged).
DesignFieldBuilder = Widget Function(BuildContext context, DesignFieldParts parts)
Lays out a field's parts.
DesignHandleBuilder = Widget Function(BuildContext context, Set<WidgetState> states)
Builds a handle's face for its states (focused while the keyboard is on it, hovered, pressed while dragged, disabled).
DesignInputGroupBuilder = Widget Function(BuildContext context, Set<WidgetState> states, Widget child)
Builds the group's frame around child (the field and its add-ons) for states: WidgetState.focused while anything inside has focus, WidgetState.hovered, WidgetState.disabled and WidgetState.error.
DesignInventoryGroupBuilder = Widget Function(BuildContext context, String group, int present, int total)
Builds a group's heading in a DesignInventoryGallery: present of total rows carried.
DesignInventoryRowBuilder = Widget Function(BuildContext context, DesignInventoryRow row, DesignInventoryEntry? entry, Widget? specimen)
Builds one row in a DesignInventoryGallery. entry is null when the inventory does not answer the row; specimen is the entry's live specimen, built, when it has one.
DesignListSurfaceBuilder = Widget Function(BuildContext context, Widget list)
Paints the list's surface around list (a panel, its shadow).
DesignMenuItemBuilder = Widget Function(BuildContext context, DesignMenuEntry entry, DesignMenuLevel level, Set<WidgetState> states)
Paints an item for its states (WidgetState.focused while the keyboard is on it, WidgetState.selected for the active menu title, hovered, pressed, disabled). In a menu whose highlight follows the pointer, one item at most is focused or hovered: the current one.
DesignMenuSurfaceBuilder = Widget Function(BuildContext context, DesignOverlayInfo info, List<Widget> items)
Paints a menu's panel round its items (scroll them when DesignOverlayInfo.maxSize is short): a menubar's menus, a context menu's.
DesignNavigationBuilder = Widget Function(BuildContext context, DesignNavigationDetails details)
Lays out and paints the navigation round its destinations.
DesignNumberFieldBuilder = Widget Function(BuildContext context, DesignNumberFieldDetails details)
Paints the field's text input.
DesignNumberFieldButtonBuilder = Widget Function(BuildContext context, DesignNumberFieldButtonDetails details)
Paints a step button: a look gives it a finger's floor (DesignTapTarget).
DesignNumberFieldLayoutBuilder = Widget Function(BuildContext context, Widget field, Widget decrement, Widget increment)
Lays out the field and its decrement and increment buttons.
DesignOptionBuilder<T> = Widget Function(BuildContext context, T option, Set<WidgetState> states)
Paints one option for its states: WidgetState.focused while it is highlighted (the keyboard's place in the list), WidgetState.selected when it is the combobox's value, WidgetState.disabled when it cannot be taken, and a pointer's hovered and pressed.
DesignOptionSearch<T> = FutureOr<Iterable<T>> Function(String query)
Searches for the options matching query.
DesignOtpContextMenuBuilder = Widget Function(BuildContext context, TextSelectionToolbarAnchors anchors, List<ContextMenuButtonItem> items)
Draws the field's edit menu: Flutter's toolbar arguments, so a look can hand them on (Material's AdaptiveTextSelectionToolbar.buttonItems, Cupertino's CupertinoAdaptiveTextSelectionToolbar.buttonItems) or draw its own. items is the Paste item (its label from its ContextMenuButtonType, in the app's language); pressing it pastes and closes the menu.
DesignOtpLayoutBuilder = Widget Function(BuildContext context, List<Widget> slots)
Lays out the boxes (a row; a look may put a dash in the middle).
DesignOtpSlotBuilder = Widget Function(BuildContext context, DesignOtpSlot slot)
Paints one box.
DesignOverlayAnchorBuilder = Widget Function(BuildContext context, DesignOverlayAnchor anchor)
Paints the anchor.
DesignOverlaySurfaceBuilder = Widget Function(BuildContext context, DesignOverlayInfo info)
Paints the surface.
DesignPaletteLayoutBuilder = Widget Function(BuildContext context, Widget field, Widget results)
A palette's list, as DesignCommandPalette.layoutBuilder lays it out.
DesignPieChartBuilder = Widget Function(BuildContext context, DesignPieChartDetails details)
Draws a pie chart from its details.
DesignPressableBuilder = Widget Function(BuildContext context, Set<WidgetState> states, Widget? child)
Builds a pressable's face for its current states (hovered, focused, pressed, disabled, selected, error). child is the pressable's own child, passed through so a face that does not change with state is built once.
DesignRatingItemBuilder = Widget Function(BuildContext context, DesignRatingItemDetails details)
Paints one item of a rating.
DesignRatingLayoutBuilder = Widget Function(BuildContext context, List<Widget> items)
Lays out a rating's items, in reading order.
DesignScrollbarBuilder = Widget Function(BuildContext context, DesignScrollThumb thumb)
Paints a scrollbar's thumb or track.
DesignSearchErrorBuilder = Widget Function(BuildContext context, DesignSearchError error)
Paints a failed search (error) in the list's surface.
DesignSwipeActionBuilder = Widget Function(BuildContext context, DesignSwipeAction action, DesignSwipeActionDetails details)
Paints an action.
DesignTabBuilder = Widget Function(BuildContext context, DesignTab tab, DesignTabDetails details)
Paints a tab.
DesignTabIndicatorBuilder = Widget Function(BuildContext context, DesignTabIndicatorDetails details)
Paints the indicator, laid out in DesignTabIndicatorDetails.rect.
DesignTableHeaderBuilder<R> = Widget Function(BuildContext context, DesignTableColumn<R> column, DesignSortDirection? sort, Set<WidgetState> states)
A sortable header, as DesignDataTable.headerBuilder gets it.
DesignTagBuilder<T> = Widget Function(BuildContext context, T value, DesignTagDetails tag)
Paints one tag.
DesignTagLayoutBuilder = Widget Function(BuildContext context, List<Widget> tags, Widget field)
Lays out the tags and the field (a wrap, by default).
DesignToastBuilder = Widget Function(BuildContext context, DesignToastDetails details)
Paints one toast.
DesignToastStackBuilder = Widget Function(BuildContext context, List<Widget> toasts)
Lays out the shown toasts, oldest first.
DesignToggleItemBuilder<T> = Widget Function(BuildContext context, T value, Set<WidgetState> states)
Builds an item's face for its states (selected, focused while the keyboard is on it, hovered, pressed, disabled).
DesignWheelColumnBuilder = Widget Function(BuildContext context, DesignWheelColumnDetails details, Widget wheel)
Frames one column of a DesignWheelPicker round its wheel.
DesignWheelItemBuilder = Widget Function(BuildContext context, DesignWheelItemDetails details)
Builds one row of a DesignWheelPicker.
LedgerCommand = DesignCommand
One act a palette offers: ui_core's DesignCommand (its label, what it runs, its group, its shortcut's keys).
LedgerDateRange = DesignDateRange
A span of days, its end null while half chosen: ui_core's DesignDateRange.
LedgerDestinationPainter = Widget Function(BuildContext context, int index, Set<WidgetState> states)
Paints the face of the shell's destination index in states.
LedgerPlotParts = ({List<LedgerPlotLabel> labels, CustomPainter painter})
A drawn plot: its engraving and the labels over it.
LedgerRangeValues = DesignRangeValues
A span's two values, low and high: ui_core's DesignRangeValues.
LedgerRulerMark = ({bool first, String text, bool today, double x})
One label of a day ruler under a month's plot (.xlab): its words, the x it stands centred on, and whether it is the first (set from the start, unshifted) or today's (in the ink, medium).
LedgerSplitAction = DesignSplitAction
One of a LedgerSplitButton's other acts: its DesignSplitAction.label and what it runs (null disables it).
LedgerStyle = DesignStyle
How one part looks: ui_core's DesignStyle, under Ledger's name. Every slot resolves for the part's states (WidgetState.disabled, WidgetState.hovered, WidgetState.focused, WidgetState.pressed, WidgetState.selected).
LedgerStyleOf = DesignStyleOf
A part's style layers read at its states: its own style:, then its component theme (first wins). ui_core's DesignStyleOf under Ledger's name.

Exceptions / Errors

DesignInventoryError
Thrown by DesignInventory.verify: the rows an inventory answers wrong.