1 files changed, 24 insertions, 115 deletions

diff --git a/ui/iconprovider.go b/ui/iconprovider.go
index e1bee869..ac373d90 100644
--- a/ui/iconprovider.go
+++ b/ui/iconprovider.go
@@ -14,51 +14,26 @@ import (
 	"path"
 )
 
-type rectAndState struct {
-	size  walk.Rectangle
-	state service.TunnelState
-}
-
 type IconProvider struct {
-	wireguardIcon        *walk.Icon
-	imagesByRectAndState map[rectAndState]*walk.Bitmap
-	iconsByState         map[service.TunnelState]*walk.Icon
-	scale                float64
+	wireguardIcon       *walk.Icon
+	overlayIconsByState map[service.TunnelState]*walk.Icon
 }
 
-func NewIconProvider(dpi int) (*IconProvider, error) {
-	tsip := &IconProvider{
-		imagesByRectAndState: make(map[rectAndState]*walk.Bitmap),
-		iconsByState:         make(map[service.TunnelState]*walk.Icon),
-		scale:                float64(dpi) / 96.0,
-	}
-
+func NewIconProvider() (*IconProvider, error) {
+	tsip := &IconProvider{overlayIconsByState: make(map[service.TunnelState]*walk.Icon)}
 	var err error
-
-	var disposables walk.Disposables
-	defer disposables.Treat()
-
 	if tsip.wireguardIcon, err = walk.NewIconFromResource("$wireguard.ico"); err != nil {
 		return nil, err
 	}
-	disposables.Add(tsip.wireguardIcon)
-
-	disposables.Spare()
 	return tsip, nil
 }
 
 func (tsip *IconProvider) Dispose() {
-	if tsip.imagesByRectAndState != nil {
-		for _, img := range tsip.imagesByRectAndState {
-			img.Dispose()
-		}
-		tsip.imagesByRectAndState = nil
-	}
-	if tsip.iconsByState != nil {
-		for _, icon := range tsip.iconsByState {
+	if tsip.overlayIconsByState != nil {
+		for _, icon := range tsip.overlayIconsByState {
 			icon.Dispose()
 		}
-		tsip.iconsByState = nil
+		tsip.overlayIconsByState = nil
 	}
 	if tsip.wireguardIcon != nil {
 		tsip.wireguardIcon.Dispose()
@@ -66,48 +41,8 @@ func (tsip *IconProvider) Dispose() {
 	}
 }
 
-func (tsip *IconProvider) scaleForDPI(i int) int {
-	return int(tsip.scale * float64(i))
-}
-
-func (tsip *IconProvider) ImageForTunnel(tunnel *service.Tunnel, size walk.Size) (*walk.Bitmap, error) {
-	state, err := tunnel.State()
-	if err != nil {
-		return nil, err
-	}
-
-	return tsip.ImageForState(state, walk.Rectangle{0, 0, size.Width, size.Height})
-}
-
-func (tsip *IconProvider) ImageForState(state service.TunnelState, rect walk.Rectangle) (*walk.Bitmap, error) {
-	key := rectAndState{rect, state}
-
-	if img, ok := tsip.imagesByRectAndState[key]; ok {
-		return img, nil
-	}
-
-	img, err := walk.NewBitmapWithTransparentPixels(rect.Size())
-	if err != nil {
-		return nil, err
-	}
-
-	canvas, err := walk.NewCanvasFromImage(img)
-	if err != nil {
-		return nil, err
-	}
-	defer canvas.Dispose()
-
-	if err := tsip.PaintForState(state, canvas, rect); err != nil {
-		return nil, err
-	}
-
-	tsip.imagesByRectAndState[key] = img
-
-	return img, nil
-}
-
 func (tsip *IconProvider) IconWithOverlayForState(state service.TunnelState) (*walk.Icon, error) {
-	if icon, ok := tsip.iconsByState[state]; ok {
+	if icon, ok := tsip.overlayIconsByState[state]; ok {
 		return icon, nil
 	}
 
@@ -129,67 +64,41 @@ func (tsip *IconProvider) IconWithOverlayForState(state service.TunnelState) (*w
 		return nil, err
 	}
 
-	w := int(float64(size.Width) * 0.75)
-	h := int(float64(size.Height) * 0.75)
-	margin := tsip.scaleForDPI(2)
-	bounds := walk.Rectangle{margin + size.Width - w, margin + size.Height - h, w, h}
-
-	if err := tsip.PaintForState(state, canvas, bounds); err != nil {
+	overlayIcon, err := tsip.IconForState(state)
+	if err != nil {
 		return nil, err
 	}
+	defer overlayIcon.Dispose()
 
+	w := int(float64(size.Width) * 0.65)
+	h := int(float64(size.Height) * 0.65)
+	bounds := walk.Rectangle{size.Width - w, size.Height - h, w, h}
+
+	if err := canvas.DrawImageStretched(overlayIcon, bounds); err != nil {
+		return nil, err
+	}
 	canvas.Dispose()
 
 	icon, err := walk.NewIconFromBitmap(bmp)
 	if err != nil {
 		return nil, err
 	}
-
-	tsip.iconsByState[state] = icon
-
+	tsip.overlayIconsByState[state] = icon
 	return icon, nil
 }
 
-func (tsip *IconProvider) PaintForTunnel(tunnel *service.Tunnel, canvas *walk.Canvas, bounds walk.Rectangle) error {
-	state, err := tunnel.State()
-	if err != nil {
-		return err
-	}
-
-	return tsip.PaintForState(state, canvas, bounds)
-}
-
-func (tsip *IconProvider) PaintForState(state service.TunnelState, canvas *walk.Canvas, bounds walk.Rectangle) error {
-	iconSize := tsip.scaleForDPI(bounds.Height)
-	var dot *walk.Icon
-	var err error
-
+func (tsip *IconProvider) IconForState(state service.TunnelState) (icon *walk.Icon, err error) {
 	switch state {
 	case service.TunnelStarted:
-		dot, err = loadSystemIcon("imageres", 101)
+		icon, err = loadSystemIcon("imageres", 101)
 
 	case service.TunnelStopped:
-		dot, err = walk.NewIconFromResourceWithSize("dot-gray.ico", walk.Size{iconSize, iconSize}) //TODO: replace with real icon
+		icon, err = walk.NewIconFromResource("dot-gray.ico") //TODO: replace with real icon
 
 	default:
-		dot, err = loadSystemIcon("shell32", 238) //TODO: this doesn't look that great overlayed on the app icon
+		icon, err = loadSystemIcon("shell32", 238) //TODO: this doesn't look that great overlayed on the app icon
 	}
-	if err != nil {
-		return err
-	}
-	defer dot.Dispose()
-
-	b := bounds
-	b.X += tsip.scaleForDPI(2)
-	b.Y += tsip.scaleForDPI(2)
-	b.Height -= tsip.scaleForDPI(4)
-	b.Width = b.Height
-
-	if err := canvas.DrawImageStretched(dot, b); err != nil {
-		return err
-	}
-
-	return nil
+	return
 }
 
 func loadSystemIcon(dll string, index uint) (*walk.Icon, error) {