Ensure Canvas Matches Actual Window Size

internal/driver/glfw/canvas.go

@@ -102,6 +102,23 @@ func (c *glCanvas) Resize(size fyne.Size) {
 	// This can easily be seen with fyne/cmd/hello and a scale == 1 as the text will happear blurry without the following line.
 	nearestSize := fyne.NewSize(float32(math.Ceil(float64(size.Width))), float32(math.Ceil(float64(size.Height))))
 
+	// Use actual window size when available and different from expected (important for tiling window managers)
+	if ctx, ok := c.context.(*window); ok && ctx.viewport != nil && ctx.visible && !ctx.fullScreen {
+		actualWidth, actualHeight := ctx.viewport.GetSize()
+		if actualWidth > 0 && actualHeight > 0 {
+			// Check if actual size differs from what we expect
+			expectedWidth, expectedHeight := ctx.screenSize(nearestSize)
+			if actualWidth != expectedWidth || actualHeight != expectedHeight {
+				// Size mismatch detected - recalculate canvas size based on actual window size
+				actualCanvasSize := ctx.computeCanvasSize(actualWidth, actualHeight)
+				nearestSize = fyne.NewSize(float32(math.Ceil(float64(actualCanvasSize.Width))), float32(math.Ceil(float64(actualCanvasSize.Height))))
+
+				ctx.width = actualWidth
+				ctx.height = actualHeight
+			}
+		}
+	}
+
 	c.size = nearestSize
 
 	if c.webExtraWindows != nil {

internal/driver/glfw/window_desktop.go

@@ -718,9 +718,24 @@ func (w *window) RescaleContext() {
 		return
 	}
 
-	size := w.canvas.size.Max(w.canvas.MinSize())
-	newWidth, newHeight := w.screenSize(size)
-	w.viewport.SetSize(newWidth, newHeight)
+	// When scale changes (e.g., moving between monitors), we need to recalculate
+	// the canvas size based on the current window size, not the other way around
+	if w.visible {
+		currentWidth, currentHeight := w.viewport.GetSize()
+		if currentWidth > 0 && currentHeight > 0 {
+			canvasSize := fyne.NewSize(
+				scale.ToFyneCoordinate(w.canvas, currentWidth),
+				scale.ToFyneCoordinate(w.canvas, currentHeight))
+			w.canvas.Resize(canvasSize)
+
+			w.width = currentWidth
+			w.height = currentHeight
+		}
+	} else {
+		size := w.canvas.size.Max(w.canvas.MinSize())
+		newWidth, newHeight := w.screenSize(size)
+		w.viewport.SetSize(newWidth, newHeight)
+	}
 
 	// Ensure textures re-rasterize at the new scale
 	cache.DeleteTextTexturesFor(w.canvas)

internal/driver/glfw/window_rescale_test.go

@@ -0,0 +1,71 @@
+//go:build !wasm && !test_web_driver && !mobile && !no_glfw
+
+package glfw
+
+import (
+	"testing"
+
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/widget"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestWindow_RescaleContext_Basic(t *testing.T) {
+	// Basic test to ensure RescaleContext doesn't panic
+	w := createWindow("Test")
+	defer w.Close()
+	w.SetContent(widget.NewLabel("Test"))
+
+	// Test that RescaleContext can be called without panic
+	runOnMain(func() {
+		w.RescaleContext()
+	})
+
+	// Verify window still has valid canvas
+	assert.NotNil(t, w.Canvas())
+	assert.NotNil(t, w.Canvas().Content())
+}
+
+func TestWindow_RescaleContext_WithContent(t *testing.T) {
+	// Test RescaleContext with actual content
+	w := createWindow("Test")
+	defer w.Close()
+
+	content := container.NewVBox(
+		widget.NewLabel("Test App"),
+		widget.NewButton("Click Me", func() {}),
+	)
+	w.SetContent(content)
+
+	// Call RescaleContext
+	runOnMain(func() {
+		w.RescaleContext()
+	})
+
+	// Verify content is preserved
+	assert.Equal(t, content, w.Canvas().Content())
+	assert.Greater(t, w.Canvas().Size().Width, float32(0))
+	assert.Greater(t, w.Canvas().Size().Height, float32(0))
+}
+
+func TestWindow_RescaleContext_MinSize(t *testing.T) {
+	// Test that RescaleContext respects minimum size
+	w := createWindow("Test")
+	defer w.Close()
+
+	label := widget.NewLabel("Test with minimum size")
+	label.Resize(fyne.NewSize(300, 200))
+	w.SetContent(label)
+
+	// Call RescaleContext
+	runOnMain(func() {
+		w.RescaleContext()
+	})
+
+	// Canvas should respect content minimum size
+	minSize := label.MinSize()
+	canvasSize := w.Canvas().Size()
+	assert.GreaterOrEqual(t, canvasSize.Width, minSize.Width)
+	assert.GreaterOrEqual(t, canvasSize.Height, minSize.Height)
+}