diff --git a/container/apptabs.go b/container/apptabs.go
index 16dc198eb5..dcc1c26920 100644
--- a/container/apptabs.go
+++ b/container/apptabs.go
@@ -48,14 +48,12 @@ func NewAppTabs(items ...*TabItem) *AppTabs {
 // Implements: fyne.Widget
 func (t *AppTabs) CreateRenderer() fyne.WidgetRenderer {
 	t.BaseWidget.ExtendBaseWidget(t)
-	th := t.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 
 	r := &appTabsRenderer{
 		baseTabsRenderer: baseTabsRenderer{
 			bar:       &fyne.Container{},
-			divider:   canvas.NewRectangle(th.Color(theme.ColorNameShadow, v)),
-			indicator: canvas.NewRectangle(th.Color(theme.ColorNamePrimary, v)),
+			divider:   canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameShadow, t)),
+			indicator: canvas.NewRectangle(theme.ColorForWidget(theme.ColorNamePrimary, t)),
 		},
 		appTabs: t,
 	}
@@ -422,8 +420,7 @@ func (r *appTabsRenderer) updateIndicator(animate bool) {
 
 	var indicatorPos fyne.Position
 	var indicatorSize fyne.Size
-	th := r.appTabs.Theme()
-	pad := th.Size(theme.SizeNamePadding)
+	pad := theme.SizeForWidget(theme.SizeNamePadding, r.appTabs)
 
 	switch r.appTabs.location {
 	case TabLocationTop:
@@ -440,7 +437,7 @@ func (r *appTabsRenderer) updateIndicator(animate bool) {
 		indicatorSize = fyne.NewSize(pad, selectedSize.Height)
 	}
 
-	r.moveIndicator(indicatorPos, indicatorSize, th, animate)
+	r.moveIndicator(indicatorPos, indicatorSize, r.appTabs.Theme(), animate)
 }
 
 func (r *appTabsRenderer) updateTabs(max int) {
diff --git a/container/doctabs.go b/container/doctabs.go
index 3485acd344..cdc9728b99 100644
--- a/container/doctabs.go
+++ b/container/doctabs.go
@@ -56,14 +56,12 @@ func (t *DocTabs) Append(item *TabItem) {
 // Implements: fyne.Widget
 func (t *DocTabs) CreateRenderer() fyne.WidgetRenderer {
 	t.ExtendBaseWidget(t)
-	th := t.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 
 	r := &docTabsRenderer{
 		baseTabsRenderer: baseTabsRenderer{
 			bar:       &fyne.Container{},
-			divider:   canvas.NewRectangle(th.Color(theme.ColorNameShadow, v)),
-			indicator: canvas.NewRectangle(th.Color(theme.ColorNamePrimary, v)),
+			divider:   canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameShadow, t)),
+			indicator: canvas.NewRectangle(theme.ColorForWidget(theme.ColorNamePrimary, t)),
 		},
 		docTabs:  t,
 		scroller: NewScroll(&fyne.Container{}),
@@ -387,10 +385,9 @@ func (r *docTabsRenderer) scrollToSelected() {
 }
 
 func (r *docTabsRenderer) updateIndicator(animate bool) {
-	th := r.docTabs.Theme()
 	if r.docTabs.current < 0 {
 		r.indicator.FillColor = color.Transparent
-		r.moveIndicator(fyne.NewPos(0, 0), fyne.NewSize(0, 0), th, animate)
+		r.moveIndicator(fyne.NewPos(0, 0), fyne.NewSize(0, 0), r.docTabs.Theme(), animate)
 		return
 	}
 
@@ -423,7 +420,7 @@ func (r *docTabsRenderer) updateIndicator(animate bool) {
 
 	var indicatorPos fyne.Position
 	var indicatorSize fyne.Size
-	pad := th.Size(theme.SizeNamePadding)
+	pad := theme.SizeForWidget(theme.SizeNamePadding, r.docTabs)
 
 	switch r.docTabs.location {
 	case TabLocationTop:
@@ -454,7 +451,7 @@ func (r *docTabsRenderer) updateIndicator(animate bool) {
 		return
 	}
 
-	r.moveIndicator(indicatorPos, indicatorSize, th, animate)
+	r.moveIndicator(indicatorPos, indicatorSize, r.docTabs.Theme(), animate)
 }
 
 func (r *docTabsRenderer) updateAllTabs() {
diff --git a/container/innerwindow.go b/container/innerwindow.go
index 57d02f0ed8..0763dba812 100644
--- a/container/innerwindow.go
+++ b/container/innerwindow.go
@@ -64,7 +64,6 @@ func (w *InnerWindow) Close() {
 func (w *InnerWindow) CreateRenderer() fyne.WidgetRenderer {
 	w.ExtendBaseWidget(w)
 	th := w.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 
 	min := newBorderButton(theme.WindowMinimizeIcon(), modeMinimize, th, w.OnMinimized)
 	if w.OnMinimized == nil {
@@ -99,15 +98,15 @@ func (w *InnerWindow) CreateRenderer() fyne.WidgetRenderer {
 	title := newDraggableLabel(w.title, w)
 	title.Truncation = fyne.TextTruncateEllipsis
 
-	height := w.Theme().Size(theme.SizeNameWindowTitleBarHeight)
+	height := theme.SizeForWidget(theme.SizeNameWindowTitleBarHeight, w)
 	off := (height - title.labelMinSize().Height) / 2
 	barMid := New(layout.NewCustomPaddedLayout(off, 0, 0, 0), title)
 	if w.buttonPosition() == widget.ButtonAlignTrailing {
 		buttons = NewCenter(NewHBox(min, max, close))
 	}
 
-	bg := canvas.NewRectangle(th.Color(theme.ColorNameOverlayBackground, v))
-	contentBG := canvas.NewRectangle(th.Color(theme.ColorNameBackground, v))
+	bg := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameOverlayBackground, w))
+	contentBG := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameBackground, w))
 	corner := newDraggableCorner(w)
 	bar := New(&titleBarLayout{buttons: buttons, icon: borderIcon, title: barMid, win: w},
 		buttons, borderIcon, barMid)
@@ -214,10 +213,9 @@ func (i *innerWindowRenderer) MinSize() fyne.Size {
 
 func (i *innerWindowRenderer) Refresh() {
 	th := i.win.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-	i.bg.FillColor = th.Color(theme.ColorNameOverlayBackground, v)
+	i.bg.FillColor = theme.ColorForWidget(theme.ColorNameOverlayBackground, i.win)
 	i.bg.Refresh()
-	i.contentBG.FillColor = th.Color(theme.ColorNameBackground, v)
+	i.contentBG.FillColor = theme.ColorForWidget(theme.ColorNameBackground, i.win)
 	i.contentBG.Refresh()
 
 	if i.win.buttonPosition() == widget.ButtonAlignTrailing {
diff --git a/container/split.go b/container/split.go
index cbd6083c05..82a62d3f4c 100644
--- a/container/split.go
+++ b/container/split.go
@@ -252,11 +252,9 @@ func newDivider(split *Split) *divider {
 // CreateRenderer is a private method to Fyne which links this widget to its renderer
 func (d *divider) CreateRenderer() fyne.WidgetRenderer {
 	d.ExtendBaseWidget(d)
-	th := d.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 
-	background := canvas.NewRectangle(th.Color(theme.ColorNameShadow, v))
-	foreground := canvas.NewRectangle(th.Color(theme.ColorNameForeground, v))
+	background := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameShadow, d))
+	foreground := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameForeground, d))
 	return &dividerRenderer{
 		divider:    d,
 		background: background,
@@ -362,44 +360,29 @@ func (r *dividerRenderer) Objects() []fyne.CanvasObject {
 }
 
 func (r *dividerRenderer) Refresh() {
-	th := r.divider.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
 	if r.divider.hovered {
-		r.background.FillColor = th.Color(theme.ColorNameHover, v)
+		r.background.FillColor = theme.ColorForWidget(theme.ColorNameHover, r.divider)
 	} else {
-		r.background.FillColor = th.Color(theme.ColorNameShadow, v)
+		r.background.FillColor = theme.ColorForWidget(theme.ColorNameShadow, r.divider)
 	}
 	r.background.Refresh()
-	r.foreground.FillColor = th.Color(theme.ColorNameForeground, v)
+	r.foreground.FillColor = theme.ColorForWidget(theme.ColorNameForeground, r.divider)
 	r.foreground.Refresh()
 	r.Layout(r.divider.Size())
 }
 
-func dividerTheme(d *divider) fyne.Theme {
-	if d == nil {
-		return theme.Current()
-	}
-
-	return d.Theme()
-}
-
 func dividerThickness(d *divider) float32 {
-	th := dividerTheme(d)
-	return th.Size(theme.SizeNamePadding) * 2
+	return theme.SizeForWidget(theme.SizeNamePadding, d) * 2
 }
 
 func dividerLength(d *divider) float32 {
-	th := dividerTheme(d)
-	return th.Size(theme.SizeNamePadding) * 6
+	return theme.SizeForWidget(theme.SizeNamePadding, d) * 6
 }
 
 func handleThickness(d *divider) float32 {
-	th := dividerTheme(d)
-	return th.Size(theme.SizeNamePadding) / 2
+	return theme.SizeForWidget(theme.SizeNamePadding, d) / 2
 }
 
 func handleLength(d *divider) float32 {
-	th := dividerTheme(d)
-	return th.Size(theme.SizeNamePadding) * 4
+	return theme.SizeForWidget(theme.SizeNamePadding, d) * 4
 }
diff --git a/container/tabs.go b/container/tabs.go
index 4f1ab91e25..0f2220949c 100644
--- a/container/tabs.go
+++ b/container/tabs.go
@@ -524,18 +524,16 @@ type tabButton struct {
 
 func (b *tabButton) CreateRenderer() fyne.WidgetRenderer {
 	b.ExtendBaseWidget(b)
-	th := b.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 
-	background := canvas.NewRectangle(th.Color(theme.ColorNameHover, v))
-	background.CornerRadius = th.Size(theme.SizeNameSelectionRadius)
+	background := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameHover, b))
+	background.CornerRadius = theme.SizeForWidget(theme.SizeNameSelectionRadius, b)
 	background.Hide()
 	icon := canvas.NewImageFromResource(b.icon)
 	if b.icon == nil {
 		icon.Hide()
 	}
 
-	label := canvas.NewText(b.text, th.Color(theme.ColorNameForeground, v))
+	label := canvas.NewText(b.text, theme.ColorForWidget(theme.ColorNameForeground, b))
 	label.TextStyle.Bold = true
 
 	close := &tabCloseButton{
@@ -599,8 +597,7 @@ func (r *tabButtonRenderer) Destroy() {
 }
 
 func (r *tabButtonRenderer) Layout(size fyne.Size) {
-	th := r.button.Theme()
-	pad := th.Size(theme.SizeNamePadding)
+	pad := theme.SizeForWidget(theme.SizeNamePadding, r.button)
 	r.background.Resize(size)
 	padding := r.padding()
 	innerSize := size.Subtract(padding)
@@ -631,17 +628,16 @@ func (r *tabButtonRenderer) Layout(size fyne.Size) {
 		r.label.Resize(labelSize)
 		r.label.Move(innerOffset.Add(labelOffset))
 	}
-	inlineIconSize := th.Size(theme.SizeNameInlineIcon)
+	inlineIconSize := theme.SizeForWidget(theme.SizeNameInlineIcon, r.button)
 	r.close.Move(fyne.NewPos(size.Width-inlineIconSize-pad, (size.Height-inlineIconSize)/2))
 	r.close.Resize(fyne.NewSquareSize(inlineIconSize))
 }
 
 func (r *tabButtonRenderer) MinSize() fyne.Size {
-	th := r.button.Theme()
 	var contentWidth, contentHeight float32
 	textSize := r.label.MinSize()
 	iconSize := r.iconSize()
-	padding := th.Size(theme.SizeNamePadding)
+	padding := theme.SizeForWidget(theme.SizeNamePadding, r.button)
 	if r.button.iconPosition == buttonIconTop {
 		contentWidth = fyne.Max(textSize.Width, iconSize)
 		if r.icon.Visible() {
@@ -666,7 +662,7 @@ func (r *tabButtonRenderer) MinSize() fyne.Size {
 		}
 	}
 	if r.button.onClosed != nil {
-		inlineIconSize := th.Size(theme.SizeNameInlineIcon)
+		inlineIconSize := theme.SizeForWidget(theme.SizeNameInlineIcon, r.button)
 		contentWidth += inlineIconSize + padding
 		contentHeight = fyne.Max(contentHeight, inlineIconSize)
 	}
@@ -678,12 +674,9 @@ func (r *tabButtonRenderer) Objects() []fyne.CanvasObject {
 }
 
 func (r *tabButtonRenderer) Refresh() {
-	th := r.button.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
 	if r.button.hovered && !r.button.Disabled() {
-		r.background.FillColor = th.Color(theme.ColorNameHover, v)
-		r.background.CornerRadius = th.Size(theme.SizeNameSelectionRadius)
+		r.background.FillColor = theme.ColorForWidget(theme.ColorNameHover, r.button)
+		r.background.CornerRadius = theme.SizeForWidget(theme.SizeNameSelectionRadius, r.button)
 		r.background.Show()
 	} else {
 		r.background.Hide()
@@ -694,14 +687,14 @@ func (r *tabButtonRenderer) Refresh() {
 	r.label.Alignment = r.button.textAlignment
 	if !r.button.Disabled() {
 		if r.button.importance == widget.HighImportance {
-			r.label.Color = th.Color(theme.ColorNamePrimary, v)
+			r.label.Color = theme.ColorForWidget(theme.ColorNamePrimary, r.button)
 		} else {
-			r.label.Color = th.Color(theme.ColorNameForeground, v)
+			r.label.Color = theme.ColorForWidget(theme.ColorNameForeground, r.button)
 		}
 	} else {
-		r.label.Color = th.Color(theme.ColorNameDisabled, v)
+		r.label.Color = theme.ColorForWidget(theme.ColorNameDisabled, r.button)
 	}
-	r.label.TextSize = th.Size(theme.SizeNameText)
+	r.label.TextSize = theme.SizeForWidget(theme.SizeNameText, r.button)
 	if r.button.text == "" {
 		r.label.Hide()
 	} else {
@@ -737,7 +730,7 @@ func (r *tabButtonRenderer) Refresh() {
 }
 
 func (r *tabButtonRenderer) iconSize() float32 {
-	iconSize := r.button.Theme().Size(theme.SizeNameInlineIcon)
+	iconSize := theme.SizeForWidget(theme.SizeNameInlineIcon, r.button)
 	if r.button.iconPosition == buttonIconTop {
 		return 2 * iconSize
 	}
@@ -746,7 +739,7 @@ func (r *tabButtonRenderer) iconSize() float32 {
 }
 
 func (r *tabButtonRenderer) padding() fyne.Size {
-	padding := r.button.Theme().Size(theme.SizeNameInnerPadding)
+	padding := theme.SizeForWidget(theme.SizeNameInnerPadding, r.button)
 	if r.label.Text != "" && r.button.iconPosition == buttonIconInline {
 		return fyne.NewSquareSize(padding * 2)
 	}
@@ -768,11 +761,9 @@ type tabCloseButton struct {
 
 func (b *tabCloseButton) CreateRenderer() fyne.WidgetRenderer {
 	b.ExtendBaseWidget(b)
-	th := b.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 
-	background := canvas.NewRectangle(th.Color(theme.ColorNameHover, v))
-	background.CornerRadius = th.Size(theme.SizeNameSelectionRadius)
+	background := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameHover, b))
+	background.CornerRadius = theme.SizeForWidget(theme.SizeNameSelectionRadius, b)
 	background.Hide()
 	icon := canvas.NewImageFromResource(theme.CancelIcon())
 
@@ -830,12 +821,9 @@ func (r *tabCloseButtonRenderer) Objects() []fyne.CanvasObject {
 }
 
 func (r *tabCloseButtonRenderer) Refresh() {
-	th := r.button.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
 	if r.button.hovered {
-		r.background.FillColor = th.Color(theme.ColorNameHover, v)
-		r.background.CornerRadius = th.Size(theme.SizeNameSelectionRadius)
+		r.background.FillColor = theme.ColorForWidget(theme.ColorNameHover, r.button)
+		r.background.CornerRadius = theme.SizeForWidget(theme.SizeNameSelectionRadius, r.button)
 		r.background.Show()
 	} else {
 		r.background.Hide()
diff --git a/internal/widget/scroller.go b/internal/widget/scroller.go
index 8951e9cd41..93ce0f20d4 100644
--- a/internal/widget/scroller.go
+++ b/internal/widget/scroller.go
@@ -53,11 +53,8 @@ func (r *scrollBarRenderer) MinSize() fyne.Size {
 }
 
 func (r *scrollBarRenderer) Refresh() {
-	th := theme.CurrentForWidget(r.scrollBar)
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
-	r.background.FillColor = th.Color(theme.ColorNameScrollBar, v)
-	r.background.CornerRadius = th.Size(theme.SizeNameScrollBarRadius)
+	r.background.FillColor = theme.ColorForWidget(theme.ColorNameScrollBar, r.scrollBar)
+	r.background.CornerRadius = theme.SizeForWidget(theme.SizeNameScrollBarRadius, r.scrollBar)
 	r.background.Refresh()
 }
 
@@ -75,11 +72,8 @@ type scrollBar struct {
 }
 
 func (b *scrollBar) CreateRenderer() fyne.WidgetRenderer {
-	th := theme.CurrentForWidget(b)
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
-	background := canvas.NewRectangle(th.Color(theme.ColorNameScrollBar, v))
-	background.CornerRadius = th.Size(theme.SizeNameScrollBarRadius)
+	background := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameScrollBar, b))
+	background.CornerRadius = theme.SizeForWidget(theme.SizeNameScrollBarRadius, b)
 	r := &scrollBarRenderer{
 		scrollBar:  b,
 		background: background,
@@ -197,7 +191,7 @@ func (r *scrollBarAreaRenderer) MinSize() fyne.Size {
 func (r *scrollBarAreaRenderer) Refresh() {
 	th := theme.CurrentForWidget(r.area)
 	r.bar.Refresh()
-	r.background.FillColor = th.Color(theme.ColorNameScrollBarBackground, fyne.CurrentApp().Settings().ThemeVariant())
+	r.background.FillColor = theme.ColorForWidget(theme.ColorNameScrollBarBackground, r.area)
 	r.background.Hidden = !r.area.isLarge()
 	r.layoutWithTheme(th, r.area.Size())
 	canvas.Refresh(r.bar)
@@ -246,10 +240,8 @@ type scrollBarArea struct {
 }
 
 func (a *scrollBarArea) CreateRenderer() fyne.WidgetRenderer {
-	th := theme.CurrentForWidget(a)
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 	a.bar = newScrollBar(a)
-	background := canvas.NewRectangle(th.Color(theme.ColorNameScrollBarBackground, v))
+	background := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameScrollBarBackground, a))
 	background.Hidden = !a.isLarge()
 	return &scrollBarAreaRenderer{BaseRenderer: NewBaseRenderer([]fyne.CanvasObject{background, a.bar}), area: a, bar: a.bar, background: background}
 }
diff --git a/internal/widget/shadow.go b/internal/widget/shadow.go
index 992717e94d..b8dec658ac 100644
--- a/internal/widget/shadow.go
+++ b/internal/widget/shadow.go
@@ -121,9 +121,7 @@ func (r *shadowRenderer) Refresh() {
 }
 
 func (r *shadowRenderer) createShadows() {
-	th := theme.CurrentForWidget(r.s)
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-	fg := th.Color(theme.ColorNameShadow, v)
+	fg := theme.ColorForWidget(theme.ColorNameShadow, r.s)
 
 	switch r.s.typ {
 	case ShadowLeft:
@@ -160,9 +158,7 @@ func (r *shadowRenderer) createShadows() {
 }
 
 func (r *shadowRenderer) refreshShadows() {
-	th := theme.CurrentForWidget(r.s)
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-	fg := th.Color(theme.ColorNameShadow, v)
+	fg := theme.ColorForWidget(theme.ColorNameShadow, r.s)
 
 	updateShadowEnd(r.l, fg)
 	updateShadowStart(r.r, fg)
diff --git a/widget/accordion.go b/widget/accordion.go
index dd67fb783e..d64439a233 100644
--- a/widget/accordion.go
+++ b/widget/accordion.go
@@ -135,9 +135,8 @@ type accordionRenderer struct {
 }
 
 func (r *accordionRenderer) Layout(size fyne.Size) {
-	th := r.container.Theme()
-	pad := th.Size(theme.SizeNamePadding)
-	separator := th.Size(theme.SizeNameSeparatorThickness)
+	pad := theme.SizeForWidget(theme.SizeNamePadding, r.container)
+	separator := theme.SizeForWidget(theme.SizeNameSeparatorThickness, r.container)
 	dividerOff := (pad + separator) / 2
 	x := float32(0)
 	y := float32(0)
@@ -193,8 +192,7 @@ func (r *accordionRenderer) Layout(size fyne.Size) {
 }
 
 func (r *accordionRenderer) MinSize() fyne.Size {
-	th := r.container.Theme()
-	pad := th.Size(theme.SizeNamePadding)
+	pad := theme.SizeForWidget(theme.SizeNamePadding, r.container)
 	size := fyne.Size{}
 
 	for i, ai := range r.container.Items {
@@ -222,7 +220,6 @@ func (r *accordionRenderer) Refresh() {
 }
 
 func (r *accordionRenderer) updateObjects() {
-	th := r.container.Theme()
 	is := len(r.container.Items)
 	hs := len(r.headers)
 	ds := len(r.dividers)
@@ -252,10 +249,10 @@ func (r *accordionRenderer) updateObjects() {
 			}
 		}
 		if ai.Open {
-			h.Icon = th.Icon(theme.IconNameArrowDropUp)
+			h.Icon = theme.IconForWidget(theme.IconNameArrowDropUp, r.container)
 			ai.Detail.Show()
 		} else {
-			h.Icon = th.Icon(theme.IconNameArrowDropDown)
+			h.Icon = theme.IconForWidget(theme.IconNameArrowDropDown, r.container)
 			ai.Detail.Hide()
 		}
 		h.Refresh()
diff --git a/widget/activity.go b/widget/activity.go
index 91074e2fcf..90ece10437 100644
--- a/widget/activity.go
+++ b/widget/activity.go
@@ -59,9 +59,8 @@ func (a *Activity) Stop() {
 
 func (a *Activity) CreateRenderer() fyne.WidgetRenderer {
 	dots := make([]fyne.CanvasObject, 3)
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 	for i := range dots {
-		dots[i] = canvas.NewCircle(a.Theme().Color(theme.ColorNameForeground, v))
+		dots[i] = canvas.NewCircle(theme.ColorForWidget(theme.ColorNameForeground, a))
 	}
 	r := &activityRenderer{dots: dots, parent: a}
 	r.anim = &fyne.Animation{
@@ -171,7 +170,6 @@ func (a *activityRenderer) stop() {
 }
 
 func (a *activityRenderer) updateColor() {
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-	rr, gg, bb, aa := a.parent.Theme().Color(theme.ColorNameForeground, v).RGBA()
+	rr, gg, bb, aa := theme.ColorForWidget(theme.ColorNameForeground, a.parent).RGBA()
 	a.maxCol = color.NRGBA{R: uint8(rr >> 8), G: uint8(gg >> 8), B: uint8(bb >> 8), A: uint8(aa >> 8)}
 }
diff --git a/widget/button.go b/widget/button.go
index 3ea375f2a4..9f9816553e 100644
--- a/widget/button.go
+++ b/widget/button.go
@@ -91,18 +91,16 @@ func NewButtonWithIcon(label string, icon fyne.Resource, tapped func()) *Button
 // CreateRenderer is a private method to Fyne which links this widget to its renderer
 func (b *Button) CreateRenderer() fyne.WidgetRenderer {
 	b.ExtendBaseWidget(b)
-	th := b.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 
 	seg := &TextSegment{Text: b.Text, Style: RichTextStyleStrong}
 	seg.Style.Alignment = fyne.TextAlignCenter
 	text := NewRichText(seg)
-	text.inset = fyne.NewSquareSize(th.Size(theme.SizeNameInnerPadding))
+	text.inset = fyne.NewSquareSize(theme.SizeForWidget(theme.SizeNameInnerPadding, b))
 
-	background := canvas.NewRectangle(th.Color(theme.ColorNameButton, v))
-	background.CornerRadius = th.Size(theme.SizeNameInputRadius)
+	background := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameButton, b))
+	background.CornerRadius = theme.SizeForWidget(theme.SizeNameInputRadius, b)
 	tapBG := canvas.NewRectangle(color.Transparent)
-	b.tapAnim = newButtonTapAnimation(tapBG, b, th)
+	b.tapAnim = newButtonTapAnimation(tapBG, b)
 	b.tapAnim.Curve = fyne.AnimationEaseOut
 	objects := []fyne.CanvasObject{
 		background,
@@ -226,15 +224,14 @@ func (r *buttonRenderer) Layout(size fyne.Size) {
 	r.background.Resize(size)
 	r.tapBG.Resize(size)
 
-	th := r.button.Theme()
-	padding := r.padding(th)
+	padding := r.padding()
 	hasIcon := r.icon != nil
 	hasLabel := r.label.Segments[0].(*TextSegment).Text != ""
 	if !hasIcon && !hasLabel {
 		// Nothing to layout
 		return
 	}
-	iconSize := fyne.NewSquareSize(th.Size(theme.SizeNameInlineIcon))
+	iconSize := fyne.NewSquareSize(theme.SizeForWidget(theme.SizeNameInlineIcon, r.button))
 	labelSize := r.label.MinSize()
 
 	if hasLabel {
@@ -269,28 +266,26 @@ func (r *buttonRenderer) Layout(size fyne.Size) {
 // This is based on the contained text, any icon that is set and a standard
 // amount of padding added.
 func (r *buttonRenderer) MinSize() (size fyne.Size) {
-	th := r.button.Theme()
 	hasIcon := r.icon != nil
 	hasLabel := r.label.Segments[0].(*TextSegment).Text != ""
-	iconSize := fyne.NewSquareSize(th.Size(theme.SizeNameInlineIcon))
+	iconSize := fyne.NewSquareSize(theme.SizeForWidget(theme.SizeNameInlineIcon, r.button))
 	labelSize := r.label.MinSize()
 	if hasLabel {
 		size.Width = labelSize.Width
 	}
 	if hasIcon {
 		if hasLabel {
-			size.Width += th.Size(theme.SizeNamePadding)
+			size.Width += theme.SizeForWidget(theme.SizeNamePadding, r.button)
 		}
 		size.Width += iconSize.Width
 	}
 	size.Height = fyne.Max(labelSize.Height, iconSize.Height)
-	size = size.Add(r.padding(th))
+	size = size.Add(r.padding())
 	return
 }
 
 func (r *buttonRenderer) Refresh() {
-	th := r.button.Theme()
-	r.label.inset = fyne.NewSquareSize(th.Size(theme.SizeNameInnerPadding))
+	r.label.inset = fyne.NewSquareSize(theme.SizeForWidget(theme.SizeNameInnerPadding, r.button))
 
 	r.label.Segments[0].(*TextSegment).Text = r.button.Text
 	r.updateIconAndText()
@@ -304,19 +299,17 @@ func (r *buttonRenderer) Refresh() {
 // applyTheme updates this button to match the current theme
 // must be called with the button propertyLock RLocked
 func (r *buttonRenderer) applyTheme() {
-	th := r.button.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 	fgColorName, bgColorName, bgBlendName := r.buttonColorNames()
 	if bg := r.background; bg != nil {
 		bgColor := color.Color(color.Transparent)
 		if bgColorName != "" {
-			bgColor = th.Color(bgColorName, v)
+			bgColor = theme.ColorForWidget(bgColorName, r.button)
 		}
 		if bgBlendName != "" {
-			bgColor = blendColor(bgColor, th.Color(bgBlendName, v))
+			bgColor = blendColor(bgColor, theme.ColorForWidget(bgBlendName, r.button))
 		}
 		bg.FillColor = bgColor
-		bg.CornerRadius = th.Size(theme.SizeNameInputRadius)
+		bg.CornerRadius = theme.SizeForWidget(theme.SizeNameInputRadius, r.button)
 		bg.Refresh()
 	}
 
@@ -374,8 +367,8 @@ func (r *buttonRenderer) buttonColorNames() (foreground, background, backgroundB
 	return
 }
 
-func (r *buttonRenderer) padding(th fyne.Theme) fyne.Size {
-	return fyne.NewSquareSize(th.Size(theme.SizeNameInnerPadding) * 2)
+func (r *buttonRenderer) padding() fyne.Size {
+	return fyne.NewSquareSize(theme.SizeForWidget(theme.SizeNameInnerPadding, r.button) * 2)
 }
 
 // must be called with r.button.propertyLock RLocked
@@ -434,15 +427,14 @@ func blendColor(under, over color.Color) color.Color {
 	return color.RGBA64{R: uint16(outR), G: uint16(outG), B: uint16(outB), A: uint16(outAlpha * 0xFFFF)}
 }
 
-func newButtonTapAnimation(bg *canvas.Rectangle, w fyne.Widget, th fyne.Theme) *fyne.Animation {
-	v := fyne.CurrentApp().Settings().ThemeVariant()
+func newButtonTapAnimation(bg *canvas.Rectangle, w fyne.Widget) *fyne.Animation {
 	return fyne.NewAnimation(canvas.DurationStandard, func(done float32) {
 		mid := w.Size().Width / 2
 		size := mid * done
 		bg.Resize(fyne.NewSize(size*2, w.Size().Height))
 		bg.Move(fyne.NewPos(mid-size, 0))
 
-		r, g, bb, a := col.ToNRGBA(th.Color(theme.ColorNamePressed, v))
+		r, g, bb, a := col.ToNRGBA(theme.ColorForWidget(theme.ColorNamePressed, w))
 		aa := uint8(a)
 		fade := aa - uint8(float32(aa)*done)
 		if fade > 0 {
diff --git a/widget/card.go b/widget/card.go
index fc0591ab03..52097f9cb3 100644
--- a/widget/card.go
+++ b/widget/card.go
@@ -34,10 +34,8 @@ func NewCard(title, subtitle string, content fyne.CanvasObject) *Card {
 // CreateRenderer is a private method to Fyne which links this widget to its renderer
 func (c *Card) CreateRenderer() fyne.WidgetRenderer {
 	c.ExtendBaseWidget(c)
-	th := c.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 
-	header := canvas.NewText(c.Title, th.Color(theme.ColorNameForeground, v))
+	header := canvas.NewText(c.Title, theme.ColorForWidget(theme.ColorNameForeground, c))
 	header.TextStyle.Bold = true
 	subHeader := canvas.NewText(c.Subtitle, header.Color)
 
@@ -104,7 +102,7 @@ const (
 
 // Layout the components of the card container.
 func (c *cardRenderer) Layout(size fyne.Size) {
-	padding := c.card.Theme().Size(theme.SizeNamePadding)
+	padding := theme.SizeForWidget(theme.SizeNamePadding, c.card)
 	pos := fyne.NewSquareOffsetPos(padding / 2)
 	size = size.Subtract(fyne.NewSquareSize(padding))
 	c.LayoutShadow(size, pos)
@@ -161,7 +159,7 @@ func (c *cardRenderer) MinSize() fyne.Size {
 	hasImage := c.card.Image != nil
 	hasContent := c.card.Content != nil
 
-	padding := c.card.Theme().Size(theme.SizeNamePadding)
+	padding := theme.SizeForWidget(theme.SizeNamePadding, c.card)
 	if !hasHeader && !hasSubHeader && !hasContent { // just image, or nothing
 		if c.card.Image == nil {
 			return fyne.NewSize(padding, padding) // empty, just space for border
@@ -224,16 +222,13 @@ func (c *cardRenderer) Refresh() {
 
 // applyTheme updates this button to match the current theme
 func (c *cardRenderer) applyTheme() {
-	th := c.card.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
 	if c.header != nil {
-		c.header.TextSize = th.Size(theme.SizeNameHeadingText)
-		c.header.Color = th.Color(theme.ColorNameForeground, v)
+		c.header.TextSize = theme.SizeForWidget(theme.SizeNameHeadingText, c.card)
+		c.header.Color = theme.ColorForWidget(theme.ColorNameForeground, c.card)
 	}
 	if c.subHeader != nil {
-		c.subHeader.TextSize = th.Size(theme.SizeNameText)
-		c.subHeader.Color = th.Color(theme.ColorNameForeground, v)
+		c.subHeader.TextSize = theme.SizeForWidget(theme.SizeNameText, c.card)
+		c.subHeader.Color = theme.ColorForWidget(theme.ColorNameForeground, c.card)
 	}
 	if c.card.Content != nil {
 		c.card.Content.Refresh()
diff --git a/widget/check.go b/widget/check.go
index 87ad07dd59..12928790b0 100644
--- a/widget/check.go
+++ b/widget/check.go
@@ -162,17 +162,14 @@ func (c *Check) MinSize() fyne.Size {
 
 // CreateRenderer is a private method to Fyne which links this widget to its renderer
 func (c *Check) CreateRenderer() fyne.WidgetRenderer {
-	th := c.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
 	c.ExtendBaseWidget(c)
-	bg := canvas.NewImageFromResource(th.Icon(theme.IconNameCheckButtonFill))
-	icon := canvas.NewImageFromResource(th.Icon(theme.IconNameCheckButton))
+	bg := canvas.NewImageFromResource(theme.IconForWidget(theme.IconNameCheckButtonFill, c))
+	icon := canvas.NewImageFromResource(theme.IconForWidget(theme.IconNameCheckButton, c))
 
-	text := canvas.NewText(c.Text, th.Color(theme.ColorNameForeground, v))
+	text := canvas.NewText(c.Text, theme.ColorForWidget(theme.ColorNameForeground, c))
 	text.Alignment = fyne.TextAlignLeading
 
-	focusIndicator := canvas.NewCircle(th.Color(theme.ColorNameBackground, v))
+	focusIndicator := canvas.NewCircle(theme.ColorForWidget(theme.ColorNameBackground, c))
 	r := &checkRenderer{
 		widget.NewBaseRenderer([]fyne.CanvasObject{focusIndicator, bg, icon, text}),
 		bg,
@@ -181,10 +178,10 @@ func (c *Check) CreateRenderer() fyne.WidgetRenderer {
 		focusIndicator,
 		c,
 	}
-	r.applyTheme(th, v)
+	r.applyTheme()
 	r.updateLabel()
-	r.updateResource(th)
-	r.updateFocusIndicator(th, v)
+	r.updateResource()
+	r.updateFocusIndicator()
 	return r
 }
 
@@ -282,13 +279,11 @@ type checkRenderer struct {
 // MinSize calculates the minimum size of a check.
 // This is based on the contained text, the check icon and a standard amount of padding added.
 func (c *checkRenderer) MinSize() fyne.Size {
-	th := c.check.Theme()
-
-	pad4 := th.Size(theme.SizeNameInnerPadding) * 2
-	min := c.label.MinSize().Add(fyne.NewSize(th.Size(theme.SizeNameInlineIcon)+pad4, pad4))
+	pad4 := theme.SizeForWidget(theme.SizeNameInnerPadding, c.check) * 2
+	min := c.label.MinSize().Add(fyne.NewSize(theme.SizeForWidget(theme.SizeNameInlineIcon, c.check)+pad4, pad4))
 
 	if c.check.Text != "" {
-		min.Add(fyne.NewSize(th.Size(theme.SizeNamePadding), 0))
+		min.Add(fyne.NewSize(theme.SizeForWidget(theme.SizeNamePadding, c.check), 0))
 	}
 
 	return min
@@ -296,10 +291,9 @@ func (c *checkRenderer) MinSize() fyne.Size {
 
 // Layout the components of the check widget
 func (c *checkRenderer) Layout(size fyne.Size) {
-	th := c.check.Theme()
-	innerPadding := th.Size(theme.SizeNameInnerPadding)
-	borderSize := th.Size(theme.SizeNameInputBorder)
-	iconInlineSize := th.Size(theme.SizeNameInlineIcon)
+	innerPadding := theme.SizeForWidget(theme.SizeNameInnerPadding, c.check)
+	borderSize := theme.SizeForWidget(theme.SizeNameInputBorder, c.check)
+	iconInlineSize := theme.SizeForWidget(theme.SizeNameInlineIcon, c.check)
 
 	focusIndicatorSize := fyne.NewSquareSize(iconInlineSize + innerPadding)
 	c.focusIndicator.Resize(focusIndicatorSize)
@@ -319,22 +313,19 @@ func (c *checkRenderer) Layout(size fyne.Size) {
 }
 
 // applyTheme updates this Check to the current theme
-func (c *checkRenderer) applyTheme(th fyne.Theme, v fyne.ThemeVariant) {
-	c.label.Color = th.Color(theme.ColorNameForeground, v)
-	c.label.TextSize = th.Size(theme.SizeNameText)
+func (c *checkRenderer) applyTheme() {
+	c.label.Color = theme.ColorForWidget(theme.ColorNameForeground, c.check)
+	c.label.TextSize = theme.SizeForWidget(theme.SizeNameText, c.check)
 	if c.check.Disabled() {
-		c.label.Color = th.Color(theme.ColorNameDisabled, v)
+		c.label.Color = theme.ColorForWidget(theme.ColorNameDisabled, c.check)
 	}
 }
 
 func (c *checkRenderer) Refresh() {
-	th := c.check.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
-	c.applyTheme(th, v)
+	c.applyTheme()
 	c.updateLabel()
-	c.updateResource(th)
-	c.updateFocusIndicator(th, v)
+	c.updateResource()
+	c.updateFocusIndicator()
 	canvas.Refresh(c.check.super())
 }
 
@@ -344,18 +335,18 @@ func (c *checkRenderer) updateLabel() {
 }
 
 // must be called while holding c.check.propertyLock for reading
-func (c *checkRenderer) updateResource(th fyne.Theme) {
-	res := theme.NewThemedResource(th.Icon(theme.IconNameCheckButton))
+func (c *checkRenderer) updateResource() {
+	res := theme.NewThemedResource(theme.IconForWidget(theme.IconNameCheckButton, c.check))
 	res.ColorName = theme.ColorNameInputBorder
-	bgRes := theme.NewThemedResource(th.Icon(theme.IconNameCheckButtonFill))
+	bgRes := theme.NewThemedResource(theme.IconForWidget(theme.IconNameCheckButtonFill, c.check))
 	bgRes.ColorName = theme.ColorNameInputBackground
 
 	if c.check.Partial {
-		res = theme.NewThemedResource(th.Icon(theme.IconNameCheckButtonPartial))
+		res = theme.NewThemedResource(theme.IconForWidget(theme.IconNameCheckButtonPartial, c.check))
 		res.ColorName = theme.ColorNamePrimary
 		bgRes.ColorName = theme.ColorNameBackground
 	} else if c.check.Checked {
-		res = theme.NewThemedResource(th.Icon(theme.IconNameCheckButtonChecked))
+		res = theme.NewThemedResource(theme.IconForWidget(theme.IconNameCheckButtonChecked, c.check))
 		res.ColorName = theme.ColorNamePrimary
 		bgRes.ColorName = theme.ColorNameBackground
 	}
@@ -373,13 +364,13 @@ func (c *checkRenderer) updateResource(th fyne.Theme) {
 }
 
 // must be called while holding c.check.propertyLock for reading
-func (c *checkRenderer) updateFocusIndicator(th fyne.Theme, v fyne.ThemeVariant) {
+func (c *checkRenderer) updateFocusIndicator() {
 	if c.check.Disabled() {
 		c.focusIndicator.FillColor = color.Transparent
 	} else if c.check.focused {
-		c.focusIndicator.FillColor = th.Color(theme.ColorNameFocus, v)
+		c.focusIndicator.FillColor = theme.ColorForWidget(theme.ColorNameFocus, c.check)
 	} else if c.check.hovered {
-		c.focusIndicator.FillColor = th.Color(theme.ColorNameHover, v)
+		c.focusIndicator.FillColor = theme.ColorForWidget(theme.ColorNameHover, c.check)
 	} else {
 		c.focusIndicator.FillColor = color.Transparent
 	}
diff --git a/widget/check_internal_test.go b/widget/check_internal_test.go
index 359232ea05..a83a66a2d9 100644
--- a/widget/check_internal_test.go
+++ b/widget/check_internal_test.go
@@ -270,19 +270,3 @@ func TestCheck_Disabled(t *testing.T) {
 	check.Enable()
 	assert.False(t, check.Disabled())
 }
-
-func TestCheckRenderer_ApplyTheme(t *testing.T) {
-	check := &Check{}
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-	render := test.TempWidgetRenderer(t, check).(*checkRenderer)
-
-	textSize := render.label.TextSize
-	customTextSize := textSize
-	test.WithTestTheme(t, func() {
-		th := test.NewTheme()
-		render.applyTheme(th, v)
-		customTextSize = render.label.TextSize
-	})
-
-	assert.NotEqual(t, textSize, customTextSize)
-}
diff --git a/widget/entry.go b/widget/entry.go
index 9d809627c5..067ceff4ff 100644
--- a/widget/entry.go
+++ b/widget/entry.go
@@ -163,8 +163,6 @@ func (e *Entry) Bind(data binding.String) {
 //
 // Implements: fyne.Widget
 func (e *Entry) CreateRenderer() fyne.WidgetRenderer {
-	th := e.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 	e.ExtendBaseWidget(e)
 
 	// initialise
@@ -172,12 +170,12 @@ func (e *Entry) CreateRenderer() fyne.WidgetRenderer {
 	e.placeholderProvider()
 	e.syncSelectable()
 
-	box := canvas.NewRectangle(th.Color(theme.ColorNameInputBackground, v))
-	box.CornerRadius = th.Size(theme.SizeNameInputRadius)
+	box := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameInputBackground, e))
+	box.CornerRadius = theme.SizeForWidget(theme.SizeNameInputRadius, e)
 	border := canvas.NewRectangle(color.Transparent)
-	border.StrokeWidth = th.Size(theme.SizeNameInputBorder)
-	border.StrokeColor = th.Color(theme.ColorNameInputBorder, v)
-	border.CornerRadius = th.Size(theme.SizeNameInputRadius)
+	border.StrokeWidth = theme.SizeForWidget(theme.SizeNameInputBorder, e)
+	border.StrokeColor = theme.ColorForWidget(theme.ColorNameInputBorder, e)
+	border.CornerRadius = theme.SizeForWidget(theme.SizeNameInputRadius, e)
 	cursor := canvas.NewRectangle(color.Transparent)
 	cursor.Hide()
 
@@ -213,10 +211,9 @@ func (e *Entry) CreateRenderer() fyne.WidgetRenderer {
 // Since: 2.7
 func (e *Entry) CursorPosition() fyne.Position {
 	provider := e.textProvider()
-	th := e.Theme()
-	innerPad := th.Size(theme.SizeNameInnerPadding)
-	inputBorder := th.Size(theme.SizeNameInputBorder)
-	textSize := th.Size(theme.SizeNameText)
+	innerPad := theme.SizeForWidget(theme.SizeNameInnerPadding, e)
+	inputBorder := theme.SizeForWidget(theme.SizeNameInputBorder, e)
+	textSize := theme.SizeForWidget(theme.SizeNameText, e)
 
 	size := provider.lineSizeToColumn(e.CursorColumn, e.CursorRow, textSize, innerPad)
 	xPos := size.Width
@@ -1512,7 +1509,6 @@ func (r *entryRenderer) Destroy() {
 }
 
 func (r *entryRenderer) trailingInset() float32 {
-	th := r.entry.Theme()
 	xInset := float32(0)
 
 	if r.entry.ActionItem != nil {
@@ -1520,9 +1516,9 @@ func (r *entryRenderer) trailingInset() float32 {
 	}
 
 	if r.entry.Validator != nil {
-		iconSpace := th.Size(theme.SizeNameInlineIcon) + th.Size(theme.SizeNameLineSpacing)
+		iconSpace := theme.SizeForWidget(theme.SizeNameInlineIcon, r.entry) + theme.SizeForWidget(theme.SizeNameLineSpacing, r.entry)
 		if r.entry.ActionItem == nil {
-			xInset = iconSpace + th.Size(theme.SizeNameInnerPadding)
+			xInset = iconSpace + theme.SizeForWidget(theme.SizeNameInnerPadding, r.entry)
 		} else {
 			xInset += iconSpace
 		}
@@ -1532,11 +1528,10 @@ func (r *entryRenderer) trailingInset() float32 {
 }
 
 func (r *entryRenderer) Layout(size fyne.Size) {
-	th := r.entry.Theme()
-	borderSize := th.Size(theme.SizeNameInputBorder)
-	iconSize := th.Size(theme.SizeNameInlineIcon)
-	innerPad := th.Size(theme.SizeNameInnerPadding)
-	inputBorder := th.Size(theme.SizeNameInputBorder)
+	borderSize := theme.SizeForWidget(theme.SizeNameInputBorder, r.entry)
+	iconSize := theme.SizeForWidget(theme.SizeNameInlineIcon, r.entry)
+	innerPad := theme.SizeForWidget(theme.SizeNameInnerPadding, r.entry)
+	inputBorder := theme.SizeForWidget(theme.SizeNameInputBorder, r.entry)
 
 	// 0.5 is removed so on low DPI it rounds down on the trailing edge
 	r.border.Resize(fyne.NewSize(size.Width-borderSize-.5, size.Height-borderSize-.5))
@@ -1654,9 +1649,7 @@ func (r *entryRenderer) Refresh() {
 	r.entry.text.Refresh()
 	r.entry.placeholder.Refresh()
 
-	th := r.entry.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-	inputBorder := th.Size(theme.SizeNameInputBorder)
+	inputBorder := theme.SizeForWidget(theme.SizeNameInputBorder, r.entry)
 
 	// correct our scroll wrappers if the wrap mode changed
 	entrySize := r.entry.Size().Subtract(fyne.NewSize(r.trailingInset(), inputBorder*2))
@@ -1688,16 +1681,16 @@ func (r *entryRenderer) Refresh() {
 	}
 	r.entry.updateCursorAndSelection()
 
-	r.box.FillColor = th.Color(theme.ColorNameInputBackground, v)
-	r.box.CornerRadius = th.Size(theme.SizeNameInputRadius)
+	r.box.FillColor = theme.ColorForWidget(theme.ColorNameInputBackground, r.entry)
+	r.box.CornerRadius = theme.SizeForWidget(theme.SizeNameInputRadius, r.entry)
 	r.border.CornerRadius = r.box.CornerRadius
 	if focusedAppearance {
-		r.border.StrokeColor = th.Color(theme.ColorNamePrimary, v)
+		r.border.StrokeColor = theme.ColorForWidget(theme.ColorNamePrimary, r.entry)
 	} else {
 		if r.entry.Disabled() {
-			r.border.StrokeColor = th.Color(theme.ColorNameDisabled, v)
+			r.border.StrokeColor = theme.ColorForWidget(theme.ColorNameDisabled, r.entry)
 		} else {
-			r.border.StrokeColor = th.Color(theme.ColorNameInputBorder, v)
+			r.border.StrokeColor = theme.ColorForWidget(theme.ColorNameInputBorder, r.entry)
 		}
 	}
 	if r.entry.ActionItem != nil {
@@ -1706,7 +1699,7 @@ func (r *entryRenderer) Refresh() {
 
 	if r.entry.Validator != nil || r.entry.AlwaysShowValidationError {
 		if !r.entry.focused && !r.entry.Disabled() && (r.entry.dirty || r.entry.AlwaysShowValidationError) && r.entry.validationError != nil {
-			r.border.StrokeColor = th.Color(theme.ColorNameError, v)
+			r.border.StrokeColor = theme.ColorForWidget(theme.ColorNameError, r.entry)
 		}
 		r.ensureValidationSetup()
 		r.entry.validationStatus.Refresh()
@@ -1828,13 +1821,11 @@ func (r *entryContentRenderer) Refresh() {
 		placeholder.Hide()
 	}
 
-	th := r.content.entry.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 	if focusedAppearance {
 		if fyne.CurrentApp().Settings().ShowAnimations() {
 			r.content.entry.cursorAnim.start()
 		} else {
-			r.cursor.FillColor = th.Color(theme.ColorNamePrimary, v)
+			r.cursor.FillColor = theme.ColorForWidget(theme.ColorNamePrimary, r.content.entry)
 		}
 		r.cursor.Show()
 	} else {
diff --git a/widget/entry_password.go b/widget/entry_password.go
index d3c92ef2e5..e920087907 100644
--- a/widget/entry_password.go
+++ b/widget/entry_password.go
@@ -21,9 +21,8 @@ type passwordRevealer struct {
 }
 
 func newPasswordRevealer(e *Entry) *passwordRevealer {
-	th := e.Theme()
 	pr := &passwordRevealer{
-		icon:  canvas.NewImageFromResource(th.Icon(theme.IconNameVisibilityOff)),
+		icon:  canvas.NewImageFromResource(theme.IconForWidget(theme.IconNameVisibilityOff, e)),
 		entry: e,
 	}
 	pr.ExtendBaseWidget(pr)
@@ -62,22 +61,21 @@ type passwordRevealerRenderer struct {
 }
 
 func (r *passwordRevealerRenderer) Layout(size fyne.Size) {
-	iconSize := r.entry.Theme().Size(theme.SizeNameInlineIcon)
+	iconSize := theme.SizeForWidget(theme.SizeNameInlineIcon, r.entry)
 	r.icon.Resize(fyne.NewSquareSize(iconSize))
 	r.icon.Move(fyne.NewPos((size.Width-iconSize)/2, (size.Height-iconSize)/2))
 }
 
 func (r *passwordRevealerRenderer) MinSize() fyne.Size {
-	iconSize := r.entry.Theme().Size(theme.SizeNameInlineIcon)
-	return fyne.NewSquareSize(iconSize + r.entry.Theme().Size(theme.SizeNameInnerPadding)*2)
+	iconSize := theme.SizeForWidget(theme.SizeNameInlineIcon, r.entry)
+	return fyne.NewSquareSize(iconSize + theme.SizeForWidget(theme.SizeNameInnerPadding, r.entry)*2)
 }
 
 func (r *passwordRevealerRenderer) Refresh() {
-	th := r.entry.Theme()
 	if !r.entry.Password {
-		r.icon.Resource = th.Icon(theme.IconNameVisibility)
+		r.icon.Resource = theme.IconForWidget(theme.IconNameVisibility, r.entry)
 	} else {
-		r.icon.Resource = th.Icon(theme.IconNameVisibilityOff)
+		r.icon.Resource = theme.IconForWidget(theme.IconNameVisibilityOff, r.entry)
 	}
 
 	if r.entry.Disabled() {
diff --git a/widget/fileicon.go b/widget/fileicon.go
index 15524dd2d2..5cab2143c3 100644
--- a/widget/fileicon.go
+++ b/widget/fileicon.go
@@ -63,20 +63,17 @@ func (i *FileIcon) MinSize() fyne.Size {
 
 // CreateRenderer is a private method to Fyne which links this widget to its renderer
 func (i *FileIcon) CreateRenderer() fyne.WidgetRenderer {
-	th := i.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
 	i.ExtendBaseWidget(i)
 	i.setURI(i.URI)
 
 	// TODO remove background when `SetSelected` is gone.
-	background := canvas.NewRectangle(th.Color(theme.ColorNameSelection, v))
+	background := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameSelection, i))
 	background.Hide()
 
 	s := &fileIconRenderer{file: i, background: background}
 	s.img = canvas.NewImageFromResource(s.file.resource)
 	s.img.FillMode = canvas.ImageFillContain
-	s.ext = canvas.NewText(s.file.extension, th.Color(theme.ColorNameBackground, v))
+	s.ext = canvas.NewText(s.file.extension, theme.ColorForWidget(theme.ColorNameBackground, i))
 	s.ext.Alignment = fyne.TextAlignCenter
 
 	s.SetObjects([]fyne.CanvasObject{s.background, s.img, s.ext})
@@ -101,21 +98,20 @@ func (i *FileIcon) lookupIcon(uri fyne.URI) fyne.Resource {
 		return theme.FolderIcon()
 	}
 
-	th := i.Theme()
 	mainMimeType, _ := mime.Split(uri.MimeType())
 	switch mainMimeType {
 	case "application":
-		return th.Icon(theme.IconNameFileApplication)
+		return theme.IconForWidget(theme.IconNameFileApplication, i)
 	case "audio":
-		return th.Icon(theme.IconNameFileAudio)
+		return theme.IconForWidget(theme.IconNameFileAudio, i)
 	case "image":
-		return th.Icon(theme.IconNameFileImage)
+		return theme.IconForWidget(theme.IconNameFileImage, i)
 	case "text":
-		return th.Icon(theme.IconNameFileText)
+		return theme.IconForWidget(theme.IconNameFileText, i)
 	case "video":
-		return th.Icon(theme.IconNameFileVideo)
+		return theme.IconForWidget(theme.IconNameFileVideo, i)
 	default:
-		return th.Icon(theme.IconNameFile)
+		return theme.IconForWidget(theme.IconNameFile, i)
 	}
 }
 
@@ -144,8 +140,7 @@ type fileIconRenderer struct {
 }
 
 func (s *fileIconRenderer) MinSize() fyne.Size {
-	th := s.file.Theme()
-	return fyne.NewSquareSize(th.Size(theme.SizeNameInlineIcon))
+	return fyne.NewSquareSize(theme.SizeForWidget(theme.SizeNameInlineIcon, s.file))
 }
 
 func (s *fileIconRenderer) Layout(size fyne.Size) {
@@ -172,20 +167,17 @@ func (s *fileIconRenderer) Layout(size fyne.Size) {
 }
 
 func (s *fileIconRenderer) Refresh() {
-	th := s.file.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
 	s.file.setURI(s.file.URI)
 
 	if s.file.Selected {
 		s.background.Show()
-		s.ext.Color = th.Color(theme.ColorNameSelection, v)
+		s.ext.Color = theme.ColorForWidget(theme.ColorNameSelection, s.file)
 		if _, ok := s.img.Resource.(*theme.InvertedThemedResource); !ok {
 			s.img.Resource = theme.NewInvertedThemedResource(s.img.Resource)
 		}
 	} else {
 		s.background.Hide()
-		s.ext.Color = th.Color(theme.ColorNameBackground, v)
+		s.ext.Color = theme.ColorForWidget(theme.ColorNameBackground, s.file)
 		if res, ok := s.img.Resource.(*theme.InvertedThemedResource); ok {
 			s.img.Resource = res.Original()
 		}
diff --git a/widget/form.go b/widget/form.go
index 1d43528b48..6b7938e557 100644
--- a/widget/form.go
+++ b/widget/form.go
@@ -169,11 +169,8 @@ func (f *Form) createInput(item *FormItem) fyne.CanvasObject {
 		}
 	}
 
-	th := f.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
-	text := canvas.NewText(item.HintText, th.Color(theme.ColorNamePlaceHolder, v))
-	text.TextSize = th.Size(theme.SizeNameCaptionText)
+	text := canvas.NewText(item.HintText, theme.ColorForWidget(theme.ColorNamePlaceHolder, f))
+	text.TextSize = theme.SizeForWidget(theme.SizeNameCaptionText, f)
 	item.helperOutput = text
 	f.updateHelperText(item)
 	textContainer := &fyne.Container{Objects: []fyne.CanvasObject{text}}
@@ -194,13 +191,11 @@ func (f *Form) itemWidgetHasValidator(w fyne.CanvasObject) bool {
 }
 
 func (f *Form) createLabel(text string) fyne.CanvasObject {
-	th := f.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 	label := &canvas.Text{
 		Text:      text,
 		Alignment: fyne.TextAlignTrailing,
-		Color:     th.Color(theme.ColorNameForeground, v),
-		TextSize:  th.Size(theme.SizeNameText),
+		Color:     theme.ColorForWidget(theme.ColorNameForeground, f),
+		TextSize:  theme.SizeForWidget(theme.SizeNameText, f),
 		TextStyle: fyne.TextStyle{Bold: true},
 	}
 	if f.isVertical() {
@@ -347,9 +342,6 @@ func (f *Form) setValidationError(err error) {
 }
 
 func (f *Form) updateHelperText(item *FormItem) {
-	th := f.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
 	if item.helperOutput == nil {
 		return // testing probably, either way not rendered yet
 	}
@@ -365,10 +357,10 @@ func (f *Form) updateHelperText(item *FormItem) {
 
 	if item.validationError == nil || showHintIfError {
 		item.helperOutput.Text = item.HintText
-		item.helperOutput.Color = th.Color(theme.ColorNamePlaceHolder, v)
+		item.helperOutput.Color = theme.ColorForWidget(theme.ColorNamePlaceHolder, f)
 	} else {
 		item.helperOutput.Text = item.validationError.Error()
-		item.helperOutput.Color = th.Color(theme.ColorNameError, v)
+		item.helperOutput.Color = theme.ColorForWidget(theme.ColorNameError, f)
 	}
 
 	if item.helperOutput.Text == "" {
@@ -380,20 +372,17 @@ func (f *Form) updateHelperText(item *FormItem) {
 }
 
 func (f *Form) updateLabels() {
-	th := f.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
 	for i, item := range f.Items {
 		l := f.itemGrid.Objects[i*2].(*fyne.Container).Objects[0].(*canvas.Text)
-		l.TextSize = th.Size(theme.SizeNameText)
+		l.TextSize = theme.SizeForWidget(theme.SizeNameText, f)
 		if dis, ok := item.Widget.(fyne.Disableable); ok {
 			if dis.Disabled() {
-				l.Color = th.Color(theme.ColorNameDisabled, v)
+				l.Color = theme.ColorForWidget(theme.ColorNameDisabled, f)
 			} else {
-				l.Color = th.Color(theme.ColorNameForeground, v)
+				l.Color = theme.ColorForWidget(theme.ColorNameForeground, f)
 			}
 		} else {
-			l.Color = th.Color(theme.ColorNameForeground, v)
+			l.Color = theme.ColorForWidget(theme.ColorNameForeground, f)
 		}
 
 		l.Text = item.Text
@@ -410,9 +399,8 @@ func (f *Form) updateLabels() {
 // CreateRenderer is a private method to Fyne which links this widget to its renderer
 func (f *Form) CreateRenderer() fyne.WidgetRenderer {
 	f.ExtendBaseWidget(f)
-	th := f.Theme()
-	f.cancelButton = &Button{Icon: th.Icon(theme.IconNameCancel), OnTapped: f.OnCancel}
-	f.submitButton = &Button{Icon: th.Icon(theme.IconNameConfirm), OnTapped: f.OnSubmit, Importance: HighImportance}
+	f.cancelButton = &Button{Icon: theme.IconForWidget(theme.IconNameCancel, f), OnTapped: f.OnCancel}
+	f.submitButton = &Button{Icon: theme.IconForWidget(theme.IconNameConfirm, f), OnTapped: f.OnSubmit, Importance: HighImportance}
 	buttons := &fyne.Container{Layout: layout.NewGridLayoutWithRows(1), Objects: []fyne.CanvasObject{f.cancelButton, f.submitButton}}
 	f.buttonBox = &fyne.Container{Layout: layout.NewBorderLayout(nil, nil, nil, buttons), Objects: []fyne.CanvasObject{buttons}}
 	f.validationError = errFormItemInitialState // set initial state error to guarantee next error (if triggers) is always different
diff --git a/widget/gridwrap.go b/widget/gridwrap.go
index 7d144df9bb..f93b6a6d35 100644
--- a/widget/gridwrap.go
+++ b/widget/gridwrap.go
@@ -435,11 +435,9 @@ func newGridWrapItem(child fyne.CanvasObject, tapped func()) *gridWrapItem {
 // CreateRenderer is a private method to Fyne which links this widget to its renderer.
 func (gw *gridWrapItem) CreateRenderer() fyne.WidgetRenderer {
 	gw.ExtendBaseWidget(gw)
-	th := gw.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 
-	gw.background = canvas.NewRectangle(th.Color(theme.ColorNameHover, v))
-	gw.background.CornerRadius = th.Size(theme.SizeNameSelectionRadius)
+	gw.background = canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameHover, gw))
+	gw.background.CornerRadius = theme.SizeForWidget(theme.SizeNameSelectionRadius, gw)
 	gw.background.Hide()
 
 	objects := []fyne.CanvasObject{gw.background, gw.child}
@@ -500,15 +498,12 @@ func (gw *gridWrapItemRenderer) Layout(size fyne.Size) {
 }
 
 func (gw *gridWrapItemRenderer) Refresh() {
-	th := gw.item.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
-	gw.item.background.CornerRadius = th.Size(theme.SizeNameSelectionRadius)
+	gw.item.background.CornerRadius = theme.SizeForWidget(theme.SizeNameSelectionRadius, gw.item)
 	if gw.item.selected {
-		gw.item.background.FillColor = th.Color(theme.ColorNameSelection, v)
+		gw.item.background.FillColor = theme.ColorForWidget(theme.ColorNameSelection, gw.item)
 		gw.item.background.Show()
 	} else if gw.item.hovered {
-		gw.item.background.FillColor = th.Color(theme.ColorNameHover, v)
+		gw.item.background.FillColor = theme.ColorForWidget(theme.ColorNameHover, gw.item)
 		gw.item.background.Show()
 	} else {
 		gw.item.background.Hide()
diff --git a/widget/hyperlink.go b/widget/hyperlink.go
index c2d5c75cf2..41de4abdc3 100644
--- a/widget/hyperlink.go
+++ b/widget/hyperlink.go
@@ -69,13 +69,11 @@ func (hl *Hyperlink) CreateRenderer() fyne.WidgetRenderer {
 	hl.provider.ExtendBaseWidget(&hl.provider)
 	hl.syncSegments()
 
-	th := hl.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 	focus := canvas.NewRectangle(color.Transparent)
-	focus.StrokeColor = th.Color(theme.ColorNameFocus, v)
+	focus.StrokeColor = theme.ColorForWidget(theme.ColorNameFocus, hl)
 	focus.StrokeWidth = 2
 	focus.Hide()
-	under := canvas.NewRectangle(th.Color(theme.ColorNameHyperlink, v))
+	under := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameHyperlink, hl))
 	under.Hide()
 	return &hyperlinkRenderer{hl: hl, objects: []fyne.CanvasObject{&hl.provider, focus, under}, focus: focus, under: under}
 }
@@ -124,10 +122,8 @@ func (hl *Hyperlink) MouseOut() {
 }
 
 func (hl *Hyperlink) focusWidth() float32 {
-	th := hl.Theme()
-
-	innerPad := th.Size(theme.SizeNameInnerPadding)
-	return fyne.Min(hl.Size().Width, hl.textSize.Width+innerPad+th.Size(theme.SizeNamePadding)*2) - innerPad
+	innerPad := theme.SizeForWidget(theme.SizeNameInnerPadding, hl)
+	return fyne.Min(hl.Size().Width, hl.textSize.Width+innerPad+theme.SizeForWidget(theme.SizeNamePadding, hl)*2) - innerPad
 }
 
 func (hl *Hyperlink) focusXPos() float32 {
@@ -146,9 +142,8 @@ func (hl *Hyperlink) focusXPos() float32 {
 }
 
 func (hl *Hyperlink) isPosOverText(pos fyne.Position) bool {
-	th := hl.Theme()
-	innerPad := th.Size(theme.SizeNameInnerPadding)
-	pad := th.Size(theme.SizeNamePadding)
+	innerPad := theme.SizeForWidget(theme.SizeNameInnerPadding, hl)
+	pad := theme.SizeForWidget(theme.SizeNamePadding, hl)
 	lineCount := fyne.Max(1, float32(len(hl.provider.rowBounds)))
 
 	xpos := hl.focusXPos()
@@ -253,8 +248,6 @@ func (hl *Hyperlink) openURL() {
 }
 
 func (hl *Hyperlink) syncSegments() {
-	th := hl.Theme()
-
 	hl.provider.Wrapping = hl.Wrapping
 	hl.provider.Truncation = hl.Truncation
 
@@ -283,7 +276,7 @@ func (hl *Hyperlink) syncSegments() {
 		sizeName = theme.SizeNameText
 	}
 	hl.provider.Segments[0].(*TextSegment).Style.SizeName = sizeName
-	hl.textSize = fyne.MeasureText(hl.Text, th.Size(sizeName), hl.TextStyle)
+	hl.textSize = fyne.MeasureText(hl.Text, theme.SizeForWidget(sizeName, hl), hl.TextStyle)
 }
 
 var _ fyne.WidgetRenderer = (*hyperlinkRenderer)(nil)
@@ -326,13 +319,11 @@ func (r *hyperlinkRenderer) Objects() []fyne.CanvasObject {
 
 func (r *hyperlinkRenderer) Refresh() {
 	r.hl.provider.Refresh()
-	th := r.hl.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 
-	r.focus.StrokeColor = th.Color(theme.ColorNameFocus, v)
+	r.focus.StrokeColor = theme.ColorForWidget(theme.ColorNameFocus, r.hl)
 	r.focus.Hidden = !r.hl.focused
 	r.focus.Refresh()
-	r.under.FillColor = th.Color(theme.ColorNameHyperlink, v)
+	r.under.FillColor = theme.ColorForWidget(theme.ColorNameHyperlink, r.hl)
 	r.under.Hidden = !r.hl.hovered
 	r.under.Refresh()
 }
diff --git a/widget/list.go b/widget/list.go
index e1801ec2bd..83abc3a3dc 100644
--- a/widget/list.go
+++ b/widget/list.go
@@ -392,7 +392,7 @@ func (l *List) contentMinSize() fyne.Size {
 }
 
 // fills l.visibleRowHeights and also returns offY and minRow
-func (l *listLayout) calculateVisibleRowHeights(itemHeight float32, length int, th fyne.Theme) (offY float32, minRow int) {
+func (l *listLayout) calculateVisibleRowHeights(itemHeight float32, length int) (offY float32, minRow int) {
 	rowOffset := float32(0)
 	isVisible := false
 	l.visibleRowHeights = l.visibleRowHeights[:0]
@@ -401,7 +401,7 @@ func (l *listLayout) calculateVisibleRowHeights(itemHeight float32, length int,
 		return
 	}
 
-	padding := th.Size(theme.SizeNamePadding)
+	padding := theme.SizeForWidget(theme.SizeNamePadding, l.list)
 
 	if len(l.list.itemHeights) == 0 {
 		paddedItemHeight := itemHeight + padding
@@ -523,11 +523,9 @@ func newListItem(child fyne.CanvasObject, tapped func()) *listItem {
 // CreateRenderer is a private method to Fyne which links this widget to its renderer.
 func (li *listItem) CreateRenderer() fyne.WidgetRenderer {
 	li.ExtendBaseWidget(li)
-	th := li.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 
-	li.background = canvas.NewRectangle(th.Color(theme.ColorNameHover, v))
-	li.background.CornerRadius = th.Size(theme.SizeNameSelectionRadius)
+	li.background = canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameHover, li))
+	li.background.CornerRadius = theme.SizeForWidget(theme.SizeNameSelectionRadius, li)
 	li.background.Hide()
 
 	objects := []fyne.CanvasObject{li.background, li.child}
@@ -588,15 +586,12 @@ func (li *listItemRenderer) Layout(size fyne.Size) {
 }
 
 func (li *listItemRenderer) Refresh() {
-	th := li.item.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
-	li.item.background.CornerRadius = th.Size(theme.SizeNameSelectionRadius)
+	li.item.background.CornerRadius = theme.SizeForWidget(theme.SizeNameSelectionRadius, li.item)
 	if li.item.selected {
-		li.item.background.FillColor = th.Color(theme.ColorNameSelection, v)
+		li.item.background.FillColor = theme.ColorForWidget(theme.ColorNameSelection, li.item)
 		li.item.background.Show()
 	} else if li.item.hovered {
-		li.item.background.FillColor = th.Color(theme.ColorNameHover, v)
+		li.item.background.FillColor = theme.ColorForWidget(theme.ColorNameHover, li.item)
 		li.item.background.Show()
 	} else {
 		li.item.background.Hide()
@@ -692,8 +687,7 @@ func (l *listLayout) setupListItem(li *listItem, id ListItemID, focus bool) {
 }
 
 func (l *listLayout) updateList(newOnly bool) {
-	th := l.list.Theme()
-	separatorThickness := th.Size(theme.SizeNamePadding)
+	separatorThickness := theme.SizeForWidget(theme.SizeNamePadding, l.list)
 	width := l.list.Size().Width
 	length := 0
 	if f := l.list.Length; f != nil {
@@ -708,7 +702,7 @@ func (l *listLayout) updateList(newOnly bool) {
 	l.wasVisible = append(l.wasVisible, l.visible...)
 	l.visible = l.visible[:0]
 
-	offY, minRow := l.calculateVisibleRowHeights(l.list.itemMin.Height, length, th)
+	offY, minRow := l.calculateVisibleRowHeights(l.list.itemMin.Height, length)
 	if len(l.visibleRowHeights) == 0 && length > 0 { // we can't show anything until we have some dimensions
 		return
 	}
diff --git a/widget/menu.go b/widget/menu.go
index 68731df7f0..67b1e2329f 100644
--- a/widget/menu.go
+++ b/widget/menu.go
@@ -325,10 +325,7 @@ func newMenuBox(items []fyne.CanvasObject) *menuBox {
 }
 
 func (b *menuBox) CreateRenderer() fyne.WidgetRenderer {
-	th := b.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
-	background := canvas.NewRectangle(th.Color(theme.ColorNameMenuBackground, v))
+	background := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameMenuBackground, b))
 	cont := &fyne.Container{Layout: layout.NewVBoxLayout(), Objects: b.items}
 	return &menuBoxRenderer{
 		BaseRenderer: widget.NewBaseRenderer([]fyne.CanvasObject{background, cont}),
@@ -358,10 +355,7 @@ func (r *menuBoxRenderer) MinSize() fyne.Size {
 }
 
 func (r *menuBoxRenderer) Refresh() {
-	th := r.b.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
-	r.background.FillColor = th.Color(theme.ColorNameMenuBackground, v)
+	r.background.FillColor = theme.ColorForWidget(theme.ColorNameMenuBackground, r.b)
 	r.background.Refresh()
 	canvas.Refresh(r.b)
 }
diff --git a/widget/menu_item.go b/widget/menu_item.go
index b6b0cf41e0..c5da20a24f 100644
--- a/widget/menu_item.go
+++ b/widget/menu_item.go
@@ -45,21 +45,18 @@ func (i *menuItem) Child() *Menu {
 //
 // Implements: fyne.Widget
 func (i *menuItem) CreateRenderer() fyne.WidgetRenderer {
-	th := i.parent.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
-	background := canvas.NewRectangle(th.Color(theme.ColorNameHover, v))
-	background.CornerRadius = th.Size(theme.SizeNameSelectionRadius)
+	background := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameHover, i.parent))
+	background.CornerRadius = theme.SizeForWidget(theme.SizeNameSelectionRadius, i.parent)
 	background.Hide()
-	text := canvas.NewText(i.Item.Label, th.Color(theme.ColorNameForeground, v))
+	text := canvas.NewText(i.Item.Label, theme.ColorForWidget(theme.ColorNameForeground, i.parent))
 	text.Alignment = i.alignment
 	objects := []fyne.CanvasObject{background, text}
 	var expandIcon *canvas.Image
 	if i.Item.ChildMenu != nil {
-		expandIcon = canvas.NewImageFromResource(th.Icon(theme.IconNameMenuExpand))
+		expandIcon = canvas.NewImageFromResource(theme.IconForWidget(theme.IconNameMenuExpand, i.parent))
 		objects = append(objects, expandIcon)
 	}
-	checkIcon := canvas.NewImageFromResource(th.Icon(theme.IconNameConfirm))
+	checkIcon := canvas.NewImageFromResource(theme.IconForWidget(theme.IconNameConfirm, i.parent))
 	if !i.Item.Checked {
 		checkIcon.Hide()
 	}
@@ -70,7 +67,7 @@ func (i *menuItem) CreateRenderer() fyne.WidgetRenderer {
 	}
 	var shortcutTexts []*canvas.Text
 	if s, ok := i.Item.Shortcut.(fyne.KeyboardShortcut); ok {
-		shortcutTexts = textsForShortcut(s, th)
+		shortcutTexts = i.textsForShortcut(s)
 		for _, t := range shortcutTexts {
 			objects = append(objects, t)
 		}
@@ -289,13 +286,11 @@ func (r *menuItemRenderer) MinSize() fyne.Size {
 }
 
 func (r *menuItemRenderer) updateVisuals() {
-	th := r.i.parent.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-	r.background.CornerRadius = th.Size(theme.SizeNameSelectionRadius)
+	r.background.CornerRadius = theme.SizeForWidget(theme.SizeNameSelectionRadius, r.i.parent)
 	if fyne.CurrentDevice().IsMobile() {
 		r.background.Hide()
 	} else if r.i.isActive() {
-		r.background.FillColor = th.Color(theme.ColorNameFocus, v)
+		r.background.FillColor = theme.ColorForWidget(theme.ColorNameFocus, r.i.parent)
 		r.background.Show()
 	} else {
 		r.background.Hide()
@@ -312,8 +307,8 @@ func (r *menuItemRenderer) updateVisuals() {
 	} else {
 		r.checkIcon.Hide()
 	}
-	r.updateIcon(r.checkIcon, th.Icon(theme.IconNameConfirm))
-	r.updateIcon(r.expandIcon, th.Icon(theme.IconNameMenuExpand))
+	r.updateIcon(r.checkIcon, theme.IconForWidget(theme.IconNameConfirm, r.i.parent))
+	r.updateIcon(r.expandIcon, theme.IconForWidget(theme.IconNameMenuExpand, r.i.parent))
 	r.updateIcon(r.icon, r.i.Item.Icon)
 }
 
@@ -350,30 +345,26 @@ func (r *menuItemRenderer) updateIcon(img *canvas.Image, rsc fyne.Resource) {
 }
 
 func (r *menuItemRenderer) refreshText(text *canvas.Text, shortcut bool) {
-	th := r.i.parent.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
-	text.TextSize = th.Size(theme.SizeNameText)
+	text.TextSize = theme.SizeForWidget(theme.SizeNameText, r.i.parent)
 	if r.i.Item.Disabled {
-		text.Color = th.Color(theme.ColorNameDisabled, v)
+		text.Color = theme.ColorForWidget(theme.ColorNameDisabled, r.i.parent)
 	} else {
 		if shortcut {
-			text.Color = shortcutColor(th)
+			text.Color = r.i.shortcutColor()
 		} else {
-			text.Color = th.Color(theme.ColorNameForeground, v)
+			text.Color = theme.ColorForWidget(theme.ColorNameForeground, r.i.parent)
 		}
 	}
 	text.Refresh()
 }
 
-func shortcutColor(th fyne.Theme) color.Color {
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-	r, g, b, a := th.Color(theme.ColorNameForeground, v).RGBA()
+func (i *menuItem) shortcutColor() color.Color {
+	r, g, b, a := theme.ColorForWidget(theme.ColorNameForeground, i.parent).RGBA()
 	a = uint32(float32(a) * 0.95)
 	return color.NRGBA{R: uint8(r), G: uint8(g), B: uint8(b), A: uint8(a)}
 }
 
-func textsForShortcut(sc fyne.KeyboardShortcut, th fyne.Theme) (texts []*canvas.Text) {
+func (i *menuItem) textsForShortcut(sc fyne.KeyboardShortcut) (texts []*canvas.Text) {
 	// add modifier
 	b := strings.Builder{}
 	mods := sc.Mod()
@@ -389,7 +380,7 @@ func textsForShortcut(sc fyne.KeyboardShortcut, th fyne.Theme) (texts []*canvas.
 	if mods&fyne.KeyModifierSuper != 0 {
 		b.WriteString(textModifierSuper)
 	}
-	shortColor := shortcutColor(th)
+	shortColor := i.shortcutColor()
 	if b.Len() > 0 {
 		t := canvas.NewText(b.String(), shortColor)
 		t.TextStyle = styleModifiers
diff --git a/widget/popup.go b/widget/popup.go
index ec102b82cd..07e040baba 100644
--- a/widget/popup.go
+++ b/widget/popup.go
@@ -100,13 +100,10 @@ func (p *PopUp) MinSize() fyne.Size {
 
 // CreateRenderer is a private method to Fyne which links this widget to its renderer
 func (p *PopUp) CreateRenderer() fyne.WidgetRenderer {
-	th := p.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
 	p.ExtendBaseWidget(p)
-	background := canvas.NewRectangle(th.Color(theme.ColorNameOverlayBackground, v))
+	background := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameOverlayBackground, p))
 	if p.modal {
-		underlay := canvas.NewRectangle(th.Color(theme.ColorNameShadow, v))
+		underlay := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameShadow, p))
 		objects := []fyne.CanvasObject{underlay, background, p.Content}
 		return &modalPopUpRenderer{
 			widget.NewShadowingRenderer(objects, widget.DialogLevel),
@@ -227,9 +224,7 @@ func (r *popUpRenderer) MinSize() fyne.Size {
 }
 
 func (r *popUpRenderer) Refresh() {
-	th := r.popUp.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-	r.background.FillColor = th.Color(theme.ColorNameOverlayBackground, v)
+	r.background.FillColor = theme.ColorForWidget(theme.ColorNameOverlayBackground, r.popUp)
 	expectedContentSize := r.popUp.innerSize.Max(r.popUp.MinSize()).Subtract(r.padding())
 	shouldRelayout := r.popUp.Content.Size() != expectedContentSize
 
@@ -274,10 +269,8 @@ func (r *modalPopUpRenderer) MinSize() fyne.Size {
 }
 
 func (r *modalPopUpRenderer) Refresh() {
-	th := r.popUp.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-	r.underlay.FillColor = th.Color(theme.ColorNameShadow, v)
-	r.background.FillColor = th.Color(theme.ColorNameOverlayBackground, v)
+	r.underlay.FillColor = theme.ColorForWidget(theme.ColorNameShadow, r.popUp)
+	r.background.FillColor = theme.ColorForWidget(theme.ColorNameOverlayBackground, r.popUp)
 	expectedContentSize := r.popUp.innerSize.Max(r.popUp.MinSize()).Subtract(r.padding())
 	shouldLayout := r.popUp.Content.Size() != expectedContentSize
 
diff --git a/widget/progressbar.go b/widget/progressbar.go
index f655bff56b..6c154627f2 100644
--- a/widget/progressbar.go
+++ b/widget/progressbar.go
@@ -72,18 +72,15 @@ func (p *progressRenderer) Layout(size fyne.Size) {
 
 // applyTheme updates the progress bar to match the current theme
 func (p *progressRenderer) applyTheme() {
-	th := p.progress.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
-	primaryColor := th.Color(theme.ColorNamePrimary, v)
-	inputRadius := th.Size(theme.SizeNameInputRadius)
+	primaryColor := theme.ColorForWidget(theme.ColorNamePrimary, p.progress)
+	inputRadius := theme.SizeForWidget(theme.SizeNameInputRadius, p.progress)
 
 	p.background.FillColor = progressBlendColor(primaryColor)
 	p.background.CornerRadius = inputRadius
 	p.bar.FillColor = primaryColor
 	p.bar.CornerRadius = inputRadius
-	p.label.Color = th.Color(theme.ColorNameForegroundOnPrimary, v)
-	p.label.TextSize = th.Size(theme.SizeNameText)
+	p.label.Color = theme.ColorForWidget(theme.ColorNameForegroundOnPrimary, p.progress)
+	p.label.TextSize = theme.SizeForWidget(theme.SizeNameText, p.progress)
 }
 
 func (p *progressRenderer) Refresh() {
diff --git a/widget/progressbarinfinite.go b/widget/progressbarinfinite.go
index 389699f08c..e0a8c992e1 100644
--- a/widget/progressbarinfinite.go
+++ b/widget/progressbarinfinite.go
@@ -74,10 +74,8 @@ func (p *infProgressRenderer) Refresh() {
 		return
 	}
 
-	th := p.progress.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-	cornerRadius := th.Size(theme.SizeNameInputRadius)
-	primaryColor := th.Color(theme.ColorNamePrimary, v)
+	cornerRadius := theme.SizeForWidget(theme.SizeNameInputRadius, p.progress)
+	primaryColor := theme.ColorForWidget(theme.ColorNamePrimary, p.progress)
 
 	p.background.FillColor = progressBlendColor(primaryColor)
 	p.background.CornerRadius = cornerRadius
@@ -167,11 +165,9 @@ func (p *ProgressBarInfinite) MinSize() fyne.Size {
 // CreateRenderer is a private method to Fyne which links this widget to its renderer
 func (p *ProgressBarInfinite) CreateRenderer() fyne.WidgetRenderer {
 	p.ExtendBaseWidget(p)
-	th := p.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 
-	primaryColor := th.Color(theme.ColorNamePrimary, v)
-	cornerRadius := th.Size(theme.SizeNameInputRadius)
+	primaryColor := theme.ColorForWidget(theme.ColorNamePrimary, p)
+	cornerRadius := theme.SizeForWidget(theme.SizeNameInputRadius, p)
 
 	render := &infProgressRenderer{
 		background: canvas.Rectangle{
diff --git a/widget/radio_item.go b/widget/radio_item.go
index df7bd0eecc..7d947dadb0 100644
--- a/widget/radio_item.go
+++ b/widget/radio_item.go
@@ -181,20 +181,17 @@ func (r *radioItemRenderer) Refresh() {
 }
 
 func (r *radioItemRenderer) update() {
-	th := r.item.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
 	r.label.Text = r.item.Label
-	r.label.TextSize = th.Size(theme.SizeNameText)
+	r.label.TextSize = theme.SizeForWidget(theme.SizeNameText, r.item)
 	if r.item.Disabled() {
-		r.label.Color = th.Color(theme.ColorNameDisabled, v)
+		r.label.Color = theme.ColorForWidget(theme.ColorNameDisabled, r.item)
 	} else {
-		r.label.Color = th.Color(theme.ColorNameForeground, v)
+		r.label.Color = theme.ColorForWidget(theme.ColorNameForeground, r.item)
 	}
 
-	out := theme.NewThemedResource(th.Icon(theme.IconNameRadioButton))
+	out := theme.NewThemedResource(theme.IconForWidget(theme.IconNameRadioButton, r.item))
 	out.ColorName = theme.ColorNameInputBorder
-	in := theme.NewThemedResource(th.Icon(theme.IconNameRadioButtonFill))
+	in := theme.NewThemedResource(theme.IconForWidget(theme.IconNameRadioButtonFill, r.item))
 	in.ColorName = theme.ColorNameInputBackground
 	if r.item.Selected {
 		in.ColorName = theme.ColorNamePrimary
@@ -216,9 +213,9 @@ func (r *radioItemRenderer) update() {
 	if r.item.Disabled() {
 		r.focusIndicator.FillColor = color.Transparent
 	} else if r.item.focused {
-		r.focusIndicator.FillColor = th.Color(theme.ColorNameFocus, v)
+		r.focusIndicator.FillColor = theme.ColorForWidget(theme.ColorNameFocus, r.item)
 	} else if r.item.hovered {
-		r.focusIndicator.FillColor = th.Color(theme.ColorNameHover, v)
+		r.focusIndicator.FillColor = theme.ColorForWidget(theme.ColorNameHover, r.item)
 	} else {
 		r.focusIndicator.FillColor = color.Transparent
 	}
diff --git a/widget/select.go b/widget/select.go
index d0cd32ef20..a6085384ac 100644
--- a/widget/select.go
+++ b/widget/select.go
@@ -87,15 +87,13 @@ func (s *Select) ClearSelected() {
 // CreateRenderer is a private method to Fyne which links this widget to its renderer
 func (s *Select) CreateRenderer() fyne.WidgetRenderer {
 	s.ExtendBaseWidget(s)
-	th := s.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 
-	icon := NewIcon(th.Icon(theme.IconNameArrowDropDown))
+	icon := NewIcon(theme.IconForWidget(theme.IconNameArrowDropDown, s))
 	if s.PlaceHolder == "" {
 		s.PlaceHolder = defaultPlaceHolder
 	}
 	txtProv := NewRichTextWithText(s.Selected)
-	txtProv.inset = fyne.NewSquareSize(th.Size(theme.SizeNamePadding))
+	txtProv.inset = fyne.NewSquareSize(theme.SizeForWidget(theme.SizeNamePadding, s))
 	txtProv.ExtendBaseWidget(txtProv)
 	txtProv.Truncation = fyne.TextTruncateEllipsis
 	if s.Disabled() {
@@ -104,13 +102,13 @@ func (s *Select) CreateRenderer() fyne.WidgetRenderer {
 
 	background := &canvas.Rectangle{}
 	tapBG := canvas.NewRectangle(color.Transparent)
-	s.tapAnim = newButtonTapAnimation(tapBG, s, th)
+	s.tapAnim = newButtonTapAnimation(tapBG, s)
 	s.tapAnim.Curve = fyne.AnimationEaseOut
 	objects := []fyne.CanvasObject{background, tapBG, txtProv, icon}
 	r := &selectRenderer{icon, txtProv, background, objects, s}
-	background.FillColor = r.bgColor(th, v)
-	background.CornerRadius = th.Size(theme.SizeNameInputRadius)
-	r.updateIcon(th)
+	background.FillColor = r.bgColor()
+	background.CornerRadius = theme.SizeForWidget(theme.SizeNameInputRadius, s)
+	r.updateIcon()
 	r.updateLabel()
 	return r
 }
@@ -410,12 +408,9 @@ func (s *selectRenderer) MinSize() fyne.Size {
 }
 
 func (s *selectRenderer) Refresh() {
-	th := s.combo.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
 	s.updateLabel()
-	s.updateIcon(th)
-	s.background.FillColor = s.bgColor(th, v)
+	s.updateIcon()
+	s.background.FillColor = s.bgColor()
 	s.background.CornerRadius = s.combo.Theme().Size(theme.SizeNameInputRadius)
 
 	s.Layout(s.combo.Size())
@@ -429,21 +424,21 @@ func (s *selectRenderer) Refresh() {
 	canvas.Refresh(s.combo.super())
 }
 
-func (s *selectRenderer) bgColor(th fyne.Theme, v fyne.ThemeVariant) color.Color {
+func (s *selectRenderer) bgColor() color.Color {
 	if s.combo.Disabled() {
-		return th.Color(theme.ColorNameDisabledButton, v)
+		return theme.ColorForWidget(theme.ColorNameDisabledButton, s.combo)
 	}
 	if s.combo.focused {
-		return th.Color(theme.ColorNameFocus, v)
+		return theme.ColorForWidget(theme.ColorNameFocus, s.combo)
 	}
 	if s.combo.hovered {
-		return th.Color(theme.ColorNameHover, v)
+		return theme.ColorForWidget(theme.ColorNameHover, s.combo)
 	}
-	return th.Color(theme.ColorNameInputBackground, v)
+	return theme.ColorForWidget(theme.ColorNameInputBackground, s.combo)
 }
 
-func (s *selectRenderer) updateIcon(th fyne.Theme) {
-	icon := th.Icon(theme.IconNameArrowDropDown)
+func (s *selectRenderer) updateIcon() {
+	icon := theme.IconForWidget(theme.IconNameArrowDropDown, s.combo)
 	if s.combo.Disabled() {
 		s.icon.Resource = theme.NewDisabledResource(icon)
 	} else {
diff --git a/widget/separator.go b/widget/separator.go
index 30d9433156..f30a13ed75 100644
--- a/widget/separator.go
+++ b/widget/separator.go
@@ -33,13 +33,11 @@ func NewSeparator() *Separator {
 // Implements: fyne.Widget
 func (s *Separator) CreateRenderer() fyne.WidgetRenderer {
 	s.ExtendBaseWidget(s)
-	th := s.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 	var col color.Color
 	if s.invert {
-		col = th.Color(theme.ColorNameForeground, v)
+		col = theme.ColorForWidget(theme.ColorNameForeground, s)
 	} else {
-		col = th.Color(theme.ColorNameSeparator, v)
+		col = theme.ColorForWidget(theme.ColorNameSeparator, s)
 	}
 	bar := canvas.NewRectangle(col)
 
@@ -71,13 +69,10 @@ func (r *separatorRenderer) MinSize() fyne.Size {
 }
 
 func (r *separatorRenderer) Refresh() {
-	th := r.d.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
 	if r.d.invert {
-		r.bar.FillColor = th.Color(theme.ColorNameForeground, v)
+		r.bar.FillColor = theme.ColorForWidget(theme.ColorNameForeground, r.d)
 	} else {
-		r.bar.FillColor = th.Color(theme.ColorNameSeparator, v)
+		r.bar.FillColor = theme.ColorForWidget(theme.ColorNameSeparator, r.d)
 	}
 	canvas.Refresh(r.d)
 }
diff --git a/widget/slider.go b/widget/slider.go
index 8d870177d8..47c160ddd9 100644
--- a/widget/slider.go
+++ b/widget/slider.go
@@ -349,12 +349,10 @@ func (s *Slider) Disabled() bool {
 // CreateRenderer links this widget to its renderer.
 func (s *Slider) CreateRenderer() fyne.WidgetRenderer {
 	s.ExtendBaseWidget(s)
-	th := s.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 
-	track := canvas.NewRectangle(th.Color(theme.ColorNameInputBackground, v))
-	active := canvas.NewRectangle(th.Color(theme.ColorNameForeground, v))
-	thumb := &canvas.Circle{FillColor: th.Color(theme.ColorNameForeground, v)}
+	track := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameInputBackground, s))
+	active := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameForeground, s))
+	thumb := &canvas.Circle{FillColor: theme.ColorForWidget(theme.ColorNameForeground, s)}
 	focusIndicator := &canvas.Circle{FillColor: color.Transparent}
 
 	objects := []fyne.CanvasObject{track, active, thumb, focusIndicator}
@@ -428,21 +426,18 @@ type sliderRenderer struct {
 
 // Refresh updates the widget state for drawing.
 func (s *sliderRenderer) Refresh() {
-	th := s.slider.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
-	s.track.FillColor = th.Color(theme.ColorNameInputBackground, v)
+	s.track.FillColor = theme.ColorForWidget(theme.ColorNameInputBackground, s.slider)
 	if s.slider.disabled {
-		s.thumb.FillColor = th.Color(theme.ColorNameDisabled, v)
+		s.thumb.FillColor = theme.ColorForWidget(theme.ColorNameDisabled, s.slider)
 	} else {
-		s.thumb.FillColor = th.Color(theme.ColorNameForeground, v)
+		s.thumb.FillColor = theme.ColorForWidget(theme.ColorNameForeground, s.slider)
 	}
 	s.active.FillColor = s.thumb.FillColor
 
 	if s.slider.focused && !s.slider.disabled {
-		s.focusIndicator.FillColor = th.Color(theme.ColorNameFocus, v)
+		s.focusIndicator.FillColor = theme.ColorForWidget(theme.ColorNameFocus, s.slider)
 	} else if s.slider.hovered && !s.slider.disabled {
-		s.focusIndicator.FillColor = th.Color(theme.ColorNameHover, v)
+		s.focusIndicator.FillColor = theme.ColorForWidget(theme.ColorNameHover, s.slider)
 	} else {
 		s.focusIndicator.FillColor = color.Transparent
 	}
diff --git a/widget/table.go b/widget/table.go
index 16f2501ba8..70f95e31c1 100644
--- a/widget/table.go
+++ b/widget/table.go
@@ -1164,18 +1164,16 @@ func newTableCells(t *Table) *tableCells {
 }
 
 func (c *tableCells) CreateRenderer() fyne.WidgetRenderer {
-	th := c.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-	marker := canvas.NewRectangle(th.Color(theme.ColorNameSelection, v))
-	marker.CornerRadius = th.Size(theme.SizeNameSelectionRadius)
-	hover := canvas.NewRectangle(th.Color(theme.ColorNameHover, v))
-	hover.CornerRadius = th.Size(theme.SizeNameSelectionRadius)
+	marker := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameSelection, c))
+	marker.CornerRadius = theme.SizeForWidget(theme.SizeNameSelectionRadius, c)
+	hover := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameHover, c))
+	hover.CornerRadius = theme.SizeForWidget(theme.SizeNameSelectionRadius, c)
 
 	r := &tableCellsRenderer{
 		cells:   c,
 		visible: make(map[TableCellID]fyne.CanvasObject), headers: make(map[TableCellID]fyne.CanvasObject),
-		headRowBG: canvas.NewRectangle(th.Color(theme.ColorNameHeaderBackground, v)), headColBG: canvas.NewRectangle(theme.Color(theme.ColorNameHeaderBackground)),
-		headRowStickyBG: canvas.NewRectangle(th.Color(theme.ColorNameHeaderBackground, v)), headColStickyBG: canvas.NewRectangle(theme.Color(theme.ColorNameHeaderBackground)),
+		headRowBG: canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameHeaderBackground, c)), headColBG: canvas.NewRectangle(theme.Color(theme.ColorNameHeaderBackground)),
+		headRowStickyBG: canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameHeaderBackground, c)), headColStickyBG: canvas.NewRectangle(theme.Color(theme.ColorNameHeaderBackground)),
 		marker: marker, hover: hover,
 	}
 
@@ -1267,10 +1265,7 @@ func (r *tableCellsRenderer) Refresh() {
 }
 
 func (r *tableCellsRenderer) refreshForID(toDraw TableCellID) {
-	th := r.cells.t.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
-	separatorThickness := th.Size(theme.SizeNamePadding)
+	separatorThickness := theme.SizeForWidget(theme.SizeNamePadding, r.cells.t)
 	dataRows, dataCols := 0, 0
 	if f := r.cells.t.Length; f != nil {
 		dataRows, dataCols = r.cells.t.Length()
@@ -1347,7 +1342,7 @@ func (r *tableCellsRenderer) refreshForID(toDraw TableCellID) {
 	}
 
 	inline := r.refreshHeaders(visibleRowHeights, visibleColWidths, offX, offY, startRow, maxRow, startCol, maxCol,
-		separatorThickness, th, v)
+		separatorThickness)
 	cells = append(cells, inline...)
 
 	offX -= r.cells.t.content.Offset.X
@@ -1390,11 +1385,11 @@ func (r *tableCellsRenderer) refreshForID(toDraw TableCellID) {
 	}
 
 	r.moveIndicators()
-	r.marker.FillColor = th.Color(theme.ColorNameSelection, v)
-	r.marker.CornerRadius = th.Size(theme.SizeNameSelectionRadius)
+	r.marker.FillColor = theme.ColorForWidget(theme.ColorNameSelection, r.cells.t)
+	r.marker.CornerRadius = theme.SizeForWidget(theme.SizeNameSelectionRadius, r.cells.t)
 	r.marker.Refresh()
-	r.hover.FillColor = th.Color(theme.ColorNameHover, v)
-	r.hover.CornerRadius = th.Size(theme.SizeNameSelectionRadius)
+	r.hover.FillColor = theme.ColorForWidget(theme.ColorNameHover, r.cells.t)
+	r.hover.CornerRadius = theme.SizeForWidget(theme.SizeNameSelectionRadius, r.cells.t)
 	r.hover.Refresh()
 }
 
@@ -1607,7 +1602,7 @@ func (r *tableCellsRenderer) moveMarker(marker fyne.CanvasObject, row, col int,
 }
 
 func (r *tableCellsRenderer) refreshHeaders(visibleRowHeights, visibleColWidths map[int]float32, offX, offY float32,
-	startRow, maxRow, startCol, maxCol int, separatorThickness float32, th fyne.Theme, v fyne.ThemeVariant,
+	startRow, maxRow, startCol, maxCol int, separatorThickness float32,
 ) []fyne.CanvasObject {
 	wasVisible := r.headers
 	r.headers = make(map[TableCellID]fyne.CanvasObject)
@@ -1701,18 +1696,19 @@ func (r *tableCellsRenderer) refreshHeaders(visibleRowHeights, visibleColWidths
 	r.cells.t.left.Content.(*fyne.Container).Objects = over
 	r.cells.t.left.Content.Refresh()
 
+	table := r.cells.t
 	r.headColBG.Hidden = !r.cells.t.ShowHeaderColumn
-	r.headColBG.FillColor = th.Color(theme.ColorNameHeaderBackground, v)
+	r.headColBG.FillColor = theme.ColorForWidget(theme.ColorNameHeaderBackground, table)
 	r.headColBG.Resize(fyne.NewSize(colWidth, r.cells.t.Size().Height))
 
 	r.headColStickyBG.Hidden = !r.cells.t.ShowHeaderColumn
-	r.headColStickyBG.FillColor = th.Color(theme.ColorNameHeaderBackground, v)
+	r.headColStickyBG.FillColor = theme.ColorForWidget(theme.ColorNameHeaderBackground, table)
 	r.headColStickyBG.Resize(fyne.NewSize(colWidth, r.cells.t.stuckHeight+rowHeight))
 	r.headRowBG.Hidden = !r.cells.t.ShowHeaderRow
-	r.headRowBG.FillColor = th.Color(theme.ColorNameHeaderBackground, v)
+	r.headRowBG.FillColor = theme.ColorForWidget(theme.ColorNameHeaderBackground, table)
 	r.headRowBG.Resize(fyne.NewSize(r.cells.t.Size().Width, rowHeight))
 	r.headRowStickyBG.Hidden = !r.cells.t.ShowHeaderRow
-	r.headRowStickyBG.FillColor = th.Color(theme.ColorNameHeaderBackground, v)
+	r.headRowStickyBG.FillColor = theme.ColorForWidget(theme.ColorNameHeaderBackground, table)
 	r.headRowStickyBG.Resize(fyne.NewSize(r.cells.t.stuckWidth+colWidth, rowHeight))
 	r.cells.t.corner.Content.(*fyne.Container).Objects = corner
 	r.cells.t.corner.Content.Refresh()
diff --git a/widget/textgrid.go b/widget/textgrid.go
index de828fe8df..41cd728283 100644
--- a/widget/textgrid.go
+++ b/widget/textgrid.go
@@ -359,10 +359,8 @@ func (t *TextGrid) SetStyleRange(startRow, startCol, endRow, endCol int, style T
 func (t *TextGrid) CreateRenderer() fyne.WidgetRenderer {
 	t.ExtendBaseWidget(t)
 
-	th := t.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
 	TextGridStyleDefault = &CustomTextGridStyle{}
-	TextGridStyleWhitespace = &CustomTextGridStyle{FGColor: th.Color(theme.ColorNameDisabled, v)}
+	TextGridStyleWhitespace = &CustomTextGridStyle{FGColor: theme.ColorForWidget(theme.ColorNameDisabled, t)}
 
 	var scroll *widget.Scroll
 	content := newTextGridContent(t)
@@ -663,10 +661,7 @@ func (t *textGridRow) setRow(row int) {
 }
 
 func (t *textGridRow) appendTextCell(str rune) {
-	th := t.text.text.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
-	text := canvas.NewText(string(str), th.Color(theme.ColorNameForeground, v))
+	text := canvas.NewText(string(str), theme.ColorForWidget(theme.ColorNameForeground, t.text.text))
 	text.TextStyle.Monospace = true
 
 	bg := canvas.NewRectangle(color.Transparent)
@@ -698,10 +693,8 @@ func (t *textGridRow) setCellRune(str rune, pos int, style, rowStyle TextGridSty
 	text := t.objects[pos*3+1].(*canvas.Text)
 	underline := t.objects[pos*3+2].(*canvas.Line)
 
-	th := t.text.text.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-	fg := th.Color(theme.ColorNameForeground, v)
-	text.TextSize = th.Size(theme.SizeNameText)
+	fg := theme.ColorForWidget(theme.ColorNameForeground, t.text.text)
+	text.TextSize = theme.SizeForWidget(theme.SizeNameText, t.text.text)
 
 	var underlineStrokeWidth float32 = 1
 	var underlineStrokeColor color.Color = color.Transparent
@@ -897,9 +890,7 @@ func (t *textGridRowRenderer) MinSize() fyne.Size {
 }
 
 func (t *textGridRowRenderer) Refresh() {
-	th := t.obj.text.text.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-	TextGridStyleWhitespace = &CustomTextGridStyle{FGColor: th.Color(theme.ColorNameDisabled, v)}
+	TextGridStyleWhitespace = &CustomTextGridStyle{FGColor: theme.ColorForWidget(theme.ColorNameDisabled, t.obj.text.text)}
 	t.obj.updateGridSize(t.obj.text.text.Size())
 	t.obj.refreshCells()
 }
diff --git a/widget/tree.go b/widget/tree.go
index 73d9f22066..376efa297c 100644
--- a/widget/tree.go
+++ b/widget/tree.go
@@ -857,11 +857,8 @@ func (n *treeNode) Content() fyne.CanvasObject {
 }
 
 func (n *treeNode) CreateRenderer() fyne.WidgetRenderer {
-	th := n.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
-	background := canvas.NewRectangle(th.Color(theme.ColorNameHover, v))
-	background.CornerRadius = th.Size(theme.SizeNameSelectionRadius)
+	background := canvas.NewRectangle(theme.ColorForWidget(theme.ColorNameHover, n))
+	background.CornerRadius = theme.SizeForWidget(theme.SizeNameSelectionRadius, n)
 	background.Hide()
 	return &treeNodeRenderer{
 		BaseRenderer: widget.BaseRenderer{},
@@ -980,18 +977,15 @@ func (r *treeNodeRenderer) Refresh() {
 }
 
 func (r *treeNodeRenderer) partialRefresh() {
-	th := r.treeNode.Theme()
-	v := fyne.CurrentApp().Settings().ThemeVariant()
-
 	if r.treeNode.icon != nil {
 		r.treeNode.icon.Refresh()
 	}
-	r.background.CornerRadius = th.Size(theme.SizeNameSelectionRadius)
+	r.background.CornerRadius = theme.SizeForWidget(theme.SizeNameSelectionRadius, r.treeNode)
 	if len(r.treeNode.tree.selected) > 0 && r.treeNode.uid == r.treeNode.tree.selected[0] {
-		r.background.FillColor = th.Color(theme.ColorNameSelection, v)
+		r.background.FillColor = theme.ColorForWidget(theme.ColorNameSelection, r.treeNode)
 		r.background.Show()
 	} else if r.treeNode.hovered || (r.treeNode.tree.focused && r.treeNode.tree.currentFocus == r.treeNode.uid) {
-		r.background.FillColor = th.Color(theme.ColorNameHover, v)
+		r.background.FillColor = theme.ColorForWidget(theme.ColorNameHover, r.treeNode)
 		r.background.Show()
 	} else {
 		r.background.Hide()