Ubuntu 26 improved app Look & Feel

Author: gcclinux

Makefile

@@ -1,8 +1,7 @@
 # Weather Widget Build Configuration
 BINARY_NAME=weatherwidget
 CMD_PATH=./cmd/weatherwidget/
-GO_CMD=/usr/local/go/bin/go
-
+GO_CMD=/usr/bin/go
 # Detect OS
 ifeq ($(OS),Windows_NT)
     BINARY_NAME=weatherwidget.exe

internal/ui/drag_linux.go

@@ -19,12 +19,16 @@ 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
+// through XWayland) and detect when the user has moved the window using
+// the compositor's built-in drag mechanism (typically Super+drag or
+// Alt+drag on GNOME).
+//
+// On X11, the same polling approach is used with xdotool.
 //
-// Requires xdotool to be installed.
+// The onDragEnd callback is invoked when a position change is detected
+// so the caller can persist the new coordinates.
 func enableWindowDrag(onDragEnd func()) {
 	linuxDragMu.Lock()
 	defer linuxDragMu.Unlock()
@@ -39,7 +43,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
@@ -86,7 +95,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
 
+// linuxOpacityAlpha stores the alpha value for Linux background transparency.
+// Range: 0 (fully transparent) to 255 (fully opaque). Default is 255.
+var linuxOpacityAlpha atomic.Int32
+
+func init() {
+	linuxOpacityAlpha.Store(255)
+}
+
 // SetTransparencyActive switches the background color key on or off.
 func SetTransparencyActive(active bool) {
 	if active {
@@ -25,6 +34,19 @@ 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) {
+	alpha := opacityPercent * 255 / 100
+	if alpha < 0 {
+		alpha = 0
+	}
+	if alpha > 255 {
+		alpha = 255
+	}
+	linuxOpacityAlpha.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.
 type widgetTheme struct {
@@ -40,6 +62,15 @@ func (t *widgetTheme) Color(name fyne.ThemeColorName, variant fyne.ThemeVariant)
 	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
 		}
 	}

internal/ui/window_linux.go

@@ -0,0 +1,36 @@
+//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.
+//
+// On Windows this is not needed because Win32 API calls strip decorations
+// post-creation.
+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)
+		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,15 @@
+//go:build !windows && !linux
+
+package ui
+
+import (
+	"fyne.io/fyne/v2"
+)
+
+// createWidgetWindow creates the main widget window on unsupported platforms.
+func createWidgetWindow(app fyne.App, title string) fyne.Window {
+	w := app.NewWindow(title)
+	w.SetFixedSize(true)
+	w.SetPadded(false)
+	return w
+}

internal/ui/window_windows.go

@@ -0,0 +1,16 @@
+//go:build windows
+
+package ui
+
+import (
+	"fyne.io/fyne/v2"
+)
+
+// createWidgetWindow creates the main widget window on Windows.
+// Decorations are removed later via Win32 API calls in applyToolWindowStyle.
+func createWidgetWindow(app fyne.App, title string) fyne.Window {
+	w := app.NewWindow(title)
+	w.SetFixedSize(true)
+	w.SetPadded(false)
+	return w
+}