devtools

type ButtonPainter ¶

type ButtonPainter struct {
	Theme *Theme // nil uses default DevTools dark fallback
}

ButtonPainter renders buttons using DevTools design tokens. DevTools buttons are compact (28px height) with 4px corner radius, matching JetBrains IDE toolbar and dialog button styling.

If Theme is nil, ButtonPainter falls back to the default DevTools dark palette.

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

type CheckboxPainter ¶

type CheckboxPainter struct {
	Theme *Theme // nil uses default DevTools dark fallback
}

CheckboxPainter renders checkboxes using DevTools design tokens. DevTools checkboxes are 16px with 2px corner radius, matching JetBrains IDE settings panel checkbox styling.

If Theme is nil, CheckboxPainter falls back to the default DevTools dark palette.

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

type CollapsiblePainter ¶

type CollapsiblePainter struct {
	Theme *Theme // nil uses default DevTools dark fallback
}

CollapsiblePainter renders collapsible section headers using DevTools design tokens. DevTools collapsibles use minimal styling: Surface background, a subtle chevron (Gray7 -> Gray12 on hover), 1px bottom border separator, and compact 8px padding, matching JetBrains IDE tool window section headers.

If Theme is nil, CollapsiblePainter falls back to the default DevTools dark palette.

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

type ColorScheme ¶

type ColorScheme struct {
	// Surface group: neutral backgrounds from darkest to lightest.
	Background         widget.Color // deepest background (editor area)
	Surface            widget.Color // panel/surface background
	SurfaceElevated    widget.Color // elevated surface, separator
	OnSurface          widget.Color // primary text/foreground
	OnSurfaceSecondary widget.Color // secondary text (dimmer)
	OnSurfaceDisabled  widget.Color // disabled/muted text

	// Accent/Primary: brand accent color and interactive states.
	Primary      widget.Color // primary accent (buttons, links, focus ring)
	PrimaryHover widget.Color // hover state
	PrimaryPress widget.Color // pressed state
	OnPrimary    widget.Color // text/icon on primary-colored surfaces

	// Selection: text/item selection background.
	Selection widget.Color

	// Borders: varying strengths for visual hierarchy.
	Border       widget.Color // default border (subtle)
	BorderStrong widget.Color // stronger border (emphasis)
	BorderFocus  widget.Color // focused element border (accent)

	// Input/Control: fills for interactive controls.
	InputBackground widget.Color // text input background
	ControlFill     widget.Color // default control fill
	ControlHover    widget.Color // control hover fill

	// Header/Toolbar: always dark in both light and dark modes.
	HeaderBackground widget.Color // dark toolbar background
	HeaderForeground widget.Color // toolbar text/icons

	// Semantic: status-indicating colors.
	Error           widget.Color // error border/icon
	ErrorBackground widget.Color // error surface tint
	Warning         widget.Color // warning icon
	Success         widget.Color // success icon
	Info            widget.Color // info (same as primary)

	// Overlay: backdrops and shadows.
	Backdrop widget.Color // modal backdrop
	Shadow   widget.Color // drop shadow

	// Scrollbar: thumb and track colors.
	ScrollbarThumb      widget.Color // scrollbar thumb at rest
	ScrollbarThumbHover widget.Color // scrollbar thumb hovered
	ScrollbarTrack      widget.Color // scrollbar track (typically transparent)
}

ColorScheme holds all DevTools design system color roles.

The scheme is organized around a neutral gray scale with a blue accent, following the JetBrains Int UI color system. Dark mode uses deep grays (#1E1F22 through #393B40) for surfaces with light text (#DFE1E5), while light mode inverts to white/light-gray surfaces with dark text.

Both modes share the same blue accent (#3574F0) and a dark header toolbar, matching JetBrains IDEs where the main toolbar is always dark.

func DarkScheme() ColorScheme

func LightScheme() ColorScheme

type DataTablePainter ¶

type DataTablePainter struct {
	Theme *Theme // nil uses default DevTools dark fallback
}

DataTablePainter renders data tables using DevTools design tokens. DevTools tables use striped rows (alternating Background/Surface), compact 24px row height, and a fixed header with SurfaceElevated background, matching JetBrains IDE table styling.

If Theme is nil, DataTablePainter falls back to the default DevTools dark 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 DevTools dark fallback
}

DialogPainter renders dialogs using DevTools design tokens. DevTools dialogs use Surface (#2B2D30) background with 8px radius, subtle shadow, 1px border, and 16px bold title — matching JetBrains IDE modal dialog styling.

If Theme is nil, DialogPainter falls back to the default DevTools dark palette.

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

type DockingPainter ¶

type DockingPainter struct {
	Theme *Theme // nil uses default DevTools dark fallback
}

DockingPainter renders docking zones and tab bars using DevTools design tokens. DevTools docking uses a tool window style: compact tab strip at bottom/side, 24px tabs with 12px font, Surface background for panels, SurfaceElevated for tab bars, and a Blue6 underline (2px) for the selected tab, matching JetBrains IDE tool window tab styling.

If Theme is nil, DockingPainter falls back to the default DevTools dark 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 DevTools dark fallback
}

DropdownPainter renders dropdowns using DevTools design tokens. DevTools dropdowns use the same InputBackground as text fields, with SurfaceElevated popup menus and compact spacing.

If Theme is nil, DropdownPainter falls back to the default DevTools dark palette.

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

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

type LineChartPainter ¶

type LineChartPainter struct {
	Theme *Theme // nil uses default DevTools dark fallback
}

LineChartPainter renders line charts using DevTools design tokens. DevTools charts use a dark grid (Gray3 lines on Background), muted axes (Gray7 text, Gray3 axis lines), and 1.5px line width with Blue6 as the default series color, matching JetBrains IDE performance monitoring charts.

If Theme is nil, LineChartPainter falls back to the default DevTools dark palette.

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

type ListViewPainter ¶

type ListViewPainter struct {
	Theme *Theme // nil uses default DevTools dark fallback
}

ListViewPainter renders list view elements using DevTools design tokens. DevTools lists use wide full-row selection (Blue2 background), 24px row height, ControlHover highlight, and optional alternating rows (Background/Surface), matching JetBrains IDE file list styling.

If Theme is nil, ListViewPainter falls back to the default DevTools dark 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 DevTools dark fallback
}

MenuPainter renders menus and menu bars using DevTools design tokens. DevTools menus use a dark popup (SurfaceElevated #393B40) with 8px radius, 1px border, 28px item height, right-aligned keyboard shortcut text in Gray9, and a ControlHover (#43454A) highlight, matching JetBrains IDE menu styling.

If Theme is nil, MenuPainter falls back to the default DevTools dark palette.

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

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

type Option ¶

type Option func(*themeConfig)

Option configures a DevTools theme.

func WithAccentColor(accent widget.Color) Option

type Painters ¶

type Painters struct {
	Button      ButtonPainter
	Checkbox    CheckboxPainter
	Radio       RadioPainter
	TextField   TextFieldPainter
	Dropdown    DropdownPainter
	Slider      SliderPainter
	Dialog      DialogPainter
	Scrollbar   ScrollbarPainter
	TabView     TabViewPainter
	TreeView    TreeViewPainter
	DataTable   DataTablePainter
	Toolbar     ToolbarPainter
	Menu        MenuPainter
	Collapsible CollapsiblePainter
	Progress    ProgressPainter
	SplitView   SplitViewPainter
	Docking     DockingPainter
	Popover     PopoverPainter
	LineChart   LineChartPainter
	ListView    ListViewPainter
	TitleBar    TitleBarPainter
	Stripe      StripePainter
}

Painters provides all DevTools painters for convenient widget construction.

Instead of creating each painter individually:

btn := button.New(button.PainterOpt(devtools.ButtonPainter{Theme: dt}))
cb  := checkbox.New(checkbox.PainterOpt(devtools.CheckboxPainter{Theme: dt}))

Use NewPainters to create all painters at once:

p := devtools.NewPainters(dt)
btn := button.New(button.PainterOpt(p.Button))
cb  := checkbox.New(checkbox.PainterOpt(p.Checkbox))

func NewPainters(t *Theme) Painters

type PopoverPainter ¶

type PopoverPainter struct {
	Theme *Theme // nil uses default DevTools dark fallback
}

PopoverPainter renders popovers and tooltips using DevTools design tokens. DevTools popovers use SurfaceElevated (#393B40) background with 4px border radius, 1px Gray5 border, 8px padding, and a subtle shadow, matching JetBrains IDE popup and tooltip styling.

If Theme is nil, PopoverPainter falls back to the default DevTools dark palette.

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

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

type ProgressPainter ¶

type ProgressPainter struct {
	Theme *Theme // nil uses default DevTools dark fallback
}

ProgressPainter renders progress indicators using DevTools design tokens. DevTools progress uses a 2px stroke: Gray3 track with Blue6 fill for both linear and circular indicators. The indeterminate mode uses an animated Blue6 arc, matching JetBrains IDE progress bar styling.

If Theme is nil, ProgressPainter falls back to the default DevTools dark palette.

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

type RadioPainter ¶

type RadioPainter struct {
	Theme *Theme // nil uses default DevTools dark fallback
}

RadioPainter renders radio items using DevTools design tokens. DevTools radio buttons are 16px diameter circles with a 6px inner dot when selected, matching JetBrains IDE settings panel radio styling.

If Theme is nil, RadioPainter falls back to the default DevTools dark palette.

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

type ScrollbarPainter ¶

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

ScrollbarPainter renders scrollbars using DevTools design tokens. DevTools scrollbars are thin (6px width, 4px idle expanding to 6px on hover) with transparent track — matching JetBrains IDE editor scrollbar styling.

If Theme is nil, ScrollbarPainter falls back to the default DevTools dark palette.

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

type SliderPainter ¶

type SliderPainter struct {
	Theme *Theme // nil uses default DevTools dark fallback
}

SliderPainter renders sliders using DevTools design tokens. DevTools sliders have a 2px track and 12px thumb circle with Blue6 accent, matching JetBrains IDE preference panel slider styling.

If Theme is nil, SliderPainter falls back to the default DevTools dark palette.

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

type SplitViewPainter ¶

type SplitViewPainter struct {
	Theme *Theme // nil uses default DevTools dark fallback
}

SplitViewPainter renders split view dividers using DevTools design tokens. DevTools split views use a minimal 1px divider line (Gray3) with a 3px invisible drag zone (cursor change on hover), no shadow and no handle decoration. On hover the divider brightens to Gray5, matching JetBrains IDE panel divider styling.

If Theme is nil, SplitViewPainter falls back to the default DevTools dark palette.

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

type StripePainter ¶

type StripePainter struct {
	Theme *Theme // nil uses default DevTools dark fallback
}

StripePainter renders stripe toolbars using DevTools design tokens. DevTools stripes use a Surface background with a 1px border, and SquareStripeButton styling: 40x40 buttons, 20px icons, 12px corner radius on hover, matching JetBrains IDE tool window strip styling.

If Theme is nil, StripePainter falls back to the default DevTools dark palette.

func (p StripePainter) PaintBackground(canvas widget.Canvas, bounds geometry.Rect)

func (p StripePainter) PaintButton(canvas widget.Canvas, state stripe.ButtonPaintState)

type TabViewPainter ¶

type TabViewPainter struct {
	Theme *Theme // nil uses default DevTools dark fallback
}

TabViewPainter renders tab bars using DevTools design tokens. DevTools tabs use a flat underline indicator (2px Blue6) instead of pills, matching JetBrains IDE editor tab styling. Unselected tabs show Gray9 text, selected tabs show Gray12 text with a bold bottom accent line.

If Theme is nil, TabViewPainter falls back to the default DevTools dark palette.

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

type TextFieldPainter ¶

type TextFieldPainter struct {
	Theme *Theme // nil uses default DevTools dark fallback
}

TextFieldPainter renders text fields using DevTools design tokens. DevTools text fields use a deep InputBackground (#1E1F22) with 4px radius, subtle Gray5 border, and Blue6 border on focus — matching JetBrains IDE input field styling.

If Theme is nil, TextFieldPainter falls back to the default DevTools dark palette.

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

type Theme ¶

type Theme struct {
	// Colors holds the DevTools color scheme.
	Colors ColorScheme
	// contains filtered or unexported fields
}

Theme provides JetBrains-inspired DevTools design tokens.

A Theme contains the complete set of design tokens needed to style a DevTools application: colors (based on JetBrains Int UI gray scale with a customizable accent), and references to the shared theme.Theme for typography, spacing, shadows, and radii.

DevTools is dark-first: NewDarkTheme produces the primary theme, while NewTheme produces a light variant. Both themes feature a dark header toolbar, matching JetBrains IDE behavior.

Create a theme:

dark := devtools.NewDarkTheme()                                         // default dark
dark := devtools.NewDarkTheme(devtools.WithAccentColor(widget.Hex(0x57965C))) // green accent
light := devtools.NewTheme()                                           // default light

func NewDarkTheme(opts ...Option) *Theme

func NewTheme(opts ...Option) *Theme

t := devtools.NewTheme(devtools.WithAccentColor(widget.Hex(0x57965C)))

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

func (t *Theme) IsDark() bool

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

type TitleBarPainter ¶

type TitleBarPainter struct {
	Theme *Theme // nil uses default DevTools dark fallback
}

TitleBarPainter renders title bars using DevTools design tokens.

DevTools title bars use a dark header background (#27282E) that is always dark even in light mode, matching JetBrains IDE behavior. Window control buttons are 46x40px with no border and Windows-style hover effects.

If Theme is nil, TitleBarPainter falls back to default DevTools dark colors.

func (p TitleBarPainter) DrawBackground(canvas widget.Canvas, bounds geometry.Rect, _ titlebar.BackgroundState)

func (p TitleBarPainter) DrawControlButton(canvas widget.Canvas, bounds geometry.Rect, control titlebar.ControlType, state titlebar.ControlState)

type ToolbarPainter ¶

type ToolbarPainter struct {
	Theme *Theme // nil uses default DevTools dark fallback
}

ToolbarPainter renders toolbars using DevTools design tokens. DevTools toolbars are flat and transparent with no background, featuring a subtle 1px bottom border (Gray3) and compact 28px square icon buttons with 4px radius, matching JetBrains IDE toolbar styling.

If Theme is nil, ToolbarPainter falls back to the default DevTools dark 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 DevTools dark fallback
}

TreeViewPainter renders tree views using DevTools design tokens. DevTools tree views use full-row selection highlighting (Blue2 #2E436E), dotted indent guides, and compact 24px row height matching JetBrains IDE project tree styling.

If Theme is nil, TreeViewPainter falls back to the default DevTools dark 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)