Ubuntu background on new branch fixed

Author: gcclinux

internal/ui/drag_linux.go

@@ -19,12 +19,12 @@ var (
 
 // enableWindowDrag enables drag-to-reposition detection on Linux.
 //
-// Since the title bar is removed, most window managers still allow moving
-// via Alt+left-click drag or Super+drag. This function starts a background
-// poller that detects when the window position changes and calls onDragEnd
-// so the caller can persist the new coordinates.
+// On Wayland, direct window-move interception is not possible through the
+// protocol. Instead we poll the window position (via wmctrl or xdotool)
+// and detect when the user has moved the window using the compositor's
+// built-in drag mechanism (Super+drag or Alt+drag on GNOME).
 //
-// Requires xdotool to be installed.
+// On X11, the same polling approach is used with xdotool.
 func enableWindowDrag(onDragEnd func()) {
 	linuxDragMu.Lock()
 	defer linuxDragMu.Unlock()
@@ -39,7 +39,12 @@ func enableWindowDrag(onDragEnd func()) {
 	linuxLastX, linuxLastY = getWindowPosition()
 
 	go pollWindowPosition(linuxDragStop)
-	log.Println("Linux drag: position poller started")
+
+	if isWayland() {
+		log.Println("Linux/Wayland: drag position poller started (use Super+drag or Alt+drag to reposition)")
+	} else {
+		log.Println("Linux/X11: drag position poller started")
+	}
 }
 
 // notifyLinuxMoveByUs should be called before programmatic moves so the
@@ -71,7 +76,6 @@ func pollWindowPosition(stop chan struct{}) {
 			linuxDragMu.Unlock()
 
 			if movedByUs {
-				// Update last known position but don't fire callback.
 				linuxDragMu.Lock()
 				linuxLastX = x
 				linuxLastY = y
@@ -86,7 +90,7 @@ func pollWindowPosition(stop chan struct{}) {
 				linuxDragMu.Unlock()
 
 				if cb != nil {
-					log.Printf("Linux drag: position changed from (%d,%d) to (%d,%d), saving", lastX, lastY, x, y)
+					log.Printf("Linux: position changed from (%d,%d) to (%d,%d), saving", lastX, lastY, x, y)
 					cb()
 				}
 			}

internal/ui/manager.go

@@ -24,12 +24,11 @@ type UIManager struct {
 }
 
 // NewUIManager creates a new UIManager and its main widget window.
-// After the window is shown, call applyToolWindowStyle to set Win32
-// WS_EX_TOOLWINDOW and HWND_TOPMOST styles (no-op on non-Windows).
+// On Linux the window is created without decorations (borderless) via
+// CreateSplashWindow. On Windows decorations are removed post-creation
+// by applyToolWindowStyle using Win32 API calls.
 func NewUIManager(app fyne.App, lm *i18n.LocaleManager) *UIManager {
-	w := app.NewWindow(widgetTitle)
-	w.SetFixedSize(true)
-	w.SetPadded(false)
+	w := createWidgetWindow(app, widgetTitle)
 
 	return &UIManager{
 		app:    app,

internal/ui/theme.go

@@ -2,6 +2,7 @@ package ui
 
 import (
 	"image/color"
+	"runtime"
 	"sync/atomic"
 
 	"fyne.io/fyne/v2"
@@ -16,6 +17,14 @@ 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
 
+// linuxBgShade stores the background RGB value for Linux (0=black, 255=white).
+// Controlled by the opacity setting: 100% = fully dark (30), 25% = lighter (90).
+var linuxBgShade atomic.Int32
+
+func init() {
+	linuxBgShade.Store(30) // default: dark background
+}
+
 // SetTransparencyActive switches the background color key on or off.
 func SetTransparencyActive(active bool) {
 	if active {
@@ -25,8 +34,32 @@ func SetTransparencyActive(active bool) {
 	}
 }
 
-// widgetTheme is a Fyne theme that replaces the window background with the
-// color key when transparency is active, leaving all other colors unchanged.
+// SetLinuxBackgroundShade sets the Linux background darkness level.
+// opacityPercent maps to background shade:
+//
+//	100% → RGB(30,30,30)  — fully dark, content most visible
+//	 75% → RGB(50,50,50)  — slightly lighter
+//	 50% → RGB(70,70,70)  — medium grey
+//	 25% → RGB(90,90,90)  — lighter grey
+func SetLinuxBackgroundShade(opacityPercent int) {
+	var shade int
+	switch {
+	case opacityPercent >= 100:
+		shade = 30
+	case opacityPercent >= 75:
+		shade = 50
+	case opacityPercent >= 50:
+		shade = 70
+	default:
+		shade = 90
+	}
+	linuxBgShade.Store(int32(shade))
+}
+
+// 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
 }
@@ -37,12 +70,33 @@ 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:
 			return transparencyKey
 		}
 	}
+
+	// Linux: always use dark variant colors for a consistent widget appearance,
+	// regardless of the system theme (light/dark). The background shade is
+	// controlled by the opacity setting.
+	if runtime.GOOS == "linux" {
+		switch name {
+		case theme.ColorNameBackground, theme.ColorNameOverlayBackground:
+			shade := uint8(linuxBgShade.Load())
+			return color.NRGBA{R: shade, G: shade, B: shade, A: 255}
+		case theme.ColorNameForeground:
+			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/window_linux.go

@@ -0,0 +1,35 @@
+//go:build linux
+
+package ui
+
+import (
+	"log"
+
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/driver/desktop"
+)
+
+// createWidgetWindow creates the main widget window on Linux.
+//
+// On Linux (especially Wayland/GNOME), window decorations cannot be removed
+// after creation. We use Fyne's CreateSplashWindow() which sets the GLFW
+// Decorated hint to false before the window is created, producing a truly
+// borderless window on both Wayland and X11.
+func createWidgetWindow(app fyne.App, title string) fyne.Window {
+	drv, ok := app.Driver().(desktop.Driver)
+	if !ok {
+		log.Println("Linux: desktop driver not available, falling back to standard window")
+		w := app.NewWindow(title)
+		w.SetFixedSize(true)
+		w.SetPadded(false)
+		return w
+	}
+
+	w := drv.CreateSplashWindow()
+	w.SetTitle(title)
+	w.SetFixedSize(true)
+	w.SetPadded(false)
+
+	log.Println("Linux: created undecorated widget window via CreateSplashWindow")
+	return w
+}

internal/ui/window_other.go

@@ -0,0 +1,16 @@
+//go:build !linux
+
+package ui
+
+import (
+	"fyne.io/fyne/v2"
+)
+
+// createWidgetWindow creates the main widget window on non-Linux platforms.
+// On Windows, decorations are removed post-creation via Win32 API calls.
+func createWidgetWindow(app fyne.App, title string) fyne.Window {
+	w := app.NewWindow(title)
+	w.SetFixedSize(true)
+	w.SetPadded(false)
+	return w
+}