fluent2_design_parts library

Helpers for customizing components copied from fluent2_design_ui.

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

import 'package:fluent2_design_ui/fluent2_design_parts.dart';

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

Classes

AnimatedFluent2Shape
Builds builder with shape, easing to each new shape over Fluent's durationNormal (a cut under Reduce Motion). Rounded shapes morph into each other; other shapes snap at the middle. A null shape builds at once with null: the part draws its own.
AnimatedFluent2Theme
Animates to a new data over duration (200 ms, as Material's AnimatedTheme): the colours and the density blend through Fluent2ThemeData.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.
Fluent2Accordion
Fluent 2's Accordion: items as sections that open and shut, each a header (the chevron, the title, 10 in at the start and 12 at the end, 44 tall) over its panel 12 in from either side. One open at a time unless multiple; the open one shuts again only when collapsible. Open state is the caller's (expanded, told through onExpansionChanged) or the accordion's own from initiallyExpanded. Panels open with Fluent's collapse motion (durationNormal), at once under Reduce Motion. Read as headers that say whether they are expanded.
Fluent2AccordionItem
One section of a Fluent2Accordion: its value, the title its header says (an icon before it), the child its panel shows while open, and whether it can be opened (enabled).
Fluent2Account
Who the app belongs to, as its chrome shows them: their name and initials (or image) in the avatar, the quiet meta line under the name at the nav pane's foot, the unread count the bell wears, and where the avatar (onProfile) and the bell (onNotifications) lead. The app mounts one Fluent2AccountScope above its router; the top bars and the nav pane read it, so no page passes the person around. profileLocation is the profile page's path: the pane'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.
Fluent2AccountScope
Publishes the app's Fluent2Account to its chrome: mount one above the router (around the host's child).
Fluent2Acrylic
Fluent's acrylic under child, in the theme's recipe (Fluent2ThemeData.acrylic), clipped to radius: what floats over the page (the tab bar, a pinned top bar, the nav pane over content, a menu), the page behind blurred, a luminosity layer and a tint over it, and a fine noise. One BackdropFilter under its fills, cheap enough for a bar over a long list; solid stands its opaque fallback in for the blur (on a media ground, under a test, where a page says nothing should blur), as every acrylic does under a theme with Fluent2ThemeData.solidAcrylic.
Fluent2AcrylicRecipe
The recipe of Fluent's acrylic, the material of what floats over the page (the tab bar, the nav pane, a menu, a popover, a tooltip's pane): a blur of what lies behind, a luminosity layer that steadies it, a tint, and a fine noise, as Fluent's in-app acrylic layers them. Drawn by Fluent2Acrylic: one BackdropFilter under the fills, so a list of rows never pays for it.
Fluent2ActionSheet<T>
A short list of acts up from the foot of the page, on Fluent 2's bottom sheet: an optional title and message, each act a row the height of a phone's menu row, the way out apart under a hairline. Each row is the menu's own face. showFluent2ActionSheet raises one and answers the chosen value.
Fluent2ActionSheetAction<T>
One act of a Fluent2ActionSheet.
Fluent2ActsFill
Where a button fills the width it is given: the acts of a phone's sheet foot, a narrow dialog's stacked acts. Plumbing of those surfaces; a page asks a button to fill with its expand.
Fluent2AppBar
The head of a page, in the register its route earns (RoutePresentation.of):
Fluent2AreaChart
Fluent2LineChart with each line washed down to the baseline at 16% of its hue: how much, more than where it went.
Fluent2ArrowPlacement
Where the arrow of a tooltip or a popover stands this frame: written by the layout that places the bubble, read when it paints. Plumbing of the tooltip and the popover.
Fluent2Avatar
Fluent 2's Avatar: a person (or a group, with Fluent2AvatarShape.square) as their picture (image), else the initials of name (or initials) in the size's type, else the person glyph; coloured by color; with a presence badge at its bottom end, and the brand ring while selected. size is one of Fluent's (16 to 128, 32 by default). Read as an image named name and its presence; with onPressed a button.
Fluent2AvatarGroup
Fluent 2's AvatarGroup: up to max of people as colourful avatars of size, stacked (each overlapping the one before by Fluent's step and ringed in neutralBackground2, as Fluent rings them) or spread, then the overflow "+N" in the neutral disc. Read as one image: the names shown and how many more. With onPressed (open the list of everyone) a button.
Fluent2AvatarPerson
One person of a Fluent2AvatarGroup.
Fluent2Back
The way back off a pushed page, or the close of a sheet or a cover, as the route's bar draws it: on a phone the subtle icon button with the back arrow (the dismiss glyph to close), saying "Back to label"; at desktop width the crumb over the title: the chevron and label in body1, a link in the second ink. label names where back goes; unset, the bar's backLabel names it.
Fluent2Badge
Fluent 2's CounterBadge: a count on a Fluent2LabelBadge (filled brand and circular by default, Fluent2BadgeAppearance.ghost for the ink alone), shown as [overflowCount]+ past overflowCount (99), hidden at zero unless showZero, or a 6 dot that says only that something is new (Fluent2Badge.dot). Rides child's top end corner, as Material's Badge rides an icon, or stands alone at a row's end. Read as label, else its count ("99+").
Fluent2BadgeFace
The colours one Fluent Badge wears: its fill, its words' and glyph's ink, and the 1 stroke laid inside its edge (transparent where it has none). Plumbing of the badges.
Fluent2Bar
One bar of a Fluent2BarChart: its axis label ("Mon"), its value and the words that value is printed and said in (valueText, "3 h"; null prints the number).
Fluent2BarBand
The band a phone's bar is pinned in: the status bar's room over the bar, both on the acrylic, a hairline under them. Plumbing of the screen.
Fluent2BarChart
Vertical bars across categories or days: bars grown from one hairline baseline in their hue (the brand by default), at most 24 wide with a 4 rounded top; the highlighted one in the full hue and the rest at a lighter wash of it, each value printed over its cap in caption1 (the highlighted one in the first ink, strong) and each label under the baseline in caption1. With onHighlight each bar is a button that picks it. Derived: Fluent's charting has a VerticalBarChart; this one is drawn from the tokens to common chart mark specs. Read as label, then every bar and its value.
Fluent2BarGutter
The page's gutter at a phone's pinned top bar: the screen hands it to the bar instead of padding the bar itself, and the bar stands each end that far in less the room its end part keeps round what it shows, so the back arrow, the avatar's face and the last glyph meet the keylines the page's words use while every target stays whole. Plumbing of the screen and the bar, as Fluent2BarBand is; pages never place one.
Fluent2Bell
The bell that opens account's notifications, its count at its top end corner. Plumbing of the bars.
Fluent2Beside
The desktop's two columns: the pane at the start on the ground, and child on the content layer beside it, the layer's top-start corner rounded at 8 with a hairline along its top and start edges. Plumbing of the shell and the preview.
Fluent2BottomActionBar
The acts pinned at a page's foot in Fluent 2's idiom: the primaryLabel act (the brand's button, the one the page exists for) and an optional secondaryLabel one beside it, with a summary (and its quieter detail) at the start where the page has a figure to stand by them. It goes in a Fluent2Scaffold's footer, which draws the band (the surface over a hairline, the safe area under it); the bar lays out its acts only. On the desktop the acts stand at the band's end, the primary last, at the medium size; under 480 wide (or with large text) they stack the width of the page, the primary on top, at the large size (40). Outside a footer it draws the band itself. Read as its summary, then its buttons.
Fluent2BottomSheet
Fluent 2's bottom sheet: the surface rising off the bottom edge in shadow28, its top corners 8, the handle over its optional title with the dismiss beside it when onClose is set, child scrolling once it outgrows the sheet, and the actions at its foot. showFluent2BottomSheet raises one.
Fluent2BottomStand
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.
Fluent2Breadcrumb
Fluent 2's Breadcrumb: the path to the current page as its items with a chevron between each pair, every ancestor a subtle button in the second ink and the last, the current page, in the strong cut and inert. When the path is longer than its room (or than maxDisplayedItems) the middle folds into Fluent's overflow button (the more glyph) after the first item, which opens a Fluent2Menu of the hidden places. Read as a navigation path of links, the current page said.
Fluent2BreadcrumbItem
One place on a Fluent2Breadcrumb's path: its label, a glyph before it (icon) and where a press leads (onPressed).
Fluent2Button
Fluent 2's Button: label in the size's type, an optional icon before it (after it with iconPosition Fluent2IconPosition.after), on the appearance's face at the shape's corner, stepping through its rest, hover and pressed colours. expand stretches it across its parent (a sheet's one act). Read as a button named label; null onPressed draws it disabled. Use one Fluent2ButtonAppearance.primary per view.
Fluent2ButtonBox
The box every button draws: the face's fill inside its stroke at the shape's corner (or along a styled shape), child centred in it. Plumbing of the buttons.
Fluent2ButtonFace
The faces a button wears in each state: Fluent's button styles, read from useButtonStyles per appearance. Plumbing of the buttons.
Fluent2ButtonLook
A button's look in its states, slot by slot: its own style:, then the icon button's theme (for one) and its appearance's theme, then Fluent's own, moved by the theme's density. Plumbing of the buttons.
Fluent2ButtonMetrics
The geometry of a button size: its height, its room at the sides, its least width with words, its glyph and the gap before the words, its type.
Fluent2ButtonSegment<T>
One choice of a Fluent2SegmentedButton: its value, its words, an optional glyph before them.
Fluent2Calendar
A month calendar with a single selected date and optional marked days.
Fluent2Card
Fluent 2's Card: a bounded surface summarising one item (a file, a meeting, a person), its children laid in a column (or a row with orientation) at the size's room, a Fluent2CardPreview reaching its edges, in the appearance's face. With onPressed the whole card is one press, stepping to its hover face (shadow8 for a filled card) and its pressed fill. With selected set it is selectable: its check at the top end corner and, while selected, its selected fill inside the selected stroke; a press asks onSelected for the other state (null draws it disabled). Read as its words, or as label when given.
Fluent2CardFooter
Fluent 2's CardFooter: the card's acts in a row 12 apart (wrapping rather than overflowing), an action pushed to the end. A Fluent2Card's part.
Fluent2CardHeader
Fluent 2's CardHeader: an image (an avatar, a file's glyph tile, an app's logo) 12 before the header in body1Strong over its description in caption1 and the third ink, an action (a subtle icon button) 12 after them at the end. A Fluent2Card's part.
Fluent2CardPreview
Fluent 2's CardPreview: a picture reaching the card's edges (a file's first page, a meeting's photo, a map), its child at aspectRatio (or height) in a vertical card, width wide and the card's height in a horizontal one, an optional logo 32 square at its bottom start, 12 in. A Fluent2Card's part.
Fluent2CarouselView
Slides one at a time, Fluent's Carousel: the viewport with its corners 4, and under it a chevron each way either side of the page dots, with play and pause when it autoplays. A slide turns by drag, by the chevrons or by the arrows while it holds focus.
Fluent2ChartSeries
One line or area of a Fluent2LineChart or Fluent2AreaChart.
Fluent2Checkbox
Fluent 2's Checkbox: the box (16, its corner 2; Fluent2CheckboxShape.circular a disc; Fluent2CheckboxSize.large 20) 8 in from its edges, its label 4 beside it in body1, the whole row one checkbox. Unchecked it is the accessible stroke with the label in the third ink; checked the brand fill (compoundBrandBackground) with the white check and the label in the first ink; a null value is mixed, the brand stroke round the brand square. A press, or Space, asks onChanged for the other state (mixed goes to checked); null onChanged draws it disabled.
Fluent2CheckIndicator
Fluent 2's Checkbox indicator as a selectable card, list row, table row and tree item draw it (useCheckboxStyles): a 16 square at the small corner (2) in a 1 stroke of neutralStrokeAccessible; checked, the compoundBrandBackground fill with the 12 checkmark in neutralForegroundInverted; mixed (checked null), the brand stroke round an 8 square of compoundBrandForeground1; disabled, the disabled stroke and mark. Drawn in press's step. Plumbing of the structure components, never exported: the control a page places is the checkbox's own.
Fluent2ChromeMetrics
The bars, panes and parts of Fluent 2's chrome, in logical pixels.
Fluent2ColorPicker
Fluent's colour picker: the saturation and brightness area, the hue strip and with showAlpha the opacity strip, each thumb a white ring round its colour, then a swatch and the hex field. Holds its colour in controller, the caller's own (DesignColorController(const Color(0xFF0F6CBD)), disposed by the caller).
Fluent2Colors
Every Fluent 2 alias colour of one preset in one appearance: the neutral layers (neutralBackground1 to 8, the subtle and transparent fills), the inks (neutralForeground1 to 4, disabled, inverted, on brand), the strokes, the brand fills and inks with their hover, pressed and selected steps, the status colours (danger, success, warning) and the shadow colours, each named as @fluentui/tokens names it without its color prefix (colorNeutralBackground1Hover is neutralBackground1Hover). A component reads the token its Fluent counterpart's styles read. The values are generated (internal/presets.g.dart); Fluent2ThemeData carries one.
Fluent2Combobox<T>
Fluent 2's Combobox: a text field with the down chevron at its end whose typed words filter the listbox of options under it (the popover, on a phone too, so the keyboard stays up). Down or Up opens the list on the chosen option (else the first in use), every option listed until the words are edited; the arrows then move the active option (the focus ring on it) round the list, past an option out of use; Enter or a press chooses it and the field then says its label; Escape closes the list, and leaving the field puts back the chosen label. An app's search can find the options instead, the list saying "Loading" while it runs and offering "Try again" when it fails. A choice calls onChanged; null draws it disabled. Read as a text field named label.
Fluent2CompletionCheck
A task's done mark drawn as Fluent's circular checkbox at its large size: a 20 ring in the accessible stroke while open, the brand disc with the white check once value. A press or Space asks onChanged for the other state; with no onChanged it is disabled, inert in the disabled inks; readOnly makes it a mark that only reports (drawn at full strength, not a control). label names the task to a screen reader. Its target is 44.
Fluent2ComponentThemes
Every component theme in one, as ThemeData holds Material's: what Fluent2ThemeData carries and lerps. Each is empty by default: the part draws Fluent's own.
Fluent2Composer
A multiline message field with a send button and optional attachment, emoji, and custom actions. Enter sends on desktop and Shift+Enter inserts a new line. Sending clears the draft.
Fluent2CompoundButton
Fluent 2's CompoundButton: a 40 glyph before two lines, the label in body1Strong over its secondary line in caption1, 14 over and under and 12 at the sides; for a choice that needs its consequence said ("Join now / With camera and mic on"). style restyles it over its appearance's button theme and the theme's knobs.
Fluent2Counter
A figure that counts its way to value (a total updating, a tile arriving): its digits run from the value before (from from on its first showing, when given) over 500 ms, easing out, in figures of one width so the line never jitters; at once under Reduce Motion. Formatted by format (whole numbers with thousands commas by default). A screen reader hears only where it lands.
Fluent2DataGrid<R>
A sortable data grid with optional row selection and pagination.
Fluent2DateBlock
A day set as a block, the date an agenda's rows and event cards lead with: the short weekday over the day's number in title3 over the short month, in caption1, on Fluent's grey with 4 corners; emphasis (today, the day picked) wears the brand's tint (brandBackground2 under brandForeground2). compact drops the weekday. Derived: composed from Fluent's type ramp and tints. Read as the whole date, "Monday, November 3".
Fluent2DatePicker
A date field that opens a Fluent2Calendar.
Fluent2DateRangePicker
A span of days on Fluent's calendar: two months side by side where there's room and one where there's not, the ends on the brand disc and the days between on its tint. Holds its range in controller, the caller's own (made in range mode, DesignCalendarController(firstDate: start, lastDate: end, mode: DesignCalendarMode.range), and disposed by the caller). showFluent2DateRangePicker raises one in a dialog.
Fluent2Density
How compact the controls stand, in Flutter's words for VisualDensity (this is the look's own type, free of Material's): each step of vertical takes 4 from a control's height and each step of horizontal 2 from its padding at either side, from -4 (tightest) to 4 (roomiest). The touch target does not move: 48 where a touch reaches the control, 44 elsewhere, whatever the density, so a compact face stands in the same target with room around it. A control's own size: (small, medium, large) picks Fluent's measures first; the density moves from there. A theme is standard unless set, on every platform: Fluent's measures are its desktop measures; touch grows targets, not faces (adaptivePlatformDensity is there for an app that wants a desktop more compact still).
Fluent2DescriptionItem
One fact of a Fluent2DescriptionList: its label and its value (or a child standing as the value: a persona, a tag), a glyph before the value (icon), and what a press on it opens (onPressed, its chevron at the end).
Fluent2DescriptionList
A record's facts as a Fluent 2 details pane draws them (a file's type, size, owner and dates): each Fluent2DescriptionItem a pair, the label in caption1 and the third ink, the value in body1, laid in layout; a hairline between pairs with dividers. An optional title heads it in subtitle2. Read as label and value, pair by pair.
Fluent2Dialog
Fluent 2's Dialog, its surface drawn in place: the surface centred over the overlay, at most 600 wide, its corners 8, 24 round its parts, in shadow64; the title in subtitle1, the message and content 8 under it in body1, the actions 24 under that at the end, 8 apart, the primary last (on a narrow phone they stack, the primary on top). An alert dialog: no dismiss in its head, closed by its own acts. Raise one with show or confirm.
Fluent2Divider
Fluent 2's Divider: a 1 hairline separating content, across (vertical false) or down, optionally with label in caption1 set in it 12 from the lines either side, at align; inset keeps 12 off its ends. A vertical one is 20 tall at least (84 with words). A divider is a separator, not an edge a control is read by: its strokes are Fluent's own (neutralStroke2 by default), its words held at 4.5:1. Read as its words, or as nothing.
Fluent2Eased<T>
Builds builder with value, easing to each new value as Fluent's controls ease their fill, stroke and inks: over duration (Fluent's durationFaster unless set) on curve (curveEasyEase unless set). A change that comes mid-way turns from where the value stands, with no jump back; under Reduce Motion each change is a cut.
Fluent2EditorTaps
Takes a tap anywhere over child for the text editor inside it: the editor takes focus and the caret goes where the tap is nearest the words, as Flutter's TextField takes one anywhere on its decorator. A field's frame (its padding, its strokes, the room a touch target adds) and a tag picker's input beside its tags stand round one. A tap on the words, or on a control in the row (clear, reveal, a stepper), is that one's: it stands deeper, so it wins the tap.
Fluent2EmptyState
What a page shows when it has nothing to show yet: the glyph of what it holds, filled in the brand's ink on a soft brand disc, as Fluent's apps open an empty view, the title, the body and, with onAction, one primary act (Upload a file, Clear filters).
Fluent2ErrorState
What a page shows when its content failed to load: the error glyph in the danger ink on the danger tint's disc, the title, the message and, with onRetry, the Try again button.
Fluent2FieldButton
A field-faced button (a dropdown's, a date picker's): it takes focus and Enter, Space and the down arrow (onOpen), the pointer's hover and click, and says it is a button that opens hint; the face is builder's, told whether the field is focused (the brand underline is Fluent's focus indicator on a field, not a ring) and pressed.
Fluent2FieldContextMenu
Fluent's Menu over a selection: Cut, Copy, Paste, Select all and what else the platform offers, by a pointer or above the selection on a phone. Each row is the menu's own face; its words are Fluent2Localizations'.
Fluent2FieldEditor
The editing core every Fluent 2 text control writes through (the input, the search box, the textarea, the combobox, the tag picker, the spin button, the composer): Material's text field for its editing, selection and IME, with no decoration of its own, its words and its hint in style on a line box of the style's line height, the leading split evenly about the face's ascent and descent as CSS leads a line; one line (maxLines 1) stands in the middle of the height its field hands it, more stand from the top.
Fluent2FieldFrame
Fluent's field frame: the face's fill at the field's corner (4; none for Fluent2InputAppearance.underline, which draws its bottom stroke alone), the 1 stroke with its accessible bottom, and the 2 brand underline (compoundBrandStroke) that grows from the middle while the field holds focus (in at durationNormal, out at durationUltraFast). Tracks the pointer for the hover face; child stands inside the strokes (strokesOf) with padding round it, at least minHeight tall.
Fluent2FieldMetrics
The geometry of a field size, Fluent's Input: height (24, 32, 40), the room at a side with no slot (combined: 8, 12, 18), the root's room before a slot (root: 6, 10, 12) and the words' room after it (inner: 2, 2, 6), the slot glyph (16, 20, 24) and the gap between slot and words (2, 2, 6).
Fluent2FieldPopover
Holds a popover under (or, short of room, over) its child: Fluent's positioning="below-start" with a 4 gap, as wide as the child (at least minWidth) or width, at most maxHeight tall and never past the window's edge less 8; a tap outside both, or Escape, calls onDismiss. Shown and hidden through controller. The popover follows its anchor as the page scrolls. The system back (Android's) closes it through onDismiss before it pops the page under it. A route pushed over the anchor's (an alert, a dialog, a sheet), on its navigator or another, closes it through onDismiss too, focus left to the new route: it is never left open under the route, nor found open once the route is gone.
Fluent2FieldScope
What a Fluent2FormField tells the control it labels: its label (the control's spoken name when it has none of its own), whether it is required, and whether its validation is an error (the control's stroke turns paletteRedBorder2).
Fluent2FileUpload
A place to drop or browse for files: a subtle plane (Fluent's second background, a shade darker under the pointer and pressed) met by its solid 1 hairline, its corners 8, the upload glyph over label in body1 strong and the hint in caption1, with the browse link at its foot. A press anywhere on it calls onPressed; null draws it out of use. The app reads the files; the zone is only the place.
Fluent2FloatingActionButton
Fluent 2's floating action button, the shell's act on a phone: a 56 disc of the brand with its glyph 24 in the ink on brand, in the brand's shadow8; with label the extended button, a 48 pill with the glyph 8 before the words. Read as a button named label (or semanticLabel).
Fluent2Flyout
Fluent 2's Popover surface (the Flyout of Fluent's desktop libraries, so named beside the fields' anchored listbox holder), drawn in place: child in body1 on the appearance's face, 4 corners, the size's room round it, shadow16; with arrowAt its arrow on the edge facing the control (arrowUp: the popover hangs under it), its centre arrowAt from the start. Open one anchored to a control with show. Content that teaches a control is a Fluent2TeachingPopover.
Fluent2FocusRing
Fluent's focus indicator, filling its box: a 2 stroke of strokeFocus2 on the edge and a 1 stroke of strokeFocus1 inside it, radius round (or along shape). The two tones stand apart on any fill, so the ring reads on a brand or a selected face as on the page. A Fluent2Pressable draws it while the keyboard holds focus; a control that draws its own ring (one that takes text) places it the same way.
Fluent2FooterBand
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.
Fluent2Format
US English formatters for dates, times, durations, counts, and file sizes.
Fluent2FormField
Fluent 2's Field: its label (a Fluent2Label, or a Fluent2InfoLabel when info is given; the asterisk when required) 4 over the child control, then the validation line (validationMessage with its validationState's glyph: an error by default) and the helper in caption1 in the third ink, 2 apart. The control takes the field's label as its spoken name and, for an error, its red stroke. Fluent2FieldOrientation.horizontal stands the label in the start third. A group of choices (a radio group, a segmented control, toolbar toggles, tags) is named by the label as a group, each choice keeping its own node a screen reader reaches; a single control takes the label, hint and validity into its own node.
Fluent2FormSection
A titled group of fields, as Fluent's forms and settings pages set them: the title in subtitle2 (a header to a screen reader) and its description in body1 in the third ink 4 under it, then the children (fields, a checkbox, a switch) 16 apart, 12 under the head, and a footnote in caption1 under the last.
Fluent2Gap
A fixed spacer of one Fluent2Spacing step.
Fluent2HangRoom
Lets a choice control's room hang outside its keyline: a checkbox, radio or switch keeps Fluent's 8 of room round its indicator, which holds the focus ring, and is moved back by those 8 toward the start, so the indicator's ink, the label above a switch included, starts where a field and a title in the same column start. Paint and hits move together; the part lays out at its own size. Plumbing of the components; pages never place one.
Fluent2Host
The one mount of Fluent 2 in a host app. Picks the theme for the brightness in force and puts it in scope with a Fluent2Theme (which gives the platform primitives beneath the thin Material ThemeData they read and sets Fluent's body1 as the default text style), paints the page's ground behind the app, carries status-bar polarity, and clamps the text scale at maxTextScale so a large accessibility size grows rows rather than breaking them. Every render host mounts it once above its Navigator: the app in its router builder, a page preview in its own.
Fluent2IconButton
Fluent 2's icon-only Button: one glyph in a square of the size's height (24, 32, 40), on the appearance's face (subtle by default, as a toolbar's and a bar's commands are), named by label for a screen reader. filled is the glyph worn while selected (a toggled command); its hit target reaches 44 where there is room. style restyles it over Fluent2ThemeData.iconButtonTheme, then its appearance's button theme and the theme's knobs.
Fluent2Icons
The glyphs Fluent 2 draws: the subset of Fluent UI System Icons the library and its kit parts use, bundled as the Fluent2Icons (regular) and Fluent2IconsFilled faces. A name without a size is the 20 px design, the size every control's glyph is drawn at by default (chevronDown16, checkmark12 are the smaller designs the small controls use); a Filled name is the filled design, which a selected tab, a checked toggle or a status glyph wears. Draw one with Fluent2Icon (or Flutter's Icon) at its design size.
Fluent2IconSize
Glyph sizes: the designs Fluent UI System Icons draws (12, 16, 20, 24, 28, 32, 48); a control's glyph is 20 at its medium size.
Fluent2IconTile
A glyph on a square of one of Fluent's named hues, the icon tile set at the start of a list row or a card to say what kind of thing it is (a folder, a meeting, a plan): icon in the hue's ink on its fill, size across (24 to 48; 40 by default) with the square avatar's corners and the glyph a step smaller (16 at 24 and 28, 20 at 32 and 36, 24 at 40 and 44, 28 at 48). Derived: Fluent has no icon tile; it is the square avatar with a glyph. Read as an image named label; with no label it is silent, its row saying what it is.
Fluent2Image
Fluent 2's Image: a picture (image) at width by height (or at aspectRatio, or the width of its parent with block), laid by fit in its shape, with a neutralStroke1 hairline when bordered and shadow4 under it with shadow. While the picture loads, and when it fails or there is none, it stands as a quiet placeholder: the inset ground with the image glyph in the fourth ink. Read as an image named semanticLabel; without one it is decoration and says nothing.
Fluent2InfoLabel
Fluent 2's InfoLabel: a Fluent2Label with the info button after it (the 16 info glyph, 12 small and 20 large, in the second ink, its filled design and the brand ink under the pointer, 4 round it) that opens a popover (at most 264 wide, 12 round its words in caption1, body1 large) saying info. Read as the label, then a button named "Information about" the label.
Fluent2InputGroup
A text field with fixed prefix and suffix text or custom leading and trailing widgets. The contents follow the enclosing Directionality. For a URL, wrap the group in a left-to-right Directionality so the scheme, hostname, and suffix stay in address order.
Fluent2InRow
Marks child as standing at a list row's end: the row keeps 8 over and under its words, so a part that pads itself where it stands alone (a bare switch's 8 round its track) drops that padding here, and a row with a switch stands as tall as its neighbours. Plumbing of the components; pages never place one.
Fluent2InteractionTag
Fluent 2's InteractionTag: a tag that acts. Its primary part (onPressed) opens what it names, or, with selected set, toggles the tag in and out of a choice (the brand fill while chosen: a filter, a topic, a day); an onDeleted adds its secondary part past a hairline, the dismiss mark as its own button. Both parts take the 44 touch target where there is room. Null onPressed and onDeleted draw it disabled. Read as a button named label, selected or not, and "Remove label".
Fluent2InventoryGallery
A scrollable gallery of Fluent 2 components grouped by purpose. Each entry shows the widget name and a live example.
Fluent2Kbd
The keys of a shortcut written out, as Fluent's menus and tooltips write one: the keys joined by "+" ("Ctrl+K") in caption1 and the third ink, with no caps round them. Read as the keys joined by "plus". Fluent2Kbd.shortcut takes the keys from an app's shortcut instead.
Fluent2KeyFocus
Keyboard reach for a control: it takes focus, answers keys, and draws Fluent's focus indicator while the keyboard, not a pointer, holds focus: a 2 stroke of strokeFocus2 on the control's own edge and a 1 stroke of strokeFocus1 inside it. Plumbing of the components; pages never place one.
Fluent2KeyRing
Fluent's focus indicator round child while focused and the keyboard, not a pointer, holds focus: for a control whose focus ui_core keeps (a rating, a number field, a wheel, a chart), which reports it in its states. Plumbing of the components.
Fluent2Label
Fluent 2's Label: text in body1 (caption1 small, 16/22 semibold large) in the first ink, and, when required, the asterisk 4 after it in paletteRedForeground1 (Fluent's paletteRedForeground3 misses 4.5:1 on the light presets' ground); the disabled ink when not enabled.
Fluent2LabelBadge
Fluent 2's Badge: a short status or category word (label) with an optional icon before it (after it with iconPosition Fluent2IconPosition.after) on the appearance's face in its color, at one of Fluent's six sizes; the tiny and extra-small sizes are dots that carry no words. It states, never acts. Read as semanticLabel, else its label; a bare dot or glyph needs a semanticLabel to be heard.
Fluent2Layer
Marks the desktop content layer the shell stands its pages on: a layer over the window's ground, the ground seen through a half-opaque neutralBackground1, its top-start corner rounded where it meets the nav pane. A page and a pushed route paint groundOf so they stand on it there and on the ground elsewhere. Plumbing of the shell and the screen; pages never place one.
Fluent2Layout
Responsive layout invariants shared by Fluent 2 apps.
Fluent2LineChart
Lines across a shared run of labels: one axis from zero, a recessive grid, 2 lines in the data hues, the last or the hovered point marked with an 8 dot ringed in the ground. Two or more series get a legend, and up to four their names at the line ends. Hover or a drag shows a crosshair and a card of the values. Read as label, then where each series starts and ends.
Fluent 2's Link: words in the link ink (brandForegroundLink, or the second ink's link aliases when appearance is subtle), underlined under the pointer and while pressed, always underlined when inline (a link inside a sentence, which must not lean on colour alone); the keyboard's focus rings it. Null onPressed draws it disabled in the disabled ink. Read as a link named by its words; Enter follows it.
Fluent2ListboxColumn
The listbox column: its rows 2 apart, scrolling once they outgrow the popover; an empty line in the third ink when nothing matches.
Fluent2ListGroup
Fluent 2's list as a grouped list: its rows (Fluent2ListItems) on a card's surface (neutralBackground1 at the medium corner, raised by shadow4) with a hairline between each pair, under an optional title (a Fluent2SectionHeader with its action) and over a quiet footer line. asCard false lays the rows on the bare ground with the hairlines alone. Read as its title's heading over the rows.
Fluent2ListItem
Fluent 2's list item: one row of a list (a file, a thread, a meeting, a setting), its leading part (or an icon in the second ink) before the title in body1 over a subtitle in caption1, a value in body1 and the second ink and a trailing part (a tag, a switch) at the end, then the chevron of a row that opens a page. 44 tall at least on a phone and 40 on the desktop, 8 over and under its words. With onTap it is one press on the subtle fill's hover and pressed steps; selected marks the page's own row in the selected fill. With checked set it is a row of a multiple selection: Fluent's checkbox at its start, a press asking onChanged for the other state. enabled false draws it in the disabled ink and makes it inert. Read as one: its words, then its parts.
Fluent2ListKeys
child, a list of options each holding one of nodes, with the keys of an open list: labels are the options' words, enabled whether each is in use.
Fluent2ListSection
A titled section of rows of one kind (a team's files, today's meetings, a channel's chats): a Fluent2SectionHeader (title, a quiet aside, its one action at the end), the selector that picks a set of rows when they come in sets (a Fluent2TabList: Recent, Shared, Favourites) 8 under it, then the rows in a Fluent2ListGroup on a card (asCard false lays them on the ground) with a hairline between each pair (dividers) and a quiet footer.
Fluent2LoadingState
What a page shows while its content loads: Fluent's medium spinner with its message under it, centred in the room it has.
Fluent2Localizations
The words only Fluent 2's parts say when the caller gives none; the words every look shares (Cancel, Close, Today) are DesignLocalizations'. English ships (Fluent2LocalizationsEn); another language is a subclass and a delegate that loads it, listed before delegate (the first delegate for a locale wins). With no delegate installed, the parts speak English.
Fluent2LocalizationsEn
Fluent 2's English words.
Fluent2MediaGround
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.
Fluent2Menu<T>
Fluent 2's Menu, its popover drawn in place: the surface in shadow16, its corners 4, 4 round its items, at least 138 and at most 300 wide; an optional title (Fluent's MenuGroupHeader, caption1 strong in the third ink); one row per item, 32 tall under a pointer and 44 under a finger, 6 round its parts, the glyph 20 in the second ink, the words in body1, a subtle fill under the pointer. A choice calls onSelected with its value. Open one from a control with show: the focus goes to its checked item, else its first; Down and Up move round it, Home and End go to its ends, a typed letter to the next item it starts, Enter chooses and Escape closes it, the focus back on the control. One row is current, as in Fluent's menus: opened by a key, the focused row in the focus ring; opened by a pointer, none until the pointer or a key moves; the pointer's row takes the focus, so the keys go on from it, and a key puts the pointer's fill out until it moves. Its surface reads style, then the menu theme (Fluent2ThemeData.menuTheme), then Fluent's own: fill, edge or side, shape and padding.
Fluent2MenuButton
Fluent 2's MenuButton: a Fluent2Button whose words end in the down chevron, saying it opens a menu; onPressed opens it (a Fluent2Menu).
Fluent2MenuItem<T>
One choice of a Fluent2Menu (Fluent's MenuItem): its label, a glyph before it (icon), its secondary words at the end (a shortcut, a count), the check before it while checked (a MenuItemRadio or MenuItemCheckbox), the danger ink when danger (Delete), and the value the menu returns. A divider draws a hairline above it.
Fluent2MenuLead
The rows of an open menu in child, one of them current: the keys lead first when keys (the menu opened by a key). Each row's face reads Fluent2MenuLead.of for what to draw.
Fluent2MenuLeadState
What an open menu's rows draw: shown filters a row's states.
Fluent2MenuRowFace
A menu row's face, Fluent's MenuItem: 32 tall under a pointer and 44 under a finger, the check column when checks, the glyph 20 in the second ink, the words in body1, secondary in the third ink at the end, a chevron when submenu. Hover and press step the fill and turn the glyph brand; a checked row in the check column stands out as the chosen option of an open list does (the brand's fill, its pill, the check in the brand); a face a behaviour drives by key draws its ring from ring with the focused state. In an open menu it draws what the menu's lead shows (Fluent2MenuLead: one current row), and the pointer moving over it takes the focus there. The rows of the menu, the command palette and the menu bar are this one face.
Fluent2MenuSurface
Fluent's menu panel round the rows a kit menu hands it (the menu bar's, the split button's): the first layer's fill at the medium corner, a stroke in dark, shadow16, 4 round the rows inside its 1 px stroke, between the menu's least and most widths and no taller than the overlay allows (it scrolls past that), fading in on the overlay's presence; one row current (Fluent2MenuLead: the keys lead when a key opened it). Plumbing of the components; pages never place one.
Fluent2MessageBar
Fluent 2's MessageBar: a standing message in the page's flow, on its intent's tint inside its border (the neutral layer for info), its glyph in the tone's ink, an optional title in body1Strong running into its body in body1, then its actions (Fluent's MessageBarActions, medium buttons) and the dismiss (onDismiss). For a state that holds (offline, storage nearly full, a file shared read-only), never a moment's news (that is a toast). Spoken as it appears, a live region.
Fluent2MetaItem
One item of a Fluent2MetaLine: its text and an optional icon before it; keepOnPhone holds it whole while the others shorten (a time, a count).
Fluent2MetaLine
One dense line of facts about an item, as Fluent's list rows and file cards set them ("Kai Tanaka · Edited 2h ago · 4 comments"): items in caption1 in the second ink, each after its optional 12 glyph, parted by the separator in the third ink; the items not kept shorten with an ellipsis so the line never wraps (the kept ones too, once even they overrun the width). Derived: composed from Fluent's caption1 and inks. Read as one, the items in order.
Fluent2Motion
Motion, Fluent's duration* and curve* tokens.
Fluent2MultiSelect<T>
Fluent 2's TagPicker: a field-faced control (32 tall, 12 in at each side, the brand underline while it holds focus) holding the chosen options as filled tags (20 tall, Fluent's grey, caption1 in the second ink, a 12 dismiss glyph that turns brand under the pointer; a press on a tag takes it away), then a text input that filters the options not yet chosen into a listbox under the field (the list closes when nothing matches); the arrows move the active option round the list, past an option out of use. Enter or a press adds the active option; a comma adds what was typed when it names an option; Backspace or Left in an empty input moves to the last tag, where Backspace or Delete takes it away and the arrows walk the tags; Escape closes the list. An app's search can find the options instead, the list saying "Loading" while it runs and offering "Try again" when it fails. Null onChanged draws it disabled. Read as a text field named label, each tag a button "Remove …" with a Remove action. The behaviour is the design kit's DesignTagInput; Fluent 2 paints the field, the tags and the list.
Fluent2NavigationBar
The phone tab bar, Fluent 2's mobile tab bar: the acrylic under a hairline along its top, 56 tall over the device inset; the tabs share its width evenly, each its glyph 2 over its word in caption1 (every word whole and at one size, 8 in from its tab's sides: as the reader's text grows the words grow only while all of them fit, as iOS keeps a tab bar's), at rest the regular glyph in the third ink, selected the filled glyph and the word in the brand under a short brand mark along the bar's top. An accessory stands 8 over the bar; the shell's act floats over its end (Fluent2FloatingActionButton). On the media ground (solid) the bar, and the room over it the act and accessory stand in, are the dark surface and nothing blurs.
Fluent2NavigationDrawer
The desktop nav pane, Fluent 2's NavDrawer standing on the window's ground: the hamburger and the app's brand at its head (the hamburger folds the pane to a 48 rail of glyphs, collapsed), the shell's act as the primary button under it, then one item per destination (40 tall, its glyph 20 and 16 before its word in body1, the second ink), the selected item in body1Strong with its filled glyph in the brand on a subtle fill, Fluent's selection indicator (a brand pill 4 by 20) at its start; the account at its foot as a persona that opens the profile, current while the profile is shown (profileCurrent). On the media ground (solid) it stands on the dark surface.
Fluent2NavigationDrawerItem
One destination of the nav pane (Fluent's NavItem): 40 tall, its glyph 20 and 16 before its word, a subtle fill under the pointer and while selected, the selection indicator at its start; folded (collapsed), the glyph alone. Read as a button named label, selected or not.
Fluent2NavigationRail
The folded nav pane as a rail: 48 wide, each destination its glyph alone in a 40 item, the selection indicator at its start, its name in a tooltip.
Fluent2NavItem
A destination in the tab bar or navigation pane. label provides the visible name and screen reader label. key identifies its hit target. The selected destination uses the brand color and selectedIcon, or the filled variant of icon when available.
Fluent2Option<T>
One option of a listbox, Fluent's Option: the value it stands for, its label, a glyph before it (icon), a secondary word at its end; a disabled one (enabled false) is drawn in the disabled ink and never chosen.
Fluent2OptionFace
The face of a listbox option for its states: the check, the glyph, the words and the second word, the subtle fill under the pointer, the ring while it is highlighted; while selected, the brand fill and pill. Plumbing of the listboxes.
Fluent2OptionRow
One option row of Fluent's listbox (Option): 6 over and under and 8 at the sides, its corners 4, the check (16) before its words while selected (a 16 box with the brand fill when multiselect), a glyph, the words in body1 and a secondary line in caption1; the hover and pressed neutral fills; highlighted draws the 2 strokeFocus2 ring the keyboard's active option wears. A selected row stands out at a glance as Fluent's selected list item does: the subtle brand fill, the brand pill at its leading edge and the check in the brand. 32 tall on the desktop, 44 on a phone.
Fluent2Page<T>
The go_router Page for a route pushed off a root: on Material's page route, so the push runs the page motion the Fluent2Theme sets for the platform (Fluent2PageTransitionsBuilder: Fluent 2's own, everywhere, on iOS with the swipe back from the screen's leading edge), standing on the ground (on the desktop, the content layer the shell stands its pages on).
Fluent2PageDots
Fluent's carousel nav: a dot for each page, 8 round in the accessible stroke, the current a 16 pill in the brand. Each is a 44 target when onChanged is set; otherwise the row only tells.
Fluent2PageTransition
A page coming in as Fluent 2 moves one (Fluent2PageTransitionsBuilder), for a route an app builds itself: child rises from transparent as it travels travel from the reading end (up from below with rises) while animation runs forward, and back the same way while it runs in reverse. The page under it holds still. With reduced motion asked for, it shows as the push starts and is gone as the pop starts.
Fluent2PageTransitionsBuilder
Builds the Fluent transition for a pushed or popped page. The incoming page fades in and travels 20 logical pixels from the trailing edge. A full-screen dialog rises from below. The underlying page stays still. Pushes take 250 ms and pops take 200 ms. With reduced motion enabled, the route switches immediately.
Fluent2Pagination
A pager of subtle buttons: a chevron each way, the page numbers with gaps where there are too many, the current one on the selected fill in strong words. Too narrow for the numbers, it says "Page 4 of 12" between the chevrons.
Fluent2PasswordField
A password field with a button to show or hide the entered text.
Fluent2Persona
Fluent 2's Persona: an avatar of size with its presence, beside the person's name (body1, or the size's larger type) over a secondary line and a tertiary one in the quieter inks. Read as one: the name, the presence and the lines.
Fluent2PieChart
Parts of a whole as a donut: the data hues in fixed order with 2 gaps between them, past five parts the rest folded into a neutral "Other", a legend of every part with its value beside it. The pointer on a part sets the others back and says it in the hole. Read as label, then each part.
Fluent2PieSlice
One part of a Fluent2PieChart.
Fluent2Plate
A styled surface: fill inside side at Fluent's radius, or along shape when one is styled, in shadows, child inside padding and clipped to the outline when clip. What a card, a menu, a popover, a dialog, a sheet, a toast and a tooltip stand on.
Fluent2Popover
Words or a small form on Fluent's flyout beside its trigger, opened and closed by a press. Escape, a press outside and Tab out close it, and the focus goes back to the trigger. Fluent2Flyout.show raises a flyout from code with no trigger of its own.
Fluent2PopoverSurface
Fluent's popover surface: neutralBackground1 at the control corner (4) in shadow16, a hairline of neutralStroke2 in the dark (as the menu draws it), its content clipped and padding round it (the listbox's 4; a popover's 12).
Fluent2PresenceBadge
Fluent 2's PresenceBadge: the person's presence as a disc of size (6 to 28) in its colour with its mark (the tick of available, the clock of away, the bar of do not disturb, the ring of offline), on a 1 ring of the surface so it reads over an avatar. Spoken by its status; an avatar carrying one speaks it after the name.
Fluent2Pressable
Makes a face a Fluent 2 control. Every control in this library stands on it; place one yourself only to make a row or a tile you composed one tap target.
Fluent2Preview
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 dismiss on a sheet. A pushed or sheet page is raised over a blank stage so its exit renders as it does live. A root stands over the tab bar on a phone; at desktop width a root and a pushed page stand on the content layer beside the nav pane (tabs, selectedIndex its current). Given the page's location, the pane marks the account's foot when the page is its profile.
Fluent2ProgressBar
Fluent 2's ProgressBar: how far a task has come, a fill of its color running in Fluent's grey track, 2 or 4 thick; value of max (0..1 by default) is determinate and eases to a new value over 300 ms; a null value is indeterminate, a third of the track sliding across it every 3 s (still at the middle under Reduce Motion). Fluent's Field round it is optional: a label over it in body1 and a hint under it in caption1 (what the value means: "6.2 GB of 10 GB"). Read as a progress bar named label with its percentage, or as busy.
Fluent2Radio<T>
One choice of a Fluent2RadioGroup, Fluent's Radio: the 16 circle 8 in from its edges, its label 4 after it in body1 (under it in a stacked group). Unchosen, the accessible stroke with the label in the third ink; chosen, the brand stroke round the brand dot (10) with the label in the first. enabled false draws this one inert.
Fluent2RadioGroup<T>
Fluent 2's RadioGroup: one choice among its options (Fluent2Radios), laid out by layout; a press, Space or an arrow key chooses (the arrows move the choice and the focus along the group). value is the chosen one's value; null onChanged draws every radio disabled. Read as a group named label (an enclosing field's label when null).
Fluent2Radius
Corner radii, Fluent's borderRadius*: controls and cards at medium (4), the small parts at small (2), a dialog at xLarge (8), a pill or a disc at circular.
Fluent2Raised
A handle on a raised snack bar: take it down, or wait for it to leave.
Fluent2RangeSlider
Fluent's slider with two thumbs: a span between min and max, the rail filled in the brand between them. Each thumb takes the arrows. Null onChanged draws it out of use.
Fluent2Rating
Fluent 2's Rating: a row of max stars (28 by default, Fluent's extra-large; 12, 16 and 20 too) to give a score: the chosen stars filled in the color's ink, the rest outlined in it; with allowHalf a star's start half chooses the half step. The pointer previews the score it passes over, a press or a drag across the row sets it (a step played at each star); arrows step it (mirrored right to left), End fills it, Home or 0 clears it, a digit sets that many. Null onChanged draws it disabled. Read as a slider named label saying "3 of 5". It is ui_core's DesignRating drawn in Fluent's stars.
Fluent2RatingDisplay
Fluent 2's RatingDisplay: a score shown, not given: max stars (16 by default) with the score's filled in the color's ink over the others filled in Fluent's grey (laid over the ground, so they show on a tinted page as on a card), rounded to the half; then the value in caption1 strong and the count after a middle dot ("4.5 · 1,160"), body1 at large and body2 at extra-large. compact draws one filled star and the words. Read as one image: "Rated 4.5 out of 5, 1,160 ratings".
Fluent2RefreshIndicator
A list that refreshes when pulled from its top, as Windows' refresh container does: the pull opens a band of the page's ground over the list's top edge (a hairline at its foot), and Fluent's spinner in it fills with the pull, then turns until onRefresh completes. Nothing floats over the rows: no disc, no shadow.
Fluent2ReorderableListView<T extends Object>
A list whose rows drag by their grip, or move with the keyboard from it: a dot grip at each row's end, a hairline between rows, and the row being carried lifted in shadow16.
Fluent2ReportHeight
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.
Fluent2Resizable
Two panes with a hairline between them that drags, or with the keyboard on its grip takes the arrows, to share the room: Fluent's subtle grip, the line in the brand while it is held.
Fluent2Scaffold
Root of every page: the ground (the page's ground on a phone, the content layer on the desktop), its top bar and the body in a column at the gutter. On a phone the bar is pinned over the page on the acrylic with a hairline under it, and the page scrolls under it; on the desktop the bar stands in the page and scrolls away with it, spanning the layer (its title on the column's start, its commands and the account's bell and avatar at the layer's end, as an app's head does), and the column under it runs at most 1120 wide from the layer's start.
Fluent2ScrollArea
A scrolling region with Fluent's thin bar: 6 wide while it rests, in the accessible stroke, fading when idle. It takes the keyboard when reached and wears the focus ring round the region.
Fluent2SearchBox
Fluent 2's SearchBox: an Input with the search glyph before the words and, once it holds a query, the dismiss glyph that clears it (calling onChanged with the empty text and onClear); 8 at the sides, the words 6 after the glyph, on the outline face by default. Read as a search field named label (Search). With neither onChanged nor a controller it is disabled.
Fluent2SearchEntry
A way into search drawn as Fluent's SearchBox: the same field face and search glyph with its hint in the fourth ink, or the query the page already holds in the first; the whole field is one button that opens the search (onPressed). onFilter stands a filter button beside it. Null onPressed draws it disabled.
Fluent2SectionHeader
A section's title as Fluent 2 sets one: title in subtitle2 with a quiet aside (a count) after it, and at its end the section's one action (a Fluent2SectionHeader.link, See all), 8 over what it heads. Read as a heading.
Fluent2SegmentBar
One whole split into its parts (what fills the team's storage, where a sprint's hours went): segments side by side in the chart hues, each as wide as its share of total (the parts' sum when null; what is left of a larger total stays the progress track), parted by 2 of the ground, the ends round, thickness 8 by default; with legend, a wrapping key under it, each part's swatch, name and amount in caption1. Derived: Fluent has no segmented bar; this is its ProgressBar's track holding the chart palette. Read as one image: label, then every part and its amount.
Fluent2SegmentBarPart
One part of a Fluent2SegmentBar: what it is (label), how much (value, in the bar's unit), the words its amount is said in (valueText, "3.1 GB"; null prints the number) and its hue (null takes the next of Fluent2ChartHue.categorical).
Fluent2SegmentedButton<T>
A segmented control in Fluent 2's terms: a TabList of the filled-circular appearance joined into one strip, since Fluent on the web has no segmented control of its own: under a finger a pill, as Fluent 2's iOS and Android segmented control; with a pointer the buttons' medium corner, as Fluent's toggle buttons on the web and Windows. One grey track (Fluent's grey step laid over the ground it stands on, so it shows on the page, a card or a tinted ground) holding segments of one width, the chosen one on a brand thumb that slides to the choice, its words in body1 strong in the on-brand ink; the others in body1 in the second ink, tinted under the pointer. 32 tall (24 small, 40 large); expand fills the row's width, else the widest segment sets every segment's width. The arrows move the choice. Read as a group named label of selectable buttons.
Fluent2Select<T>
Fluent 2's Dropdown: a field-faced button (32 tall, 12 in at its start and 10 at its end, at least 250 wide where there is room) saying the chosen option's label, or its prompt in the fourth ink, before the down chevron in the accessible stroke; where the options carry glyphs, the chosen one's glyph before its words, its column kept while the prompt shows, so the words stand where the list's do. It opens the listbox of options (the chosen one in the brand's fill, its pill and check): on a tablet, the desktop or under a pointer the popover under the field (shadow16, 4 round its rows), the field's width or its widest option's, its rows a finger's tall under a finger; on a phone a bottom sheet headed by label. A choice calls onChanged; null draws it disabled. Enter, Space and the down arrow open it, the arrows move through the list, Escape closes it.
Fluent2Shadows
Fluent's elevations, each an ambient shadow all round and a key shadow cast down, as shadow2 to shadow64 lay them.
Fluent2SharedColors
Fluent 2's shared colour palette in one appearance: thirty-odd named hues (red, cranberry, pumpkin, marigold, forest, teal, steel, blue, navy, lavender, purple, grape, berry, pink, magenta, plum, beige, mink, platinum, anchor and the rest), each as backgrounds, a foreground and borders, as @fluentui/tokens names them without color (colorPaletteRedBackground2 is paletteRedBackground2). The avatars' colours, the badges' and the tags' read them; the same in every preset.
Fluent2Sheet
Present a sheet: show raises a transient one from a control (share, move to, confirm) over the whole app; pageRoute is the route a declared sheet PAGE rides (Fluent2SheetPage), whose bar becomes the sheet's head with its dismiss.
Fluent2SheetCard
The card a sheet stands on: the surface with its corners (the top two at 8 on a phone's bottom sheet, all four on the desktop's dialog, the start two on a side drawer), its shadow, its content clipped and marked as on a card (Fluent2SheetShell.around). The unnamed constructor stands it as a phone's bottom sheet and a desktop's dialog; Fluent2SheetCard.bottom, Fluent2SheetCard.dialog and Fluent2SheetCard.side pick one. Plumbing of the sheets; a page never places one.
Fluent2SheetHandle
The handle over a phone's bottom sheet: 36 by 4, round, in the accessible stroke, 8 under the sheet's top. Plumbing of the sheets.
Fluent2SheetHead
A sheet's head (Fluent's DrawerHeaderTitle and DialogTitle): its title in subtitle1 and, at its end, the dismiss button (close; none for a dialog that closes by its own Cancel), or at its start the way back (leading), 8 between, at least 48 tall.
Fluent2SheetPage<T>
The go_router Page whose route is Fluent 2's page sheet, created on the root navigator so it rises over the shell's bar. drawer stands it as tall as its content on a phone and as the end drawer on the desktop; fullScreen raises a full-screen cover on the ground instead, drawn as a pushed page whose exit is the dismiss. Either publishes RoutePresentation.sheet around its child, so the screen inside derives its dismiss, or with back the way back.
Fluent2SheetShell
A modal sheet's card, drawn in place: on a phone Fluent 2's bottom sheet (the surface rising off the bottom edge, its top corners 8, the handle over the head, in shadow28); at desktop width Fluent's dialog surface (centred, at most 600 wide, its corners 8, 24 round its parts, in shadow64). The head (Fluent2SheetHead: the title and the dismiss button), the body's children 8 under it, then the foot 16 under that: the acts at the end, the primary last (on a phone they share the width). The card scrolls once its parts outgrow it. For a sheet composed in place; Fluent2Sheet.show presents this same widget.
Fluent2ShellAction
The app-level act beside the tabs, as Fluent 2 draws it: the floating action button over the tab bar's end on a phone (extended with its label), and the primary button under the nav pane's head at desktop width.
Fluent2ShellInsets
The bottom allowance the shell asks each branch root to reserve: the tab bar over the device inset, the act and any accessory over it. The shell publishes it through the design kit's ShellInsets; a screen reads it with of.
Fluent2SideInset
How far the desktop nav pane stands over the left of the pages under it: a page lays its content out to the right of inset and its ground on under the pane. The shell publishes it on the desktop; elsewhere it is none. Plumbing of the shell and the screen; pages never place one.
Fluent2Skeleton
Fluent 2's Skeleton: the stand-in for content still loading, holding Fluent2SkeletonItems laid as the content will be (an avatar circle beside two lines of a row), all breathing together by its animation in its appearance (still under Reduce Motion). Read as one busy node, label ("Loading files"), its shapes silent.
Fluent2SkeletonItem
One shape of a Fluent2Skeleton: a Fluent2SkeletonShape.rectangle as wide as width (the parent's by default) and size tall, or a Fluent2SkeletonShape.circle or Fluent2SkeletonShape.square size across (Fluent's sizes 8 to 128; 16 by default). Outside a skeleton it stands still in the opaque stencil.
Fluent2Slider
Fluent 2's Slider: a value between min and max along a rail (4, its corners 8) in the accessible stroke, filled in the brand (compoundBrandBackground) up to the thumb: a 20 disc of the surface with its 1 neutralStroke1 edge round a 12 brand disc (the brand ring). With step the value snaps and the rail is cut at each step. A drag or a tap on the rail moves it, as do the arrow keys (a step, or a hundredth), Page Up and Down (a tenth), Home and End; onChanged gets each value and onChangeEnd the one let go at. Read as a slider named label saying valueLabel's words (the value by default). Null onChanged draws it disabled.
Fluent2Spacing
Design tokens and theme assembly: the only styling vocabulary a Fluent 2 page may use.
Fluent2Sparkline
An axis-less inline trend: values as one 2 line in its hue (the brand by default) across the width, its last point marked with an 8 dot in a 2 ring of the ground (ground, the surface by default), an area wash of the hue at 10% under it. Derived: Fluent's charting has a Sparkline; this one is drawn from the tokens to common chart mark specs. Read as label with where it starts and ends.
Fluent2SpinButton
Fluent 2's SpinButton: a number in a field 32 tall (24 small), 10 in at its start, and at its end the two 24 wide steppers stacked, the up and down chevrons (16) in the third ink on a subtle fill under the pointer; each moves value to the next multiple of step within min and max (the one at a bound is disabled), repeating while held, as do the up and down arrow keys (Page Up and Down by ten steps); figures typed in the reader's digits are taken on Enter (the field keeps the focus) or when the field lets go of it, and text that is no number puts the last value back. format says the value in the field while it rests (the number at step's precision by default); editing, it shows the number. onChanged gets each value; null draws it disabled. Read as an adjustable field named label. It is ui_core's DesignNumberField in Fluent's field and steppers.
Fluent2Spinner
Fluent 2's Spinner: a ring in the brand's contrast stroke with the brand's arc running round it (on a brand fill, inverted: the light arc on a faint ring), and its label after it or under it (below) in body1. While Reduce Motion is on it stands still at a quarter. Read as "label" (Loading by default), a live region.
Fluent2SplitAction
One of a Fluent2SplitButton's other choices: its label (and icon) on a menu row, onPressed run when it is chosen; a null onPressed draws the row in the disabled ink and passes it over.
Fluent2SplitButton
Fluent 2's SplitButton: the act (label, onPressed) and, joined to it past a hairline, the chevron that opens a menu of its other choices (actions) under its end. Two tap targets, two buttons to a screen reader ("label", "More options for label", which says whether its menu is open); Down on either half opens the menu, the arrows walk it, Escape closes it and gives focus back. One row of the open menu is current: opened by a key, its first in the focus ring; by a pointer, none until the pointer or a key moves. The behaviour is the design kit's DesignSplitButton; Fluent 2 paints both halves and the menu.
Fluent2Stat
One figure and what it measures, a dashboard's stat tile (Fluent has no stat component; this one is composed from its type ramp, its Card surface and its Badge): the label in caption1 over the value in title1 (largeTitle at Fluent2StatSize.large) with figures of one width and an optional unit after it in body1, a delta badge beside it, a quiet caption under it, a trend sparkline at its foot and an icon at its start. On a Fluent card (neutralCardBackground, 4 corners, 12 round, shadow4) unless framed is false; with onPressed the card opens what it counts. Read as one: label, value, delta, caption.
Fluent2StatDelta
A stat's change against a named period: its words (text, "+12% vs last week"), its direction (up) and whether that direction is good (good; null takes up as good). Drawn as a tint badge in success's green when good, danger's red when not, with the arrow of its direction.
Fluent2StatusGlyph
A workflow state as Fluent draws one in Planner and To Do: Fluent UI System Icons' status set, each status its glyph in its tone's ink (the empty circle, the clock, the filled tick, the warning, the error circle, the dismiss circle), with an optional label in body1 (caption1 at the small size) after it. The glyph never stands alone as the only cue to a sighted reader of a dense list: pair it with words or a column heading. Read as its label or the status's own name.
Fluent2StatusView
The shared name for a page's loading, error and success states: Fluent's spinner, or the status glyph over the title, the message and one act.
Fluent2StepProgress
Where a run of steps has got to: "Step 2 of 3" in caption1 over the step's name in subtitle2, its phase beside it, and a 4 bar cut into one segment per step, the done and the current in the brand.
Fluent2Stroke
Stroke widths, Fluent's strokeWidth*.
Fluent2SwipeAction
One act a swiped row reveals, as a mail app's rows set them: its label under its icon on a full-height pane of its tone's solid (archive in success's green, delete in danger's red, flag in warning's orange, read in the brand, a quiet act in the informative grey).
Fluent2SwipeActions
A row with acts revealed by a swipe, as a phone's mail app lays a message's: dragging the row sideways uncovers full-height panes 80 wide in the tones' solids, the first nearest the edge. Let go past half their width and the row settles open; short of it, it settles shut. A press on a pane does its act and shuts the row. With fullSwipe a drag past 60% of the width does the edge's first act (a mail app's archive or delete), its pane widening as it arms. The arrows open a side from the keyboard and focus its first pane; Escape shuts it. Each act is also a custom action on the row, so a screen reader or a pointer that cannot swipe reaches it. initiallyOpen stands an edge open on the first frame: the trailing one, the leading one when there is no trailing act. The behaviour is the design kit's DesignSwipeActions; Fluent 2 paints the panes.
Fluent2Switch
Fluent 2's Switch: a 40 by 20 track (32 by 16 small) 8 in from its edges, its 14 thumb 3 inside the stroke, and its label 4 beside it in body1, the whole row one switch. Off, the accessible stroke and thumb; on, the brand fill (compoundBrandBackground) with the white thumb at its end, sliding over durationNormal. A press or Space asks onChanged for the other state; null onChanged draws it disabled.
Fluent2Tab
One tab of a Fluent2TabList.items: its label, a glyph before it (icon, selectedIcon while it is the selected tab, Fluent's filled design), and whether it can be chosen (enabled).
Fluent2Table
Fluent 2's Table (and DataGrid's look): a header row in body1 over rows 44 tall with a hairline under each, cells 8 in at their sides, each a Fluent2TableCell layout. A Fluent2TableColumn.sortable header is a press that asks onSort for its column, the sorted one wearing its 12 arrow. With selected set the rows are selectable: Fluent's checkbox in a 44 column at the start (the header's selects them all), a selected row lit by selectionAppearance, a change told through onSelectionChanged. Rows step through the subtle fill's hover and pressed steps. When the columns need more room than there is (a phone) the table scrolls sideways. Read as rows of cells, sorting and selection said.
Fluent2TableCell
One cell of a Fluent2TableRow, Fluent's TableCellLayout: its media (a glyph or an avatar, 20, or 24 when primary) 8 before its text (semibold when primary) over a description in caption1 and the second ink.
Fluent2TableColumn
One column of a Fluent2Table: its header label, a fixed width or a flex share of the room no narrower than minWidth, numeric figures set at the end in tabular digits, and whether its header sorts (sortable).
Fluent2TableRow
One row of a Fluent2Table: its cells in the columns' order and what a press on it does (onPressed).
Fluent2TabList
Fluent 2's TabList: peer sections of one page as a row of tabs (a column with vertical), the one at selectedIndex selected: its words in body1Strong (the width each tab keeps either way), its glyph filled and in the brand, and under it the 3 brand indicator that slides from the tab chosen before on a spring that settles in durationSlow (critically damped under Reduce Motion), or in the circular appearances its pill. A row longer than its room scrolls, keeping the selected and the focused tab in view. A row of transparent or subtle tabs hangs its first tab's inset (its padding round the words) toward the start, so the first word and its indicator start where a title and a field in the same column start; a pill's edge stays on the column's. A tab press, or the arrows along the row (one tab stop; mirrored right to left, Home and End to the ends, tabs out of use skipped), asks onChanged for its index; null draws the list disabled. Fluent2TabList.items takes tabs with glyphs, or one out of use. Read as a tab bar of tabs, "Files, Tab 2 of 3". It is ui_core's DesignTabBar in Fluent's faces.
Fluent2Tag
Fluent 2's Tag: a compact label for a category, a person or a picked value: label (over a secondary line in caption2 at the medium size) after an icon or a person's avatar, on the appearance's face at Fluent's three sizes. Static, it states (a file's labels, a task's project); with onDeleted it is a removable token (a picked recipient) whose whole face is one button ending in the dismiss mark. enabled false draws the disabled face. Read as its label (and "remove" with onDeleted).
Fluent2TagFace
The colours of one Fluent Tag in one state: its fill, its stroke, its words' ink and its glyph's glyph. Plumbing of the tags.
Fluent2TagGroup<T>
Fluent 2's TagGroup: items in one wrapping row at the size's gap (8, 6, 4), sharing a size, an appearance and a shape. With selected and onSelectionChanged each is a choosable Fluent2InteractionTag (one at a time unless multiple): the filters over a list, the topics of a post. With onDeleted each is removable (the recipients picked, the labels set). Neither: static Fluent2Tags. Null onSelectionChanged draws a choosable group inert. Read as a group named label.
Fluent2TagItem<T>
One tag of a Fluent2TagGroup: its value, its label and what leads it (icon or a person's avatar); dismissible false keeps it in a group that removes the others.
Fluent2TeachingPopover
Fluent 2's TeachingPopover: a coach mark that teaches one control in place, anchored to it by its arrow: the title in subtitle2, the body in body1, then its acts at the end (the secondaryLabel before the primaryLabel, "Got it"), the step ("step of steps") at the start of a tour, and the dismiss at the title's end. On the brand fill by default, at least 320 wide, 16 round its content, 8 corners. It stays until an act or the dismiss closes it. Open one anchored to the control with show; drawn in place it points with arrowAt. Read as a dialog named by its title.
Fluent2TextArea
Fluent 2's Textarea: several lines in a field at least 52 tall (40 small, 64 large), 6 over the words and 12 at the sides, growing with its text up to 260 (200, 320) and scrolling past it, on the outline or a filled face with the brand underline on focus (Fluent's Textarea has no underline face). The page owns the text through value and onChanged, or a controller; with neither it is disabled.
Fluent2TextField
A single-line Fluent text field with a brand-colored focus underline. Manage its text with value and onChanged, or supply a controller. The field is disabled when neither a controller nor a callback is supplied.
Fluent2Theme
Puts Fluent 2 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, and every look installs the same way (<Look>Theme(data: <Look>ThemeData.preset(...))). Under it, Flutter's own text field reads Fluent's caret, selection and handles, with no ink, splash or highlight; the default text style is Fluent's body1 and the default icon its first ink at 20.
Fluent2ThemeData
Fluent 2's theme: one preset in one appearance, as Material's ThemeData is Material's. Every colour is a Fluent alias in colors (ui_core's roles below are named views of them), the page's ground (background), the acrylic (acrylic), the elevations (shadows, brandShadows), the type ramp (caption2 to display, Fluent's own names), the component themes (components), and the density, typeface and solidAcrylic settings. Corners and strokes are Fluent's tokens (Fluent2Radius, Fluent2Stroke), and the acrylic's recipe and the elevations are Fluent's too; a component theme sets one part's shape.
Fluent2ThemeDataTween
A tween between two Fluent 2 themes, through Fluent2ThemeData.lerp.
Fluent2Time
A time of day, neutral of any toolkit: hour 0 to 23, minute 0 to 59.
Fluent2Timeline
An activity feed, as Fluent's apps list what happened (a Teams activity, a file's version history): each event a row led by its glyph (filled when it has a tone, as a status glyph is) on a 32 disc of its tone's tint (the neutral tint when it has none), the title in body1 strong with its time in caption1 at the end, its words in body1 under it. No rail joins the rows; their order says the sequence. An entry with no glyph wears its tone's: a check for success, the warning and error glyphs, the info glyph, else the history glyph.
Fluent2TimelineEntry
One event of a Fluent2Timeline.
Fluent2TimePicker
Fluent's TimePicker: a select of the day's times every minuteStep minutes, in the field's own dropdown. Null onChanged draws it out of use. showFluent2TimePicker asks with two wheels instead.
Fluent2Toast
A snack bar's face, drawn in place: the tone's glyph (16) in its ink, the title in body1Strong over the message in body1 (the message alone in body1Strong), the one action's link (actionLabel) at the end, on the surface card in shadow8, its corners 4, 12 round its parts. A page notifies through showFluent2Toast, never by standing this in its body.
Fluent2Toaster
Where snack bars queue, over the whole app: up to maxVisible at its foot, the newest nearest; the pointer resting on one, or the focus in it, holds its time, and F6 reaches them from anywhere. Put it once around the app, inside the theme; showFluent2Toast finds it from anywhere below.
Fluent2ToggleButton
Fluent 2's ToggleButton: a Fluent2Button that stays pressed while checked, on the appearance's selected face, its glyph turning to checkedIcon; a press asks onChanged for the other state. Read as a toggle named label.
Fluent2ToneColors
One tone's colours: a word or glyph ink (ink, 4.5:1 on its tint and on the page's surfaces), the solid fill (solid) with the ink set on it (onSolid), the subtle tint (tint) and its border (border).
Fluent2Toolbar
Fluent 2's Toolbar: a row of subtle commands (icon buttons, toggles that stay pressed, labelled buttons) in groups split by its dividers, 4 over and under it and 8 at its sides. When the row runs out of room its last commands fold into the more button at its end, which opens a Fluent2Menu of them (a toggle a checkable item). vertical stacks it in a column. 44 tall on a phone. Read as a toolbar of buttons.
Fluent2ToolbarGroup
Fluent 2's ToolbarGroup: commands that belong together (a document's text formatting, a file's sharing) standing side by side as a toolbar's subtle buttons, toggles and dividers, read as a group named label. It has no room of its own: it stands in a row or a Fluent2Toolbar's place, and unlike a toolbar it never folds its commands into a more button: where they don't fit on one line (large text on a phone) they run on to the next. It keeps to its commands' width. Fluent joins no buttons in one frame: related acts share a toolbar's group, not a border.
Fluent2ToolbarItem
One part of a Fluent2Toolbar: a command (Fluent2ToolbarItem.button), an on/off command (Fluent2ToolbarItem.toggle) or Fluent's ToolbarDivider between groups (Fluent2ToolbarItem.divider). A command is its glyph alone (named by its label for a screen reader) or, with showLabel, its glyph and its words.
Fluent2ToolbarToggle<T>
One toggle of a Fluent2ToolbarToggleGroup: Fluent's ToolbarRadioButton in a one-choice group, its ToolbarToggleButton in a group of any number. Its icon alone (named by label for a screen reader) or, with showLabel, its glyph and its words; while chosen it wears checkedIcon, else icon's filled twin.
Fluent2ToolbarToggleGroup<T>
Fluent 2's toolbar toggles that belong together, on the toolbar's subtle faces: a ToolbarRadioGroup (one choice of several: a list's layout) or, with multiSelectionEnabled, ToolbarToggleButtons that share a name (any number: a mail list's flagged, unread, with files). A chosen toggle stays on the subtle selected face with its glyph filled. Tab reaches the group once, the arrows move along it (mirrored right to left), Space and Enter press. Read as a radio group or a group of toggles named label. It keeps to its toggles' width, and where they don't fit on one line (large text on a phone) they run on to the next. One choice of a view's few modes with a sliding thumb is the segmented control (Fluent2SegmentedButton) instead.
Fluent2Tooltip
Fluent 2's Tooltip: a short message naming or explaining its child (an icon-only command, a truncated name), shown in a bubble above it (or Fluent2TooltipPosition.below) after the pointer rests on it for 250 ms, on a long press on a touch screen, and while the keyboard's focus is inside it; hidden 250 ms after the pointer leaves it and the bubble. The pointer may move onto the bubble, Escape hides it, and one shows at a time: along a toolbar the next shows at once. withArrow adds the 6 arrow pointing at the control (Fluent draws none by default), aimed where the bubble landed. The message is the control's tooltip to a screen reader. It is ui_core's DesignTooltip in Fluent's bubble. Never put an act or the only copy of something needed inside one.
Fluent2TooltipBubble
The bubble displayed by Fluent2Tooltip. Set placement to draw an arrow toward the control that owns the tooltip.
Fluent2Tree<T>
Fluent 2's Tree: nested items (a workspace's folders and files, a channel list), each a row 32 tall (44 on a phone) on the subtle fill's hover and pressed steps, indented 24 a level: a branch leads with its 12 chevron in a 24 column (turning down while open, durationNormal), a leaf stands where the chevron would. A press on a branch opens or shuts it; a press on a leaf asks onChanged for its value, and the item whose value is value wears the subtle selected fill. Open branches are the tree's own, from initiallyExpanded. Read as items that say whether they are expanded and which is selected.
Fluent2TreeItem<T>
One item of a Fluent2Tree: its value, its label, a glyph before it (icon, openIcon while its branch is open), a quiet aside at its end (a count) and the items under it (children); with children it is a branch.
Fluent2Typeface
The face the type ramp is set in: family from package (the package that bundles it, null for the app's own fonts), at Fluent's sizes. Fluent sets everything in one face; the default is the bundled Selawik, the open stand-in for Fluent's system face. An app's own face (a brand's, or one for a script Selawik lacks) works when it declares it in its pubspec and loads it before the first frame.
Fluent2WebBaseline
Sets child, words in style (a field's line, a trigger's label), where a browser sets them in their line box: fluent2WebBaselineDrop higher, in paint and in hit testing; the box it takes stays its own.
Fluent2WeekStrip
One week as a row of days to pick from, the strip a phone's calendar heads its agenda with: seven equal cells, each the short weekday in caption1 (the third ink) over the day's number in a 32 circle and a 4 dot under it when hasEvents says the day holds something. The value day is the brand's fill with its number in the on-brand ink, strong; today (when not picked) has its number in the brand's ink, strong. The week shown is the one holding value, starting on firstDayOfWeek (Monday by default). A press picks a day through onChanged; with none it is inert. Derived: Fluent has no week strip; it is composed from its calendar's day button. Each day reads as a button, "Monday, November 3", selected when picked.
Fluent2WheelPicker<T>
A turning drum of choices: the chosen line on the subtle selected fill, its words strong, the lines above and below in the third ink, drawn smaller round the drum. Drag or fling it, or tap a line; the arrows step it (Page Up and Down by five, Home and End to the ends), typing a choice's first letters finds it, and a screen reader steps it as an adjustable. It is ui_core's DesignWheelPicker, one column, in Fluent's lines and band.
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.
Fluent2AccordionSize
An accordion header's size, Fluent's size: small 32 tall in caption1 (44 on a phone), medium 44 in body1 (the default), large 44 in body2, extraLarge 44 in subtitle1's 20/28 regular.
Fluent2AvatarColor
How an avatar is coloured, Fluent's color: neutral the quiet grey (the default), brand the brand's fill, colorful one of Fluent's thirty named hues picked by the person's name, the same name the same hue everywhere.
Fluent2AvatarGroupLayout
How a Fluent2AvatarGroup lays its people, Fluent's layout: stack overlapping, each over a ring of the surface; spread side by side with a gap.
Fluent2AvatarShape
An avatar's outline, Fluent's shape: a circular person, a square group, team or app (its corners stepping with its size).
Fluent2BadgeAppearance
How a Fluent2LabelBadge wears its colour, Fluent's appearance: filled the solid fill (the default), ghost the ink alone, outline the ink in a stroke, tint the colour's pale wash with its border.
Fluent2BadgeColor
A badge's colour, Fluent's color: brand (the default), danger, important (the page's own ink, inverted), informative (the quiet grey), severe (the dark orange between warning and danger), subtle (the surface: for a badge on a photograph or a brand fill), success and warning.
Fluent2BadgeCountColor
A counter badge's colours, Fluent's CounterBadge color: brand (the default), danger, important, informative.
Fluent2BadgeShape
A badge's corners, Fluent's shape: circular a pill (the default), rounded at 4 (2 on the small sizes), square none.
Fluent2BadgeSize
A badge's size, Fluent's size: tiny a 6 dot, extraSmall a 10 dot, small 16 tall (caption2Strong), medium 20 (caption1Strong, the default), large 24, extraLarge 32.
Fluent2BreadcrumbSize
A breadcrumb's size, Fluent's size: small 24 tall in caption1 with 12 chevrons, medium 32 in body1 with 16 chevrons (the default), large 40 in body2 with 20 chevrons.
Fluent2ButtonAppearance
How loud a Fluent2Button is, Fluent's appearance: secondary the default (the surface with its stroke), primary the brand fill (the one act a view exists for), outline the stroke alone, subtle no fill until the pointer is over it, transparent never a fill, its words in the brand under the pointer.
Fluent2ButtonShape
A button's corners, Fluent's shape: rounded at 4, circular a pill, square none.
Fluent2ButtonSize
A button's size, Fluent's size: small 24 tall (caption1), medium 32 (body1Strong), large 40 (subtitle2's 16/22).
Fluent2CardAppearance
How a Fluent2Card stands on the page, Fluent's appearance: filled the surface (neutralBackground1) raised by shadow4 (the default), filledAlternative the second neutral layer raised the same, outline no fill inside a neutralStroke1 hairline, subtle no fill and no edge until the pointer is over it.
Fluent2CardOrientation
Which way a Fluent2Card lays its parts, Fluent's orientation: a vertical column (a preview over its header) or a horizontal row (a thumbnail beside it).
Fluent2CardSize
A card's size, Fluent's size: the room round and between its parts and its corner. small 8 at the small corner (2), medium 12 at 4, large 16 at 6.
Fluent2ChartHue
The colours Fluent 2's charts draw data in: the brand (Fluent's compoundBrandBackground, a single series' default), five of Fluent's shared palette hues for parts and categories (cornflower, pumpkin, magenta, forest, lavender, in that fixed order: categorical), and neutral for "Other" (neutralStrokeAccessible).
Fluent2CheckboxShape
A checkbox's indicator, Fluent's shape: square at 2, circular a disc.
Fluent2CheckboxSize
A checkbox's size, Fluent's size: medium a 16 box with its 12 check, large a 20 box with its 16 check.
Fluent2ComposerAppearance
Where a Fluent2Composer writes: a chat's message box or an assistant's prompt box.
Fluent2CounterStyle
The ramp step a Fluent2Counter is set in.
Fluent2DescriptionListLayout
How a Fluent2DescriptionList lays its pairs: columns the label at the start and the value beside it, stacked the label over the value (a narrow details pane), or auto: columns from 360 wide, stacked under.
Fluent2DividerAlign
Where a divider's words stand, Fluent's alignContent: start 8 from the line's start, center, end 8 from its end.
Fluent2DividerAppearance
A divider's weight, Fluent's appearance: standard (Fluent's default) the second stroke under the second ink, subtle the third stroke and ink, brand the brand's stroke and ink, strong the first.
Fluent2ExpandIconPosition
Which end of a header its chevron stands at, Fluent's expandIconPosition: at the start, pointing at its words and turning down when open (the default), or at the end, down when shut and up when open.
Fluent2FieldOrientation
How a field lays out, Fluent's orientation: vertical the label over the control, horizontal the label in the start third beside it (vertical again once the field is under 400 wide).
Fluent2FlyoutAppearance
A flyout's face, Fluent's Popover appearance: neutral the surface (the default), brand the brand fill, inverted the dark static plane.
Fluent2FlyoutSize
A flyout's room round its content, Fluent's Popover size: small 12 (a 6 arrow), medium 16 (the default, an 8 arrow), large 20.
Fluent2Hue
The hue an icon tile or a category wears: the brand, neutral, or one of Fluent's thirty named hues (the colourful avatar's), each its palette<Name>Background2 fill under its palette<Name>Foreground2 glyph, a pair that holds 4.5:1 in light and dark. The brand is brandBackground2 under brandForeground2; neutral Fluent's grey (laid over the ground it stands on) under neutralForeground3.
Fluent2IconPosition
Which side of the words a part's glyph stands on, Fluent's iconPosition: before (the default) or after (a "Next" that points on).
Fluent2ImageFit
How a Fluent2Image's picture fills its box, Fluent's fit: fill (Fluent's default) stretched to the box, none at its own size from the top start, center at its own size centred, contain whole inside the box, cover filling the box and cropped.
Fluent2ImageShape
An image's outline, Fluent's shape: square corners, rounded at the medium corner (4), circular.
Fluent2InputAppearance
A field's face, Fluent's Input appearance: outline the default (the surface inside a 1 stroke whose bottom is the accessible stroke), underline the bottom stroke alone, filledDarker the darker neutral fill (Fluent's grey, for a field on the surface), filledLighter the surface fill (for a field on the page's grey ground). Every one grows the 2 brand underline while it holds focus. The filled-darker grey is laid over whatever the field stands on, so it shows on the page's tinted ground too.
Fluent2InputSize
A field's size, Fluent's Input size: small 24 tall in caption1, medium 32 in body1, large 40 in body2.
Fluent2LabelPosition
Where a control's label stands, Fluent's labelPosition: a checkbox takes before or after, a switch before, after or above, a radio after or below.
Fluent2LabelWeight
A label's weight, Fluent's Label weight.
Fluent2LinkAppearance
How a Fluent2Link reads: Fluent's default brand link, or subtle in the second ink.
Fluent2MessageIntent
What a Fluent2MessageBar tells, Fluent's intent: info (the default, the neutral grey), success, warning, error.
Fluent2MessageLayout
How a message bar lays its parts, Fluent's layout: singleline the glyph, the words and the acts on one 36 line; multiline the words wrapping beside the glyph with the acts under them at the end; auto (the default) one line when it all fits, else the two.
Fluent2MetaSeparator
What parts a Fluent2MetaLine's items: a middle dot (the default) or a bullet.
Fluent2MultiSelectSize
A tag picker's size: 32 tall empty, 34 with its tags (20), or 40 and 42 (its tags 24).
Fluent2Presence
A person's presence, Fluent's PresenceBadge statuses.
Fluent2Presentation
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.
Fluent2Press
The step of Fluent's colour aliases a face is drawn in: at rest, under the pointer, pressed, or disabled, as Fluent's Hover, Pressed and Disabled aliases step. Read from a press's states with Fluent2PressStates.press.
Fluent2PressRole
What a Fluent2Pressable is to assistive technology.
Fluent2ProgressColor
What a progress measure's fill says, Fluent's color: brand (the default), success, warning, error.
Fluent2ProgressShape
A progress bar's ends, Fluent's shape: rounded at 4 (the default), square.
Fluent2ProgressThickness
A progress bar's thickness, Fluent's thickness: medium 2 (the default), large 4.
Fluent2RadioLayout
How a radio group lays out, Fluent's RadioGroup layout: vertical one radio a line, horizontal side by side (wrapping on a narrow window), horizontalStacked side by side with each label under its circle.
Fluent2RatingColor
The ink a rating's stars wear: Fluent's neutral (the first ink), brand, or marigold (a review's gold).
Fluent2RatingSize
A rating's star size: 12, 16, 20 or 28.
Fluent2SegmentedButtonSize
A segmented control's height: 24, 32 or 40.
Fluent2SkeletonAnimation
How a skeleton breathes, Fluent's animation: wave a lighter band sweeping each shape every 3 s (the default), pulse the shapes fading to 40% and back every second.
Fluent2SkeletonAppearance
A skeleton's ground, Fluent's appearance: opaque the stencil grey (the default, on a surface), translucent its alpha step (on a tinted or photographic ground).
Fluent2SkeletonShape
A skeleton shape, Fluent's SkeletonItem shape: a rectangle the parent's width (a line of words, corners 4), a circle or a square of the item's size (an avatar, a thumbnail).
Fluent2SliderSize
A slider's size, Fluent's size: medium a 20 thumb on a 4 rail, 32 tall; small a 16 thumb on a 2 rail, 24 tall; either 48 tall under a finger.
Fluent2SortDirection
Which way a Fluent2Table's sorted column runs.
Fluent2SpinnerSize
A spinner's size, Fluent's size: 16, 20, 24, 28, 32 (the default), 36, 40 and 44 across.
Fluent2StatSize
How large a Fluent2Stat's figure is: medium title1 (32/40, the default, a tile in a row), large largeTitle (40/52, the one lead figure of a view).
Fluent2StatusGlyphSize
A status glyph's size: 16 (in a dense row, beside caption words) or 20 (a control's, the default).
Fluent2StatusKind
How a Fluent2StatusView stands.
Fluent2SwitchSize
A switch's size, Fluent's size: medium a 40 by 20 track, small 32 by 16 with its label in caption1.
Fluent2TabAppearance
How a Fluent2TabList draws its tabs, Fluent's appearance: transparent words on no fill with the brand indicator under the selected one (the default), subtle the same on the subtle fill's hover, subtleCircular pills with the selected one on the brand's tint in its stroke, filledCircular pills on the third neutral layer with the selected one in the brand's fill.
Fluent2TableSelectionAppearance
How a selected row is lit, Fluent's row appearance: neutral the subtle selected fill, brand the brand's tint.
Fluent2TableSize
A table's density, Fluent's size: extraSmall rows 24 tall in caption1 with no hairlines, small 34, medium 44 (the default). On a phone every row keeps 44.
Fluent2TabSize
A tab's size, Fluent's size: small 32 tall (6 round its words), medium 44 (12 over and under, 10 at the sides), large 54 in body2 with a 24 glyph.
Fluent2TagAppearance
A tag's fill, Fluent's Tag appearance: filled the quiet grey (the default), outline a stroke on the page, brand the brand's tint.
Fluent2TagShape
A tag's corners, Fluent's shape: rounded at 4 (the default) or a circular pill; an avatar in a rounded tag is square.
Fluent2TagSize
A tag's size, Fluent's size: medium 32 tall in body1 (the default), small 24 in caption1, extraSmall 20 in caption1.
Fluent2TaskStatus
A piece of work's state, as a Fluent2StatusGlyph draws it.
Fluent2ToastIntent
What a snack bar says it is, Fluent's toast intent: each wears its status glyph in its ink.
Fluent2Tone
The tone a badge, a message bar, a field's validation or a toast wears: Fluent's informative (the neutral grey), brand, success, warning, danger (Fluent's error) and severe (its darker orange).
Fluent2ToolbarSize
A toolbar's size, Fluent's size, which sets its room alone (Fluent's ToolbarButton is a medium button, 32, at every size): small 4 at its sides and none over and under; medium 4 over and under and 8 at its sides (the default); large 4 over and under and 20 at its sides.
Fluent2TooltipAppearance
A tooltip's face, Fluent's appearance: normal the surface (the default), inverted the dark static plane.
Fluent2TooltipPosition
Where a tooltip sits from its control, Fluent's positioning: above (the default), below, or after at its end side for a rail; each flips when the window has no room.
Fluent2TreeSize
A tree's size, Fluent's size: small items 24 tall in caption1, medium 32 in body1 (the default). On a phone every item keeps 44.
Fluent2ValidationState
What a field's validation says, Fluent's validationState: error the red diamond and red words (and the control's red stroke), warning the orange warning, success the green check, none the words alone in the third ink.
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).

Mixins

Fluent2FieldOwner<T extends StatefulWidget>
The controller and the focus node a text control stands on: the caller's when given, else its own, kept in step with the value the page passes (a changed value from outside replaces the text; the caret goes to its end).

Extensions

DesignSpringDrive on AnimationController
Runs an AnimationController on a spring instead of a duration.
Fluent2PressStates on Set<WidgetState>
A press's states read by name, for a face that draws its own: states.hovered, states.pressed, and press for Fluent's colour step.
Fluent2TextStyle on TextStyle
Steps along Fluent's type ramp that stay on it.
Fluent2ThemeContext on BuildContext
context.fluent2Theme: the theme in scope.
PreviewPlatformDevice on PreviewPlatform
The platform's device, as data on the enum.

Constants

berryDark → const Fluent2Colors
The berry preset, dark. Overridden along the ramp so its words read 4.5:1: brandForeground1 110->120, brandForegroundLink 100->120, brandForegroundLinkHover 110->130, brandForegroundLinkPressed 90->110, brandForegroundLinkSelected 100->120, neutralForeground2BrandHover 100->120, neutralForeground2BrandPressed 90->110, neutralForeground2BrandSelected 100->120, neutralForeground3BrandHover 100->120, neutralForeground3BrandPressed 90->110, neutralForeground3BrandSelected 100->120, compoundBrandForeground1 100->120, compoundBrandForeground1Hover 110->130, compoundBrandForeground1Pressed 90->110.
berryLight → const Fluent2Colors
The berry preset, light.
berryRamp → const List<Color>
The berry preset's brand ramp, shades 10 to 160 (the theme designer as its form opens: getBrandTokensFromPalette(#c239b3, vibrancy 0, hue torsion 0); createLightTheme / createDarkThemeWithUpdatedMapping (brandForeground1 110, brandForeground2 120)).
cloverDark → const Fluent2Colors
The clover preset, dark. Overridden along the ramp so its words read 4.5:1: brandForegroundLink 100->110, brandForegroundLinkHover 110->120, brandForegroundLinkPressed 90->100, brandForegroundLinkSelected 100->110, neutralForeground2BrandHover 100->110, neutralForeground2BrandPressed 90->100, neutralForeground2BrandSelected 100->110, neutralForeground3BrandHover 100->110, neutralForeground3BrandPressed 90->100, neutralForeground3BrandSelected 100->110, compoundBrandForeground1 100->110, compoundBrandForeground1Hover 110->120, compoundBrandForeground1Pressed 90->100.
cloverLight → const Fluent2Colors
The clover preset, light.
cloverRamp → const List<Color>
The clover preset's brand ramp, shades 10 to 160 (the theme designer as its form opens: getBrandTokensFromPalette(#107c10, vibrancy 0, hue torsion 0); createLightTheme / createDarkThemeWithUpdatedMapping (brandForeground1 110, brandForeground2 120)).
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):
flintDark → const Fluent2Colors
The flint preset, dark. Overridden along the ramp so its words read 4.5:1: brandForeground1 110->120, brandForegroundLink 100->120, brandForegroundLinkHover 110->130, brandForegroundLinkPressed 90->110, brandForegroundLinkSelected 100->120, neutralForeground2BrandHover 100->120, neutralForeground2BrandPressed 90->110, neutralForeground2BrandSelected 100->120, neutralForeground3BrandHover 100->120, neutralForeground3BrandPressed 90->110, neutralForeground3BrandSelected 100->120, compoundBrandForeground1 100->120, compoundBrandForeground1Hover 110->130, compoundBrandForeground1Pressed 90->110.
flintLight → const Fluent2Colors
The flint preset, light.
flintRamp → const List<Color>
The flint preset's brand ramp, shades 10 to 160 (the theme designer as its form opens: getBrandTokensFromPalette(#394146, vibrancy 0, hue torsion 0); createLightTheme / createDarkThemeWithUpdatedMapping (brandForeground1 110, brandForeground2 120)).
fluent2CapHeight → const double
Selawik's cap height over its em, the same in every weight: 1434 of its 2048 units (its OS/2 sCapHeight and head unitsPerEm).
fluent2ControlMax → const double
The widest a select, a filling button or a stepper stands from fluent2RoomyFrom.
fluent2CupertinoWords → const LocalizationsDelegate<CupertinoLocalizations>
Cupertino's words in the app's language where Cupertino has it, else English.
fluent2Dark → const Fluent2Colors
The lapis preset, dark.
fluent2FontPackage → const String?
The package that bundles Fluent 2's faces, or null when the app does. Every Fluent 2 text style and glyph passes it (TextStyle.package, IconData.fontPackage).
fluent2FormMeasure → const double
The widest a form section runs: a reading measure for its labels and fields.
fluent2InventoryHeights → const Map<String, double>
The specimens that fill the height they are given; a gallery frames each in a box of this height.
fluent2Light → const Fluent2Colors
The lapis preset, light.
fluent2MaterialWords → const LocalizationsDelegate<MaterialLocalizations>
Material's words in the app's language where Material has it, else English.
fluent2PageTransitions → const Map<TargetPlatform, PageTransitionsBuilder>
The Fluent route transitions for each platform. Supply this map to your app's PageTransitionsTheme so Material page routes use Fluent motion. On iOS the transition also follows the leading-edge swipe-back gesture.
fluent2Ramp → const List<Color>
The lapis preset's brand ramp, shades 10 to 160 (brandWeb; webLightTheme / webDarkTheme).
fluent2RoomyFrom → const double
The window width from which controls keep their own width.
irisDark → const Fluent2Colors
The iris preset, dark.
irisLight → const Fluent2Colors
The iris preset, light.
irisRamp → const List<Color>
The iris preset's brand ramp, shades 10 to 160 (brandTeams; teamsLightTheme / teamsDarkTheme).
juniperDark → const Fluent2Colors
The juniper preset, dark. Overridden along the ramp so its words read 4.5:1: brandForegroundLink 100->110, brandForegroundLinkHover 110->120, brandForegroundLinkPressed 90->100, brandForegroundLinkSelected 100->110, neutralForeground2BrandHover 100->110, neutralForeground2BrandPressed 90->100, neutralForeground2BrandSelected 100->110, neutralForeground3BrandHover 100->110, neutralForeground3BrandPressed 90->100, neutralForeground3BrandSelected 100->110, compoundBrandForeground1 100->110, compoundBrandForeground1Hover 110->120, compoundBrandForeground1Pressed 90->100.
juniperLight → const Fluent2Colors
The juniper preset, light.
juniperRamp → const List<Color>
The juniper preset's brand ramp, shades 10 to 160 (the theme designer as its form opens: getBrandTokensFromPalette(#038387, vibrancy 0, hue torsion 0); createLightTheme / createDarkThemeWithUpdatedMapping (brandForeground1 110, brandForeground2 120)).
pumpkinDark → const Fluent2Colors
The pumpkin preset, dark. Overridden along the ramp so its words read 4.5:1: brandForeground1 110->120, brandForegroundLink 100->120, brandForegroundLinkHover 110->130, brandForegroundLinkPressed 90->110, brandForegroundLinkSelected 100->120, neutralForeground2BrandHover 100->120, neutralForeground2BrandPressed 90->110, neutralForeground2BrandSelected 100->120, neutralForeground3BrandHover 100->120, neutralForeground3BrandPressed 90->110, neutralForeground3BrandSelected 100->120, compoundBrandForeground1 100->120, compoundBrandForeground1Hover 110->130, compoundBrandForeground1Pressed 90->110.
pumpkinLight → const Fluent2Colors
The pumpkin preset, light.
pumpkinRamp → const List<Color>
The pumpkin preset's brand ramp, shades 10 to 160 (the theme designer as its form opens: getBrandTokensFromPalette(#ca5010, vibrancy 0, hue torsion 0); createLightTheme / createDarkThemeWithUpdatedMapping (brandForeground1 110, brandForeground2 120)).
sharedDark → const Fluent2SharedColors
Fluent's shared palette, dark.
sharedLight → const Fluent2SharedColors
Fluent's shared palette, light.

Properties

debugFluent2CapCentring ↔ bool
Whether fluent2CapCentred aligns labels by their capital letters.
getter/setter pair
fluent2Inventory → DesignInventory
Component names, availability, and live examples for the Fluent 2 gallery.
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.
fluent2AvatarHue(Fluent2ThemeData t, String name) → (Color, Color)
The colourful avatar's fill and ink for name: Fluent's thirty named hues (palette<Name>Background2 under palette<Name>Foreground2), chosen by Fluent's own hash of the name.
fluent2BarAllowance(double inset, {bool action = false}) → double
The least a tab bar's allowance can be: its bar over inset, and the act's rise when it floats over it. Plumbing of the shell.
fluent2BottomSheetPlace({required double maxHeight, required Widget child, bool fill = false}) → Widget
child, a bottom sheet's card, where it stands on ui_core's bottom sheet route: across a phone, centred over the window's foot from 600 at most Fluent's dialog width (Fluent2ChromeMetrics.dialogWidth), at most maxHeight tall; as tall as its content, or with fill as tall as the route lays it out (a page sheet's resting size).
fluent2BrandWell(Fluent2ThemeData t, [Fluent2Press press = Fluent2Press.rest]) → Color
The brand tint a part lays on the ground (a chosen day and the range round it, a brand tile, a date block, a brand-chosen table row, the empty state's disc, a banner), in its press step: Fluent's brandBackground2, or its hover shade (and on) where the tint would all but vanish on the brand-tinted page (#EBF3FC stood 1.02:1 on lapis's page by day, and by night on every preset's but iris's), so it stands at least 1.15:1 from the page, unless the brand's second ink would fall under 4.5:1 on the shade (a designer's teal by night: 4.23), where the words outrank the tint.
fluent2ButtonThemeOf(Fluent2ThemeData t, Fluent2ButtonAppearance appearance) → Fluent2Style
A button appearance's component theme on t.
fluent2CapCentred(Widget label) → Widget
label, a face's one-line words, drawn so the middle of its capitals is the middle of its box: whatever centres the box (a button's face, a tab, a menu row) then centres the capitals, not the line's ascent and descent. Wrap the words alone, never an icon. Plumbing of the components; pages never write it.
fluent2ChosenInk(Fluent2Colors c, Fluent2Press press) → Color
The ink of a chosen row's check in press: the brand's, out of use the disabled ink.
fluent2ChosenRow({required Widget row, required bool chosen, required Fluent2Colors colors, required Fluent2Press press}) → Widget
row with the selection indicator at its leading edge while chosen.
fluent2CornerOf(OutlinedBorder? shape, double height, double fallback) → double
The corner radius a styled shape stands for at height: a rounded rectangle's (its top start corner), a stadium's or a circle's half height, fallback for any other outline (and for none). What a part that draws Fluent's own strokes along a rounded rectangle (a field's accessible bottom and brand underline, a split button's halves) rounds to. A height of double.infinity asks for a pill the painter clamps to its own half height.
fluent2CssShadow({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.
fluent2DialogRise(Animation<double> presence, Widget child) → Widget
child as Fluent's dialog enters on presence: a fade from nothing and a scale from .95 to its size. Under Reduce Motion ui_core's dialog route holds presence at 1 and fades the page itself.
fluent2EasedInks(List<Color> inks, Widget builder(BuildContext context, List<Color> inks)) → Widget
A part's inks eased together: inks (a fill, a stroke, the words' and the glyph's colours, in the part's own order) given to builder as they stand this frame. Plumbing of the parts that resolve their inks inline.
fluent2Fade(Animation<double> presence, Widget child) → Widget
child faded by presence: a centred sheet's entrance.
fluent2FieldFace(Fluent2ThemeData t, Fluent2InputAppearance appearance, {required bool enabled, bool hover = false, bool active = false, bool invalid = false}) → Fluent2FieldFace
The face of a field in appearance at rest, under the pointer (hover), focused or pressed (active), disabled, or invalid, as Fluent's Input styles step them.
fluent2FieldWell(Fluent2ThemeData t) → Color
A filled-darker field's fill: by day the well a step lighter (6% ink, Fluent's neutralBackground4 step from white), so the placeholder in the third ink and the words hold 4.5:1 on it over every preset's tinted page, and it still stands clear of that page (1.13:1 or more, beyond Fluent's own #F5F5F5 on white); by night Fluent's neutralBackground3 step under a card (half ink), 1.1:1 or more from every ground.
fluent2Filled(IconData icon) → IconData
icon's filled design, or icon when it is not a regular Fluent glyph (a filled one already, another face's).
fluent2FillOn(IconData icon, Set<WidgetState> states) → IconData
icon as a control wears it in states: the filled design under the pointer and while pressed, as Fluent's bundled icons fill in; the regular one at rest and while disabled.
fluent2FirstFocus(List<bool> enabled, int chosen) → int
The option Fluent2ListKeys puts the focus on as a list opens: the chosen one (chosen, an index) when it is in use, else the first in use.
fluent2FitScale(BuildContext context, Iterable<String> lines, TextStyle style, double room, {double least = 0}) → double
The text scale at which each of lines in style stands whole on one line in room: the reader's own (at style's size, from context) where they fit, else the largest that fits, never under least. A navigation label is never cut: where its place cannot grow (the phone tab bar) it is drawn at this scale, as iOS keeps a tab bar's words at their size while the reader's text grows.
fluent2FlyoutFace(Fluent2ThemeData t, Fluent2FlyoutAppearance appearance) → (Color, Color, Color)
The fill and the ink of a flyout's appearance in t, and its edge (a hairline on the dark neutral surface, as the menu draws one). A neutral flyout is the menu's surface, so it takes its fill, foreground and edge (or side's colour) from the menu theme (Fluent2ThemeData.menuTheme) where that sets them; the brand and inverted appearances keep Fluent's own.
fluent2FontFamily(String family) → String
family under the name Flutter registers it by: Selawik when the app bundles it, packages/fluent2_design_ui/Selawik from the package. A test that loads the faces itself loads them under this name.
fluent2Initials(String name, {bool single = false}) → String
The initials Fluent's getInitials takes from name: the first letters of its first and last words, upper case; one letter when single; empty for a name of no letters.
fluent2KeepsOwnWidth(BuildContext context, {required Widget child, double content = 0}) → Widget
child (a select's or a combobox's trigger): under fluent2RoomyFrom at least 250 and its column's width, as a phone's form runs; from there as wide as its content (its widest words with its room, chevron and strokes), at least 250 (Fluent's Dropdown) and at most fluent2ControlMax, never wider than its cell, at the cell's start. Its list, anchored to child, matches it. Given room to choose, its box is that width alone, so a form field's merged node (and the box a screen reader outlines) is the trigger a tap reaches, not the column.
fluent2KeysLed() → bool
Whether a key, not a pointer, moved last (fluent2WatchInput), or a key is held as it is asked (a menu opened in the key's own handler): a browser's :focus-visible, for an open menu's first lit row.
fluent2LoadFonts() → Future<void>
Loads the faces Fluent 2 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 and draw the glyphs as empty boxes.
fluent2OnFirstLine(BuildContext context, TextStyle style, Widget control) → Widget
control beside words in style, dropped by half what their first line grows under the reader's text size, so it stays on that line's middle (0 at the default size, where the row's own padding centres it). Plumbing of the components; pages never write it.
fluent2OwnWidth(BuildContext context, Widget button) → Widget
Aligns button to the leading edge at its natural width. Under Fluent2ActsFill the button expands to fill its cell.
fluent2PaintArrow(Canvas canvas, Size size, {required Fluent2ArrowPlacement placement, required Color fill, required double height, double corner = Fluent2Radius.medium}) → void
Paints a bubble's arrow: a height triangle in fill on the edge placement says (inside the height of room left at the top and the foot of size), its centre at the placement's offset kept clear of the corners. Plumbing of the tooltip and the popover.
fluent2PlaceholderInk(Fluent2ThemeData t, Fluent2InputAppearance appearance) → Color
A field's placeholder ink: Fluent's neutralForeground4 on a field with a fill of its own, neutralForeground3 on the underline field, whose words stand on the page, and on the filled-darker field, whose grey is laid over the page (the fourth ink misses 4.5:1 on the light presets' ground and on that grey).
fluent2ProgressFill(Fluent2ThemeData t, Fluent2ProgressColor color) → Color
The fill of color: Fluent's (compoundBrandBackground, the red, dark orange and green Background3), or the tone's ink where Fluent's reads under 3:1 on the track (its status fills on the dark track).
fluent2ProgressTrack(Fluent2ThemeData t) → Color
The track a progress measure runs in: Fluent's neutralBackground6, by day laid over its ground (fluent2Rail) so the tinted page never swallows it.
fluent2Rail(Fluent2ThemeData t) → Color
The rail a measure runs in (a progress bar's track, a step bar's steps to come, a rating's unfilled stars): Fluent's neutralBackground6. By day it is laid over its ground as Fluent's step from white (#E6E6E6 on a card, 10% ink), so the brand-tinted ground never swallows it; by night the token, lighter than every ground.
fluent2Rim(Fluent2ThemeData theme, Fluent2StyleOf look, Color fallback, [double own = 1]) → BorderSide
The rim a styled part draws: the look's side when set, else its edge (or fallback) at the theme's regular stroke.
fluent2Roomy(BuildContext context) → bool
Whether the window is fluent2RoomyFrom or wider.
fluent2RowFill(Fluent2Colors c, Fluent2Press press, {required bool chosen, required Color resting}) → Color
The fill under a list row in press: the brand's subtle fill while it is chosen, else the neutral fill under the pointer and the press (resting at rest).
fluent2SearchFailed(BuildContext context, DesignSearchError failure) → Widget
The list after a search threw (failure): that it failed, in the secondary ink, and "Try again" as an option row, lit while the keys are on it (DesignSearchError.focused) and under the pointer. The focus stays in the field: the row is no tab stop.
fluent2SearchLoading(BuildContext context) → Widget
The list while a search is on its way: Fluent's extra-tiny spinner with "Loading" beside it, where the options stand.
fluent2States({bool enabled = true, bool hovered = false, bool focused = false, bool pressed = false, bool selected = false, bool error = false}) → Set<WidgetState>
The states a painted part is in, for its style.
fluent2Step(Fluent2ThemeData t, Color token) → Color
Fluent's grey token laid over whatever stands under it. By day Fluent draws its greys as steps from white (a disabled fill #F0F0F0, a disabled stroke or a divider #E0E0E0, a selected row #EBEBEB), steps the brand-tinted page all but swallows; laid as the same step of ink (#E0E0E0 is 12% black), it is Fluent's grey on a card and the same step darker on the page. By night, and for a colour that is not a grey, the token.
fluent2WatchInput() → void
Watches which hand moves last, a key or a pointer, for a menu that opens a frame after the key or click that opened it (a kit's split button): its control calls this as it builds. Idempotent; it watches again after the keyboard's handlers are cleared (as between tests).
fluent2WebBaselineDrop(TextStyle style) → double
How far below a browser's baseline Flutter sets words in style in their line box, in logical pixels (negative: above it). Both lead a line as CSS does, the room the face leaves in the line height split about its ascent and descent; Blink (the Chromium browsers, where Fluent's own fields render) first rounds the face's ascent and its descent each to a whole pixel and then floors the leaded ascent (SimpleFontData::PlatformInit, FontHeight::AddLeading), where Flutter keeps the fractions. Read off the face itself: Selawik's ascent and descent are 2027 and 431 of 2048, so caption1 (12 on 16) stands 12.68 down its line box in Flutter and 12 in Blink, body1 (14 on 20) 15.46 and 15, body2 (16 on 22) 17.23 and 17, subtitle1 (20 on 28) 21.79 and 22. Zero for a style with no line height of its own (its words fill the line box in both).
fluent2Well(Fluent2ThemeData t, [Fluent2Press press = Fluent2Press.rest]) → Color
The fill of a neutral well: a segmented control's track, a filled tag or a filled circular tab at rest, a neutral tile, in its press step (out of use, fluent2WellDisabled).
fluent2WellDisabled(Fluent2ThemeData t) → Color
A well out of use, and any disabled face (a button's, a card's, a tab's): by day Fluent's neutralBackgroundDisabled step from white (6% ink), by night Fluent's disabled fill, its neutralBackground3 step under a card (half ink), where its own #141414 stood 1.08:1 on the warm night pages; the part's disabled stroke and ink say the rest.
fluent2WellWash(Fluent2ThemeData t, Fluent2Press press) → Color
What a part laid in a well paints over it in its press step (an unchosen segment on the segmented control's track): none at rest, then more ink, so the well steps darker under the pointer and darker again pressed. By day it then stands Fluent's neutralBackground1Pressed and neutralBackground3Pressed steps from white (12% and 16%); by night the well steps darker too, toward black (Fluent lifts its dark hover back to the card's own grey, where the well would vanish).
fluent2WordsWidth(BuildContext context, Iterable<String> lines, TextStyle style) → double
The widest of lines in style, at the text scale of context.
fluent2WrapScale(BuildContext context, String words, TextStyle style, double room, {int lines = 2, double least = 0.75}) → double
The text scale at which words in style stand whole in room on at most lines lines, each word whole on its line (never "Calenda" over "r"): fluent2FitScale's one-line scale (never under 1) where the words then break into lines or fewer, else the largest scale at which they do, never under least (a page's long name on a phone: iOS shrinks a title whole before it would cut it).
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.
showFluent2ActionSheet<T>(BuildContext context, {required List<Fluent2ActionSheetAction<T>> actions, String? title, String? message, String? cancelLabel}) → Future<T?>
Raises a Fluent2ActionSheet of actions off the bottom edge; answers the chosen value, or null on the way out, Escape or the overlay.
showFluent2BottomSheet<T>(BuildContext context, {required WidgetBuilder builder}) → Future<T?>
Raises what builder makes (a Fluent2BottomSheet, usually) off the bottom edge over the overlay, at most 600 wide; completes with what it pops with, null when it is dismissed. It is ui_core's bottom sheet (DesignBottomSheetRoute): it rises on a spring that settles in Fluent's durationGentle, rides above the keyboard, follows a drag (a Fluent2BottomSheet's words, scrolled to their top, hand the drag on) and closes when let go low or flung down; focus goes back to what raised it.
showFluent2DatePicker(BuildContext context, {DateTime? value, DateTime? firstDate, DateTime? lastDate, DateTime? today, String? title}) → Future<DateTime?>
Raises a Fluent2Calendar in Fluent's dialog; answers the day pressed, or null.
showFluent2DateRangePicker(BuildContext context, {required DateTime firstDate, required DateTime lastDate, DesignDateRange? initial, String? title}) → Future<DesignDateRange?>
Raises a Fluent2DateRangePicker in Fluent's dialog; answers the range on OK, or null.
showFluent2Dialog<T>(BuildContext context, {required WidgetBuilder builder}) → Future<T?>
Raises the Fluent2Dialog builder makes over the whole app; completes with what it pops with, null when the overlay is tapped or Escape pressed.
showFluent2Menu<T>(BuildContext context, {required List<Fluent2MenuItem<T>> items, BuildContext? anchor, String? title, String? label}) → Future<T?>
Opens a Fluent2Menu of items under the control context belongs to (a Builder round it) over the whole app; anchor widens the box it drops from. Completes with the value chosen, or null when it is dismissed.
showFluent2Sheet<T>(BuildContext context, {required Widget builder(BuildContext context, VoidCallback close), DesignSheetEdge edge = DesignSheetEdge.end, double width = Fluent2ChromeMetrics.drawerWidth}) → Future<T?>
Raises the Fluent2Sheet builder makes at the window's edge, width wide (never closer than 56 to the far side), over the overlay, sliding in on ui_core's spring (settling in Fluent's durationGentle; a drag let go settles at its speed). The builder gets the sheet's close. Escape, a press on the overlay or a drag to its edge closes it and the focus goes back where it was.
showFluent2TimePicker(BuildContext context, {Fluent2Time? value, String? title}) → Future<Fluent2Time?>
Asks for a time with an hour wheel and a minute wheel in Fluent's dialog; answers it on OK, or null.
showFluent2Toast(BuildContext context, String message, {String? title, Fluent2ToastIntent tone = Fluent2ToastIntent.success, String? actionLabel, VoidCallback? onAction, Duration? duration}) → Fluent2Raised
Raises a short notice over the page, Fluent 2's Toast. Under a Fluent2Toaster it queues there, after any already showing; with no toaster it stands alone: a new one replaces the one still up, gutter to gutter 16 over the tab bar on a phone, 292 wide at the window's bottom end on the desktop. It stays for duration (three seconds, six with its one inline action) and a tap on the action takes it down.

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.
Fluent2FieldFace = ({Color bottom, Color fill, Color side})
One field face: its fill, its side strokes and its bottom stroke.
Fluent2Style = DesignStyle
How one part 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).
Fluent2StyleOf = DesignStyleOf
A styled part's layers for its states: its own style:, then its component theme. Each getter is the first layer's value for the states, or null, so the part goes on to its own Fluent default. It is ui_core's DesignStyleOf.

Exceptions / Errors

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