Ubuntu 26 opacity reveresed

Author: gcclinux

internal/ui/background_linux.go

@@ -0,0 +1,19 @@
+//go:build linux
+
+package ui
+
+import (
+	"fyne.io/fyne/v2"
+)
+
+// SetLinuxBgOpacity is a no-op on Linux — opacity is handled via the theme.
+func SetLinuxBgOpacity(_ int) {}
+
+// wrapWithPlatformBackground returns content unchanged on Linux.
+// The dark background is handled by the Fyne theme (dark variant forced).
+func wrapWithPlatformBackground(content fyne.CanvasObject) fyne.CanvasObject {
+	return content
+}
+
+// refreshPlatformBackground is a no-op on Linux.
+func refreshPlatformBackground(_ fyne.CanvasObject) {}

internal/ui/background_other.go

@@ -0,0 +1,17 @@
+//go:build !linux
+
+package ui
+
+import "fyne.io/fyne/v2"
+
+// SetLinuxBgOpacity is a no-op on non-Linux platforms.
+func SetLinuxBgOpacity(_ int) {}
+
+// wrapWithPlatformBackground returns the content unchanged on non-Linux platforms.
+// On Windows, transparency is handled via Win32 color-key in the theme.
+func wrapWithPlatformBackground(content fyne.CanvasObject) fyne.CanvasObject {
+	return content
+}
+
+// refreshPlatformBackground is a no-op on non-Linux platforms.
+func refreshPlatformBackground(_ fyne.CanvasObject) {}

internal/ui/manager.go

@@ -69,7 +69,11 @@ func (u *UIManager) ShowWidget(cities []config.CityConfig) {
 	}
 
 	grid := container.NewGridWithColumns(count, objects...)
-	u.widget.SetContent(grid)
+
+	// On Linux, wrap the grid in a rounded dark background.
+	// On Windows, the grid is used directly (transparency via color-key).
+	content := wrapWithPlatformBackground(grid)
+	u.widget.SetContent(content)
 
 	w, h, _ := CalculateLayout(count)
 	u.widget.Resize(fyne.NewSize(float32(w), float32(h)))
@@ -157,9 +161,12 @@ func (u *UIManager) GetPosition() (int, int) {
 // SetOpacity applies background-only transparency to the widget window.
 // opacityPercent should be 25, 50, 75, or 100.
 // On Windows the background color becomes transparent via Win32 color-key;
-// on Linux the whole window opacity is adjusted via _NET_WM_WINDOW_OPACITY
-// with mapped values to keep content readable.
+// on Linux the rounded background's alpha is adjusted, keeping text/icons
+// fully opaque.
 func (u *UIManager) SetOpacity(opacityPercent int) {
 	setWindowOpacity(opacityPercent)
-	u.widget.Canvas().Refresh(u.widget.Content())
+	if u.widget.Content() != nil {
+		refreshPlatformBackground(u.widget.Content())
+		u.widget.Canvas().Refresh(u.widget.Content())
+	}
 }

internal/ui/theme.go

@@ -17,12 +17,16 @@ var transparencyKey = color.NRGBA{R: 1, G: 1, B: 1, A: 255}
 // transparencyActive is 1 when a color-key background should be used.
 var transparencyActive atomic.Int32
 
-// linuxOpacityAlpha stores the alpha value for Linux background transparency.
-// Range: 0 (fully transparent) to 255 (fully opaque). Default is 255.
-var linuxOpacityAlpha atomic.Int32
+// linuxBgShade stores the background RGB value for Linux (0=black, 255=white).
+var linuxBgShade atomic.Int32
+
+// linuxBgAlpha stores the background alpha value for Linux (0=transparent, 255=opaque).
+// Controlled by the opacity setting: 100% = fully opaque (255), 25% = mostly transparent (64).
+var linuxBgAlpha atomic.Int32
 
 func init() {
-	linuxOpacityAlpha.Store(255)
+	linuxBgShade.Store(30)  // default: dark background
+	linuxBgAlpha.Store(255) // default: fully opaque
 }
 
 // SetTransparencyActive switches the background color key on or off.
@@ -34,21 +38,30 @@ func SetTransparencyActive(active bool) {
 	}
 }
 
-// SetLinuxOpacityAlpha sets the background alpha value for Linux transparency.
-// opacityPercent should be 0–100. This is converted to a 0–255 alpha value.
-func SetLinuxOpacityAlpha(opacityPercent int) {
+// SetLinuxBackgroundShade sets the Linux background transparency level.
+// opacityPercent controls the alpha channel of the dark background:
+//
+//	100% → A=255 (fully opaque dark background)
+//	 75% → A=191 (slightly transparent)
+//	 50% → A=128 (semi-transparent)
+//	 25% → A=64  (mostly transparent — desktop shows through)
+func SetLinuxBackgroundShade(opacityPercent int) {
+	// Map opacity percentage directly to alpha value (0–255).
 	alpha := opacityPercent * 255 / 100
-	if alpha < 0 {
-		alpha = 0
-	}
 	if alpha > 255 {
 		alpha = 255
 	}
-	linuxOpacityAlpha.Store(int32(alpha))
+	if alpha < 0 {
+		alpha = 0
+	}
+	linuxBgShade.Store(30) // keep background dark (RGB 30,30,30)
+	linuxBgAlpha.Store(int32(alpha))
 }
 
-// widgetTheme is a Fyne theme that replaces the window background with the
-// color key when transparency is active, leaving all other colors unchanged.
+// widgetTheme is a Fyne theme that:
+//   - On Windows: replaces the background with a color-key when transparency is active
+//   - On Linux: always uses a dark background (ignoring system light/dark preference)
+//     to ensure the widget looks consistent and native
 type widgetTheme struct {
 	base fyne.Theme
 }
@@ -59,21 +72,35 @@ func NewWidgetTheme(base fyne.Theme) fyne.Theme {
 }
 
 func (t *widgetTheme) Color(name fyne.ThemeColorName, variant fyne.ThemeVariant) color.Color {
+	// Windows: color-key transparency when active.
 	if transparencyActive.Load() == 1 {
 		switch name {
 		case theme.ColorNameBackground, theme.ColorNameOverlayBackground:
-			if runtime.GOOS == "linux" {
-				// On Linux/Wayland, use actual alpha transparency.
-				// The Fyne OpenGL/EGL renderer respects the alpha channel,
-				// giving us background-only transparency (text/icons stay opaque).
-				alpha := uint8(linuxOpacityAlpha.Load())
-				return color.NRGBA{R: 30, G: 30, B: 30, A: alpha}
-			}
-			// On Windows, use the color-key approach (Win32 LWA_COLORKEY
-			// makes this exact color invisible).
 			return transparencyKey
 		}
 	}
+
+	// Linux: always use dark variant colors for a consistent widget appearance,
+	// regardless of the system theme (light/dark). The background alpha is
+	// controlled by the opacity setting for true see-through transparency.
+	if runtime.GOOS == "linux" {
+		switch name {
+		case theme.ColorNameBackground, theme.ColorNameOverlayBackground:
+			shade := uint8(linuxBgShade.Load())
+			alpha := uint8(linuxBgAlpha.Load())
+			return color.NRGBA{R: shade, G: shade, B: shade, A: alpha}
+		case theme.ColorNameForeground:
+			// Always white text on Linux for readability on dark background.
+			return color.NRGBA{R: 255, G: 255, B: 255, A: 255}
+		case theme.ColorNameDisabled:
+			return color.NRGBA{R: 180, G: 180, B: 180, A: 255}
+		case theme.ColorNameSeparator:
+			return color.NRGBA{R: 80, G: 80, B: 80, A: 255}
+		}
+		// For all other colors, force dark variant.
+		return t.base.Color(name, theme.VariantDark)
+	}
+
 	return t.base.Color(name, variant)
 }
 

internal/ui/x11_linux.go

@@ -446,12 +446,13 @@ func getWindowPositionXdotool() (int, int) {
 
 // setWindowOpacity applies transparency to the widget window.
 //
-// On Wayland, Fyne renders via EGL/OpenGL and the compositor handles
-// transparency through the alpha channel. We use the Fyne theme's
-// background color alpha to achieve background-only transparency (similar
-// to Windows color-key approach) rather than whole-window opacity.
+// On both Wayland and X11, transparency is achieved by setting the alpha
+// channel of the Fyne theme's background color. This provides background-only
+// transparency — the desktop shows through the background while text and
+// icons remain fully opaque.
 //
-// On X11 we fall back to _NET_WM_WINDOW_OPACITY via xprop.
+// On X11, any existing _NET_WM_WINDOW_OPACITY hint is removed to prevent
+// the compositor from double-applying whole-window transparency.
 func setWindowOpacity(opacityPercent int) {
 	if isWayland() {
 		setWindowOpacityWayland(opacityPercent)
@@ -460,75 +461,47 @@ func setWindowOpacity(opacityPercent int) {
 	}
 }
 
-// setWindowOpacityWayland uses Fyne's theme alpha channel for transparency.
-// On Wayland, the compositor respects the alpha channel of the EGL/OpenGL
-// surface. We set the background color's alpha value to achieve background-only
-// transparency — text, icons, and other content remain fully opaque.
-// This is equivalent to the Windows color-key approach in visual result.
+// setWindowOpacityWayland controls background transparency on Wayland.
+// The opacity setting controls the alpha channel of the dark background,
+// allowing the desktop to show through while keeping text/icons fully opaque.
+//
+//	100% → fully opaque dark background
+//	 75% → slightly transparent
+//	 50% → semi-transparent
+//	 25% → mostly transparent (desktop visible through background)
 func setWindowOpacityWayland(opacityPercent int) {
-	if opacityPercent >= 100 {
-		SetTransparencyActive(false)
-		SetLinuxOpacityAlpha(100)
-		log.Printf("Linux/Wayland: transparency disabled (100%% opaque)")
-		return
-	}
-
-	// Set the alpha value for the background color.
-	SetLinuxOpacityAlpha(opacityPercent)
-	SetTransparencyActive(true)
-	log.Printf("Linux/Wayland: background transparency set to %d%% alpha", opacityPercent)
+	SetLinuxBackgroundShade(opacityPercent)
+	log.Printf("Linux/Wayland: background alpha set for opacity %d%%", opacityPercent)
 }
 
-// setWindowOpacityX11 applies whole-window transparency on X11 via xprop.
+// setWindowOpacityX11 controls background transparency on X11.
+// Like Wayland, we use the Fyne theme's background alpha channel for
+// background-only transparency, keeping text and icons fully opaque.
+// The _NET_WM_WINDOW_OPACITY hint is removed so the compositor doesn't
+// double-apply whole-window transparency.
 func setWindowOpacityX11(opacityPercent int) {
-	x11Percent := mapOpacityForDisplay(opacityPercent)
+	SetLinuxBackgroundShade(opacityPercent)
 
 	go func() {
 		time.Sleep(600 * time.Millisecond)
 
 		if _, err := exec.LookPath("xprop"); err != nil {
-			log.Printf("Linux/X11: xprop not found, cannot set opacity")
-			return
-		}
-
-		if x11Percent >= 100 {
-			cmd := exec.Command("xprop", "-name", widgetTitle, "-remove", "_NET_WM_WINDOW_OPACITY")
-			if err := cmd.Run(); err != nil {
-				log.Printf("Linux/X11: failed to remove _NET_WM_WINDOW_OPACITY: %v", err)
-			}
+			log.Printf("Linux/X11: xprop not found, relying on theme alpha only")
 			return
 		}
 
-		opacity := uint64(x11Percent) * 0xFFFFFFFF / 100
-		val := strconv.FormatUint(opacity, 10)
-
-		cmd := exec.Command("xprop", "-name", widgetTitle,
-			"-f", "_NET_WM_WINDOW_OPACITY", "32c",
-			"-set", "_NET_WM_WINDOW_OPACITY", val)
+		// Remove any whole-window opacity hint so only the background alpha
+		// (set via the theme) controls transparency.
+		cmd := exec.Command("xprop", "-name", widgetTitle, "-remove", "_NET_WM_WINDOW_OPACITY")
 		if err := cmd.Run(); err != nil {
-			log.Printf("Linux/X11: xprop opacity failed: %v", err)
-			return
+			log.Printf("Linux/X11: failed to remove _NET_WM_WINDOW_OPACITY: %v", err)
 		}
-		log.Printf("Linux/X11: set window opacity to %d%% (user: %d%%)", x11Percent, opacityPercent)
+		log.Printf("Linux/X11: background alpha set for opacity %d%%", opacityPercent)
 	}()
 }
 
-// mapOpacityForDisplay maps user-facing opacity percentages to display
-// values that keep content readable when using whole-window opacity.
-func mapOpacityForDisplay(opacityPercent int) int {
-	switch {
-	case opacityPercent >= 100:
-		return 100
-	case opacityPercent >= 75:
-		return 85
-	case opacityPercent >= 50:
-		return 70
-	case opacityPercent >= 25:
-		return 55
-	default:
-		return 55
-	}
-}
+// (mapOpacityForDisplay removed — no longer needed; transparency is now
+// handled via the theme's background alpha channel on both X11 and Wayland.)
 
 // ---------------------------------------------------------------------------
 // Monitor enumeration