material3

type ButtonPainter ¶

type ButtonPainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

ButtonPainter renders buttons using Material 3 design tokens. It maps button variants (Filled, Outlined, TextOnly, Tonal) to the M3 color scheme and applies appropriate interaction feedback.

If Theme is nil, ButtonPainter falls back to the default M3 purple palette.

func (p ButtonPainter) PaintButton(canvas widget.Canvas, state button.PaintState)

type CheckboxPainter ¶

type CheckboxPainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

CheckboxPainter renders checkboxes using Material 3 design tokens. It maps checkbox states (checked, unchecked, indeterminate) to the M3 color scheme and applies appropriate interaction feedback.

If Theme is nil, CheckboxPainter falls back to the default M3 purple palette.

func (p CheckboxPainter) PaintCheckbox(canvas widget.Canvas, state checkbox.PaintState)

type CollapsiblePainter ¶

type CollapsiblePainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

CollapsiblePainter renders collapsible section headers using Material 3 design tokens. It maps header states (expanded, hovered, pressed, focused) to the M3 color scheme with surface colors for the header and on-surface colors for text.

If Theme is nil, CollapsiblePainter falls back to the default M3 purple palette.

func (p CollapsiblePainter) PaintHeader(canvas widget.Canvas, s collapsible.HeaderState)

type ColorScheme ¶

type ColorScheme struct {
	// Primary group: key brand color and its variants.
	Primary            widget.Color
	OnPrimary          widget.Color
	PrimaryContainer   widget.Color
	OnPrimaryContainer widget.Color

	// Secondary group: accent color for less prominent elements.
	Secondary            widget.Color
	OnSecondary          widget.Color
	SecondaryContainer   widget.Color
	OnSecondaryContainer widget.Color

	// Tertiary group: complementary color for contrast and balance.
	Tertiary            widget.Color
	OnTertiary          widget.Color
	TertiaryContainer   widget.Color
	OnTertiaryContainer widget.Color

	// Error group: error states and destructive actions.
	Error            widget.Color
	OnError          widget.Color
	ErrorContainer   widget.Color
	OnErrorContainer widget.Color

	// Surface group: neutral backgrounds at various elevation levels.
	Surface                 widget.Color
	OnSurface               widget.Color
	SurfaceVariant          widget.Color
	OnSurfaceVariant        widget.Color
	SurfaceContainerLowest  widget.Color
	SurfaceContainerLow     widget.Color
	SurfaceContainer        widget.Color
	SurfaceContainerHigh    widget.Color
	SurfaceContainerHighest widget.Color

	// Background colors.
	Background   widget.Color
	OnBackground widget.Color

	// Outline colors for borders and dividers.
	Outline        widget.Color
	OutlineVariant widget.Color

	// Inverse colors for elements that appear on inverse surfaces.
	InverseSurface   widget.Color
	InverseOnSurface widget.Color
	InversePrimary   widget.Color
}

ColorScheme holds all Material 3 color roles.

Material 3 defines a comprehensive set of color roles organized in primary/secondary/tertiary/error groups, each with container variants and corresponding "on" colors for content placed on top. Surface colors provide a neutral backdrop with multiple elevation levels.

func Dark(seed widget.Color) ColorScheme

func Light(seed widget.Color) ColorScheme

type DataTablePainter ¶

type DataTablePainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

DataTablePainter renders data tables using Material 3 design tokens. It maps M3 color roles to table elements: surface-container for header, on-surface for text, surface-variant for zebra striping, and primary for selection.

If Theme is nil, DataTablePainter falls back to the default M3 purple palette.

func (p DataTablePainter) PaintCell(canvas widget.Canvas, cps datatable.CellPaintState)

func (p DataTablePainter) PaintEmptyState(canvas widget.Canvas, bounds geometry.Rect)

func (p DataTablePainter) PaintHeader(canvas widget.Canvas, bounds geometry.Rect, hps datatable.HeaderPaintState)

func (p DataTablePainter) PaintHeaderCell(canvas widget.Canvas, bounds geometry.Rect, hcs datatable.HeaderCellPaintState)

func (p DataTablePainter) PaintRow(canvas widget.Canvas, rps datatable.RowPaintState)

type DialogPainter ¶

type DialogPainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

DialogPainter renders dialogs using Material 3 design tokens. It applies the M3 dialog specification: surface tint, headline small typography, and text action buttons.

If Theme is nil, DialogPainter falls back to the default M3 purple palette.

func (p DialogPainter) PaintDialog(canvas widget.Canvas, ps dialog.PaintState)

type DockingPainter ¶

type DockingPainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

DockingPainter renders docking zones and tab bars using Material 3 design tokens. It maps M3 color roles to docking elements: surface for zones, outline for borders, and surface-variant for the tab bar background.

If Theme is nil, DockingPainter falls back to the default M3 purple palette.

func (p DockingPainter) PaintZoneBorder(canvas widget.Canvas, borderRect geometry.Rect, _ docking.Zone)

func (p DockingPainter) PaintZoneTabs(canvas widget.Canvas, ps docking.ZoneTabsPaintState)

type DropdownPainter ¶

type DropdownPainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

DropdownPainter renders dropdowns using Material 3 design tokens. It implements the outlined dropdown variant with theme-derived colors.

If Theme is nil, DropdownPainter falls back to the default M3 purple palette.

func (p DropdownPainter) PaintMenu(canvas widget.Canvas, st *dropdown.MenuPaintState)

func (p DropdownPainter) PaintTrigger(canvas widget.Canvas, st *dropdown.TriggerPaintState)

type GridViewPainter ¶

type GridViewPainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

GridViewPainter renders grid view elements using Material 3 design tokens. It maps cell states (selected, hovered, focused) to the M3 color scheme with primary for selection, secondary-container for hover, and surface for cells.

If Theme is nil, GridViewPainter falls back to the default M3 purple palette.

func (p GridViewPainter) PaintCellBackground(canvas widget.Canvas, cps gridview.CellPaintState)

func (p GridViewPainter) PaintEmptyState(canvas widget.Canvas, bounds geometry.Rect)

func (p GridViewPainter) PaintSelection(canvas widget.Canvas, cps gridview.CellPaintState)

type LineChartPainter ¶

type LineChartPainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

LineChartPainter renders line charts using Material 3 design tokens. It maps M3 color roles to chart elements: primary for data lines, surface for background, and on-surface-variant for grid/labels.

If Theme is nil, LineChartPainter falls back to the default M3 purple palette.

func (p LineChartPainter) PaintChart(canvas widget.Canvas, bounds geometry.Rect, state linechart.PaintState)

type ListViewPainter ¶

type ListViewPainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

ListViewPainter renders list view elements using Material 3 design tokens. It maps list states (divider, empty, hover, selection) to the M3 color scheme and applies appropriate visual feedback.

If Theme is nil, ListViewPainter falls back to the default M3 purple palette.

func (p ListViewPainter) PaintDivider(canvas widget.Canvas, ds listview.DividerState)

func (p ListViewPainter) PaintEmptyState(canvas widget.Canvas, bounds geometry.Rect)

func (p ListViewPainter) PaintItemBackground(canvas widget.Canvas, ips listview.ItemPaintState)

func (p ListViewPainter) PaintSelection(canvas widget.Canvas, ips listview.ItemPaintState)

type MenuPainter ¶

type MenuPainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

MenuPainter renders menus and menu bars using Material 3 design tokens. It maps M3 color roles to menu elements: surface for containers, elevation shadow for depth, on-surface for text, and primary for highlight states.

If Theme is nil, MenuPainter falls back to the default M3 purple palette.

func (p MenuPainter) PaintMenu(canvas widget.Canvas, st *menu.MenuPaintState)

func (p MenuPainter) PaintMenuBar(canvas widget.Canvas, st *menu.MenuBarPaintState)

type PopoverPainter ¶

type PopoverPainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

PopoverPainter renders popovers and tooltips using Material 3 design tokens. It applies M3 surface container elevation, outline-variant borders, and inverse-surface tooltip styling.

If Theme is nil, PopoverPainter falls back to the default M3 purple palette.

func (p PopoverPainter) PaintPopover(canvas widget.Canvas, st *popover.PopoverPaintState)

func (p PopoverPainter) PaintTooltip(canvas widget.Canvas, st *popover.TooltipPaintState)

type ProgressBarPainter ¶

type ProgressBarPainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

ProgressBarPainter renders progress bars using Material 3 design tokens. It maps progress bar states (normal, disabled) to the M3 color scheme with primary color for the filled bar and surface variant for the track.

If Theme is nil, ProgressBarPainter falls back to the default M3 purple palette.

func (p ProgressBarPainter) PaintProgressBar(canvas widget.Canvas, ps progressbar.PaintState)

type ProgressPainter ¶

type ProgressPainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

ProgressPainter renders circular progress indicators using Material 3 design tokens. It maps progress states (determinate, indeterminate, disabled) to the M3 color scheme with primary color for the arc and surface variant for the track.

If Theme is nil, ProgressPainter falls back to the default M3 purple palette.

func (p ProgressPainter) PaintProgress(canvas widget.Canvas, ps progress.PaintState)

type RadioPainter ¶

type RadioPainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

RadioPainter renders radio items using Material 3 design tokens. It maps radio states (selected, unselected) to the M3 color scheme and applies appropriate interaction feedback.

If Theme is nil, RadioPainter falls back to the default M3 purple palette.

func (p RadioPainter) PaintRadio(canvas widget.Canvas, state radio.PaintState)

type ScrollbarPainter ¶

type ScrollbarPainter struct {
	Theme *Theme // nil uses default M3 fallback
}

ScrollbarPainter renders scrollbars using Material 3 design tokens. It maps scrollbar states (normal, hover, dragging) to the M3 color scheme.

If Theme is nil, ScrollbarPainter falls back to the default M3 scrollbar palette.

func (p ScrollbarPainter) PaintScrollbar(canvas widget.Canvas, ps scrollview.PaintState)

type ShapeScale ¶

type ShapeScale struct {
	// None is no rounding (sharp corners): 0dp.
	None float32

	// ExtraSmall is subtle rounding: 4dp.
	// Used for small components like chips and text fields.
	ExtraSmall float32

	// Small is moderate rounding: 8dp.
	// Used for buttons and small cards.
	Small float32

	// Medium is standard rounding: 12dp.
	// Used for cards, dialogs, and menus.
	Medium float32

	// Large is generous rounding: 16dp.
	// Used for large cards and sheets.
	Large float32

	// ExtraLarge is very generous rounding: 28dp.
	// Used for floating action buttons and large containers.
	ExtraLarge float32

	// Full is fully rounded: 9999dp.
	// Creates circular or pill shapes regardless of element size.
	Full float32
}

ShapeScale holds Material 3 corner radius values.

Material 3 defines a shape scale that ranges from no rounding (None) to fully circular (Full). These values are used for consistent corner rounding across UI components.

Reference: https://m3.material.io/styles/shape/overview

func DefaultShapeScale() ShapeScale

None:       0dp
ExtraSmall: 4dp
Small:      8dp
Medium:     12dp
Large:      16dp
ExtraLarge: 28dp
Full:       9999dp (fully rounded)

type SliderPainter ¶

type SliderPainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

SliderPainter renders sliders using Material 3 design tokens. It maps slider states (normal, hover, dragging, disabled) to the M3 color scheme and applies appropriate interaction feedback.

If Theme is nil, SliderPainter falls back to the default M3 purple palette.

func (p SliderPainter) PaintSlider(canvas widget.Canvas, ps slider.PaintState)

type SplitViewPainter ¶

type SplitViewPainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

SplitViewPainter renders split view dividers using Material 3 design tokens. It maps divider states (normal, hovered, dragging) to the M3 color scheme with outline-variant for the divider and primary color for the handle.

If Theme is nil, SplitViewPainter falls back to the default M3 purple palette.

func (p SplitViewPainter) PaintDivider(canvas widget.Canvas, ps splitview.PaintState)

type TabViewPainter ¶

type TabViewPainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

TabViewPainter renders tab bars using Material 3 design tokens. It maps tab states to the M3 color scheme and applies appropriate interaction feedback including an animated indicator.

If Theme is nil, TabViewPainter falls back to the default M3 purple palette.

func (p TabViewPainter) PaintTabBar(canvas widget.Canvas, ps tabview.PaintState)

type TextFieldPainter ¶

type TextFieldPainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

TextFieldPainter renders text fields using Material 3 design tokens. It implements the outlined text field variant with theme-derived colors.

If Theme is nil, TextFieldPainter falls back to the default M3 purple palette.

func (p TextFieldPainter) PaintTextField(canvas widget.Canvas, st textfield.PaintState)

type TextStyle ¶

type TextStyle struct {
	// FontSize is the font size in logical pixels (sp).
	FontSize float32

	// LineHeight is the line height in logical pixels.
	LineHeight float32

	// Bold indicates whether the text should be rendered in bold weight.
	// In Material 3, "bold" typically maps to Medium (500) weight.
	Bold bool
}

TextStyle defines font properties for a typography role.

This is a simplified text style containing the essential properties needed for M3 typography: font size, line height, and weight indicator.

type Theme ¶

type Theme struct {
	// Colors holds the Material 3 color scheme derived from the seed color.
	Colors ColorScheme

	// Typography holds the Material 3 type scale.
	Typography TypeScale

	// Shape holds the Material 3 corner radius scale.
	Shape ShapeScale
	// contains filtered or unexported fields
}

Theme provides Material 3 (Material You) design tokens.

A Theme contains the complete set of design tokens needed to style a Material 3 application: colors, typography, and shape. It is generated from a single seed color, which is used to derive a full harmonious color scheme.

Create a theme with New:

theme := material3.New(widget.Hex(0x6750A4))
primary := theme.Colors.Primary
fontSize := theme.Typography.BodyMedium.FontSize
radius := theme.Shape.Medium

func New(seedColor widget.Color) *Theme

func NewDark(seedColor widget.Color) *Theme

func (t *Theme) AsTheme() *theme.Theme

m3 := material3.New(widget.Hex(0x6750A4))
uiApp := app.New(app.WithTheme(m3.AsTheme()))

func (t *Theme) IsDark() bool

func (t *Theme) OnSurface() widget.Color

type ToolbarPainter ¶

type ToolbarPainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

ToolbarPainter renders toolbars using Material 3 design tokens. It maps M3 color roles to toolbar elements: surface for background, on-surface for icons, and primary-container for hover highlights.

If Theme is nil, ToolbarPainter falls back to the default M3 purple palette.

func (p ToolbarPainter) PaintButtonItem(canvas widget.Canvas, state toolbar.PaintButtonState)

func (p ToolbarPainter) PaintSeparator(canvas widget.Canvas, bounds geometry.Rect)

func (p ToolbarPainter) PaintToolbar(canvas widget.Canvas, state toolbar.PaintToolbarState)

type TreeViewPainter ¶

type TreeViewPainter struct {
	Theme *Theme // nil uses default M3 purple fallback
}

TreeViewPainter renders tree views using Material 3 design tokens. It maps M3 color roles to tree elements: primary for selection, surface for background, outline for connector lines, and on-surface for text.

If Theme is nil, TreeViewPainter falls back to the default M3 purple palette.

func (p TreeViewPainter) PaintConnectorLines(canvas widget.Canvas, s treeview.ConnectorState)

func (p TreeViewPainter) PaintEmptyState(canvas widget.Canvas, bounds geometry.Rect)

func (p TreeViewPainter) PaintExpandIcon(canvas widget.Canvas, s treeview.ExpandIconState)

func (p TreeViewPainter) PaintLabel(canvas widget.Canvas, s treeview.LabelState)

func (p TreeViewPainter) PaintRowBackground(canvas widget.Canvas, s treeview.RowPaintState)

func (p TreeViewPainter) PaintSelection(canvas widget.Canvas, s treeview.RowPaintState)

type TypeScale ¶

type TypeScale struct {
	DisplayLarge  TextStyle
	DisplayMedium TextStyle
	DisplaySmall  TextStyle

	HeadlineLarge  TextStyle
	HeadlineMedium TextStyle
	HeadlineSmall  TextStyle

	TitleLarge  TextStyle
	TitleMedium TextStyle
	TitleSmall  TextStyle

	BodyLarge  TextStyle
	BodyMedium TextStyle
	BodySmall  TextStyle

	LabelLarge  TextStyle
	LabelMedium TextStyle
	LabelSmall  TextStyle
}

TypeScale holds the 15 Material 3 typography roles.

Material 3 organizes typography into five categories (Display, Headline, Title, Body, Label), each with three sizes (Large, Medium, Small). This provides a complete type scale for building consistent UIs.

func DefaultTypeScale() TypeScale