refactor: enhance plugin visibility w/bar reveal state

.gitignore

@@ -115,5 +115,3 @@ core.*
 .direnv/
 quickshell/dms-plugins
 __pycache__
-
-.vscode/

core/cmd/dms/commands_colorpicker.go

@@ -19,12 +19,7 @@ var (
 var colorCmd = &cobra.Command{
 	Use:   "color",
 	Short: "Color utilities",
-	Long: `Color utilities including picking colors from the screen.
-
-This is the screen eyedropper CLI. To open the in-shell color modal, use:
-  dms ipc call color-picker toggle
-
-See: https://danklinux.com/docs/dankmaterialshell/keybinds-ipc`,
+	Long:  "Color utilities including picking colors from the screen",
 }
 
 var colorPickCmd = &cobra.Command{
@@ -34,9 +29,6 @@ var colorPickCmd = &cobra.Command{
 
 Click on any pixel to capture its color, or press Escape to cancel.
 
-This is the screen eyedropper CLI. To open the in-shell color modal, use:
-  dms ipc call color-picker toggle
-
 Output format flags (mutually exclusive, default: --hex):
   --hex  - Hexadecimal (#RRGGBB)
   --rgb  - RGB values (R G B)

core/cmd/dms/commands_common.go

@@ -77,15 +77,10 @@ var killCmd = &cobra.Command{
 }
 
 var ipcCmd = &cobra.Command{
-	Use:   "ipc",
+	Use:   "ipc [target] [function] [args...]",
 	Short: "Send IPC commands to running DMS shell",
-	Long: `Send IPC commands to the running DMS shell.
-
-  dms ipc call <target> <function> [args...]   invoke a command
-  dms ipc list                                 list all targets and functions
-
-Full reference: https://danklinux.com/docs/dankmaterialshell/keybinds-ipc`,
 	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		_ = findConfig(cmd, args)
 		return getShellIPCCompletions(args, toComplete), cobra.ShellCompDirectiveNoFileComp
 	},
 	Run: func(cmd *cobra.Command, args []string) {
@@ -93,17 +88,9 @@ Full reference: https://danklinux.com/docs/dankmaterialshell/keybinds-ipc`,
 	},
 }
 
-var ipcListCmd = &cobra.Command{
-	Use:   "list",
-	Short: "List all IPC targets and functions",
-	Run: func(cmd *cobra.Command, args []string) {
-		printIPCHelp()
-	},
-}
-
 func init() {
-	ipcCmd.AddCommand(ipcListCmd)
 	ipcCmd.SetHelpFunc(func(cmd *cobra.Command, args []string) {
+		_ = findConfig(cmd, args)
 		printIPCHelp()
 	})
 }

core/cmd/dms/commands_config.go

@@ -72,7 +72,7 @@ func runResolveInclude(cmd *cobra.Command, args []string) {
 		result, err = checkHyprlandInclude(filename)
 	case "niri":
 		result, err = checkNiriInclude(filename)
-	case "mangowc", "mango":
+	case "mangowc", "dwl", "mango":
 		result, err = checkMangoWCInclude(filename)
 	default:
 		log.Fatalf("Unknown compositor: %s", compositor)

core/cmd/dms/commands_screenshot.go

@@ -39,7 +39,7 @@ Modes:
   full        - Capture the focused output
   all         - Capture all outputs combined
   output      - Capture a specific output by name
-  window      - Capture the focused window (Hyprland/Mango)
+  window      - Capture the focused window (Hyprland/DWL)
   last        - Capture the last selected region
 
 Output format (--format):
@@ -97,7 +97,7 @@ If no previous region exists, falls back to interactive selection.`,
 var ssWindowCmd = &cobra.Command{
 	Use:   "window",
 	Short: "Capture the focused window",
-	Long:  `Capture the currently focused window. Supported on Hyprland and Mango.`,
+	Long:  `Capture the currently focused window. Supported on Hyprland and DWL.`,
 	Run:   runScreenshotWindow,
 }
 

core/cmd/dms/shell.go

@@ -601,30 +601,12 @@ func parseTargetsFromIPCShowOutput(output string) ipcTargets {
 	return targets
 }
 
-func buildQsIPCBaseArgs() ([]string, error) {
-	cmdArgs := []string{"ipc"}
-	switch pid, ok := getFirstDMSPID(); {
-	case ok:
-		cmdArgs = append(cmdArgs, "--pid", strconv.Itoa(pid))
-	default:
-		if err := findConfig(nil, nil); err != nil {
-			return nil, err
-		}
-		if qsHasAnyDisplay() {
-			cmdArgs = append(cmdArgs, "--any-display")
-		}
-		cmdArgs = append(cmdArgs, "-p", configPath)
-	}
-	return cmdArgs, nil
-}
-
 func getShellIPCCompletions(args []string, _ string) []string {
-	baseArgs, err := buildQsIPCBaseArgs()
-	if err != nil {
-		log.Debugf("Error building IPC args for completions: %v", err)
-		return nil
+	cmdArgs := []string{"ipc"}
+	if qsHasAnyDisplay() {
+		cmdArgs = append(cmdArgs, "--any-display")
 	}
-	cmdArgs := append(baseArgs, "show")
+	cmdArgs = append(cmdArgs, "-p", configPath, "show")
 	cmd := exec.Command("qs", cmdArgs...)
 	var targets ipcTargets
 
@@ -641,7 +623,7 @@ func getShellIPCCompletions(args []string, _ string) []string {
 
 	if len(args) == 0 {
 		targetNames := make([]string, 0)
-		targetNames = append(targetNames, "call", "list")
+		targetNames = append(targetNames, "call")
 		for k := range targets {
 			targetNames = append(targetNames, k)
 		}
@@ -714,11 +696,23 @@ func runShellIPCCommand(args []string) {
 		args = append([]string{"call"}, args...)
 	}
 
-	baseArgs, err := buildQsIPCBaseArgs()
-	if err != nil {
-		log.Fatalf("Error finding config: %v", err)
+	cmdArgs := []string{"ipc"}
+
+	switch pid, ok := getFirstDMSPID(); {
+	case ok:
+		cmdArgs = append(cmdArgs, "--pid", strconv.Itoa(pid))
+	default:
+		if err := findConfig(nil, nil); err != nil {
+			log.Fatalf("Error finding config: %v", err)
+		}
+		// ! TODO - remove check when QS 0.3 is released
+		if qsHasAnyDisplay() {
+			cmdArgs = append(cmdArgs, "--any-display")
+		}
+		cmdArgs = append(cmdArgs, "-p", configPath)
 	}
-	cmdArgs := append(baseArgs, args...)
+
+	cmdArgs = append(cmdArgs, args...)
 	cmd := exec.Command("qs", cmdArgs...)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
@@ -730,20 +724,19 @@ func runShellIPCCommand(args []string) {
 }
 
 func printIPCHelp() {
-	fmt.Println("Usage: dms ipc call <target> <function> [args...]")
+	fmt.Println("Usage: dms ipc <target> <function> [args...]")
 	fmt.Println()
 
-	baseArgs, err := buildQsIPCBaseArgs()
-	if err != nil {
-		printIPCHelpFailure(err)
-		return
+	cmdArgs := []string{"ipc"}
+	if qsHasAnyDisplay() {
+		cmdArgs = append(cmdArgs, "--any-display")
 	}
-	cmdArgs := append(baseArgs, "show")
+	cmdArgs = append(cmdArgs, "-p", configPath, "show")
 	cmd := exec.Command("qs", cmdArgs...)
 
 	output, err := cmd.Output()
 	if err != nil {
-		printIPCHelpFailure(err)
+		fmt.Println("Could not retrieve available IPC targets (is DMS running?)")
 		return
 	}
 
@@ -772,16 +765,6 @@ func printIPCHelp() {
 	}
 }
 
-func printIPCHelpFailure(err error) {
-	fmt.Println("Could not retrieve IPC targets.")
-	if err != nil {
-		fmt.Printf("  %v\n", err)
-	}
-	fmt.Println()
-	fmt.Println("  Full docs:  https://danklinux.com/docs/dankmaterialshell/keybinds-ipc")
-	fmt.Println("  Try:        dms ipc call <target> <function>")
-}
-
 // ensureFontCache rebuilds the fontconfig cache if user-configured fonts are missing while skipping defaults
 func ensureFontCache() {
 	if _, err := exec.LookPath("fc-list"); err != nil {

core/internal/keybinds/providers/niri_parser.go

@@ -51,7 +51,7 @@ type NiriParser struct {
 }
 
 func parseKDL(data []byte) (*document.Document, error) {
-	return kdl.Parse(strings.NewReader(normalizeKDLBraces(quoteLeadingUnderscoreIdents(string(data)))))
+	return kdl.Parse(strings.NewReader(normalizeKDLBraces(string(data))))
 }
 
 func normalizeKDLBraces(input string) string {
@@ -94,93 +94,6 @@ func normalizeKDLBraces(input string) string {
 	return sb.String()
 }
 
-// quoteLeadingUnderscoreIdents wraps bare KDL identifiers that begin with '_'
-// in double quotes. kdl-go rejects '_' as the first character of a bare
-// identifier (e.g. the common `_JAVA_AWT_WM_NONREPARENTING "1"` environment
-// node), even though niri's own parser and the KDL spec accept it — so without
-// this the whole config fails to parse and no keybinds load. Quoting lets
-// kdl-go parse it; this is safe because the niri parser only dispatches on
-// fixed node/section names (binds, recent-windows, include, ...) that never
-// start with '_', so re-quoting such a name cannot change what DMS reads.
-// Underscores elsewhere in an identifier (XDG_CURRENT_DESKTOP) are left
-// untouched, and underscores inside strings or comments are skipped. Only a
-// leading '_' is handled; other start characters kdl-go over-rejects (e.g. '.'
-// or '?') do not occur in niri configs.
-func quoteLeadingUnderscoreIdents(input string) string {
-	var sb strings.Builder
-	sb.Grow(len(input))
-
-	var prev byte
-	n := len(input)
-	for i := 0; i < n; {
-		c := input[i]
-
-		switch {
-		case c == '"':
-			end := findStringEnd(input, i)
-			sb.WriteString(input[i:end])
-			prev = '"'
-			i = end
-		case c == '/' && i+1 < n && input[i+1] == '/':
-			end := findLineCommentEnd(input, i)
-			sb.WriteString(input[i:end])
-			prev = '\n'
-			i = end
-		case c == '/' && i+1 < n && input[i+1] == '*':
-			end := findBlockCommentEnd(input, i)
-			sb.WriteString(input[i:end])
-			prev = ' '
-			i = end
-		case c == '/' && i+1 < n && input[i+1] == '-':
-			// KDL slashdash: /- comments out the next node/value. Keep the
-			// marker but treat what follows as a fresh token start, so a
-			// slashdashed leading-underscore node (e.g. `/-_FOO "1"`) still
-			// gets quoted instead of crashing kdl-go.
-			sb.WriteByte('/')
-			sb.WriteByte('-')
-			prev = ' '
-			i += 2
-		case c == '_' && isIdentBoundary(prev):
-			end := scanBareIdent(input, i)
-			sb.WriteByte('"')
-			sb.WriteString(input[i:end])
-			sb.WriteByte('"')
-			prev = '"'
-			i = end
-		default:
-			sb.WriteByte(c)
-			prev = c
-			i++
-		}
-	}
-
-	return sb.String()
-}
-
-// isIdentBoundary reports whether the previously emitted byte ends a token, so
-// that a following '_' starts a fresh bare identifier rather than sitting in
-// the middle of one.
-func isIdentBoundary(prev byte) bool {
-	switch prev {
-	case 0, ' ', '\t', '\n', '\r', '{', '}', ';', '=', '(', ')', ',':
-		return true
-	}
-	return false
-}
-
-// scanBareIdent returns the index just past the bare identifier starting at
-// start, stopping at whitespace or any KDL delimiter.
-func scanBareIdent(s string, start int) int {
-	n := len(s)
-	for i := start; i < n; i++ {
-		switch s[i] {
-		case ' ', '\t', '\n', '\r', '"', '{', '}', '(', ')', ';', '=', ',', '/', '\\', '<', '>', '[', ']':
-			return i
-		}
-	}
-	return n
-}
-
 func findStringEnd(s string, start int) int {
 	n := len(s)
 	for i := start + 1; i < n; {

core/internal/keybinds/providers/niri_parser_test.go

@@ -71,101 +71,6 @@ func TestNormalizeKDLBraces(t *testing.T) {
 	}
 }
 
-func TestQuoteLeadingUnderscoreIdents(t *testing.T) {
-	tests := []struct {
-		name string
-		in   string
-		out  string
-	}{
-		{"leading underscore node", `_JAVA_AWT_WM_NONREPARENTING "1"`, `"_JAVA_AWT_WM_NONREPARENTING" "1"`},
-		{"mid underscore untouched", `XDG_CURRENT_DESKTOP "niri"`, `XDG_CURRENT_DESKTOP "niri"`},
-		{"indented node", "environment {\n  _FOO \"1\"\n}", "environment {\n  \"_FOO\" \"1\"\n}"},
-		{"underscore in string", `spawn "_not_a_node"`, `spawn "_not_a_node"`},
-		{"underscore in line comment", "// _comment\n_FOO \"1\"", "// _comment\n\"_FOO\" \"1\""},
-		{"underscore in block comment", "/* _x */ _FOO \"1\"", "/* _x */ \"_FOO\" \"1\""},
-		{"block comment abuts node", `/* x */_FOO "1"`, `/* x */"_FOO" "1"`},
-		{"slashdash before node", `/-_FOO "1"`, `/-"_FOO" "1"`},
-		{"node after closing paren", "node (u8)_v", `node (u8)"_v"`},
-		{"node before brace without space", "_FOO{ }", `"_FOO"{ }`},
-		{"lone underscore", `_ "x"`, `"_" "x"`},
-		{"property value", "node key=_val", `node key="_val"`},
-		{"no underscores", "node child", "node child"},
-	}
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			got := quoteLeadingUnderscoreIdents(tc.in)
-			if got != tc.out {
-				t.Errorf("quoteLeadingUnderscoreIdents(%q) = %q, want %q", tc.in, got, tc.out)
-			}
-		})
-	}
-}
-
-func TestNiriParseLeadingUnderscoreEnvironment(t *testing.T) {
-	tmpDir := t.TempDir()
-	configFile := filepath.Join(tmpDir, "config.kdl")
-
-	// A leading-underscore environment node (a common Java/tiling-WM fix) must
-	// not abort parsing of the rest of the config — keybinds still have to load.
-	content := `environment {
-    XDG_CURRENT_DESKTOP "niri"
-    _JAVA_AWT_WM_NONREPARENTING "1"
-}
-binds {
-    Mod+Q { close-window; }
-    Mod+KP_Home { focus-workspace 1; }
-}
-`
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
-		t.Fatalf("Failed to write test config: %v", err)
-	}
-
-	result, err := ParseNiriKeys(tmpDir)
-	if err != nil {
-		t.Fatalf("ParseNiriKeys failed on config with leading-underscore env node: %v", err)
-	}
-
-	if len(result.Section.Keybinds) != 2 {
-		t.Errorf("Expected 2 keybinds, got %d", len(result.Section.Keybinds))
-	}
-
-	foundClose := false
-	for _, kb := range result.Section.Keybinds {
-		if kb.Action == "close-window" {
-			foundClose = true
-		}
-	}
-	if !foundClose {
-		t.Error("close-window keybind not found — leading-underscore env node broke parsing")
-	}
-}
-
-func TestNiriParseSlashdashLeadingUnderscore(t *testing.T) {
-	tmpDir := t.TempDir()
-	configFile := filepath.Join(tmpDir, "config.kdl")
-
-	// A slashdashed leading-underscore node must not abort parsing either.
-	content := `environment {
-    /-_JAVA_AWT_WM_NONREPARENTING "1"
-}
-binds {
-    Mod+Q { close-window; }
-}
-`
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
-		t.Fatalf("Failed to write test config: %v", err)
-	}
-
-	result, err := ParseNiriKeys(tmpDir)
-	if err != nil {
-		t.Fatalf("ParseNiriKeys failed on config with slashdashed leading-underscore node: %v", err)
-	}
-
-	if len(result.Section.Keybinds) != 1 {
-		t.Errorf("Expected 1 keybind, got %d", len(result.Section.Keybinds))
-	}
-}
-
 func TestNiriParseKeyCombo(t *testing.T) {
 	tests := []struct {
 		combo        string

core/internal/proto/dwl_ipc/dwl_ipc.go

@@ -0,0 +1,791 @@
+// Generated by go-wayland-scanner
+// https://github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/cmd/go-wayland-scanner
+// XML file : internal/proto/xml/dwl-ipc-unstable-v2.xml
+//
+// dwl_ipc_unstable_v2 Protocol Copyright:
+
+package dwl_ipc
+
+import "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
+
+// ZdwlIpcManagerV2InterfaceName is the name of the interface as it appears in the [client.Registry].
+// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
+// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
+const ZdwlIpcManagerV2InterfaceName = "zdwl_ipc_manager_v2"
+
+// ZdwlIpcManagerV2 : manage dwl state
+//
+// This interface is exposed as a global in wl_registry.
+//
+// Clients can use this interface to get a dwl_ipc_output.
+// After binding the client will recieve the dwl_ipc_manager.tags and dwl_ipc_manager.layout events.
+// The dwl_ipc_manager.tags and dwl_ipc_manager.layout events expose tags and layouts to the client.
+type ZdwlIpcManagerV2 struct {
+	client.BaseProxy
+	tagsHandler   ZdwlIpcManagerV2TagsHandlerFunc
+	layoutHandler ZdwlIpcManagerV2LayoutHandlerFunc
+}
+
+// NewZdwlIpcManagerV2 : manage dwl state
+//
+// This interface is exposed as a global in wl_registry.
+//
+// Clients can use this interface to get a dwl_ipc_output.
+// After binding the client will recieve the dwl_ipc_manager.tags and dwl_ipc_manager.layout events.
+// The dwl_ipc_manager.tags and dwl_ipc_manager.layout events expose tags and layouts to the client.
+func NewZdwlIpcManagerV2(ctx *client.Context) *ZdwlIpcManagerV2 {
+	zdwlIpcManagerV2 := &ZdwlIpcManagerV2{}
+	ctx.Register(zdwlIpcManagerV2)
+	return zdwlIpcManagerV2
+}
+
+// Release : release dwl_ipc_manager
+//
+// Indicates that the client will not the dwl_ipc_manager object anymore.
+// Objects created through this instance are not affected.
+func (i *ZdwlIpcManagerV2) Release() error {
+	defer i.MarkZombie()
+	const opcode = 0
+	const _reqBufLen = 8
+	var _reqBuf [_reqBufLen]byte
+	l := 0
+	client.PutUint32(_reqBuf[l:4], i.ID())
+	l += 4
+	client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
+	l += 4
+	err := i.Context().WriteMsg(_reqBuf[:], nil)
+	return err
+}
+
+// GetOutput : get a dwl_ipc_outout for a wl_output
+//
+// Get a dwl_ipc_outout for the specified wl_output.
+func (i *ZdwlIpcManagerV2) GetOutput(output *client.Output) (*ZdwlIpcOutputV2, error) {
+	id := NewZdwlIpcOutputV2(i.Context())
+	const opcode = 1
+	const _reqBufLen = 8 + 4 + 4
+	var _reqBuf [_reqBufLen]byte
+	l := 0
+	client.PutUint32(_reqBuf[l:4], i.ID())
+	l += 4
+	client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
+	l += 4
+	client.PutUint32(_reqBuf[l:l+4], id.ID())
+	l += 4
+	client.PutUint32(_reqBuf[l:l+4], output.ID())
+	l += 4
+	err := i.Context().WriteMsg(_reqBuf[:], nil)
+	return id, err
+}
+
+// ZdwlIpcManagerV2TagsEvent : Announces tag amount
+//
+// This event is sent after binding.
+// A roundtrip after binding guarantees the client recieved all tags.
+type ZdwlIpcManagerV2TagsEvent struct {
+	Amount uint32
+}
+type ZdwlIpcManagerV2TagsHandlerFunc func(ZdwlIpcManagerV2TagsEvent)
+
+// SetTagsHandler : sets handler for ZdwlIpcManagerV2TagsEvent
+func (i *ZdwlIpcManagerV2) SetTagsHandler(f ZdwlIpcManagerV2TagsHandlerFunc) {
+	i.tagsHandler = f
+}
+
+// ZdwlIpcManagerV2LayoutEvent : Announces a layout
+//
+// This event is sent after binding.
+// A roundtrip after binding guarantees the client recieved all layouts.
+type ZdwlIpcManagerV2LayoutEvent struct {
+	Name string
+}
+type ZdwlIpcManagerV2LayoutHandlerFunc func(ZdwlIpcManagerV2LayoutEvent)
+
+// SetLayoutHandler : sets handler for ZdwlIpcManagerV2LayoutEvent
+func (i *ZdwlIpcManagerV2) SetLayoutHandler(f ZdwlIpcManagerV2LayoutHandlerFunc) {
+	i.layoutHandler = f
+}
+
+func (i *ZdwlIpcManagerV2) Dispatch(opcode uint32, fd int, data []byte) {
+	switch opcode {
+	case 0:
+		if i.tagsHandler == nil {
+			return
+		}
+		var e ZdwlIpcManagerV2TagsEvent
+		l := 0
+		e.Amount = client.Uint32(data[l : l+4])
+		l += 4
+
+		i.tagsHandler(e)
+	case 1:
+		if i.layoutHandler == nil {
+			return
+		}
+		var e ZdwlIpcManagerV2LayoutEvent
+		l := 0
+		nameLen := client.PaddedLen(int(client.Uint32(data[l : l+4])))
+		l += 4
+		e.Name = client.String(data[l : l+nameLen])
+		l += nameLen
+
+		i.layoutHandler(e)
+	}
+}
+
+// ZdwlIpcOutputV2InterfaceName is the name of the interface as it appears in the [client.Registry].
+// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
+// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
+const ZdwlIpcOutputV2InterfaceName = "zdwl_ipc_output_v2"
+
+// ZdwlIpcOutputV2 : control dwl output
+//
+// Observe and control a dwl output.
+//
+// Events are double-buffered:
+// Clients should cache events and redraw when a dwl_ipc_output.frame event is sent.
+//
+// Request are not double-buffered:
+// The compositor will update immediately upon request.
+type ZdwlIpcOutputV2 struct {
+	client.BaseProxy
+	toggleVisibilityHandler ZdwlIpcOutputV2ToggleVisibilityHandlerFunc
+	activeHandler           ZdwlIpcOutputV2ActiveHandlerFunc
+	tagHandler              ZdwlIpcOutputV2TagHandlerFunc
+	layoutHandler           ZdwlIpcOutputV2LayoutHandlerFunc
+	titleHandler            ZdwlIpcOutputV2TitleHandlerFunc
+	appidHandler            ZdwlIpcOutputV2AppidHandlerFunc
+	layoutSymbolHandler     ZdwlIpcOutputV2LayoutSymbolHandlerFunc
+	frameHandler            ZdwlIpcOutputV2FrameHandlerFunc
+	fullscreenHandler       ZdwlIpcOutputV2FullscreenHandlerFunc
+	floatingHandler         ZdwlIpcOutputV2FloatingHandlerFunc
+	xHandler                ZdwlIpcOutputV2XHandlerFunc
+	yHandler                ZdwlIpcOutputV2YHandlerFunc
+	widthHandler            ZdwlIpcOutputV2WidthHandlerFunc
+	heightHandler           ZdwlIpcOutputV2HeightHandlerFunc
+	lastLayerHandler        ZdwlIpcOutputV2LastLayerHandlerFunc
+	kbLayoutHandler         ZdwlIpcOutputV2KbLayoutHandlerFunc
+	keymodeHandler          ZdwlIpcOutputV2KeymodeHandlerFunc
+	scalefactorHandler      ZdwlIpcOutputV2ScalefactorHandlerFunc
+}
+
+// NewZdwlIpcOutputV2 : control dwl output
+//
+// Observe and control a dwl output.
+//
+// Events are double-buffered:
+// Clients should cache events and redraw when a dwl_ipc_output.frame event is sent.
+//
+// Request are not double-buffered:
+// The compositor will update immediately upon request.
+func NewZdwlIpcOutputV2(ctx *client.Context) *ZdwlIpcOutputV2 {
+	zdwlIpcOutputV2 := &ZdwlIpcOutputV2{}
+	ctx.Register(zdwlIpcOutputV2)
+	return zdwlIpcOutputV2
+}
+
+// Release : release dwl_ipc_outout
+//
+// Indicates to that the client no longer needs this dwl_ipc_output.
+func (i *ZdwlIpcOutputV2) Release() error {
+	defer i.MarkZombie()
+	const opcode = 0
+	const _reqBufLen = 8
+	var _reqBuf [_reqBufLen]byte
+	l := 0
+	client.PutUint32(_reqBuf[l:4], i.ID())
+	l += 4
+	client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
+	l += 4
+	err := i.Context().WriteMsg(_reqBuf[:], nil)
+	return err
+}
+
+// SetTags : Set the active tags of this output
+//
+//	tagmask: bitmask of the tags that should be set.
+//	toggleTagset: toggle the selected tagset, zero for invalid, nonzero for valid.
+func (i *ZdwlIpcOutputV2) SetTags(tagmask, toggleTagset uint32) error {
+	const opcode = 1
+	const _reqBufLen = 8 + 4 + 4
+	var _reqBuf [_reqBufLen]byte
+	l := 0
+	client.PutUint32(_reqBuf[l:4], i.ID())
+	l += 4
+	client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
+	l += 4
+	client.PutUint32(_reqBuf[l:l+4], uint32(tagmask))
+	l += 4
+	client.PutUint32(_reqBuf[l:l+4], uint32(toggleTagset))
+	l += 4
+	err := i.Context().WriteMsg(_reqBuf[:], nil)
+	return err
+}
+
+// SetClientTags : Set the tags of the focused client.
+//
+// The tags are updated as follows:
+// new_tags = (current_tags AND and_tags) XOR xor_tags
+func (i *ZdwlIpcOutputV2) SetClientTags(andTags, xorTags uint32) error {
+	const opcode = 2
+	const _reqBufLen = 8 + 4 + 4
+	var _reqBuf [_reqBufLen]byte
+	l := 0
+	client.PutUint32(_reqBuf[l:4], i.ID())
+	l += 4
+	client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
+	l += 4
+	client.PutUint32(_reqBuf[l:l+4], uint32(andTags))
+	l += 4
+	client.PutUint32(_reqBuf[l:l+4], uint32(xorTags))
+	l += 4
+	err := i.Context().WriteMsg(_reqBuf[:], nil)
+	return err
+}
+
+// SetLayout : Set the layout of this output
+//
+//	index: index of a layout recieved by dwl_ipc_manager.layout
+func (i *ZdwlIpcOutputV2) SetLayout(index uint32) error {
+	const opcode = 3
+	const _reqBufLen = 8 + 4
+	var _reqBuf [_reqBufLen]byte
+	l := 0
+	client.PutUint32(_reqBuf[l:4], i.ID())
+	l += 4
+	client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
+	l += 4
+	client.PutUint32(_reqBuf[l:l+4], uint32(index))
+	l += 4
+	err := i.Context().WriteMsg(_reqBuf[:], nil)
+	return err
+}
+
+// Quit : Quit mango
+// This request allows clients to instruct the compositor to quit mango.
+func (i *ZdwlIpcOutputV2) Quit() error {
+	const opcode = 4
+	const _reqBufLen = 8
+	var _reqBuf [_reqBufLen]byte
+	l := 0
+	client.PutUint32(_reqBuf[l:4], i.ID())
+	l += 4
+	client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
+	l += 4
+	err := i.Context().WriteMsg(_reqBuf[:], nil)
+	return err
+}
+
+// SendDispatch : Set the active tags of this output
+//
+//	dispatch: dispatch name.
+//	arg1: arg1.
+//	arg2: arg2.
+//	arg3: arg3.
+//	arg4: arg4.
+//	arg5: arg5.
+func (i *ZdwlIpcOutputV2) SendDispatch(dispatch, arg1, arg2, arg3, arg4, arg5 string) error {
+	const opcode = 5
+	dispatchLen := client.PaddedLen(len(dispatch) + 1)
+	arg1Len := client.PaddedLen(len(arg1) + 1)
+	arg2Len := client.PaddedLen(len(arg2) + 1)
+	arg3Len := client.PaddedLen(len(arg3) + 1)
+	arg4Len := client.PaddedLen(len(arg4) + 1)
+	arg5Len := client.PaddedLen(len(arg5) + 1)
+	_reqBufLen := 8 + (4 + dispatchLen) + (4 + arg1Len) + (4 + arg2Len) + (4 + arg3Len) + (4 + arg4Len) + (4 + arg5Len)
+	_reqBuf := make([]byte, _reqBufLen)
+	l := 0
+	client.PutUint32(_reqBuf[l:4], i.ID())
+	l += 4
+	client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
+	l += 4
+	client.PutString(_reqBuf[l:l+(4+dispatchLen)], dispatch)
+	l += (4 + dispatchLen)
+	client.PutString(_reqBuf[l:l+(4+arg1Len)], arg1)
+	l += (4 + arg1Len)
+	client.PutString(_reqBuf[l:l+(4+arg2Len)], arg2)
+	l += (4 + arg2Len)
+	client.PutString(_reqBuf[l:l+(4+arg3Len)], arg3)
+	l += (4 + arg3Len)
+	client.PutString(_reqBuf[l:l+(4+arg4Len)], arg4)
+	l += (4 + arg4Len)
+	client.PutString(_reqBuf[l:l+(4+arg5Len)], arg5)
+	l += (4 + arg5Len)
+	err := i.Context().WriteMsg(_reqBuf, nil)
+	return err
+}
+
+type ZdwlIpcOutputV2TagState uint32
+
+// ZdwlIpcOutputV2TagState :
+const (
+	// ZdwlIpcOutputV2TagStateNone : no state
+	ZdwlIpcOutputV2TagStateNone ZdwlIpcOutputV2TagState = 0
+	// ZdwlIpcOutputV2TagStateActive : tag is active
+	ZdwlIpcOutputV2TagStateActive ZdwlIpcOutputV2TagState = 1
+	// ZdwlIpcOutputV2TagStateUrgent : tag has at least one urgent client
+	ZdwlIpcOutputV2TagStateUrgent ZdwlIpcOutputV2TagState = 2
+)
+
+func (e ZdwlIpcOutputV2TagState) Name() string {
+	switch e {
+	case ZdwlIpcOutputV2TagStateNone:
+		return "none"
+	case ZdwlIpcOutputV2TagStateActive:
+		return "active"
+	case ZdwlIpcOutputV2TagStateUrgent:
+		return "urgent"
+	default:
+		return ""
+	}
+}
+
+func (e ZdwlIpcOutputV2TagState) Value() string {
+	switch e {
+	case ZdwlIpcOutputV2TagStateNone:
+		return "0"
+	case ZdwlIpcOutputV2TagStateActive:
+		return "1"
+	case ZdwlIpcOutputV2TagStateUrgent:
+		return "2"
+	default:
+		return ""
+	}
+}
+
+func (e ZdwlIpcOutputV2TagState) String() string {
+	return e.Name() + "=" + e.Value()
+}
+
+// ZdwlIpcOutputV2ToggleVisibilityEvent : Toggle client visibilty
+//
+// Indicates the client should hide or show themselves.
+// If the client is visible then hide, if hidden then show.
+type ZdwlIpcOutputV2ToggleVisibilityEvent struct{}
+type ZdwlIpcOutputV2ToggleVisibilityHandlerFunc func(ZdwlIpcOutputV2ToggleVisibilityEvent)
+
+// SetToggleVisibilityHandler : sets handler for ZdwlIpcOutputV2ToggleVisibilityEvent
+func (i *ZdwlIpcOutputV2) SetToggleVisibilityHandler(f ZdwlIpcOutputV2ToggleVisibilityHandlerFunc) {
+	i.toggleVisibilityHandler = f
+}
+
+// ZdwlIpcOutputV2ActiveEvent : Update the selected output.
+//
+// Indicates if the output is active. Zero is invalid, nonzero is valid.
+type ZdwlIpcOutputV2ActiveEvent struct {
+	Active uint32
+}
+type ZdwlIpcOutputV2ActiveHandlerFunc func(ZdwlIpcOutputV2ActiveEvent)
+
+// SetActiveHandler : sets handler for ZdwlIpcOutputV2ActiveEvent
+func (i *ZdwlIpcOutputV2) SetActiveHandler(f ZdwlIpcOutputV2ActiveHandlerFunc) {
+	i.activeHandler = f
+}
+
+// ZdwlIpcOutputV2TagEvent : Update the state of a tag.
+//
+// Indicates that a tag has been updated.
+type ZdwlIpcOutputV2TagEvent struct {
+	Tag     uint32
+	State   uint32
+	Clients uint32
+	Focused uint32
+}
+type ZdwlIpcOutputV2TagHandlerFunc func(ZdwlIpcOutputV2TagEvent)
+
+// SetTagHandler : sets handler for ZdwlIpcOutputV2TagEvent
+func (i *ZdwlIpcOutputV2) SetTagHandler(f ZdwlIpcOutputV2TagHandlerFunc) {
+	i.tagHandler = f
+}
+
+// ZdwlIpcOutputV2LayoutEvent : Update the layout.
+//
+// Indicates a new layout is selected.
+type ZdwlIpcOutputV2LayoutEvent struct {
+	Layout uint32
+}
+type ZdwlIpcOutputV2LayoutHandlerFunc func(ZdwlIpcOutputV2LayoutEvent)
+
+// SetLayoutHandler : sets handler for ZdwlIpcOutputV2LayoutEvent
+func (i *ZdwlIpcOutputV2) SetLayoutHandler(f ZdwlIpcOutputV2LayoutHandlerFunc) {
+	i.layoutHandler = f
+}
+
+// ZdwlIpcOutputV2TitleEvent : Update the title.
+//
+// Indicates the title has changed.
+type ZdwlIpcOutputV2TitleEvent struct {
+	Title string
+}
+type ZdwlIpcOutputV2TitleHandlerFunc func(ZdwlIpcOutputV2TitleEvent)
+
+// SetTitleHandler : sets handler for ZdwlIpcOutputV2TitleEvent
+func (i *ZdwlIpcOutputV2) SetTitleHandler(f ZdwlIpcOutputV2TitleHandlerFunc) {
+	i.titleHandler = f
+}
+
+// ZdwlIpcOutputV2AppidEvent : Update the appid.
+//
+// Indicates the appid has changed.
+type ZdwlIpcOutputV2AppidEvent struct {
+	Appid string
+}
+type ZdwlIpcOutputV2AppidHandlerFunc func(ZdwlIpcOutputV2AppidEvent)
+
+// SetAppidHandler : sets handler for ZdwlIpcOutputV2AppidEvent
+func (i *ZdwlIpcOutputV2) SetAppidHandler(f ZdwlIpcOutputV2AppidHandlerFunc) {
+	i.appidHandler = f
+}
+
+// ZdwlIpcOutputV2LayoutSymbolEvent : Update the current layout symbol
+//
+// Indicates the layout has changed. Since layout symbols are dynamic.
+// As opposed to the zdwl_ipc_manager.layout event, this should take precendence when displaying.
+// You can ignore the zdwl_ipc_output.layout event.
+type ZdwlIpcOutputV2LayoutSymbolEvent struct {
+	Layout string
+}
+type ZdwlIpcOutputV2LayoutSymbolHandlerFunc func(ZdwlIpcOutputV2LayoutSymbolEvent)
+
+// SetLayoutSymbolHandler : sets handler for ZdwlIpcOutputV2LayoutSymbolEvent
+func (i *ZdwlIpcOutputV2) SetLayoutSymbolHandler(f ZdwlIpcOutputV2LayoutSymbolHandlerFunc) {
+	i.layoutSymbolHandler = f
+}
+
+// ZdwlIpcOutputV2FrameEvent : The update sequence is done.
+//
+// Indicates that a sequence of status updates have finished and the client should redraw.
+type ZdwlIpcOutputV2FrameEvent struct{}
+type ZdwlIpcOutputV2FrameHandlerFunc func(ZdwlIpcOutputV2FrameEvent)
+
+// SetFrameHandler : sets handler for ZdwlIpcOutputV2FrameEvent
+func (i *ZdwlIpcOutputV2) SetFrameHandler(f ZdwlIpcOutputV2FrameHandlerFunc) {
+	i.frameHandler = f
+}
+
+// ZdwlIpcOutputV2FullscreenEvent : Update fullscreen status
+//
+// Indicates if the selected client on this output is fullscreen.
+type ZdwlIpcOutputV2FullscreenEvent struct {
+	IsFullscreen uint32
+}
+type ZdwlIpcOutputV2FullscreenHandlerFunc func(ZdwlIpcOutputV2FullscreenEvent)
+
+// SetFullscreenHandler : sets handler for ZdwlIpcOutputV2FullscreenEvent
+func (i *ZdwlIpcOutputV2) SetFullscreenHandler(f ZdwlIpcOutputV2FullscreenHandlerFunc) {
+	i.fullscreenHandler = f
+}
+
+// ZdwlIpcOutputV2FloatingEvent : Update the floating status
+//
+// Indicates if the selected client on this output is floating.
+type ZdwlIpcOutputV2FloatingEvent struct {
+	IsFloating uint32
+}
+type ZdwlIpcOutputV2FloatingHandlerFunc func(ZdwlIpcOutputV2FloatingEvent)
+
+// SetFloatingHandler : sets handler for ZdwlIpcOutputV2FloatingEvent
+func (i *ZdwlIpcOutputV2) SetFloatingHandler(f ZdwlIpcOutputV2FloatingHandlerFunc) {
+	i.floatingHandler = f
+}
+
+// ZdwlIpcOutputV2XEvent : Update the x coordinates
+//
+// Indicates if x coordinates of the selected client.
+type ZdwlIpcOutputV2XEvent struct {
+	X int32
+}
+type ZdwlIpcOutputV2XHandlerFunc func(ZdwlIpcOutputV2XEvent)
+
+// SetXHandler : sets handler for ZdwlIpcOutputV2XEvent
+func (i *ZdwlIpcOutputV2) SetXHandler(f ZdwlIpcOutputV2XHandlerFunc) {
+	i.xHandler = f
+}
+
+// ZdwlIpcOutputV2YEvent : Update the y coordinates
+//
+// Indicates if y coordinates of the selected client.
+type ZdwlIpcOutputV2YEvent struct {
+	Y int32
+}
+type ZdwlIpcOutputV2YHandlerFunc func(ZdwlIpcOutputV2YEvent)
+
+// SetYHandler : sets handler for ZdwlIpcOutputV2YEvent
+func (i *ZdwlIpcOutputV2) SetYHandler(f ZdwlIpcOutputV2YHandlerFunc) {
+	i.yHandler = f
+}
+
+// ZdwlIpcOutputV2WidthEvent : Update the width
+//
+// Indicates if width of the selected client.
+type ZdwlIpcOutputV2WidthEvent struct {
+	Width int32
+}
+type ZdwlIpcOutputV2WidthHandlerFunc func(ZdwlIpcOutputV2WidthEvent)
+
+// SetWidthHandler : sets handler for ZdwlIpcOutputV2WidthEvent
+func (i *ZdwlIpcOutputV2) SetWidthHandler(f ZdwlIpcOutputV2WidthHandlerFunc) {
+	i.widthHandler = f
+}
+
+// ZdwlIpcOutputV2HeightEvent : Update the height
+//
+// Indicates if height of the selected client.
+type ZdwlIpcOutputV2HeightEvent struct {
+	Height int32
+}
+type ZdwlIpcOutputV2HeightHandlerFunc func(ZdwlIpcOutputV2HeightEvent)
+
+// SetHeightHandler : sets handler for ZdwlIpcOutputV2HeightEvent
+func (i *ZdwlIpcOutputV2) SetHeightHandler(f ZdwlIpcOutputV2HeightHandlerFunc) {
+	i.heightHandler = f
+}
+
+// ZdwlIpcOutputV2LastLayerEvent : last map layer.
+//
+// last map layer.
+type ZdwlIpcOutputV2LastLayerEvent struct {
+	LastLayer string
+}
+type ZdwlIpcOutputV2LastLayerHandlerFunc func(ZdwlIpcOutputV2LastLayerEvent)
+
+// SetLastLayerHandler : sets handler for ZdwlIpcOutputV2LastLayerEvent
+func (i *ZdwlIpcOutputV2) SetLastLayerHandler(f ZdwlIpcOutputV2LastLayerHandlerFunc) {
+	i.lastLayerHandler = f
+}
+
+// ZdwlIpcOutputV2KbLayoutEvent : current keyboard layout.
+//
+// current keyboard layout.
+type ZdwlIpcOutputV2KbLayoutEvent struct {
+	KbLayout string
+}
+type ZdwlIpcOutputV2KbLayoutHandlerFunc func(ZdwlIpcOutputV2KbLayoutEvent)
+
+// SetKbLayoutHandler : sets handler for ZdwlIpcOutputV2KbLayoutEvent
+func (i *ZdwlIpcOutputV2) SetKbLayoutHandler(f ZdwlIpcOutputV2KbLayoutHandlerFunc) {
+	i.kbLayoutHandler = f
+}
+
+// ZdwlIpcOutputV2KeymodeEvent : current keybind mode.
+//
+// current keybind mode.
+type ZdwlIpcOutputV2KeymodeEvent struct {
+	Keymode string
+}
+type ZdwlIpcOutputV2KeymodeHandlerFunc func(ZdwlIpcOutputV2KeymodeEvent)
+
+// SetKeymodeHandler : sets handler for ZdwlIpcOutputV2KeymodeEvent
+func (i *ZdwlIpcOutputV2) SetKeymodeHandler(f ZdwlIpcOutputV2KeymodeHandlerFunc) {
+	i.keymodeHandler = f
+}
+
+// ZdwlIpcOutputV2ScalefactorEvent : scale factor of monitor.
+//
+// scale factor of monitor.
+type ZdwlIpcOutputV2ScalefactorEvent struct {
+	Scalefactor uint32
+}
+type ZdwlIpcOutputV2ScalefactorHandlerFunc func(ZdwlIpcOutputV2ScalefactorEvent)
+
+// SetScalefactorHandler : sets handler for ZdwlIpcOutputV2ScalefactorEvent
+func (i *ZdwlIpcOutputV2) SetScalefactorHandler(f ZdwlIpcOutputV2ScalefactorHandlerFunc) {
+	i.scalefactorHandler = f
+}
+
+func (i *ZdwlIpcOutputV2) Dispatch(opcode uint32, fd int, data []byte) {
+	switch opcode {
+	case 0:
+		if i.toggleVisibilityHandler == nil {
+			return
+		}
+		var e ZdwlIpcOutputV2ToggleVisibilityEvent
+
+		i.toggleVisibilityHandler(e)
+	case 1:
+		if i.activeHandler == nil {
+			return
+		}
+		var e ZdwlIpcOutputV2ActiveEvent
+		l := 0
+		e.Active = client.Uint32(data[l : l+4])
+		l += 4
+
+		i.activeHandler(e)
+	case 2:
+		if i.tagHandler == nil {
+			return
+		}
+		var e ZdwlIpcOutputV2TagEvent
+		l := 0
+		e.Tag = client.Uint32(data[l : l+4])
+		l += 4
+		e.State = client.Uint32(data[l : l+4])
+		l += 4
+		e.Clients = client.Uint32(data[l : l+4])
+		l += 4
+		e.Focused = client.Uint32(data[l : l+4])
+		l += 4
+
+		i.tagHandler(e)
+	case 3:
+		if i.layoutHandler == nil {
+			return
+		}
+		var e ZdwlIpcOutputV2LayoutEvent
+		l := 0
+		e.Layout = client.Uint32(data[l : l+4])
+		l += 4
+
+		i.layoutHandler(e)
+	case 4:
+		if i.titleHandler == nil {
+			return
+		}
+		var e ZdwlIpcOutputV2TitleEvent
+		l := 0
+		titleLen := client.PaddedLen(int(client.Uint32(data[l : l+4])))
+		l += 4
+		e.Title = client.String(data[l : l+titleLen])
+		l += titleLen
+
+		i.titleHandler(e)
+	case 5:
+		if i.appidHandler == nil {
+			return
+		}
+		var e ZdwlIpcOutputV2AppidEvent
+		l := 0
+		appidLen := client.PaddedLen(int(client.Uint32(data[l : l+4])))
+		l += 4
+		e.Appid = client.String(data[l : l+appidLen])
+		l += appidLen
+
+		i.appidHandler(e)
+	case 6:
+		if i.layoutSymbolHandler == nil {
+			return
+		}
+		var e ZdwlIpcOutputV2LayoutSymbolEvent
+		l := 0
+		layoutLen := client.PaddedLen(int(client.Uint32(data[l : l+4])))
+		l += 4
+		e.Layout = client.String(data[l : l+layoutLen])
+		l += layoutLen
+
+		i.layoutSymbolHandler(e)
+	case 7:
+		if i.frameHandler == nil {
+			return
+		}
+		var e ZdwlIpcOutputV2FrameEvent
+
+		i.frameHandler(e)
+	case 8:
+		if i.fullscreenHandler == nil {
+			return
+		}
+		var e ZdwlIpcOutputV2FullscreenEvent
+		l := 0
+		e.IsFullscreen = client.Uint32(data[l : l+4])
+		l += 4
+
+		i.fullscreenHandler(e)
+	case 9:
+		if i.floatingHandler == nil {
+			return
+		}
+		var e ZdwlIpcOutputV2FloatingEvent
+		l := 0
+		e.IsFloating = client.Uint32(data[l : l+4])
+		l += 4
+
+		i.floatingHandler(e)
+	case 10:
+		if i.xHandler == nil {
+			return
+		}
+		var e ZdwlIpcOutputV2XEvent
+		l := 0
+		e.X = int32(client.Uint32(data[l : l+4]))
+		l += 4
+
+		i.xHandler(e)
+	case 11:
+		if i.yHandler == nil {
+			return
+		}
+		var e ZdwlIpcOutputV2YEvent
+		l := 0
+		e.Y = int32(client.Uint32(data[l : l+4]))
+		l += 4
+
+		i.yHandler(e)
+	case 12:
+		if i.widthHandler == nil {
+			return
+		}
+		var e ZdwlIpcOutputV2WidthEvent
+		l := 0
+		e.Width = int32(client.Uint32(data[l : l+4]))
+		l += 4
+
+		i.widthHandler(e)
+	case 13:
+		if i.heightHandler == nil {
+			return
+		}
+		var e ZdwlIpcOutputV2HeightEvent
+		l := 0
+		e.Height = int32(client.Uint32(data[l : l+4]))
+		l += 4
+
+		i.heightHandler(e)
+	case 14:
+		if i.lastLayerHandler == nil {
+			return
+		}
+		var e ZdwlIpcOutputV2LastLayerEvent
+		l := 0
+		lastLayerLen := client.PaddedLen(int(client.Uint32(data[l : l+4])))
+		l += 4
+		e.LastLayer = client.String(data[l : l+lastLayerLen])
+		l += lastLayerLen
+
+		i.lastLayerHandler(e)
+	case 15:
+		if i.kbLayoutHandler == nil {
+			return
+		}
+		var e ZdwlIpcOutputV2KbLayoutEvent
+		l := 0
+		kbLayoutLen := client.PaddedLen(int(client.Uint32(data[l : l+4])))
+		l += 4
+		e.KbLayout = client.String(data[l : l+kbLayoutLen])
+		l += kbLayoutLen
+
+		i.kbLayoutHandler(e)
+	case 16:
+		if i.keymodeHandler == nil {
+			return
+		}
+		var e ZdwlIpcOutputV2KeymodeEvent
+		l := 0
+		keymodeLen := client.PaddedLen(int(client.Uint32(data[l : l+4])))
+		l += 4
+		e.Keymode = client.String(data[l : l+keymodeLen])
+		l += keymodeLen
+
+		i.keymodeHandler(e)
+	case 17:
+		if i.scalefactorHandler == nil {
+			return
+		}
+		var e ZdwlIpcOutputV2ScalefactorEvent
+		l := 0
+		e.Scalefactor = client.Uint32(data[l : l+4])
+		l += 4
+
+		i.scalefactorHandler(e)
+	}
+}

core/internal/qmlchecks/lockscreen_input_test.go

@@ -1,25 +0,0 @@
-package qmlchecks
-
-import (
-	"os"
-	"regexp"
-	"strings"
-	"testing"
-)
-
-func TestLockScreenPasswordFieldBypassesTextInputIME(t *testing.T) {
-	data, err := os.ReadFile("../../../quickshell/Modules/Lock/LockScreenContent.qml")
-	if err != nil {
-		t.Fatalf("read lock screen QML: %v", err)
-	}
-
-	content := string(data)
-	textInputPasswordField := regexp.MustCompile(`(?s)TextInput\s*\{[^{}]*id:\s*passwordField`)
-	if textInputPasswordField.MatchString(content) {
-		t.Fatalf("passwordField must not be a TextInput because TextInput can route physical keyboard input through IME")
-	}
-
-	if !strings.Contains(content, "Keys.onPressed") || !strings.Contains(content, "event.text") {
-		t.Fatalf("passwordField should handle physical key text manually instead of relying on a text input control")
-	}
-}

core/internal/screenshot/compositor.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"os/exec"
 
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/proto/dwl_ipc"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/proto/wlr_output_management"
 	wlhelpers "github.com/AvengeMedia/DankMaterialShell/core/internal/wayland/client"
 	"github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
@@ -18,9 +19,9 @@ const (
 	CompositorHyprland
 	CompositorSway
 	CompositorNiri
+	CompositorDWL
 	CompositorScroll
 	CompositorMiracle
-	CompositorMango
 )
 
 var detectedCompositor Compositor = -1
@@ -35,14 +36,8 @@ func DetectCompositor() Compositor {
 	swaySocket := os.Getenv("SWAYSOCK")
 	scrollSocket := os.Getenv("SCROLLSOCK")
 	miracleSocket := os.Getenv("MIRACLESOCK")
-	mangoSocket := os.Getenv("MANGO_INSTANCE_SIGNATURE")
 
 	switch {
-	case mangoSocket != "":
-		if _, err := os.Stat(mangoSocket); err == nil {
-			detectedCompositor = CompositorMango
-			return detectedCompositor
-		}
 	case niriSocket != "":
 		if _, err := os.Stat(niriSocket); err == nil {
 			detectedCompositor = CompositorNiri
@@ -68,29 +63,66 @@ func DetectCompositor() Compositor {
 		return detectedCompositor
 	}
 
+	if detectDWLProtocol() {
+		detectedCompositor = CompositorDWL
+		return detectedCompositor
+	}
+
 	detectedCompositor = CompositorUnknown
 	return detectedCompositor
 }
 
+func detectDWLProtocol() bool {
+	display, err := client.Connect("")
+	if err != nil {
+		return false
+	}
+	ctx := display.Context()
+	defer ctx.Close()
+
+	registry, err := display.GetRegistry()
+	if err != nil {
+		return false
+	}
+
+	found := false
+	registry.SetGlobalHandler(func(e client.RegistryGlobalEvent) {
+		if e.Interface == dwl_ipc.ZdwlIpcManagerV2InterfaceName {
+			found = true
+		}
+	})
+
+	if err := wlhelpers.Roundtrip(display, ctx); err != nil {
+		return false
+	}
+
+	return found
+}
+
+func SetCompositorDWL() {
+	detectedCompositor = CompositorDWL
+}
+
 type WindowGeometry struct {
-	X       int32
-	Y       int32
-	Width   int32
-	Height  int32
-	Output  string
-	Scale   float64
-	OutputX int32
-	OutputY int32
+	X               int32
+	Y               int32
+	Width           int32
+	Height          int32
+	Output          string
+	Scale           float64
+	OutputX         int32
+	OutputY         int32
+	OutputTransform int32
 }
 
 func GetActiveWindow() (*WindowGeometry, error) {
 	switch DetectCompositor() {
 	case CompositorHyprland:
 		return getHyprlandActiveWindow()
-	case CompositorMango:
-		return getMangoActiveWindow()
+	case CompositorDWL:
+		return getDWLActiveWindow()
 	default:
-		return nil, fmt.Errorf("window capture requires Hyprland or Mango")
+		return nil, fmt.Errorf("window capture requires Hyprland or DWL")
 	}
 }
 
@@ -253,93 +285,6 @@ func getMiracleFocusedMonitor() string {
 	return ""
 }
 
-type mangoMonitor struct {
-	Name   string  `json:"name"`
-	Active bool    `json:"active"`
-	X      int32   `json:"x"`
-	Y      int32   `json:"y"`
-	Scale  float64 `json:"scale"`
-}
-
-func getMangoMonitors() []mangoMonitor {
-	output, err := exec.Command("mmsg", "get", "all-monitors").Output()
-	if err != nil {
-		return nil
-	}
-
-	var data struct {
-		Monitors []mangoMonitor `json:"monitors"`
-	}
-	if err := json.Unmarshal(output, &data); err != nil {
-		return nil
-	}
-	return data.Monitors
-}
-
-func getMangoFocusedMonitor() string {
-	for _, m := range getMangoMonitors() {
-		if m.Active {
-			return m.Name
-		}
-	}
-	return ""
-}
-
-type mangoClient struct {
-	Monitor   string `json:"monitor"`
-	IsFocused bool   `json:"is_focused"`
-	X         int32  `json:"x"`
-	Y         int32  `json:"y"`
-	Width     int32  `json:"width"`
-	Height    int32  `json:"height"`
-}
-
-func getMangoActiveWindow() (*WindowGeometry, error) {
-	output, err := exec.Command("mmsg", "get", "all-clients").Output()
-	if err != nil {
-		return nil, fmt.Errorf("mmsg get all-clients: %w", err)
-	}
-
-	var data struct {
-		Clients []mangoClient `json:"clients"`
-	}
-	if err := json.Unmarshal(output, &data); err != nil {
-		return nil, fmt.Errorf("parse all-clients: %w", err)
-	}
-
-	for _, c := range data.Clients {
-		if !c.IsFocused {
-			continue
-		}
-		if c.Width <= 0 || c.Height <= 0 {
-			return nil, fmt.Errorf("no active window")
-		}
-
-		geom := &WindowGeometry{
-			X:      c.X,
-			Y:      c.Y,
-			Width:  c.Width,
-			Height: c.Height,
-			Output: c.Monitor,
-			Scale:  1.0,
-		}
-		for _, m := range getMangoMonitors() {
-			if m.Name != c.Monitor {
-				continue
-			}
-			geom.OutputX = m.X
-			geom.OutputY = m.Y
-			if m.Scale > 0 {
-				geom.Scale = m.Scale
-			}
-			break
-		}
-		return geom, nil
-	}
-
-	return nil, fmt.Errorf("no focused window")
-}
-
 type niriWorkspace struct {
 	Output    string `json:"output"`
 	IsFocused bool   `json:"is_focused"`
@@ -364,6 +309,121 @@ func getNiriFocusedMonitor() string {
 	return ""
 }
 
+var dwlActiveOutput string
+
+func SetDWLActiveOutput(name string) {
+	dwlActiveOutput = name
+}
+
+func getDWLFocusedMonitor() string {
+	if dwlActiveOutput != "" {
+		return dwlActiveOutput
+	}
+	return queryDWLActiveOutput()
+}
+
+func queryDWLActiveOutput() string {
+	display, err := client.Connect("")
+	if err != nil {
+		return ""
+	}
+	ctx := display.Context()
+	defer ctx.Close()
+
+	registry, err := display.GetRegistry()
+	if err != nil {
+		return ""
+	}
+
+	var dwlManager *dwl_ipc.ZdwlIpcManagerV2
+	outputs := make(map[uint32]*client.Output)
+
+	registry.SetGlobalHandler(func(e client.RegistryGlobalEvent) {
+		switch e.Interface {
+		case dwl_ipc.ZdwlIpcManagerV2InterfaceName:
+			mgr := dwl_ipc.NewZdwlIpcManagerV2(ctx)
+			if err := registry.Bind(e.Name, e.Interface, e.Version, mgr); err == nil {
+				dwlManager = mgr
+			}
+		case client.OutputInterfaceName:
+			out := client.NewOutput(ctx)
+			version := e.Version
+			if version > 4 {
+				version = 4
+			}
+			if err := registry.Bind(e.Name, e.Interface, version, out); err == nil {
+				outputs[e.Name] = out
+			}
+		}
+	})
+
+	if err := wlhelpers.Roundtrip(display, ctx); err != nil {
+		return ""
+	}
+
+	if dwlManager == nil || len(outputs) == 0 {
+		return ""
+	}
+
+	outputNames := make(map[uint32]string)
+	for name, out := range outputs {
+		n := name
+		out.SetNameHandler(func(e client.OutputNameEvent) {
+			outputNames[n] = e.Name
+		})
+	}
+
+	if err := wlhelpers.Roundtrip(display, ctx); err != nil {
+		return ""
+	}
+
+	type outputState struct {
+		name     string
+		active   bool
+		gotFrame bool
+	}
+	states := make(map[uint32]*outputState)
+
+	for name, out := range outputs {
+		dwlOut, err := dwlManager.GetOutput(out)
+		if err != nil {
+			continue
+		}
+		state := &outputState{name: outputNames[name]}
+		states[name] = state
+
+		dwlOut.SetActiveHandler(func(e dwl_ipc.ZdwlIpcOutputV2ActiveEvent) {
+			state.active = e.Active != 0
+		})
+		dwlOut.SetFrameHandler(func(e dwl_ipc.ZdwlIpcOutputV2FrameEvent) {
+			state.gotFrame = true
+		})
+	}
+
+	allFramesReceived := func() bool {
+		for _, s := range states {
+			if !s.gotFrame {
+				return false
+			}
+		}
+		return true
+	}
+
+	for !allFramesReceived() {
+		if err := ctx.Dispatch(); err != nil {
+			return ""
+		}
+	}
+
+	for _, state := range states {
+		if state.active {
+			return state.name
+		}
+	}
+
+	return ""
+}
+
 func GetFocusedMonitor() string {
 	switch DetectCompositor() {
 	case CompositorHyprland:
@@ -376,8 +436,8 @@ func GetFocusedMonitor() string {
 		return getMiracleFocusedMonitor()
 	case CompositorNiri:
 		return getNiriFocusedMonitor()
-	case CompositorMango:
-		return getMangoFocusedMonitor()
+	case CompositorDWL:
+		return getDWLFocusedMonitor()
 	}
 	return ""
 }
@@ -474,3 +534,161 @@ func getAllOutputInfos() map[string]*outputInfo {
 	}
 	return result
 }
+
+func getOutputInfo(outputName string) (*outputInfo, bool) {
+	infos := getAllOutputInfos()
+	if infos == nil {
+		return nil, false
+	}
+	info, ok := infos[outputName]
+	return info, ok
+}
+
+func getDWLActiveWindow() (*WindowGeometry, error) {
+	display, err := client.Connect("")
+	if err != nil {
+		return nil, fmt.Errorf("connect: %w", err)
+	}
+	ctx := display.Context()
+	defer ctx.Close()
+
+	registry, err := display.GetRegistry()
+	if err != nil {
+		return nil, fmt.Errorf("get registry: %w", err)
+	}
+
+	var dwlManager *dwl_ipc.ZdwlIpcManagerV2
+	outputs := make(map[uint32]*client.Output)
+
+	registry.SetGlobalHandler(func(e client.RegistryGlobalEvent) {
+		switch e.Interface {
+		case dwl_ipc.ZdwlIpcManagerV2InterfaceName:
+			mgr := dwl_ipc.NewZdwlIpcManagerV2(ctx)
+			if err := registry.Bind(e.Name, e.Interface, e.Version, mgr); err == nil {
+				dwlManager = mgr
+			}
+		case client.OutputInterfaceName:
+			out := client.NewOutput(ctx)
+			version := e.Version
+			if version > 4 {
+				version = 4
+			}
+			if err := registry.Bind(e.Name, e.Interface, version, out); err == nil {
+				outputs[e.Name] = out
+			}
+		}
+	})
+
+	if err := wlhelpers.Roundtrip(display, ctx); err != nil {
+		return nil, fmt.Errorf("roundtrip: %w", err)
+	}
+
+	if dwlManager == nil {
+		return nil, fmt.Errorf("dwl_ipc_manager not available")
+	}
+
+	if len(outputs) == 0 {
+		return nil, fmt.Errorf("no outputs found")
+	}
+
+	outputNames := make(map[uint32]string)
+	for name, out := range outputs {
+		n := name
+		out.SetNameHandler(func(e client.OutputNameEvent) {
+			outputNames[n] = e.Name
+		})
+	}
+
+	if err := wlhelpers.Roundtrip(display, ctx); err != nil {
+		return nil, fmt.Errorf("roundtrip: %w", err)
+	}
+
+	type dwlOutputState struct {
+		output      *dwl_ipc.ZdwlIpcOutputV2
+		name        string
+		active      bool
+		x, y        int32
+		w, h        int32
+		scalefactor uint32
+		gotFrame    bool
+	}
+
+	dwlOutputs := make(map[uint32]*dwlOutputState)
+	for name, out := range outputs {
+		dwlOut, err := dwlManager.GetOutput(out)
+		if err != nil {
+			continue
+		}
+		state := &dwlOutputState{output: dwlOut, name: outputNames[name]}
+		dwlOutputs[name] = state
+
+		dwlOut.SetActiveHandler(func(e dwl_ipc.ZdwlIpcOutputV2ActiveEvent) {
+			state.active = e.Active != 0
+		})
+		dwlOut.SetXHandler(func(e dwl_ipc.ZdwlIpcOutputV2XEvent) {
+			state.x = e.X
+		})
+		dwlOut.SetYHandler(func(e dwl_ipc.ZdwlIpcOutputV2YEvent) {
+			state.y = e.Y
+		})
+		dwlOut.SetWidthHandler(func(e dwl_ipc.ZdwlIpcOutputV2WidthEvent) {
+			state.w = e.Width
+		})
+		dwlOut.SetHeightHandler(func(e dwl_ipc.ZdwlIpcOutputV2HeightEvent) {
+			state.h = e.Height
+		})
+		dwlOut.SetScalefactorHandler(func(e dwl_ipc.ZdwlIpcOutputV2ScalefactorEvent) {
+			state.scalefactor = e.Scalefactor
+		})
+		dwlOut.SetFrameHandler(func(e dwl_ipc.ZdwlIpcOutputV2FrameEvent) {
+			state.gotFrame = true
+		})
+	}
+
+	allFramesReceived := func() bool {
+		for _, s := range dwlOutputs {
+			if !s.gotFrame {
+				return false
+			}
+		}
+		return true
+	}
+
+	for !allFramesReceived() {
+		if err := ctx.Dispatch(); err != nil {
+			return nil, fmt.Errorf("dispatch: %w", err)
+		}
+	}
+
+	for _, state := range dwlOutputs {
+		if !state.active {
+			continue
+		}
+		if state.w <= 0 || state.h <= 0 {
+			return nil, fmt.Errorf("no active window")
+		}
+		scale := float64(state.scalefactor) / 100.0
+		if scale <= 0 {
+			scale = 1.0
+		}
+
+		geom := &WindowGeometry{
+			X:      state.x,
+			Y:      state.y,
+			Width:  state.w,
+			Height: state.h,
+			Output: state.name,
+			Scale:  scale,
+		}
+
+		if info, ok := getOutputInfo(state.name); ok {
+			geom.OutputX = info.x
+			geom.OutputY = info.y
+			geom.OutputTransform = info.transform
+		}
+
+		return geom, nil
+	}
+
+	return nil, fmt.Errorf("no active output found")
+}

core/internal/screenshot/screenshot.go

@@ -156,14 +156,14 @@ func (s *Screenshoter) captureWindow() (*CaptureResult, error) {
 	switch DetectCompositor() {
 	case CompositorHyprland:
 		return s.captureAndCrop(output, region)
-	case CompositorMango:
-		return s.captureMangoWindow(output, region, geom)
+	case CompositorDWL:
+		return s.captureDWLWindow(output, region, geom)
 	default:
 		return s.captureRegionOnOutput(output, region)
 	}
 }
 
-func (s *Screenshoter) captureMangoWindow(output *WaylandOutput, region Region, geom *WindowGeometry) (*CaptureResult, error) {
+func (s *Screenshoter) captureDWLWindow(output *WaylandOutput, region Region, geom *WindowGeometry) (*CaptureResult, error) {
 	result, err := s.captureWholeOutput(output)
 	if err != nil {
 		return nil, err
@@ -628,7 +628,7 @@ func (s *Screenshoter) captureRegionOnOutput(output *WaylandOutput, region Regio
 	w := int32(float64(region.Width) * scale)
 	h := int32(float64(region.Height) * scale)
 
-	if DetectCompositor() == CompositorMango {
+	if DetectCompositor() == CompositorDWL {
 		scaledOutW := int32(float64(output.width) * scale)
 		scaledOutH := int32(float64(output.height) * scale)
 		if localX >= scaledOutW {

core/internal/server/clipboard/manager.go

@@ -935,7 +935,7 @@ func (m *Manager) CreateHistoryEntryFromPinned(pinnedEntry *Entry) error {
 		Pinned:    false,
 	}
 
-	if err := m.storeEntry(newEntry); err != nil {
+	if err := m.storeEntryWithoutDedup(newEntry); err != nil {
 		return err
 	}
 
@@ -945,6 +945,36 @@ func (m *Manager) CreateHistoryEntryFromPinned(pinnedEntry *Entry) error {
 	return nil
 }
 
+func (m *Manager) storeEntryWithoutDedup(entry Entry) error {
+	if m.db == nil {
+		return fmt.Errorf("database not available")
+	}
+
+	entry.Hash = computeHash(entry.Data)
+
+	return m.db.Update(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte("clipboard"))
+
+		id, err := b.NextSequence()
+		if err != nil {
+			return err
+		}
+
+		entry.ID = id
+
+		encoded, err := encodeEntry(entry)
+		if err != nil {
+			return err
+		}
+
+		if err := b.Put(itob(id), encoded); err != nil {
+			return err
+		}
+
+		return m.trimLengthInTx(b)
+	})
+}
+
 func (m *Manager) ClearHistory() {
 	if m.db == nil {
 		return
@@ -1623,37 +1653,6 @@ func (m *Manager) UnpinEntry(id uint64) error {
 			return err
 		}
 
-		if entry.Pinned {
-			currentKey := itob(id)
-			var keepKey []byte
-			var deleteKeys [][]byte
-
-			c := b.Cursor()
-			for k, v := c.Last(); k != nil; k, v = c.Prev() {
-				if bytes.Equal(k, currentKey) || extractHash(v) != entry.Hash {
-					continue
-				}
-				duplicate, err := decodeEntryMeta(v)
-				if err == nil && !duplicate.Pinned {
-					key := append([]byte(nil), k...)
-					if keepKey == nil {
-						keepKey = key
-					} else {
-						deleteKeys = append(deleteKeys, key)
-					}
-				}
-			}
-
-			if keepKey != nil {
-				for _, key := range deleteKeys {
-					if err := b.Delete(key); err != nil {
-						return err
-					}
-				}
-				return b.Delete(currentKey)
-			}
-		}
-
 		entry.Pinned = false
 		encoded, err := encodeEntry(entry)
 		if err != nil {

core/internal/server/clipboard/manager_test.go

@@ -14,7 +14,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
-	bolt "go.etcd.io/bbolt"
 
 	mocks_wlcontext "github.com/AvengeMedia/DankMaterialShell/core/internal/mocks/wlcontext"
 )
@@ -274,110 +273,6 @@ func TestHandleGetEntry_MissingIDReturnsNullResult(t *testing.T) {
 	assert.Nil(t, resp.Result)
 }
 
-func TestUnpinEntry_KeepsTopUnpinnedDuplicate(t *testing.T) {
-	m := newTestManagerWithDB(t)
-
-	require.NoError(t, m.storeEntry(Entry{
-		Data:      []byte("saved content"),
-		MimeType:  "text/plain;charset=utf-8",
-		Preview:   "saved content",
-		Size:      len("saved content"),
-		Timestamp: time.Now().Add(-time.Minute).Truncate(time.Second),
-		IsImage:   false,
-	}))
-
-	history := m.GetHistory()
-	require.Len(t, history, 1)
-	pinnedID := history[0].ID
-	require.NoError(t, m.PinEntry(pinnedID))
-
-	pinnedEntry, err := m.GetEntry(pinnedID)
-	require.NoError(t, err)
-	require.True(t, pinnedEntry.Pinned)
-
-	// Bypass storeEntry to simulate legacy duplicate ordinary history entries.
-	insertLegacyUnpinnedDuplicate := func(timestamp time.Time) Entry {
-		duplicate := Entry{
-			Data:      pinnedEntry.Data,
-			MimeType:  pinnedEntry.MimeType,
-			Preview:   pinnedEntry.Preview,
-			Size:      pinnedEntry.Size,
-			Timestamp: timestamp,
-			IsImage:   pinnedEntry.IsImage,
-			Pinned:    false,
-		}
-		duplicate.Hash = computeHash(duplicate.Data)
-
-		require.NoError(t, m.db.Update(func(tx *bolt.Tx) error {
-			b := tx.Bucket([]byte("clipboard"))
-			id, err := b.NextSequence()
-			if err != nil {
-				return err
-			}
-			duplicate.ID = id
-
-			encoded, err := encodeEntry(duplicate)
-			if err != nil {
-				return err
-			}
-			return b.Put(itob(id), encoded)
-		}))
-
-		return duplicate
-	}
-
-	olderHistoryDuplicate := insertLegacyUnpinnedDuplicate(time.Now().Add(time.Hour))
-	topHistoryDuplicate := insertLegacyUnpinnedDuplicate(time.Now().Add(-time.Hour))
-	require.Greater(t, topHistoryDuplicate.ID, olderHistoryDuplicate.ID)
-	require.True(t, olderHistoryDuplicate.Timestamp.After(topHistoryDuplicate.Timestamp))
-
-	history = m.GetHistory()
-	require.Len(t, history, 3)
-	require.Equal(t, topHistoryDuplicate.ID, history[0].ID)
-	require.NoError(t, m.UnpinEntry(pinnedID))
-
-	history = m.GetHistory()
-	require.Len(t, history, 1)
-	assert.False(t, history[0].Pinned)
-	assert.Equal(t, pinnedEntry.Hash, history[0].Hash)
-	assert.Equal(t, topHistoryDuplicate.ID, history[0].ID)
-}
-
-func TestCreateHistoryEntryFromPinned_KeepsLatestUnpinnedDuplicate(t *testing.T) {
-	m := newTestManagerWithDB(t)
-
-	require.NoError(t, m.storeEntry(Entry{
-		Data:      []byte("saved content"),
-		MimeType:  "text/plain;charset=utf-8",
-		Preview:   "saved content",
-		Size:      len("saved content"),
-		Timestamp: time.Now().Add(-time.Minute).Truncate(time.Second),
-		IsImage:   false,
-	}))
-
-	history := m.GetHistory()
-	require.Len(t, history, 1)
-	pinnedID := history[0].ID
-	require.NoError(t, m.PinEntry(pinnedID))
-
-	pinnedEntry, err := m.GetEntry(pinnedID)
-	require.NoError(t, err)
-	require.True(t, pinnedEntry.Pinned)
-	require.NoError(t, m.CreateHistoryEntryFromPinned(pinnedEntry))
-	firstDuplicate := m.GetHistory()[0]
-	require.NotEqual(t, pinnedID, firstDuplicate.ID)
-	require.NoError(t, m.CreateHistoryEntryFromPinned(pinnedEntry))
-	latestDuplicate := m.GetHistory()[0]
-
-	history = m.GetHistory()
-	require.Len(t, history, 2)
-	assert.Equal(t, latestDuplicate.ID, history[0].ID)
-	assert.False(t, history[0].Pinned)
-	assert.Equal(t, pinnedID, history[1].ID)
-	assert.True(t, history[1].Pinned)
-	assert.NotEqual(t, firstDuplicate.ID, latestDuplicate.ID)
-}
-
 func TestManager_ConcurrentSubscriberAccess(t *testing.T) {
 	m := &Manager{
 		subscribers: make(map[string]chan State),

core/internal/server/dwl/handlers.go

@@ -0,0 +1,138 @@
+package dwl
+
+import (
+	"encoding/json"
+	"fmt"
+	"net"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+)
+
+type SuccessResult struct {
+	Success bool   `json:"success"`
+	Message string `json:"message"`
+}
+
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
+	if manager == nil {
+		models.RespondError(conn, req.ID, "dwl manager not initialized")
+		return
+	}
+
+	switch req.Method {
+	case "dwl.getState":
+		handleGetState(conn, req, manager)
+	case "dwl.setTags":
+		handleSetTags(conn, req, manager)
+	case "dwl.setClientTags":
+		handleSetClientTags(conn, req, manager)
+	case "dwl.setLayout":
+		handleSetLayout(conn, req, manager)
+	case "dwl.subscribe":
+		handleSubscribe(conn, req, manager)
+	default:
+		models.RespondError(conn, req.ID, fmt.Sprintf("unknown method: %s", req.Method))
+	}
+}
+
+func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
+	state := manager.GetState()
+	models.Respond(conn, req.ID, state)
+}
+
+func handleSetTags(conn net.Conn, req models.Request, manager *Manager) {
+	output, ok := models.Get[string](req, "output")
+	if !ok {
+		models.RespondError(conn, req.ID, "missing or invalid 'output' parameter")
+		return
+	}
+
+	tagmask, ok := models.Get[float64](req, "tagmask")
+	if !ok {
+		models.RespondError(conn, req.ID, "missing or invalid 'tagmask' parameter")
+		return
+	}
+
+	toggleTagset, ok := models.Get[float64](req, "toggleTagset")
+	if !ok {
+		models.RespondError(conn, req.ID, "missing or invalid 'toggleTagset' parameter")
+		return
+	}
+
+	if err := manager.SetTags(output, uint32(tagmask), uint32(toggleTagset)); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "tags set"})
+}
+
+func handleSetClientTags(conn net.Conn, req models.Request, manager *Manager) {
+	output, ok := models.Get[string](req, "output")
+	if !ok {
+		models.RespondError(conn, req.ID, "missing or invalid 'output' parameter")
+		return
+	}
+
+	andTags, ok := models.Get[float64](req, "andTags")
+	if !ok {
+		models.RespondError(conn, req.ID, "missing or invalid 'andTags' parameter")
+		return
+	}
+
+	xorTags, ok := models.Get[float64](req, "xorTags")
+	if !ok {
+		models.RespondError(conn, req.ID, "missing or invalid 'xorTags' parameter")
+		return
+	}
+
+	if err := manager.SetClientTags(output, uint32(andTags), uint32(xorTags)); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "client tags set"})
+}
+
+func handleSetLayout(conn net.Conn, req models.Request, manager *Manager) {
+	output, ok := models.Get[string](req, "output")
+	if !ok {
+		models.RespondError(conn, req.ID, "missing or invalid 'output' parameter")
+		return
+	}
+
+	index, ok := models.Get[float64](req, "index")
+	if !ok {
+		models.RespondError(conn, req.ID, "missing or invalid 'index' parameter")
+		return
+	}
+
+	if err := manager.SetLayout(output, uint32(index)); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "layout set"})
+}
+
+func handleSubscribe(conn net.Conn, req models.Request, manager *Manager) {
+	clientID := fmt.Sprintf("client-%p", conn)
+	stateChan := manager.Subscribe(clientID)
+	defer manager.Unsubscribe(clientID)
+
+	initialState := manager.GetState()
+	if err := json.NewEncoder(conn).Encode(models.Response[State]{
+		ID:     req.ID,
+		Result: &initialState,
+	}); err != nil {
+		return
+	}
+
+	for state := range stateChan {
+		if err := json.NewEncoder(conn).Encode(models.Response[State]{
+			Result: &state,
+		}); err != nil {
+			return
+		}
+	}
+}

core/internal/server/dwl/manager.go

@@ -0,0 +1,522 @@
+package dwl
+
+import (
+	"fmt"
+	"time"
+
+	wlclient "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/proto/dwl_ipc"
+)
+
+func NewManager(display wlclient.WaylandDisplay) (*Manager, error) {
+	m := &Manager{
+		display:        display,
+		ctx:            display.Context(),
+		cmdq:           make(chan cmd, 128),
+		outputSetupReq: make(chan uint32, 16),
+		stopChan:       make(chan struct{}),
+
+		dirty:   make(chan struct{}, 1),
+		layouts: make([]string, 0),
+	}
+
+	if err := m.setupRegistry(); err != nil {
+		return nil, err
+	}
+
+	m.updateState()
+
+	m.notifierWg.Add(1)
+	go m.notifier()
+
+	m.wg.Add(1)
+	go m.waylandActor()
+
+	return m, nil
+}
+
+func (m *Manager) post(fn func()) {
+	select {
+	case m.cmdq <- cmd{fn: fn}:
+	default:
+		log.Warn("DWL actor command queue full, dropping command")
+	}
+}
+
+func (m *Manager) waylandActor() {
+	defer m.wg.Done()
+
+	for {
+		select {
+		case <-m.stopChan:
+			return
+		case c := <-m.cmdq:
+			c.fn()
+		case outputID := <-m.outputSetupReq:
+			out, exists := m.outputs.Load(outputID)
+			if !exists {
+				log.Warnf("DWL: Output %d no longer exists, skipping setup", outputID)
+				continue
+			}
+
+			if out.ipcOutput != nil {
+				continue
+			}
+
+			mgr, ok := m.manager.(*dwl_ipc.ZdwlIpcManagerV2)
+			if !ok || mgr == nil {
+				log.Errorf("DWL: Manager not available for output %d setup", outputID)
+				continue
+			}
+
+			log.Infof("DWL: Setting up ipcOutput for dynamically added output %d", outputID)
+			if err := m.setupOutput(mgr, out.output); err != nil {
+				log.Errorf("DWL: Failed to setup output %d: %v", outputID, err)
+			} else {
+				m.updateState()
+			}
+		}
+	}
+}
+
+func (m *Manager) setupRegistry() error {
+	log.Info("DWL: starting registry setup")
+
+	registry, err := m.display.GetRegistry()
+	if err != nil {
+		return fmt.Errorf("failed to get registry: %w", err)
+	}
+	m.registry = registry
+
+	outputs := make([]*wlclient.Output, 0)
+	outputRegNames := make(map[uint32]uint32)
+	var dwlMgr *dwl_ipc.ZdwlIpcManagerV2
+
+	registry.SetGlobalHandler(func(e wlclient.RegistryGlobalEvent) {
+		switch e.Interface {
+		case dwl_ipc.ZdwlIpcManagerV2InterfaceName:
+			log.Infof("DWL: found %s", dwl_ipc.ZdwlIpcManagerV2InterfaceName)
+			manager := dwl_ipc.NewZdwlIpcManagerV2(m.ctx)
+			version := e.Version
+			if version > 2 {
+				version = 2
+			}
+			if err := registry.Bind(e.Name, e.Interface, version, manager); err == nil {
+				dwlMgr = manager
+				log.Info("DWL: manager bound successfully")
+
+				// Set handlers immediately after binding, before roundtrips
+				manager.SetTagsHandler(func(e dwl_ipc.ZdwlIpcManagerV2TagsEvent) {
+					log.Infof("DWL: Tags count: %d", e.Amount)
+					m.tagCount = e.Amount
+					m.updateState()
+				})
+
+				manager.SetLayoutHandler(func(e dwl_ipc.ZdwlIpcManagerV2LayoutEvent) {
+					log.Infof("DWL: Layout: %s", e.Name)
+					m.layouts = append(m.layouts, e.Name)
+					m.updateState()
+				})
+			} else {
+				log.Errorf("DWL: failed to bind manager: %v", err)
+			}
+		case "wl_output":
+			log.Debugf("DWL: found wl_output (name=%d)", e.Name)
+			output := wlclient.NewOutput(m.ctx)
+
+			outState := &outputState{
+				registryName: e.Name,
+				output:       output,
+				tags:         make([]TagState, 0),
+			}
+
+			output.SetNameHandler(func(ev wlclient.OutputNameEvent) {
+				log.Debugf("DWL: Output name: %s (registry=%d)", ev.Name, e.Name)
+				outState.name = ev.Name
+			})
+
+			output.SetDescriptionHandler(func(ev wlclient.OutputDescriptionEvent) {
+				log.Debugf("DWL: Output description: %s", ev.Description)
+			})
+
+			version := e.Version
+			if version > 4 {
+				version = 4
+			}
+			if err := registry.Bind(e.Name, e.Interface, version, output); err == nil {
+				outputID := output.ID()
+				outState.id = outputID
+				log.Infof("DWL: Bound wl_output id=%d registry_name=%d", outputID, e.Name)
+				outputs = append(outputs, output)
+				outputRegNames[outputID] = e.Name
+
+				m.outputs.Store(outputID, outState)
+
+				if m.manager != nil {
+					select {
+					case m.outputSetupReq <- outputID:
+						log.Debugf("DWL: Queued setup for output %d", outputID)
+					default:
+						log.Warnf("DWL: Setup queue full, output %d will not be initialized", outputID)
+					}
+				}
+			} else {
+				log.Errorf("DWL: Failed to bind wl_output: %v", err)
+			}
+		}
+	})
+
+	registry.SetGlobalRemoveHandler(func(e wlclient.RegistryGlobalRemoveEvent) {
+		m.post(func() {
+			var outToRelease *outputState
+			m.outputs.Range(func(id uint32, out *outputState) bool {
+				if out.registryName == e.Name {
+					log.Infof("DWL: Output %d removed", id)
+					outToRelease = out
+					m.outputs.Delete(id)
+					return false
+				}
+				return true
+			})
+
+			if outToRelease != nil {
+				if ipcOut, ok := outToRelease.ipcOutput.(*dwl_ipc.ZdwlIpcOutputV2); ok && ipcOut != nil {
+					m.wlMutex.Lock()
+					ipcOut.Release()
+					m.wlMutex.Unlock()
+					log.Debugf("DWL: Released ipcOutput for removed output %d", outToRelease.id)
+				}
+				m.updateState()
+			}
+		})
+	})
+
+	if err := m.display.Roundtrip(); err != nil {
+		return fmt.Errorf("first roundtrip failed: %w", err)
+	}
+	if err := m.display.Roundtrip(); err != nil {
+		return fmt.Errorf("second roundtrip failed: %w", err)
+	}
+
+	if dwlMgr == nil {
+		log.Info("DWL: manager not found in registry")
+		return fmt.Errorf("dwl_ipc_manager_v2 not available")
+	}
+
+	m.manager = dwlMgr
+
+	for _, output := range outputs {
+		if err := m.setupOutput(dwlMgr, output); err != nil {
+			log.Warnf("DWL: Failed to setup output %d: %v", output.ID(), err)
+		}
+	}
+
+	if err := m.display.Roundtrip(); err != nil {
+		return fmt.Errorf("final roundtrip failed: %w", err)
+	}
+
+	log.Info("DWL: registry setup complete")
+	return nil
+}
+
+func (m *Manager) setupOutput(manager *dwl_ipc.ZdwlIpcManagerV2, output *wlclient.Output) error {
+	m.wlMutex.Lock()
+	ipcOutput, err := manager.GetOutput(output)
+	m.wlMutex.Unlock()
+	if err != nil {
+		return fmt.Errorf("failed to get dwl output: %w", err)
+	}
+
+	outState, exists := m.outputs.Load(output.ID())
+	if !exists {
+		return fmt.Errorf("output state not found for id %d", output.ID())
+	}
+	outState.ipcOutput = ipcOutput
+
+	ipcOutput.SetActiveHandler(func(e dwl_ipc.ZdwlIpcOutputV2ActiveEvent) {
+		outState.active = e.Active
+	})
+
+	ipcOutput.SetTagHandler(func(e dwl_ipc.ZdwlIpcOutputV2TagEvent) {
+		updated := false
+		for i, tag := range outState.tags {
+			if tag.Tag == e.Tag {
+				outState.tags[i] = TagState{
+					Tag:     e.Tag,
+					State:   e.State,
+					Clients: e.Clients,
+					Focused: e.Focused,
+				}
+				updated = true
+				break
+			}
+		}
+
+		if !updated {
+			outState.tags = append(outState.tags, TagState{
+				Tag:     e.Tag,
+				State:   e.State,
+				Clients: e.Clients,
+				Focused: e.Focused,
+			})
+		}
+
+		m.updateState()
+	})
+
+	ipcOutput.SetLayoutHandler(func(e dwl_ipc.ZdwlIpcOutputV2LayoutEvent) {
+		outState.layout = e.Layout
+	})
+
+	ipcOutput.SetTitleHandler(func(e dwl_ipc.ZdwlIpcOutputV2TitleEvent) {
+		outState.title = e.Title
+	})
+
+	ipcOutput.SetAppidHandler(func(e dwl_ipc.ZdwlIpcOutputV2AppidEvent) {
+		outState.appID = e.Appid
+	})
+
+	ipcOutput.SetLayoutSymbolHandler(func(e dwl_ipc.ZdwlIpcOutputV2LayoutSymbolEvent) {
+		outState.layoutSymbol = e.Layout
+	})
+
+	ipcOutput.SetKbLayoutHandler(func(e dwl_ipc.ZdwlIpcOutputV2KbLayoutEvent) {
+		outState.kbLayout = e.KbLayout
+	})
+
+	ipcOutput.SetKeymodeHandler(func(e dwl_ipc.ZdwlIpcOutputV2KeymodeEvent) {
+		outState.keymode = e.Keymode
+	})
+
+	ipcOutput.SetFrameHandler(func(e dwl_ipc.ZdwlIpcOutputV2FrameEvent) {
+		m.updateState()
+	})
+
+	return nil
+}
+
+func (m *Manager) updateState() {
+	outputs := make(map[string]*OutputState)
+	activeOutput := ""
+
+	m.outputs.Range(func(key uint32, out *outputState) bool {
+		name := out.name
+		if name == "" {
+			name = fmt.Sprintf("output-%d", out.id)
+		}
+
+		tagsCopy := make([]TagState, len(out.tags))
+		copy(tagsCopy, out.tags)
+
+		outputs[name] = &OutputState{
+			Name:         name,
+			Active:       out.active,
+			Tags:         tagsCopy,
+			Layout:       out.layout,
+			LayoutSymbol: out.layoutSymbol,
+			Title:        out.title,
+			AppID:        out.appID,
+			KbLayout:     out.kbLayout,
+			Keymode:      out.keymode,
+		}
+
+		if out.active != 0 {
+			activeOutput = name
+		}
+		return true
+	})
+
+	newState := State{
+		Outputs:      outputs,
+		TagCount:     m.tagCount,
+		Layouts:      m.layouts,
+		ActiveOutput: activeOutput,
+	}
+
+	m.stateMutex.Lock()
+	m.state = &newState
+	m.stateMutex.Unlock()
+
+	m.notifySubscribers()
+}
+
+func (m *Manager) notifier() {
+	defer m.notifierWg.Done()
+	const minGap = 100 * time.Millisecond
+	timer := time.NewTimer(minGap)
+	timer.Stop()
+	var pending bool
+
+	for {
+		select {
+		case <-m.stopChan:
+			timer.Stop()
+			return
+		case <-m.dirty:
+			if pending {
+				continue
+			}
+			pending = true
+			timer.Reset(minGap)
+		case <-timer.C:
+			if !pending {
+				continue
+			}
+
+			currentState := m.GetState()
+
+			if m.lastNotified != nil && !stateChanged(m.lastNotified, &currentState) {
+				pending = false
+				continue
+			}
+
+			m.subscribers.Range(func(key string, ch chan State) bool {
+				select {
+				case ch <- currentState:
+				default:
+					log.Warn("DWL: subscriber channel full, dropping update")
+				}
+				return true
+			})
+
+			stateCopy := currentState
+			m.lastNotified = &stateCopy
+			pending = false
+		}
+	}
+}
+
+func (m *Manager) ensureOutputSetup(out *outputState) error {
+	if out.ipcOutput != nil {
+		return nil
+	}
+
+	return fmt.Errorf("output not yet initialized - setup in progress, retry in a moment")
+}
+
+func (m *Manager) SetTags(outputName string, tagmask uint32, toggleTagset uint32) error {
+	availableOutputs := make([]string, 0)
+	var targetOut *outputState
+	m.outputs.Range(func(key uint32, out *outputState) bool {
+		name := out.name
+		if name == "" {
+			name = fmt.Sprintf("output-%d", out.id)
+		}
+		availableOutputs = append(availableOutputs, name)
+		if name == outputName {
+			targetOut = out
+			return false
+		}
+		return true
+	})
+
+	if targetOut == nil {
+		return fmt.Errorf("output not found: %s (available: %v)", outputName, availableOutputs)
+	}
+
+	if err := m.ensureOutputSetup(targetOut); err != nil {
+		return fmt.Errorf("failed to setup output %s: %w", outputName, err)
+	}
+
+	ipcOut, ok := targetOut.ipcOutput.(*dwl_ipc.ZdwlIpcOutputV2)
+	if !ok {
+		return fmt.Errorf("output %s has invalid ipcOutput type", outputName)
+	}
+
+	m.wlMutex.Lock()
+	err := ipcOut.SetTags(tagmask, toggleTagset)
+	m.wlMutex.Unlock()
+	return err
+}
+
+func (m *Manager) SetClientTags(outputName string, andTags uint32, xorTags uint32) error {
+	var targetOut *outputState
+	m.outputs.Range(func(key uint32, out *outputState) bool {
+		name := out.name
+		if name == "" {
+			name = fmt.Sprintf("output-%d", out.id)
+		}
+		if name == outputName {
+			targetOut = out
+			return false
+		}
+		return true
+	})
+
+	if targetOut == nil {
+		return fmt.Errorf("output not found: %s", outputName)
+	}
+
+	if err := m.ensureOutputSetup(targetOut); err != nil {
+		return fmt.Errorf("failed to setup output %s: %w", outputName, err)
+	}
+
+	ipcOut, ok := targetOut.ipcOutput.(*dwl_ipc.ZdwlIpcOutputV2)
+	if !ok {
+		return fmt.Errorf("output %s has invalid ipcOutput type", outputName)
+	}
+
+	m.wlMutex.Lock()
+	err := ipcOut.SetClientTags(andTags, xorTags)
+	m.wlMutex.Unlock()
+	return err
+}
+
+func (m *Manager) SetLayout(outputName string, index uint32) error {
+	var targetOut *outputState
+	m.outputs.Range(func(key uint32, out *outputState) bool {
+		name := out.name
+		if name == "" {
+			name = fmt.Sprintf("output-%d", out.id)
+		}
+		if name == outputName {
+			targetOut = out
+			return false
+		}
+		return true
+	})
+
+	if targetOut == nil {
+		return fmt.Errorf("output not found: %s", outputName)
+	}
+
+	if err := m.ensureOutputSetup(targetOut); err != nil {
+		return fmt.Errorf("failed to setup output %s: %w", outputName, err)
+	}
+
+	ipcOut, ok := targetOut.ipcOutput.(*dwl_ipc.ZdwlIpcOutputV2)
+	if !ok {
+		return fmt.Errorf("output %s has invalid ipcOutput type", outputName)
+	}
+
+	m.wlMutex.Lock()
+	err := ipcOut.SetLayout(index)
+	m.wlMutex.Unlock()
+	return err
+}
+
+func (m *Manager) Close() {
+	close(m.stopChan)
+	m.wg.Wait()
+	m.notifierWg.Wait()
+
+	m.subscribers.Range(func(key string, ch chan State) bool {
+		close(ch)
+		m.subscribers.Delete(key)
+		return true
+	})
+
+	m.outputs.Range(func(key uint32, out *outputState) bool {
+		if ipcOut, ok := out.ipcOutput.(*dwl_ipc.ZdwlIpcOutputV2); ok {
+			ipcOut.Release()
+		}
+		m.outputs.Delete(key)
+		return true
+	})
+
+	if mgr, ok := m.manager.(*dwl_ipc.ZdwlIpcManagerV2); ok {
+		mgr.Release()
+	}
+}

core/internal/server/dwl/manager_test.go

@@ -0,0 +1,366 @@
+package dwl
+
+import (
+	"errors"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+
+	mocks_wlclient "github.com/AvengeMedia/DankMaterialShell/core/internal/mocks/wlclient"
+)
+
+func TestStateChanged_BothNil(t *testing.T) {
+	assert.True(t, stateChanged(nil, nil))
+}
+
+func TestStateChanged_OneNil(t *testing.T) {
+	s := &State{TagCount: 9}
+	assert.True(t, stateChanged(s, nil))
+	assert.True(t, stateChanged(nil, s))
+}
+
+func TestStateChanged_TagCountDiffers(t *testing.T) {
+	a := &State{TagCount: 9, Outputs: make(map[string]*OutputState), Layouts: []string{}}
+	b := &State{TagCount: 10, Outputs: make(map[string]*OutputState), Layouts: []string{}}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_LayoutLengthDiffers(t *testing.T) {
+	a := &State{TagCount: 9, Layouts: []string{"tile"}, Outputs: make(map[string]*OutputState)}
+	b := &State{TagCount: 9, Layouts: []string{"tile", "monocle"}, Outputs: make(map[string]*OutputState)}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_ActiveOutputDiffers(t *testing.T) {
+	a := &State{TagCount: 9, ActiveOutput: "eDP-1", Outputs: make(map[string]*OutputState), Layouts: []string{}}
+	b := &State{TagCount: 9, ActiveOutput: "HDMI-A-1", Outputs: make(map[string]*OutputState), Layouts: []string{}}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_OutputCountDiffers(t *testing.T) {
+	a := &State{
+		TagCount: 9,
+		Outputs:  map[string]*OutputState{"eDP-1": {}},
+		Layouts:  []string{},
+	}
+	b := &State{
+		TagCount: 9,
+		Outputs:  map[string]*OutputState{},
+		Layouts:  []string{},
+	}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_OutputFieldsDiffer(t *testing.T) {
+	a := &State{
+		TagCount: 9,
+		Layouts:  []string{},
+		Outputs: map[string]*OutputState{
+			"eDP-1": {Active: 1, Layout: 0, Title: "Firefox"},
+		},
+	}
+	b := &State{
+		TagCount: 9,
+		Layouts:  []string{},
+		Outputs: map[string]*OutputState{
+			"eDP-1": {Active: 0, Layout: 0, Title: "Firefox"},
+		},
+	}
+	assert.True(t, stateChanged(a, b))
+
+	b.Outputs["eDP-1"].Active = 1
+	b.Outputs["eDP-1"].Layout = 1
+	assert.True(t, stateChanged(a, b))
+
+	b.Outputs["eDP-1"].Layout = 0
+	b.Outputs["eDP-1"].Title = "Code"
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_TagsDiffer(t *testing.T) {
+	a := &State{
+		TagCount: 9,
+		Layouts:  []string{},
+		Outputs: map[string]*OutputState{
+			"eDP-1": {Tags: []TagState{{Tag: 1, State: 1, Clients: 2, Focused: 1}}},
+		},
+	}
+	b := &State{
+		TagCount: 9,
+		Layouts:  []string{},
+		Outputs: map[string]*OutputState{
+			"eDP-1": {Tags: []TagState{{Tag: 1, State: 2, Clients: 2, Focused: 1}}},
+		},
+	}
+	assert.True(t, stateChanged(a, b))
+
+	b.Outputs["eDP-1"].Tags[0].State = 1
+	b.Outputs["eDP-1"].Tags[0].Clients = 3
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_Equal(t *testing.T) {
+	a := &State{
+		TagCount:     9,
+		ActiveOutput: "eDP-1",
+		Layouts:      []string{"tile", "monocle"},
+		Outputs: map[string]*OutputState{
+			"eDP-1": {
+				Name:         "eDP-1",
+				Active:       1,
+				Layout:       0,
+				LayoutSymbol: "[]=",
+				Title:        "Firefox",
+				AppID:        "firefox",
+				KbLayout:     "us",
+				Keymode:      "",
+				Tags:         []TagState{{Tag: 1, State: 1, Clients: 2, Focused: 1}},
+			},
+		},
+	}
+	b := &State{
+		TagCount:     9,
+		ActiveOutput: "eDP-1",
+		Layouts:      []string{"tile", "monocle"},
+		Outputs: map[string]*OutputState{
+			"eDP-1": {
+				Name:         "eDP-1",
+				Active:       1,
+				Layout:       0,
+				LayoutSymbol: "[]=",
+				Title:        "Firefox",
+				AppID:        "firefox",
+				KbLayout:     "us",
+				Keymode:      "",
+				Tags:         []TagState{{Tag: 1, State: 1, Clients: 2, Focused: 1}},
+			},
+		},
+	}
+	assert.False(t, stateChanged(a, b))
+}
+
+func TestManager_ConcurrentGetState(t *testing.T) {
+	m := &Manager{
+		state: &State{
+			TagCount: 9,
+			Layouts:  []string{"tile"},
+			Outputs:  map[string]*OutputState{"eDP-1": {Name: "eDP-1"}},
+		},
+	}
+
+	var wg sync.WaitGroup
+	const goroutines = 50
+	const iterations = 100
+
+	for i := 0; i < goroutines/2; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				s := m.GetState()
+				_ = s.TagCount
+				_ = s.Outputs
+			}
+		}()
+	}
+
+	for i := 0; i < goroutines/2; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				m.stateMutex.Lock()
+				m.state = &State{
+					TagCount: uint32(j % 10),
+					Layouts:  []string{"tile", "monocle"},
+					Outputs:  map[string]*OutputState{"eDP-1": {Active: uint32(j % 2)}},
+				}
+				m.stateMutex.Unlock()
+			}
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+func TestManager_ConcurrentSubscriberAccess(t *testing.T) {
+	m := &Manager{
+		stopChan: make(chan struct{}),
+		dirty:    make(chan struct{}, 1),
+	}
+
+	var wg sync.WaitGroup
+	const goroutines = 20
+
+	for i := 0; i < goroutines; i++ {
+		wg.Add(1)
+		go func(id int) {
+			defer wg.Done()
+			subID := string(rune('a' + id))
+			ch := m.Subscribe(subID)
+			assert.NotNil(t, ch)
+			time.Sleep(time.Millisecond)
+			m.Unsubscribe(subID)
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+func TestManager_SyncmapOutputsConcurrentAccess(t *testing.T) {
+	m := &Manager{}
+
+	var wg sync.WaitGroup
+	const goroutines = 30
+	const iterations = 50
+
+	for i := 0; i < goroutines; i++ {
+		wg.Add(1)
+		go func(id int) {
+			defer wg.Done()
+			key := uint32(id)
+
+			for j := 0; j < iterations; j++ {
+				state := &outputState{
+					id:     key,
+					name:   "test-output",
+					active: uint32(j % 2),
+					tags:   []TagState{{Tag: uint32(j), State: 1}},
+				}
+				m.outputs.Store(key, state)
+
+				if loaded, ok := m.outputs.Load(key); ok {
+					assert.Equal(t, key, loaded.id)
+				}
+
+				m.outputs.Range(func(k uint32, v *outputState) bool {
+					_ = v.name
+					_ = v.active
+					return true
+				})
+			}
+
+			m.outputs.Delete(key)
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+func TestManager_NotifySubscribersNonBlocking(t *testing.T) {
+	m := &Manager{
+		dirty: make(chan struct{}, 1),
+	}
+
+	for i := 0; i < 10; i++ {
+		m.notifySubscribers()
+	}
+
+	assert.Len(t, m.dirty, 1)
+}
+
+func TestManager_PostQueueFull(t *testing.T) {
+	m := &Manager{
+		cmdq:     make(chan cmd, 2),
+		stopChan: make(chan struct{}),
+	}
+
+	m.post(func() {})
+	m.post(func() {})
+	m.post(func() {})
+	m.post(func() {})
+
+	assert.Len(t, m.cmdq, 2)
+}
+
+func TestManager_GetStateNilState(t *testing.T) {
+	m := &Manager{}
+
+	s := m.GetState()
+	assert.NotNil(t, s.Outputs)
+	assert.NotNil(t, s.Layouts)
+	assert.Equal(t, uint32(0), s.TagCount)
+}
+
+func TestTagState_Fields(t *testing.T) {
+	tag := TagState{
+		Tag:     1,
+		State:   2,
+		Clients: 3,
+		Focused: 1,
+	}
+
+	assert.Equal(t, uint32(1), tag.Tag)
+	assert.Equal(t, uint32(2), tag.State)
+	assert.Equal(t, uint32(3), tag.Clients)
+	assert.Equal(t, uint32(1), tag.Focused)
+}
+
+func TestOutputState_Fields(t *testing.T) {
+	out := OutputState{
+		Name:         "eDP-1",
+		Active:       1,
+		Tags:         []TagState{{Tag: 1}},
+		Layout:       0,
+		LayoutSymbol: "[]=",
+		Title:        "Firefox",
+		AppID:        "firefox",
+		KbLayout:     "us",
+		Keymode:      "",
+	}
+
+	assert.Equal(t, "eDP-1", out.Name)
+	assert.Equal(t, uint32(1), out.Active)
+	assert.Len(t, out.Tags, 1)
+	assert.Equal(t, "[]=", out.LayoutSymbol)
+}
+
+func TestStateChanged_NewOutputAppears(t *testing.T) {
+	a := &State{
+		TagCount: 9,
+		Layouts:  []string{},
+		Outputs: map[string]*OutputState{
+			"eDP-1": {Name: "eDP-1"},
+		},
+	}
+	b := &State{
+		TagCount: 9,
+		Layouts:  []string{},
+		Outputs: map[string]*OutputState{
+			"eDP-1":    {Name: "eDP-1"},
+			"HDMI-A-1": {Name: "HDMI-A-1"},
+		},
+	}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_TagsLengthDiffers(t *testing.T) {
+	a := &State{
+		TagCount: 9,
+		Layouts:  []string{},
+		Outputs: map[string]*OutputState{
+			"eDP-1": {Tags: []TagState{{Tag: 1}}},
+		},
+	}
+	b := &State{
+		TagCount: 9,
+		Layouts:  []string{},
+		Outputs: map[string]*OutputState{
+			"eDP-1": {Tags: []TagState{{Tag: 1}, {Tag: 2}}},
+		},
+	}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestNewManager_GetRegistryError(t *testing.T) {
+	mockDisplay := mocks_wlclient.NewMockWaylandDisplay(t)
+
+	mockDisplay.EXPECT().Context().Return(nil)
+	mockDisplay.EXPECT().GetRegistry().Return(nil, errors.New("failed to get registry"))
+
+	_, err := NewManager(mockDisplay)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "failed to get registry")
+}

core/internal/server/dwl/types.go

@@ -0,0 +1,176 @@
+package dwl
+
+import (
+	"sync"
+
+	wlclient "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
+	"github.com/AvengeMedia/DankMaterialShell/core/pkg/syncmap"
+)
+
+type TagState struct {
+	Tag     uint32 `json:"tag"`
+	State   uint32 `json:"state"`
+	Clients uint32 `json:"clients"`
+	Focused uint32 `json:"focused"`
+}
+
+type OutputState struct {
+	Name         string     `json:"name"`
+	Active       uint32     `json:"active"`
+	Tags         []TagState `json:"tags"`
+	Layout       uint32     `json:"layout"`
+	LayoutSymbol string     `json:"layoutSymbol"`
+	Title        string     `json:"title"`
+	AppID        string     `json:"appId"`
+	KbLayout     string     `json:"kbLayout"`
+	Keymode      string     `json:"keymode"`
+}
+
+type State struct {
+	Outputs      map[string]*OutputState `json:"outputs"`
+	TagCount     uint32                  `json:"tagCount"`
+	Layouts      []string                `json:"layouts"`
+	ActiveOutput string                  `json:"activeOutput"`
+}
+
+type cmd struct {
+	fn func()
+}
+
+type Manager struct {
+	display  wlclient.WaylandDisplay
+	ctx      *wlclient.Context
+	registry *wlclient.Registry
+	manager  any
+
+	outputs syncmap.Map[uint32, *outputState]
+
+	tagCount uint32
+	layouts  []string
+
+	wlMutex        sync.Mutex
+	cmdq           chan cmd
+	outputSetupReq chan uint32
+	stopChan       chan struct{}
+	wg             sync.WaitGroup
+
+	subscribers  syncmap.Map[string, chan State]
+	dirty        chan struct{}
+	notifierWg   sync.WaitGroup
+	lastNotified *State
+
+	stateMutex sync.RWMutex
+	state      *State
+}
+
+type outputState struct {
+	id           uint32
+	registryName uint32
+	output       *wlclient.Output
+	ipcOutput    any
+	name         string
+	active       uint32
+	tags         []TagState
+	layout       uint32
+	layoutSymbol string
+	title        string
+	appID        string
+	kbLayout     string
+	keymode      string
+}
+
+func (m *Manager) GetState() State {
+	m.stateMutex.RLock()
+	defer m.stateMutex.RUnlock()
+	if m.state == nil {
+		return State{
+			Outputs:  make(map[string]*OutputState),
+			Layouts:  []string{},
+			TagCount: 0,
+		}
+	}
+	stateCopy := *m.state
+	return stateCopy
+}
+
+func (m *Manager) Subscribe(id string) chan State {
+	ch := make(chan State, 64)
+
+	m.subscribers.Store(id, ch)
+
+	return ch
+}
+
+func (m *Manager) Unsubscribe(id string) {
+	if val, ok := m.subscribers.LoadAndDelete(id); ok {
+		close(val)
+	}
+}
+
+func (m *Manager) notifySubscribers() {
+	select {
+	case m.dirty <- struct{}{}:
+	default:
+	}
+}
+
+func stateChanged(old, new *State) bool {
+	if old == nil || new == nil {
+		return true
+	}
+	if old.TagCount != new.TagCount {
+		return true
+	}
+	if len(old.Layouts) != len(new.Layouts) {
+		return true
+	}
+	if old.ActiveOutput != new.ActiveOutput {
+		return true
+	}
+	if len(old.Outputs) != len(new.Outputs) {
+		return true
+	}
+
+	for name, newOut := range new.Outputs {
+		oldOut, exists := old.Outputs[name]
+		if !exists {
+			return true
+		}
+		if oldOut.Active != newOut.Active {
+			return true
+		}
+		if oldOut.Layout != newOut.Layout {
+			return true
+		}
+		if oldOut.LayoutSymbol != newOut.LayoutSymbol {
+			return true
+		}
+		if oldOut.Title != newOut.Title {
+			return true
+		}
+		if oldOut.AppID != newOut.AppID {
+			return true
+		}
+		if oldOut.KbLayout != newOut.KbLayout {
+			return true
+		}
+		if oldOut.Keymode != newOut.Keymode {
+			return true
+		}
+		if len(oldOut.Tags) != len(newOut.Tags) {
+			return true
+		}
+		for i, newTag := range newOut.Tags {
+			if i >= len(oldOut.Tags) {
+				return true
+			}
+			oldTag := oldOut.Tags[i]
+			if oldTag.Tag != newTag.Tag || oldTag.State != newTag.State ||
+				oldTag.Clients != newTag.Clients || oldTag.Focused != newTag.Focused {
+				return true
+			}
+		}
+	}
+
+	return false
+}

core/internal/server/network/API.md

@@ -125,8 +125,6 @@ State updates are sent whenever network configuration changes:
 - `wifiConnected`: Whether associated with an access point
 - `wifiSSID`: Currently connected network name
 - `wifiIP`: Assigned IP address (empty until DHCP completes)
-- `savedWifiNetworks` (API v26+): Saved WiFi profiles exposed at SSID granularity. If a backend has multiple profiles for the same SSID, DMS merges them into one SSID-level entry. Clients talking to older servers should derive saved visible networks from `wifiNetworks` entries where `saved` is true.
-- `savedWifiNetworks[].outOfRange` (API v26+): Whether the saved profile is not currently visible in scan results. Fallback entries derived from `wifiNetworks` should be treated as visible (`outOfRange: false`).
 - `lastError`: Error message from last failed connection attempt
 
 ### network.credentials Service Events

core/internal/server/network/backend.go

@@ -67,7 +67,6 @@ type BackendState struct {
 	WiFiBSSID              string
 	WiFiSignal             uint8
 	WiFiNetworks           []WiFiNetwork
-	SavedWiFiNetworks      []WiFiNetwork
 	WiFiDevices            []WiFiDevice
 	WiredConnections       []WiredConnection
 	VPNProfiles            []VPNProfile

core/internal/server/network/backend_hybrid_test.go

@@ -27,19 +27,6 @@ func TestHybridIwdNetworkdBackend_GetCurrentState_MergesState(t *testing.T) {
 	wifi.state.WiFiBSSID = "00:11:22:33:44:55"
 	wifi.state.WiFiSignal = 75
 	wifi.state.WiFiDevice = "wlan0"
-	wifi.state.SavedWiFiNetworks = []WiFiNetwork{
-		{
-			SSID:        "TestNetwork",
-			Saved:       true,
-			Autoconnect: true,
-			Connected:   true,
-		},
-		{
-			SSID:       "AwayNetwork",
-			Saved:      true,
-			OutOfRange: true,
-		},
-	}
 
 	l3.state.WiFiIP = "192.168.1.100"
 	l3.state.EthernetConnected = false
@@ -55,9 +42,6 @@ func TestHybridIwdNetworkdBackend_GetCurrentState_MergesState(t *testing.T) {
 	assert.True(t, state.WiFiConnected)
 	assert.False(t, state.EthernetConnected)
 	assert.Equal(t, StatusWiFi, state.NetworkStatus)
-	assert.Len(t, state.SavedWiFiNetworks, 2)
-	assert.Equal(t, "TestNetwork", state.SavedWiFiNetworks[0].SSID)
-	assert.True(t, state.SavedWiFiNetworks[1].OutOfRange)
 }
 
 func TestHybridIwdNetworkdBackend_GetCurrentState_EthernetPriority(t *testing.T) {

core/internal/server/network/backend_iwd.go

@@ -80,10 +80,6 @@ func (b *IWDBackend) Initialize() error {
 		return fmt.Errorf("failed to discover iwd devices: %w", err)
 	}
 
-	if err := b.updateSavedWiFiNetworks(); err != nil {
-		log.Warnf("Failed to get initial saved WiFi networks: %v", err)
-	}
-
 	if err := b.updateState(); err != nil {
 		conn.Close()
 		return fmt.Errorf("failed to get initial state: %w", err)
@@ -149,7 +145,6 @@ func (b *IWDBackend) GetCurrentState() (*BackendState, error) {
 
 	state := *b.state
 	state.WiFiNetworks = append([]WiFiNetwork(nil), b.state.WiFiNetworks...)
-	state.SavedWiFiNetworks = append([]WiFiNetwork(nil), b.state.SavedWiFiNetworks...)
 	state.WiredConnections = append([]WiredConnection(nil), b.state.WiredConnections...)
 	state.WiFiDevices = b.getWiFiDevicesLocked()
 

core/internal/server/network/backend_iwd_signals.go

@@ -45,42 +45,12 @@ func (b *IWDBackend) StartMonitoring(onStateChange func()) error {
 		}
 	}
 
-	if err := b.conn.AddMatchSignal(
-		dbus.WithMatchInterface(dbusPropertiesInterface),
-		dbus.WithMatchMember("PropertiesChanged"),
-		dbus.WithMatchArg(0, iwdKnownNetworkInterface),
-	); err != nil {
-		return fmt.Errorf("failed to add known network signal match: %w", err)
-	}
-
-	if err := b.conn.AddMatchSignal(
-		dbus.WithMatchInterface(dbusObjectManager),
-		dbus.WithMatchMember("InterfacesAdded"),
-	); err != nil {
-		return fmt.Errorf("failed to add iwd interfaces-added signal match: %w", err)
-	}
-
-	if err := b.conn.AddMatchSignal(
-		dbus.WithMatchInterface(dbusObjectManager),
-		dbus.WithMatchMember("InterfacesRemoved"),
-	); err != nil {
-		return fmt.Errorf("failed to add iwd interfaces-removed signal match: %w", err)
-	}
-
 	b.sigWG.Add(1)
 	go b.signalHandler(sigChan)
 
 	return nil
 }
 
-func (b *IWDBackend) refreshWiFiNetworkState() bool {
-	_, err := b.updateWiFiNetworks()
-	if err == nil {
-		return true
-	}
-	return b.updateSavedWiFiNetworks() == nil
-}
-
 func (b *IWDBackend) signalHandler(sigChan chan *dbus.Signal) {
 	defer b.sigWG.Done()
 
@@ -96,36 +66,11 @@ func (b *IWDBackend) signalHandler(sigChan chan *dbus.Signal) {
 				return
 			}
 
-			if sig.Name == dbusObjectManager+".InterfacesAdded" {
-				if len(sig.Body) >= 2 {
-					if interfaces, ok := sig.Body[1].(map[string]map[string]dbus.Variant); ok {
-						if _, ok := interfaces[iwdKnownNetworkInterface]; ok {
-							if b.refreshWiFiNetworkState() && b.onStateChange != nil {
-								b.onStateChange()
-							}
-						}
-					}
-				}
+			if sig.Name != dbusPropertiesInterface+".PropertiesChanged" {
 				continue
 			}
 
-			if sig.Name == dbusObjectManager+".InterfacesRemoved" {
-				if len(sig.Body) >= 2 {
-					if interfaces, ok := sig.Body[1].([]string); ok {
-						for _, iface := range interfaces {
-							if iface == iwdKnownNetworkInterface {
-								if b.refreshWiFiNetworkState() && b.onStateChange != nil {
-									b.onStateChange()
-								}
-								break
-							}
-						}
-					}
-				}
-				continue
-			}
-
-			if sig.Name != dbusPropertiesInterface+".PropertiesChanged" || len(sig.Body) < 2 {
+			if len(sig.Body) < 2 {
 				continue
 			}
 
@@ -142,9 +87,6 @@ func (b *IWDBackend) signalHandler(sigChan chan *dbus.Signal) {
 			stateChanged := false
 
 			switch iface {
-			case iwdKnownNetworkInterface:
-				stateChanged = b.refreshWiFiNetworkState()
-
 			case iwdDeviceInterface:
 				if sig.Path == b.devicePath {
 					if poweredVar, ok := changed["Powered"]; ok {
@@ -163,7 +105,13 @@ func (b *IWDBackend) signalHandler(sigChan chan *dbus.Signal) {
 				if sig.Path == b.stationPath {
 					if scanningVar, ok := changed["Scanning"]; ok {
 						if scanning, ok := scanningVar.Value().(bool); ok && !scanning {
-							stateChanged = b.refreshWiFiNetworkState() || stateChanged
+							networks, err := b.updateWiFiNetworks()
+							if err == nil {
+								b.stateMutex.Lock()
+								b.state.WiFiNetworks = networks
+								b.stateMutex.Unlock()
+								stateChanged = true
+							}
 
 							b.stateMutex.RLock()
 							wifiConnected := b.state.WiFiConnected
@@ -288,7 +236,6 @@ func (b *IWDBackend) signalHandler(sigChan chan *dbus.Signal) {
 									}
 								}
 
-								b.refreshWiFiNetworkState()
 								stateChanged = true
 
 								if att != nil && isTarget {
@@ -335,7 +282,6 @@ func (b *IWDBackend) signalHandler(sigChan chan *dbus.Signal) {
 									b.state.NetworkStatus = StatusDisconnected
 								}
 								b.stateMutex.Unlock()
-								b.refreshWiFiNetworkState()
 								stateChanged = true
 							}
 						}
@@ -396,7 +342,6 @@ func (b *IWDBackend) signalHandler(sigChan chan *dbus.Signal) {
 								stateChanged = true
 							}
 							b.stateMutex.Unlock()
-							b.refreshWiFiNetworkState()
 						}
 					}
 				}

core/internal/server/network/backend_iwd_test.go

@@ -4,7 +4,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/godbus/dbus/v5"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -169,92 +168,6 @@ func TestIWDBackend_MapIwdDBusError(t *testing.T) {
 	}
 }
 
-func TestIWDSavedWiFiProfilesFromManagedObjects(t *testing.T) {
-	objects := map[dbus.ObjectPath]map[string]map[string]dbus.Variant{
-		"/net/connman/iwd/known_network/1": {
-			iwdKnownNetworkInterface: {
-				"Name":        dbus.MakeVariant("Home"),
-				"AutoConnect": dbus.MakeVariant(false),
-				"Hidden":      dbus.MakeVariant(true),
-				"Type":        dbus.MakeVariant("psk"),
-			},
-		},
-		"/net/connman/iwd/known_network/2": {
-			iwdKnownNetworkInterface: {
-				"Name": dbus.MakeVariant("Office"),
-				"Type": dbus.MakeVariant("8021x"),
-			},
-		},
-		"/net/connman/iwd/known_network/3": {
-			iwdKnownNetworkInterface: {
-				"Name": dbus.MakeVariant("Cafe"),
-				"Type": dbus.MakeVariant("open"),
-			},
-		},
-		"/net/connman/iwd/network/1": {
-			iwdNetworkInterface: {
-				"Name": dbus.MakeVariant("VisibleOnly"),
-			},
-		},
-	}
-
-	profiles := iwdSavedWiFiProfilesFromManagedObjects(objects)
-
-	assert.Len(t, profiles, 3)
-	assert.False(t, profiles["Home"].Autoconnect)
-	assert.True(t, profiles["Home"].Hidden)
-	assert.True(t, profiles["Home"].Secured)
-	assert.False(t, profiles["Home"].Enterprise)
-
-	assert.True(t, profiles["Office"].Autoconnect)
-	assert.True(t, profiles["Office"].Secured)
-	assert.True(t, profiles["Office"].Enterprise)
-
-	assert.True(t, profiles["Cafe"].Autoconnect)
-	assert.False(t, profiles["Cafe"].Secured)
-	assert.False(t, profiles["Cafe"].Enterprise)
-}
-
-func TestIWDWiFiNetworksFromVisibleIncludesConnectedHiddenFallback(t *testing.T) {
-	profiles := map[string]savedWiFiProfile{
-		"Home": {
-			Autoconnect: true,
-			Secured:     true,
-			Hidden:      true,
-			Mode:        "infrastructure",
-		},
-	}
-	visible := []WiFiNetwork{
-		{
-			SSID:    "Cafe",
-			Signal:  42,
-			Secured: false,
-		},
-	}
-
-	networks := iwdWiFiNetworksFromVisible(visible, profiles, "Home", true, 68)
-	savedNetworks := savedWiFiNetworksFromProfiles(profiles, map[string]WiFiNetwork{
-		networks[0].SSID: networks[0],
-		networks[1].SSID: networks[1],
-	}, "Home", true)
-
-	assert.Len(t, networks, 2)
-	assert.Equal(t, "Cafe", networks[0].SSID)
-	assert.False(t, networks[0].Connected)
-
-	assert.Equal(t, "Home", networks[1].SSID)
-	assert.True(t, networks[1].Connected)
-	assert.True(t, networks[1].Hidden)
-	assert.True(t, networks[1].Saved)
-	assert.True(t, networks[1].Autoconnect)
-	assert.Equal(t, uint8(68), networks[1].Signal)
-
-	assert.Len(t, savedNetworks, 1)
-	assert.Equal(t, "Home", savedNetworks[0].SSID)
-	assert.True(t, savedNetworks[0].Connected)
-	assert.False(t, savedNetworks[0].OutOfRange)
-}
-
 func TestConnectAttempt_Finalization(t *testing.T) {
 	backend, _ := NewIWDBackend()
 	backend.state = &BackendState{}

core/internal/server/network/backend_iwd_wifi.go

@@ -164,18 +164,22 @@ func (b *IWDBackend) updateWiFiNetworks() ([]WiFiNetwork, error) {
 		return nil, fmt.Errorf("failed to get networks: %w", err)
 	}
 
-	savedProfiles, err := b.getIWDSavedWiFiProfiles()
+	knownNetworks, err := b.getKnownNetworks()
 	if err != nil {
-		savedProfiles = make(map[string]savedWiFiProfile)
+		knownNetworks = make(map[string]bool)
+	}
+
+	autoconnectMap, err := b.getAutoconnectSettings()
+	if err != nil {
+		autoconnectMap = make(map[string]bool)
 	}
 
 	b.stateMutex.RLock()
 	currentSSID := b.state.WiFiSSID
 	wifiConnected := b.state.WiFiConnected
-	wifiSignal := b.state.WiFiSignal
 	b.stateMutex.RUnlock()
 
-	visibleNetworks := make([]WiFiNetwork, 0, len(orderedNetworks))
+	networks := make([]WiFiNetwork, 0, len(orderedNetworks))
 	for _, netData := range orderedNetworks {
 		if len(netData) < 2 {
 			continue
@@ -221,26 +225,23 @@ func (b *IWDBackend) updateWiFiNetworks() ([]WiFiNetwork, error) {
 
 		secured := netType != "open"
 
-		visibleNetworks = append(visibleNetworks, WiFiNetwork{
-			SSID:       name,
-			Signal:     signal,
-			Secured:    secured,
-			Enterprise: netType == "8021x",
-		})
-	}
+		network := WiFiNetwork{
+			SSID:        name,
+			Signal:      signal,
+			Secured:     secured,
+			Connected:   wifiConnected && name == currentSSID,
+			Saved:       knownNetworks[name],
+			Autoconnect: autoconnectMap[name],
+			Enterprise:  netType == "8021x",
+		}
 
-	networks := iwdWiFiNetworksFromVisible(visibleNetworks, savedProfiles, currentSSID, wifiConnected, wifiSignal)
-	visibleNetworkMap := make(map[string]WiFiNetwork, len(networks))
-	for _, network := range networks {
-		visibleNetworkMap[network.SSID] = network
+		networks = append(networks, network)
 	}
-	savedNetworks := savedWiFiNetworksFromProfiles(savedProfiles, visibleNetworkMap, currentSSID, wifiConnected)
 
 	sortWiFiNetworks(networks)
 
 	b.stateMutex.Lock()
 	b.state.WiFiNetworks = networks
-	b.state.SavedWiFiNetworks = savedNetworks
 	b.stateMutex.Unlock()
 
 	now := time.Now()
@@ -253,129 +254,7 @@ func (b *IWDBackend) updateWiFiNetworks() ([]WiFiNetwork, error) {
 	return networks, nil
 }
 
-func (b *IWDBackend) updateSavedWiFiNetworks() error {
-	savedProfiles, err := b.getIWDSavedWiFiProfiles()
-	if err != nil {
-		return err
-	}
-
-	b.stateMutex.RLock()
-	currentSSID := b.state.WiFiSSID
-	wifiConnected := b.state.WiFiConnected
-	wifiNetworks := append([]WiFiNetwork(nil), b.state.WiFiNetworks...)
-	b.stateMutex.RUnlock()
-
-	wifiNetworks, savedNetworks := refreshSavedWiFiState(wifiNetworks, savedProfiles, currentSSID, wifiConnected)
-
-	b.stateMutex.Lock()
-	b.state.WiFiNetworks = wifiNetworks
-	b.state.SavedWiFiNetworks = savedNetworks
-	b.stateMutex.Unlock()
-
-	return nil
-}
-
-func iwdWiFiNetworksFromVisible(visibleNetworks []WiFiNetwork, savedProfiles map[string]savedWiFiProfile, currentSSID string, wifiConnected bool, wifiSignal uint8) []WiFiNetwork {
-	networks := make([]WiFiNetwork, 0, len(visibleNetworks)+1)
-	seenSSIDs := make(map[string]struct{}, len(visibleNetworks)+1)
-
-	for _, network := range visibleNetworks {
-		profile, saved := savedProfiles[network.SSID]
-		network.Connected = wifiConnected && network.SSID == currentSSID
-		network.Saved = saved
-		network.Autoconnect = profile.Autoconnect
-		network.Hidden = network.Hidden || profile.Hidden
-		network.Secured = network.Secured || profile.Secured
-		network.Enterprise = network.Enterprise || profile.Enterprise
-		if network.Mode == "" {
-			network.Mode = profile.Mode
-		}
-		networks = append(networks, network)
-		seenSSIDs[network.SSID] = struct{}{}
-	}
-
-	if wifiConnected && currentSSID != "" {
-		if _, exists := seenSSIDs[currentSSID]; !exists {
-			profile, saved := savedProfiles[currentSSID]
-			secured := profile.Secured
-			if !saved {
-				secured = true
-			}
-			mode := profile.Mode
-			if mode == "" {
-				mode = "infrastructure"
-			}
-
-			networks = append(networks, WiFiNetwork{
-				SSID:        currentSSID,
-				Signal:      wifiSignal,
-				Secured:     secured,
-				Enterprise:  profile.Enterprise,
-				Connected:   true,
-				Saved:       saved,
-				Autoconnect: profile.Autoconnect,
-				Hidden:      true,
-				Mode:        mode,
-			})
-		}
-	}
-
-	return networks
-}
-
-func iwdSavedWiFiProfilesFromManagedObjects(objects map[dbus.ObjectPath]map[string]map[string]dbus.Variant) map[string]savedWiFiProfile {
-	profiles := make(map[string]savedWiFiProfile)
-
-	for _, interfaces := range objects {
-		knownProps, ok := interfaces[iwdKnownNetworkInterface]
-		if !ok {
-			continue
-		}
-
-		nameVar, ok := knownProps["Name"]
-		if !ok {
-			continue
-		}
-		name, ok := nameVar.Value().(string)
-		if !ok || name == "" {
-			continue
-		}
-
-		profile := savedWiFiProfile{
-			Autoconnect: true,
-			Mode:        "infrastructure",
-		}
-		if acVar, ok := knownProps["AutoConnect"]; ok {
-			if autoconnect, ok := acVar.Value().(bool); ok {
-				profile.Autoconnect = autoconnect
-			}
-		}
-		if hiddenVar, ok := knownProps["Hidden"]; ok {
-			if hidden, ok := hiddenVar.Value().(bool); ok {
-				profile.Hidden = hidden
-			}
-		}
-		if typeVar, ok := knownProps["Type"]; ok {
-			if networkType, ok := typeVar.Value().(string); ok {
-				profile.Secured = networkType != "" && networkType != "open"
-				profile.Enterprise = networkType == "8021x"
-			}
-		}
-
-		if existing, ok := profiles[name]; ok {
-			profile.Autoconnect = profile.Autoconnect || existing.Autoconnect
-			profile.Hidden = profile.Hidden || existing.Hidden
-			profile.Secured = profile.Secured || existing.Secured
-			profile.Enterprise = profile.Enterprise || existing.Enterprise
-		}
-
-		profiles[name] = profile
-	}
-
-	return profiles
-}
-
-func (b *IWDBackend) getIWDSavedWiFiProfiles() (map[string]savedWiFiProfile, error) {
+func (b *IWDBackend) getKnownNetworks() (map[string]bool, error) {
 	obj := b.conn.Object(iwdBusName, iwdObjectPath)
 
 	var objects map[dbus.ObjectPath]map[string]map[string]dbus.Variant
@@ -384,7 +263,47 @@ func (b *IWDBackend) getIWDSavedWiFiProfiles() (map[string]savedWiFiProfile, err
 		return nil, err
 	}
 
-	return iwdSavedWiFiProfilesFromManagedObjects(objects), nil
+	known := make(map[string]bool)
+	for _, interfaces := range objects {
+		if knownProps, ok := interfaces[iwdKnownNetworkInterface]; ok {
+			if nameVar, ok := knownProps["Name"]; ok {
+				if name, ok := nameVar.Value().(string); ok {
+					known[name] = true
+				}
+			}
+		}
+	}
+
+	return known, nil
+}
+
+func (b *IWDBackend) getAutoconnectSettings() (map[string]bool, error) {
+	obj := b.conn.Object(iwdBusName, iwdObjectPath)
+
+	var objects map[dbus.ObjectPath]map[string]map[string]dbus.Variant
+	err := obj.Call(dbusObjectManager+".GetManagedObjects", 0).Store(&objects)
+	if err != nil {
+		return nil, err
+	}
+
+	autoconnectMap := make(map[string]bool)
+	for _, interfaces := range objects {
+		if knownProps, ok := interfaces[iwdKnownNetworkInterface]; ok {
+			if nameVar, ok := knownProps["Name"]; ok {
+				if name, ok := nameVar.Value().(string); ok {
+					autoconnect := true
+					if acVar, ok := knownProps["AutoConnect"]; ok {
+						if ac, ok := acVar.Value().(bool); ok {
+							autoconnect = ac
+						}
+					}
+					autoconnectMap[name] = autoconnect
+				}
+			}
+		}
+	}
+
+	return autoconnectMap, nil
 }
 
 func (b *IWDBackend) GetWiFiNetworkDetails(ssid string) (*NetworkInfoResponse, error) {
@@ -695,8 +614,6 @@ func (b *IWDBackend) ForgetWiFiNetwork(ssid string) error {
 						b.stateMutex.Unlock()
 					}
 
-					_, _ = b.updateWiFiNetworks()
-
 					if b.onStateChange != nil {
 						b.onStateChange()
 					}

core/internal/server/network/backend_networkmanager.go

@@ -222,10 +222,6 @@ func (b *NetworkManagerBackend) Initialize() error {
 		log.Warnf("Failed to update WiFi state: %v", err)
 	}
 
-	if err := b.updateSavedWiFiNetworks(); err != nil {
-		log.Warnf("Failed to get initial saved WiFi networks: %v", err)
-	}
-
 	if wifiEnabled {
 		if _, err := b.updateWiFiNetworks(); err != nil {
 			log.Warnf("Failed to get initial networks: %v", err)
@@ -265,7 +261,6 @@ func (b *NetworkManagerBackend) GetCurrentState() (*BackendState, error) {
 
 	state := *b.state
 	state.WiFiNetworks = append([]WiFiNetwork(nil), b.state.WiFiNetworks...)
-	state.SavedWiFiNetworks = append([]WiFiNetwork(nil), b.state.SavedWiFiNetworks...)
 	state.WiFiDevices = append([]WiFiDevice(nil), b.state.WiFiDevices...)
 	state.WiredConnections = append([]WiredConnection(nil), b.state.WiredConnections...)
 	state.EthernetDevices = append([]EthernetDevice(nil), b.state.EthernetDevices...)

core/internal/server/network/backend_networkmanager_signals.go

@@ -5,12 +5,6 @@ import (
 	"github.com/godbus/dbus/v5"
 )
 
-const (
-	dbusNMSettingsPath                = "/org/freedesktop/NetworkManager/Settings"
-	dbusNMSettingsInterface           = "org.freedesktop.NetworkManager.Settings"
-	dbusNMSettingsConnectionInterface = "org.freedesktop.NetworkManager.Settings.Connection"
-)
-
 func (b *NetworkManagerBackend) startSignalPump() error {
 	conn, err := dbus.ConnectSystemBus()
 	if err != nil {
@@ -33,8 +27,8 @@ func (b *NetworkManagerBackend) startSignalPump() error {
 	}
 
 	if err := conn.AddMatchSignal(
-		dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMSettingsPath)),
-		dbus.WithMatchInterface(dbusNMSettingsInterface),
+		dbus.WithMatchObjectPath(dbus.ObjectPath("/org/freedesktop/NetworkManager/Settings")),
+		dbus.WithMatchInterface("org.freedesktop.NetworkManager.Settings"),
 		dbus.WithMatchMember("NewConnection"),
 	); err != nil {
 		conn.RemoveMatchSignal(
@@ -48,8 +42,8 @@ func (b *NetworkManagerBackend) startSignalPump() error {
 	}
 
 	if err := conn.AddMatchSignal(
-		dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMSettingsPath)),
-		dbus.WithMatchInterface(dbusNMSettingsInterface),
+		dbus.WithMatchObjectPath(dbus.ObjectPath("/org/freedesktop/NetworkManager/Settings")),
+		dbus.WithMatchInterface("org.freedesktop.NetworkManager.Settings"),
 		dbus.WithMatchMember("ConnectionRemoved"),
 	); err != nil {
 		conn.RemoveMatchSignal(
@@ -58,8 +52,8 @@ func (b *NetworkManagerBackend) startSignalPump() error {
 			dbus.WithMatchMember("PropertiesChanged"),
 		)
 		conn.RemoveMatchSignal(
-			dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMSettingsPath)),
-			dbus.WithMatchInterface(dbusNMSettingsInterface),
+			dbus.WithMatchObjectPath(dbus.ObjectPath("/org/freedesktop/NetworkManager/Settings")),
+			dbus.WithMatchInterface("org.freedesktop.NetworkManager.Settings"),
 			dbus.WithMatchMember("NewConnection"),
 		)
 		conn.RemoveSignal(signals)
@@ -67,31 +61,6 @@ func (b *NetworkManagerBackend) startSignalPump() error {
 		return err
 	}
 
-	if err := conn.AddMatchSignal(
-		dbus.WithMatchPathNamespace(dbus.ObjectPath(dbusNMSettingsPath)),
-		dbus.WithMatchInterface(dbusNMSettingsConnectionInterface),
-		dbus.WithMatchMember("Updated"),
-	); err != nil {
-		conn.RemoveMatchSignal(
-			dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMPath)),
-			dbus.WithMatchInterface(dbusPropsInterface),
-			dbus.WithMatchMember("PropertiesChanged"),
-		)
-		conn.RemoveMatchSignal(
-			dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMSettingsPath)),
-			dbus.WithMatchInterface(dbusNMSettingsInterface),
-			dbus.WithMatchMember("NewConnection"),
-		)
-		conn.RemoveMatchSignal(
-			dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMSettingsPath)),
-			dbus.WithMatchInterface(dbusNMSettingsInterface),
-			dbus.WithMatchMember("ConnectionRemoved"),
-		)
-		conn.RemoveSignal(signals)
-		conn.Close()
-		return err
-	}
-
 	if err := conn.AddMatchSignal(
 		dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMPath)),
 		dbus.WithMatchInterface(dbusNMInterface),
@@ -168,32 +137,6 @@ func (b *NetworkManagerBackend) stopSignalPump() {
 		dbus.WithMatchMember("PropertiesChanged"),
 	)
 
-	b.dbusConn.RemoveMatchSignal(
-		dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMSettingsPath)),
-		dbus.WithMatchInterface(dbusNMSettingsInterface),
-		dbus.WithMatchMember("NewConnection"),
-	)
-	b.dbusConn.RemoveMatchSignal(
-		dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMSettingsPath)),
-		dbus.WithMatchInterface(dbusNMSettingsInterface),
-		dbus.WithMatchMember("ConnectionRemoved"),
-	)
-	b.dbusConn.RemoveMatchSignal(
-		dbus.WithMatchPathNamespace(dbus.ObjectPath(dbusNMSettingsPath)),
-		dbus.WithMatchInterface(dbusNMSettingsConnectionInterface),
-		dbus.WithMatchMember("Updated"),
-	)
-	b.dbusConn.RemoveMatchSignal(
-		dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMPath)),
-		dbus.WithMatchInterface(dbusNMInterface),
-		dbus.WithMatchMember("DeviceAdded"),
-	)
-	b.dbusConn.RemoveMatchSignal(
-		dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMPath)),
-		dbus.WithMatchInterface(dbusNMInterface),
-		dbus.WithMatchMember("DeviceRemoved"),
-	)
-
 	for _, info := range b.wifiDevices {
 		b.dbusConn.RemoveMatchSignal(
 			dbus.WithMatchObjectPath(dbus.ObjectPath(info.device.GetPath())),
@@ -221,13 +164,9 @@ func (b *NetworkManagerBackend) stopSignalPump() {
 }
 
 func (b *NetworkManagerBackend) handleDBusSignal(sig *dbus.Signal) {
-	if sig.Name == dbusNMSettingsInterface+".NewConnection" ||
-		sig.Name == dbusNMSettingsInterface+".ConnectionRemoved" ||
-		sig.Name == dbusNMSettingsConnectionInterface+".Updated" {
+	if sig.Name == "org.freedesktop.NetworkManager.Settings.NewConnection" ||
+		sig.Name == "org.freedesktop.NetworkManager.Settings.ConnectionRemoved" {
 		b.ListVPNProfiles()
-		if err := b.updateSavedWiFiNetworks(); err != nil {
-			b.updateWiFiNetworks()
-		}
 		if b.onStateChange != nil {
 			b.onStateChange()
 		}

core/internal/server/network/backend_networkmanager_wifi.go

@@ -225,14 +225,24 @@ func (b *NetworkManagerBackend) GetWiFiQRCodeContent(ssid string) (string, error
 		return "", fmt.Errorf("failed to identify security type of network `%s`", ssid)
 	}
 
+	var securityType string
 	switch keyMgmt {
 	case "none":
-		return "", fmt.Errorf("QR code generation only supports WPA-PSK connections, `%s` is open or WEP", ssid)
+		authAlg, _ := secSettings["auth-alg"].(string)
+		switch authAlg {
+		case "open":
+			securityType = "nopass"
+		default:
+			securityType = "WEP"
+		}
 	case "ieee8021x":
-		return "", fmt.Errorf("QR code generation only supports WPA-PSK connections, `%s` is enterprise", ssid)
-	case "wpa-psk", "sae", "wpa-psk-sae":
+		securityType = "WEP"
 	default:
-		return "", fmt.Errorf("QR code generation only supports WPA-PSK connections, `%s` uses %s", ssid, keyMgmt)
+		securityType = "WPA"
+	}
+
+	if securityType != "WPA" {
+		return "", fmt.Errorf("QR code generation only supports WPA connections, `%s` uses %s", ssid, securityType)
 	}
 
 	var psk string
@@ -266,7 +276,7 @@ func (b *NetworkManagerBackend) GetWiFiQRCodeContent(ssid string) (string, error
 		return "", fmt.Errorf("failed to retrieve password for `%s`", ssid)
 	}
 
-	return FormatWiFiQRString("WPA", ssid, psk), nil
+	return FormatWiFiQRString(securityType, ssid, psk), nil
 }
 
 func (b *NetworkManagerBackend) ConnectWiFi(req ConnectionRequest) error {
@@ -395,74 +405,6 @@ func (b *NetworkManagerBackend) ForgetWiFiNetwork(ssid string) error {
 	return nil
 }
 
-func getSavedWiFiProfiles(connections []gonetworkmanager.Connection) map[string]savedWiFiProfile {
-	profiles := make(map[string]savedWiFiProfile)
-
-	for _, conn := range connections {
-		connSettings, err := conn.GetSettings()
-		if err != nil {
-			continue
-		}
-
-		connMeta, ok := connSettings["connection"]
-		if !ok {
-			continue
-		}
-
-		connType, ok := connMeta["type"].(string)
-		if !ok || connType != "802-11-wireless" {
-			continue
-		}
-
-		wifiSettings, ok := connSettings["802-11-wireless"]
-		if !ok {
-			continue
-		}
-
-		ssidBytes, ok := wifiSettings["ssid"].([]byte)
-		if !ok || len(ssidBytes) == 0 {
-			continue
-		}
-
-		ssid := string(ssidBytes)
-		profile := savedWiFiProfile{
-			Autoconnect: true,
-			Mode:        "infrastructure",
-		}
-
-		if ac, ok := connMeta["autoconnect"].(bool); ok {
-			profile.Autoconnect = ac
-		}
-		if hidden, ok := wifiSettings["hidden"].(bool); ok {
-			profile.Hidden = hidden
-		}
-		if mode, ok := wifiSettings["mode"].(string); ok && mode != "" {
-			profile.Mode = mode
-		}
-		if _, ok := connSettings["802-11-wireless-security"]; ok {
-			profile.Secured = true
-		}
-		if _, ok := connSettings["802-1x"]; ok {
-			profile.Enterprise = true
-			profile.Secured = true
-		}
-
-		if existing, ok := profiles[ssid]; ok {
-			profile.Autoconnect = profile.Autoconnect || existing.Autoconnect
-			profile.Hidden = profile.Hidden || existing.Hidden
-			profile.Secured = profile.Secured || existing.Secured
-			profile.Enterprise = profile.Enterprise || existing.Enterprise
-			if profile.Mode == "" {
-				profile.Mode = existing.Mode
-			}
-		}
-
-		profiles[ssid] = profile
-	}
-
-	return profiles
-}
-
 func (b *NetworkManagerBackend) IsConnectingTo(ssid string) bool {
 	b.stateMutex.RLock()
 	defer b.stateMutex.RUnlock()
@@ -500,7 +442,47 @@ func (b *NetworkManagerBackend) updateWiFiNetworks() ([]WiFiNetwork, error) {
 		return nil, fmt.Errorf("failed to get connections: %w", err)
 	}
 
-	savedProfiles := getSavedWiFiProfiles(connections)
+	savedSSIDs := make(map[string]bool)
+	autoconnectMap := make(map[string]bool)
+	hiddenSSIDs := make(map[string]bool)
+	for _, conn := range connections {
+		connSettings, err := conn.GetSettings()
+		if err != nil {
+			continue
+		}
+
+		connMeta, ok := connSettings["connection"]
+		if !ok {
+			continue
+		}
+
+		connType, ok := connMeta["type"].(string)
+		if !ok || connType != "802-11-wireless" {
+			continue
+		}
+
+		wifiSettings, ok := connSettings["802-11-wireless"]
+		if !ok {
+			continue
+		}
+
+		ssidBytes, ok := wifiSettings["ssid"].([]byte)
+		if !ok {
+			continue
+		}
+
+		ssid := string(ssidBytes)
+		savedSSIDs[ssid] = true
+		autoconnect := true
+		if ac, ok := connMeta["autoconnect"].(bool); ok {
+			autoconnect = ac
+		}
+		autoconnectMap[ssid] = autoconnect
+
+		if hidden, ok := wifiSettings["hidden"].(bool); ok && hidden {
+			hiddenSSIDs[ssid] = true
+		}
+	}
 
 	b.stateMutex.RLock()
 	currentSSID := b.state.WiFiSSID
@@ -509,8 +491,8 @@ func (b *NetworkManagerBackend) updateWiFiNetworks() ([]WiFiNetwork, error) {
 	wifiBSSID := b.state.WiFiBSSID
 	b.stateMutex.RUnlock()
 
-	seenSSIDs := make(map[string]int)
-	networks := make([]WiFiNetwork, 0, len(apPaths)+1)
+	seenSSIDs := make(map[string]*WiFiNetwork)
+	networks := []WiFiNetwork{}
 
 	for _, ap := range apPaths {
 		ssid, err := ap.GetPropertySSID()
@@ -518,8 +500,7 @@ func (b *NetworkManagerBackend) updateWiFiNetworks() ([]WiFiNetwork, error) {
 			continue
 		}
 
-		if existingIndex, exists := seenSSIDs[ssid]; exists {
-			existing := &networks[existingIndex]
+		if existing, exists := seenSSIDs[ssid]; exists {
 			strength, _ := ap.GetPropertyStrength()
 			if strength > existing.Signal {
 				existing.Signal = strength
@@ -569,7 +550,6 @@ func (b *NetworkManagerBackend) updateWiFiNetworks() ([]WiFiNetwork, error) {
 			}
 		}
 
-		profile, saved := savedProfiles[ssid]
 		network := WiFiNetwork{
 			SSID:        ssid,
 			BSSID:       bssid,
@@ -577,86 +557,45 @@ func (b *NetworkManagerBackend) updateWiFiNetworks() ([]WiFiNetwork, error) {
 			Secured:     secured,
 			Enterprise:  enterprise,
 			Connected:   isConnected,
-			Saved:       saved,
-			Autoconnect: profile.Autoconnect,
-			Hidden:      profile.Hidden,
+			Saved:       savedSSIDs[ssid],
+			Autoconnect: autoconnectMap[ssid],
+			Hidden:      hiddenSSIDs[ssid],
 			Frequency:   freq,
 			Mode:        modeStr,
 			Rate:        rate,
 			Channel:     channel,
 		}
 
+		seenSSIDs[ssid] = &network
 		networks = append(networks, network)
-		seenSSIDs[ssid] = len(networks) - 1
 	}
 
 	if wifiConnected && currentSSID != "" {
 		if _, exists := seenSSIDs[currentSSID]; !exists {
-			profile, saved := savedProfiles[currentSSID]
 			hiddenNetwork := WiFiNetwork{
 				SSID:        currentSSID,
 				BSSID:       wifiBSSID,
 				Signal:      wifiSignal,
 				Secured:     true,
 				Connected:   true,
-				Saved:       saved,
-				Autoconnect: profile.Autoconnect,
+				Saved:       savedSSIDs[currentSSID],
+				Autoconnect: autoconnectMap[currentSSID],
 				Hidden:      true,
 				Mode:        "infrastructure",
 			}
 			networks = append(networks, hiddenNetwork)
-			seenSSIDs[currentSSID] = len(networks) - 1
 		}
 	}
 
-	visibleNetworks := wiFiNetworksBySSID(networks, true)
-	savedNetworks := savedWiFiNetworksFromProfiles(savedProfiles, visibleNetworks, currentSSID, wifiConnected)
-
 	sortWiFiNetworks(networks)
 
 	b.stateMutex.Lock()
 	b.state.WiFiNetworks = networks
-	b.state.SavedWiFiNetworks = savedNetworks
 	b.stateMutex.Unlock()
 
 	return networks, nil
 }
 
-func (b *NetworkManagerBackend) updateSavedWiFiNetworks() error {
-	s := b.settings
-	if s == nil {
-		var err error
-		s, err = gonetworkmanager.NewSettings()
-		if err != nil {
-			return fmt.Errorf("failed to get settings: %w", err)
-		}
-		b.settings = s
-	}
-
-	settingsMgr := s.(gonetworkmanager.Settings)
-	connections, err := settingsMgr.ListConnections()
-	if err != nil {
-		return fmt.Errorf("failed to get connections: %w", err)
-	}
-
-	savedProfiles := getSavedWiFiProfiles(connections)
-
-	b.stateMutex.RLock()
-	currentSSID := b.state.WiFiSSID
-	wifiConnected := b.state.WiFiConnected
-	wifiNetworks := append([]WiFiNetwork(nil), b.state.WiFiNetworks...)
-	b.stateMutex.RUnlock()
-
-	wifiNetworks, savedNetworks := refreshSavedWiFiState(wifiNetworks, savedProfiles, currentSSID, wifiConnected)
-
-	b.stateMutex.Lock()
-	b.state.WiFiNetworks = wifiNetworks
-	b.state.SavedWiFiNetworks = savedNetworks
-	b.stateMutex.Unlock()
-
-	return nil
-}
-
 func (b *NetworkManagerBackend) findConnection(ssid string) (gonetworkmanager.Connection, error) {
 	s := b.settings
 	if s == nil {
@@ -1036,14 +975,49 @@ func (b *NetworkManagerBackend) updateAllWiFiDevices() {
 		return
 	}
 
-	savedProfiles := getSavedWiFiProfiles(connections)
+	savedSSIDs := make(map[string]bool)
+	autoconnectMap := make(map[string]bool)
+	hiddenSSIDs := make(map[string]bool)
+	for _, conn := range connections {
+		connSettings, err := conn.GetSettings()
+		if err != nil {
+			continue
+		}
+
+		connMeta, ok := connSettings["connection"]
+		if !ok {
+			continue
+		}
+
+		connType, ok := connMeta["type"].(string)
+		if !ok || connType != "802-11-wireless" {
+			continue
+		}
+
+		wifiSettings, ok := connSettings["802-11-wireless"]
+		if !ok {
+			continue
+		}
+
+		ssidBytes, ok := wifiSettings["ssid"].([]byte)
+		if !ok {
+			continue
+		}
+
+		ssid := string(ssidBytes)
+		savedSSIDs[ssid] = true
+		autoconnect := true
+		if ac, ok := connMeta["autoconnect"].(bool); ok {
+			autoconnect = ac
+		}
+		autoconnectMap[ssid] = autoconnect
+
+		if hidden, ok := wifiSettings["hidden"].(bool); ok && hidden {
+			hiddenSSIDs[ssid] = true
+		}
+	}
 
 	var devices []WiFiDevice
-	visibleNetworks := make(map[string]WiFiNetwork)
-	b.stateMutex.RLock()
-	currentSSID := b.state.WiFiSSID
-	wifiConnected := b.state.WiFiConnected
-	b.stateMutex.RUnlock()
 
 	for name, devInfo := range b.wifiDevices {
 		state, _ := devInfo.device.GetPropertyState()
@@ -1076,16 +1050,14 @@ func (b *NetworkManagerBackend) updateAllWiFiDevices() {
 		apPaths, err := devInfo.wireless.GetAccessPoints()
 		var networks []WiFiNetwork
 		if err == nil {
-			seenSSIDs := make(map[string]int)
-			networks = make([]WiFiNetwork, 0, len(apPaths)+1)
+			seenSSIDs := make(map[string]*WiFiNetwork)
 			for _, ap := range apPaths {
 				apSSID, err := ap.GetPropertySSID()
 				if err != nil || apSSID == "" {
 					continue
 				}
 
-				if existingIndex, exists := seenSSIDs[apSSID]; exists {
-					existing := &networks[existingIndex]
+				if existing, exists := seenSSIDs[apSSID]; exists {
 					strength, _ := ap.GetPropertyStrength()
 					if strength > existing.Signal {
 						existing.Signal = strength
@@ -1135,7 +1107,6 @@ func (b *NetworkManagerBackend) updateAllWiFiDevices() {
 					}
 				}
 
-				profile, saved := savedProfiles[apSSID]
 				network := WiFiNetwork{
 					SSID:        apSSID,
 					BSSID:       apBSSID,
@@ -1143,9 +1114,9 @@ func (b *NetworkManagerBackend) updateAllWiFiDevices() {
 					Secured:     secured,
 					Enterprise:  enterprise,
 					Connected:   isConnected,
-					Saved:       saved,
-					Autoconnect: profile.Autoconnect,
-					Hidden:      profile.Hidden,
+					Saved:       savedSSIDs[apSSID],
+					Autoconnect: autoconnectMap[apSSID],
+					Hidden:      hiddenSSIDs[apSSID],
 					Frequency:   freq,
 					Mode:        modeStr,
 					Rate:        rate,
@@ -1153,31 +1124,25 @@ func (b *NetworkManagerBackend) updateAllWiFiDevices() {
 					Device:      name,
 				}
 
+				seenSSIDs[apSSID] = &network
 				networks = append(networks, network)
-				seenSSIDs[apSSID] = len(networks) - 1
-				if existing, ok := visibleNetworks[apSSID]; !ok || network.Signal > existing.Signal {
-					visibleNetworks[apSSID] = network
-				}
 			}
 
 			if connected && ssid != "" {
 				if _, exists := seenSSIDs[ssid]; !exists {
-					profile, saved := savedProfiles[ssid]
 					hiddenNetwork := WiFiNetwork{
 						SSID:        ssid,
 						BSSID:       bssid,
 						Signal:      signal,
 						Secured:     true,
 						Connected:   true,
-						Saved:       saved,
-						Autoconnect: profile.Autoconnect,
+						Saved:       savedSSIDs[ssid],
+						Autoconnect: autoconnectMap[ssid],
 						Hidden:      true,
 						Mode:        "infrastructure",
 						Device:      name,
 					}
 					networks = append(networks, hiddenNetwork)
-					seenSSIDs[ssid] = len(networks) - 1
-					visibleNetworks[ssid] = hiddenNetwork
 				}
 			}
 
@@ -1203,7 +1168,6 @@ func (b *NetworkManagerBackend) updateAllWiFiDevices() {
 
 	b.stateMutex.Lock()
 	b.state.WiFiDevices = devices
-	b.state.SavedWiFiNetworks = savedWiFiNetworksFromProfiles(savedProfiles, visibleNetworks, currentSSID, wifiConnected)
 	b.stateMutex.Unlock()
 }
 

core/internal/server/network/backend_networkmanager_wifi_test.go

@@ -4,7 +4,6 @@ import (
 	"testing"
 
 	mock_gonetworkmanager "github.com/AvengeMedia/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2"
-	"github.com/Wifx/gonetworkmanager/v2"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -177,54 +176,6 @@ func TestNetworkManagerBackend_UpdateWiFiNetworks_NoDevice(t *testing.T) {
 	assert.Contains(t, err.Error(), "no WiFi device available")
 }
 
-func TestNetworkManagerBackend_UpdateSavedWiFiNetworksPreservesVisibleSavedNetworks(t *testing.T) {
-	mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
-	mockSettings := mock_gonetworkmanager.NewMockSettings(t)
-	mockConn := mock_gonetworkmanager.NewMockConnection(t)
-
-	backend, err := NewNetworkManagerBackend(mockNM)
-	assert.NoError(t, err)
-	backend.settings = mockSettings
-
-	backend.stateMutex.Lock()
-	backend.state.WiFiNetworks = []WiFiNetwork{
-		{
-			SSID:   "Home",
-			Signal: 76,
-		},
-	}
-	backend.stateMutex.Unlock()
-
-	settings := gonetworkmanager.ConnectionSettings{
-		"connection": {
-			"type":        "802-11-wireless",
-			"autoconnect": true,
-		},
-		"802-11-wireless": {
-			"ssid": []byte("Home"),
-		},
-		"802-11-wireless-security": {},
-	}
-	mockSettings.EXPECT().ListConnections().Return([]gonetworkmanager.Connection{mockConn}, nil)
-	mockConn.EXPECT().GetSettings().Return(settings, nil)
-
-	err = backend.updateSavedWiFiNetworks()
-	assert.NoError(t, err)
-
-	backend.stateMutex.RLock()
-	savedNetworks := append([]WiFiNetwork(nil), backend.state.SavedWiFiNetworks...)
-	wifiNetworks := append([]WiFiNetwork(nil), backend.state.WiFiNetworks...)
-	backend.stateMutex.RUnlock()
-
-	assert.Len(t, wifiNetworks, 1)
-	assert.True(t, wifiNetworks[0].Saved)
-	assert.Len(t, savedNetworks, 1)
-	assert.Equal(t, "Home", savedNetworks[0].SSID)
-	assert.True(t, savedNetworks[0].Saved)
-	assert.False(t, savedNetworks[0].OutOfRange)
-	assert.Equal(t, uint8(76), savedNetworks[0].Signal)
-}
-
 func TestNetworkManagerBackend_FindConnection_NoSettings(t *testing.T) {
 	mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
 

core/internal/server/network/manager.go

@@ -64,10 +64,9 @@ func NewManager() (*Manager, error) {
 	m := &Manager{
 		backend: backend,
 		state: &NetworkState{
-			NetworkStatus:     StatusDisconnected,
-			Preference:        PreferenceAuto,
-			WiFiNetworks:      []WiFiNetwork{},
-			SavedWiFiNetworks: []WiFiNetwork{},
+			NetworkStatus: StatusDisconnected,
+			Preference:    PreferenceAuto,
+			WiFiNetworks:  []WiFiNetwork{},
 		},
 		stateMutex: sync.RWMutex{},
 
@@ -121,7 +120,6 @@ func (m *Manager) syncStateFromBackend() error {
 	m.state.WiFiBSSID = backendState.WiFiBSSID
 	m.state.WiFiSignal = backendState.WiFiSignal
 	m.state.WiFiNetworks = backendState.WiFiNetworks
-	m.state.SavedWiFiNetworks = backendState.SavedWiFiNetworks
 	m.state.WiFiDevices = backendState.WiFiDevices
 	m.state.WiredConnections = backendState.WiredConnections
 	m.state.VPNProfiles = backendState.VPNProfiles
@@ -158,7 +156,6 @@ func (m *Manager) snapshotState() NetworkState {
 	defer m.stateMutex.RUnlock()
 	s := *m.state
 	s.WiFiNetworks = append([]WiFiNetwork(nil), m.state.WiFiNetworks...)
-	s.SavedWiFiNetworks = append([]WiFiNetwork(nil), m.state.SavedWiFiNetworks...)
 	s.WiFiDevices = append([]WiFiDevice(nil), m.state.WiFiDevices...)
 	s.WiredConnections = append([]WiredConnection(nil), m.state.WiredConnections...)
 	s.EthernetDevices = append([]EthernetDevice(nil), m.state.EthernetDevices...)
@@ -214,9 +211,6 @@ func stateChangedMeaningfully(old, new *NetworkState) bool {
 	if len(old.WiFiNetworks) != len(new.WiFiNetworks) {
 		return true
 	}
-	if len(old.SavedWiFiNetworks) != len(new.SavedWiFiNetworks) {
-		return true
-	}
 	if len(old.WiFiDevices) != len(new.WiFiDevices) {
 		return true
 	}
@@ -244,23 +238,6 @@ func stateChangedMeaningfully(old, new *NetworkState) bool {
 		}
 	}
 
-	for i := range old.SavedWiFiNetworks {
-		oldNet := &old.SavedWiFiNetworks[i]
-		newNet := &new.SavedWiFiNetworks[i]
-		if oldNet.SSID != newNet.SSID {
-			return true
-		}
-		if oldNet.Connected != newNet.Connected {
-			return true
-		}
-		if oldNet.Autoconnect != newNet.Autoconnect {
-			return true
-		}
-		if oldNet.OutOfRange != newNet.OutOfRange {
-			return true
-		}
-	}
-
 	for i := range old.WiredConnections {
 		oldNet := &old.WiredConnections[i]
 		newNet := &new.WiredConnections[i]

core/internal/server/network/types.go

@@ -34,7 +34,6 @@ type WiFiNetwork struct {
 	Saved       bool   `json:"saved"`
 	Autoconnect bool   `json:"autoconnect"`
 	Hidden      bool   `json:"hidden"`
-	OutOfRange  bool   `json:"outOfRange"`
 	Frequency   uint32 `json:"frequency"`
 	Mode        string `json:"mode"`
 	Rate        uint32 `json:"rate"`
@@ -112,7 +111,6 @@ type NetworkState struct {
 	WiFiBSSID              string               `json:"wifiBSSID"`
 	WiFiSignal             uint8                `json:"wifiSignal"`
 	WiFiNetworks           []WiFiNetwork        `json:"wifiNetworks"`
-	SavedWiFiNetworks      []WiFiNetwork        `json:"savedWifiNetworks"`
 	WiFiDevices            []WiFiDevice         `json:"wifiDevices"`
 	WiredConnections       []WiredConnection    `json:"wiredConnections"`
 	VPNProfiles            []VPNProfile         `json:"vpnProfiles"`

core/internal/server/network/wifi_saved.go

@@ -1,103 +0,0 @@
-package network
-
-import "sort"
-
-type savedWiFiProfile struct {
-	Autoconnect bool
-	Hidden      bool
-	Secured     bool
-	Enterprise  bool
-	Mode        string
-}
-
-// Saved WiFi state is keyed by SSID because the UI/API accepts SSID actions.
-// Multiple backend profiles for the same SSID are intentionally collapsed here.
-func mergeSavedProfilesIntoWiFiNetworks(networks []WiFiNetwork, profiles map[string]savedWiFiProfile, currentSSID string, wifiConnected bool) []WiFiNetwork {
-	merged := make([]WiFiNetwork, len(networks))
-	for i, network := range networks {
-		profile, saved := profiles[network.SSID]
-		network.Connected = wifiConnected && network.SSID == currentSSID
-		network.Saved = saved
-		if saved {
-			network.Autoconnect = profile.Autoconnect
-			network.Hidden = network.Hidden || profile.Hidden
-			network.Secured = network.Secured || profile.Secured
-			network.Enterprise = network.Enterprise || profile.Enterprise
-			if network.Mode == "" {
-				network.Mode = profile.Mode
-			}
-		} else {
-			network.Autoconnect = false
-		}
-		merged[i] = network
-	}
-	return merged
-}
-
-func wiFiNetworksBySSID(networks []WiFiNetwork, visibleOnly bool) map[string]WiFiNetwork {
-	visible := make(map[string]WiFiNetwork, len(networks))
-	for _, network := range networks {
-		if visibleOnly && network.OutOfRange {
-			continue
-		}
-		visible[network.SSID] = network
-	}
-	return visible
-}
-
-func refreshSavedWiFiState(networks []WiFiNetwork, profiles map[string]savedWiFiProfile, currentSSID string, wifiConnected bool) ([]WiFiNetwork, []WiFiNetwork) {
-	mergedNetworks := mergeSavedProfilesIntoWiFiNetworks(networks, profiles, currentSSID, wifiConnected)
-	visibleNetworks := wiFiNetworksBySSID(mergedNetworks, true)
-	savedNetworks := savedWiFiNetworksFromProfiles(profiles, visibleNetworks, currentSSID, wifiConnected)
-	return mergedNetworks, savedNetworks
-}
-
-func savedWiFiNetworksFromProfiles(profiles map[string]savedWiFiProfile, visible map[string]WiFiNetwork, currentSSID string, wifiConnected bool) []WiFiNetwork {
-	networks := make([]WiFiNetwork, 0, len(profiles))
-	for ssid, profile := range profiles {
-		if network, ok := visible[ssid]; ok {
-			network.Saved = true
-			network.Autoconnect = profile.Autoconnect
-			network.Hidden = network.Hidden || profile.Hidden
-			network.Secured = network.Secured || profile.Secured
-			network.Enterprise = network.Enterprise || profile.Enterprise
-			network.OutOfRange = false
-			if network.Mode == "" {
-				network.Mode = profile.Mode
-			}
-			networks = append(networks, network)
-			continue
-		}
-
-		isConnected := wifiConnected && ssid == currentSSID
-		networks = append(networks, WiFiNetwork{
-			SSID:        ssid,
-			Secured:     profile.Secured,
-			Enterprise:  profile.Enterprise,
-			Connected:   isConnected,
-			Saved:       true,
-			Autoconnect: profile.Autoconnect,
-			Hidden:      profile.Hidden,
-			OutOfRange:  !isConnected,
-			Mode:        profile.Mode,
-		})
-	}
-
-	sort.Slice(networks, func(i, j int) bool {
-		if networks[i].Connected && !networks[j].Connected {
-			return true
-		}
-		if !networks[i].Connected && networks[j].Connected {
-			return false
-		}
-		if networks[i].OutOfRange != networks[j].OutOfRange {
-			return !networks[i].OutOfRange
-		}
-		if networks[i].Signal != networks[j].Signal {
-			return networks[i].Signal > networks[j].Signal
-		}
-		return networks[i].SSID < networks[j].SSID
-	})
-
-	return networks
-}

core/internal/server/network/wifi_saved_test.go

@@ -1,170 +0,0 @@
-package network
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestMergeSavedProfilesIntoWiFiNetworks(t *testing.T) {
-	networks := []WiFiNetwork{
-		{
-			SSID:        "Home",
-			Signal:      80,
-			Secured:     false,
-			Autoconnect: false,
-		},
-		{
-			SSID:        "Cafe",
-			Signal:      50,
-			Secured:     false,
-			Autoconnect: true,
-		},
-	}
-	profiles := map[string]savedWiFiProfile{
-		"Home": {
-			Autoconnect: true,
-			Hidden:      true,
-			Secured:     true,
-			Mode:        "infrastructure",
-		},
-	}
-
-	merged := mergeSavedProfilesIntoWiFiNetworks(networks, profiles, "Home", true)
-
-	assert.Len(t, merged, 2)
-	assert.Equal(t, "Home", merged[0].SSID)
-	assert.True(t, merged[0].Connected)
-	assert.True(t, merged[0].Saved)
-	assert.True(t, merged[0].Autoconnect)
-	assert.True(t, merged[0].Hidden)
-	assert.True(t, merged[0].Secured)
-	assert.Equal(t, "infrastructure", merged[0].Mode)
-
-	assert.Equal(t, "Cafe", merged[1].SSID)
-	assert.False(t, merged[1].Saved)
-	assert.False(t, merged[1].Autoconnect)
-}
-
-func TestSavedWiFiNetworksFromProfilesOutOfRangeWithoutVisibleNetworks(t *testing.T) {
-	profiles := map[string]savedWiFiProfile{
-		"Home": {
-			Autoconnect: true,
-			Secured:     true,
-			Mode:        "infrastructure",
-		},
-	}
-
-	networks := savedWiFiNetworksFromProfiles(profiles, nil, "", false)
-
-	assert.Len(t, networks, 1)
-	assert.Equal(t, "Home", networks[0].SSID)
-	assert.True(t, networks[0].Saved)
-	assert.True(t, networks[0].OutOfRange)
-	assert.Equal(t, uint8(0), networks[0].Signal)
-}
-
-func TestSavedWiFiNetworksFromProfilesKeepsConnectedCurrentNetworkInRange(t *testing.T) {
-	profiles := map[string]savedWiFiProfile{
-		"Home": {
-			Autoconnect: true,
-			Secured:     true,
-		},
-	}
-
-	networks := savedWiFiNetworksFromProfiles(profiles, nil, "Home", true)
-
-	assert.Len(t, networks, 1)
-	assert.Equal(t, "Home", networks[0].SSID)
-	assert.True(t, networks[0].Connected)
-	assert.False(t, networks[0].OutOfRange)
-}
-
-func TestSavedWiFiNetworksFromProfilesIncludesOutOfRange(t *testing.T) {
-	profiles := map[string]savedWiFiProfile{
-		"Home": {
-			Autoconnect: true,
-			Hidden:      true,
-			Secured:     true,
-			Mode:        "infrastructure",
-		},
-		"Office": {
-			Autoconnect: false,
-			Secured:     true,
-			Enterprise:  true,
-			Mode:        "infrastructure",
-		},
-	}
-	visible := map[string]WiFiNetwork{
-		"Home": {
-			SSID:      "Home",
-			Signal:    72,
-			Secured:   true,
-			Connected: true,
-		},
-	}
-
-	networks := savedWiFiNetworksFromProfiles(profiles, visible, "Home", true)
-
-	assert.Len(t, networks, 2)
-	assert.Equal(t, "Home", networks[0].SSID)
-	assert.True(t, networks[0].Saved)
-	assert.True(t, networks[0].Connected)
-	assert.False(t, networks[0].OutOfRange)
-	assert.True(t, networks[0].Hidden)
-	assert.Equal(t, uint8(72), networks[0].Signal)
-
-	assert.Equal(t, "Office", networks[1].SSID)
-	assert.True(t, networks[1].Saved)
-	assert.False(t, networks[1].Autoconnect)
-	assert.True(t, networks[1].Enterprise)
-	assert.True(t, networks[1].OutOfRange)
-}
-
-func TestWiFiNetworksBySSIDVisibleOnlySkipsOutOfRange(t *testing.T) {
-	visible := wiFiNetworksBySSID([]WiFiNetwork{
-		{SSID: "Home", Signal: 70},
-		{SSID: "Office", Signal: 0, OutOfRange: true},
-	}, true)
-
-	assert.Contains(t, visible, "Home")
-	assert.NotContains(t, visible, "Office")
-}
-
-func TestRefreshSavedWiFiStatePreservesVisibleSavedNetworks(t *testing.T) {
-	networks := []WiFiNetwork{
-		{
-			SSID:   "Home",
-			Signal: 82,
-		},
-	}
-	profiles := map[string]savedWiFiProfile{
-		"Home": {
-			Autoconnect: true,
-			Secured:     true,
-			Mode:        "infrastructure",
-		},
-		"Office": {
-			Autoconnect: false,
-			Secured:     true,
-			Mode:        "infrastructure",
-		},
-	}
-
-	mergedNetworks, savedNetworks := refreshSavedWiFiState(networks, profiles, "", false)
-
-	assert.Len(t, mergedNetworks, 1)
-	assert.Equal(t, "Home", mergedNetworks[0].SSID)
-	assert.True(t, mergedNetworks[0].Saved)
-	assert.True(t, mergedNetworks[0].Autoconnect)
-
-	assert.Len(t, savedNetworks, 2)
-	assert.Equal(t, "Home", savedNetworks[0].SSID)
-	assert.True(t, savedNetworks[0].Saved)
-	assert.False(t, savedNetworks[0].OutOfRange)
-	assert.Equal(t, uint8(82), savedNetworks[0].Signal)
-
-	assert.Equal(t, "Office", savedNetworks[1].SSID)
-	assert.True(t, savedNetworks[1].Saved)
-	assert.True(t, savedNetworks[1].OutOfRange)
-}

core/internal/server/router.go

@@ -11,6 +11,7 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/clipboard"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/cups"
 	serverDbus "github.com/AvengeMedia/DankMaterialShell/core/internal/server/dbus"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/dwl"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/evdev"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/freedesktop"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/location"
@@ -124,6 +125,15 @@ func RouteRequest(conn net.Conn, req models.Request) {
 		return
 	}
 
+	if strings.HasPrefix(req.Method, "dwl.") {
+		if dwlManager == nil {
+			models.RespondError(conn, req.ID, "dwl manager not initialized")
+			return
+		}
+		dwl.HandleRequest(conn, req, dwlManager)
+		return
+	}
+
 	if strings.HasPrefix(req.Method, "brightness.") {
 		if brightnessManager == nil {
 			models.RespondError(conn, req.ID, "brightness manager not initialized")

core/internal/server/server.go

@@ -22,6 +22,7 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/clipboard"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/cups"
 	serverDbus "github.com/AvengeMedia/DankMaterialShell/core/internal/server/dbus"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/dwl"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/evdev"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/freedesktop"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/location"
@@ -38,7 +39,7 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/pkg/syncmap"
 )
 
-const APIVersion = 26
+const APIVersion = 24
 
 var CLIVersion = "dev"
 
@@ -65,6 +66,7 @@ var bluezManager *bluez.Manager
 var appPickerManager *apppicker.Manager
 var cupsManager *cups.Manager
 var tailscaleManager *tailscale.Manager
+var dwlManager *dwl.Manager
 var brightnessManager *brightness.Manager
 var wlrOutputManager *wlroutput.Manager
 var evdevManager *evdev.Manager
@@ -250,6 +252,30 @@ func InitializeCupsManager() error {
 	return nil
 }
 
+func InitializeDwlManager() error {
+	log.Info("Attempting to initialize DWL IPC...")
+
+	if wlContext == nil {
+		ctx, err := wlcontext.New()
+		if err != nil {
+			log.Errorf("Failed to create shared Wayland context: %v", err)
+			return err
+		}
+		wlContext = ctx
+	}
+
+	manager, err := dwl.NewManager(wlContext.Display())
+	if err != nil {
+		log.Debug("Failed to initialize dwl manager: %v", err)
+		return err
+	}
+
+	dwlManager = manager
+
+	log.Info("DWL IPC initialized successfully")
+	return nil
+}
+
 func InitializeBrightnessManager() error {
 	manager, err := brightness.NewManager()
 	if err != nil {
@@ -442,6 +468,10 @@ func getCapabilities() Capabilities {
 		caps = append(caps, "tailscale")
 	}
 
+	if dwlManager != nil {
+		caps = append(caps, "dwl")
+	}
+
 	if brightnessManager != nil {
 		caps = append(caps, "brightness")
 	}
@@ -508,6 +538,10 @@ func getServerInfo() ServerInfo {
 		caps = append(caps, "tailscale")
 	}
 
+	if dwlManager != nil {
+		caps = append(caps, "dwl")
+	}
+
 	if brightnessManager != nil {
 		caps = append(caps, "brightness")
 	}
@@ -1012,6 +1046,38 @@ func handleSubscribe(conn net.Conn, req models.Request) {
 		}()
 	}
 
+	if shouldSubscribe("dwl") && dwlManager != nil {
+		wg.Add(1)
+		dwlChan := dwlManager.Subscribe(clientID + "-dwl")
+		go func() {
+			defer wg.Done()
+			defer dwlManager.Unsubscribe(clientID + "-dwl")
+
+			initialState := dwlManager.GetState()
+			select {
+			case eventChan <- ServiceEvent{Service: "dwl", Data: initialState}:
+			case <-stopChan:
+				return
+			}
+
+			for {
+				select {
+				case state, ok := <-dwlChan:
+					if !ok {
+						return
+					}
+					select {
+					case eventChan <- ServiceEvent{Service: "dwl", Data: state}:
+					case <-stopChan:
+						return
+					}
+				case <-stopChan:
+					return
+				}
+			}
+		}()
+	}
+
 	if shouldSubscribe("brightness") && brightnessManager != nil {
 		wg.Add(2)
 		brightnessStateChan := brightnessManager.Subscribe(clientID + "-brightness-state")
@@ -1267,6 +1333,9 @@ func cleanupManagers() {
 	if cupsManager != nil {
 		cupsManager.Close()
 	}
+	if dwlManager != nil {
+		dwlManager.Close()
+	}
 	if brightnessManager != nil {
 		brightnessManager.Close()
 	}
@@ -1433,6 +1502,19 @@ func Start(printDocs bool) error {
 		log.Info(" cups.resumePrinter                    - Resume printer (params: printerName)")
 		log.Info(" cups.cancelJob                        - Cancel job (params: printerName, jobID)")
 		log.Info(" cups.purgeJobs                        - Cancel all jobs (params: printerName)")
+		log.Info("DWL:")
+		log.Info(" dwl.getState                          - Get current dwl state (tags, windows, layouts, keyboard)")
+		log.Info(" dwl.setTags                           - Set active tags (params: output, tagmask, toggleTagset)")
+		log.Info(" dwl.setClientTags                     - Set focused client tags (params: output, andTags, xorTags)")
+		log.Info(" dwl.setLayout                         - Set layout (params: output, index)")
+		log.Info(" dwl.subscribe                         - Subscribe to dwl state changes (streaming)")
+		log.Info("   Output state includes:")
+		log.Info("     - tags         : Tag states (active, clients, focused)")
+		log.Info("     - layoutSymbol : Current layout name")
+		log.Info("     - title        : Focused window title")
+		log.Info("     - appId        : Focused window app ID")
+		log.Info("     - kbLayout     : Current keyboard layout")
+		log.Info("     - keymode      : Current keybind mode")
 		log.Info("Brightness:")
 		log.Info(" brightness.getState                   - Get current brightness state for all devices")
 		log.Info(" brightness.setBrightness              - Set device brightness (params: device, percent)")
@@ -1609,6 +1691,10 @@ func Start(printDocs bool) error {
 		log.Debugf("AppPicker manager unavailable: %v", err)
 	}
 
+	if err := InitializeDwlManager(); err != nil {
+		log.Debugf("DWL manager unavailable: %v", err)
+	}
+
 	if err := InitializeWlrOutputManager(); err != nil {
 		log.Debugf("WlrOutput manager unavailable: %v", err)
 	}

core/internal/server/tailscale/client.go

@@ -66,17 +66,16 @@ func convertPeerStatus(ps *ipnstate.PeerStatus, users map[tailcfg.UserID]tailcfg
 	}
 
 	peer := Peer{
-		ID:             string(ps.ID),
-		Hostname:       hostname,
-		DNSName:        dnsName,
-		OS:             ps.OS,
-		Online:         ps.Online,
-		Active:         ps.Active,
-		ExitNode:       ps.ExitNode,
-		ExitNodeOption: ps.ExitNodeOption,
-		Relay:          ps.Relay,
-		RxBytes:        ps.RxBytes,
-		TxBytes:        ps.TxBytes,
+		ID:       string(ps.ID),
+		Hostname: hostname,
+		DNSName:  dnsName,
+		OS:       ps.OS,
+		Online:   ps.Online,
+		Active:   ps.Active,
+		ExitNode: ps.ExitNode,
+		Relay:    ps.Relay,
+		RxBytes:  ps.RxBytes,
+		TxBytes:  ps.TxBytes,
 	}
 
 	for _, ip := range ps.TailscaleIPs {

core/internal/server/tailscale/handlers.go

@@ -14,14 +14,6 @@ func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 		handleGetStatus(conn, req, manager)
 	case "tailscale.refresh":
 		handleRefresh(conn, req, manager)
-	case "tailscale.connect":
-		handleConnect(conn, req, manager)
-	case "tailscale.disconnect":
-		handleDisconnect(conn, req, manager)
-	case "tailscale.setExitNode":
-		handleSetExitNode(conn, req, manager)
-	case "tailscale.setAllowLanAccess":
-		handleSetAllowLanAccess(conn, req, manager)
 	default:
 		models.RespondError(conn, req.ID, fmt.Sprintf("unknown method: %s", req.Method))
 	}
@@ -36,37 +28,3 @@ func handleRefresh(conn net.Conn, req models.Request, manager *Manager) {
 	manager.RefreshState()
 	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "refreshed"})
 }
-
-func handleConnect(conn net.Conn, req models.Request, manager *Manager) {
-	if err := manager.Connect(); err != nil {
-		models.RespondError(conn, req.ID, err.Error())
-		return
-	}
-	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "connected"})
-}
-
-func handleDisconnect(conn net.Conn, req models.Request, manager *Manager) {
-	if err := manager.Disconnect(); err != nil {
-		models.RespondError(conn, req.ID, err.Error())
-		return
-	}
-	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "disconnected"})
-}
-
-func handleSetExitNode(conn net.Conn, req models.Request, manager *Manager) {
-	id := models.GetOr(req, "id", "")
-	if err := manager.SetExitNode(id); err != nil {
-		models.RespondError(conn, req.ID, err.Error())
-		return
-	}
-	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "exit node updated"})
-}
-
-func handleSetAllowLanAccess(conn net.Conn, req models.Request, manager *Manager) {
-	enabled := models.GetOr(req, "enabled", false)
-	if err := manager.SetAllowLANAccess(enabled); err != nil {
-		models.RespondError(conn, req.ID, err.Error())
-		return
-	}
-	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "lan access updated"})
-}

core/internal/server/tailscale/handlers_test.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"fmt"
 	"net"
 	"testing"
 	"time"
@@ -79,63 +78,6 @@ func TestHandleRefresh(t *testing.T) {
 	assert.True(t, resp.Result.Success)
 }
 
-func TestHandleActions(t *testing.T) {
-	cases := []struct {
-		name   string
-		method string
-		params map[string]any
-	}{
-		{"connect", "tailscale.connect", nil},
-		{"disconnect", "tailscale.disconnect", nil},
-		{"setExitNode", "tailscale.setExitNode", map[string]any{"id": "nABC123"}},
-		{"clearExitNode", "tailscale.setExitNode", map[string]any{"id": ""}},
-		{"setAllowLanAccess", "tailscale.setAllowLanAccess", map[string]any{"enabled": true}},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			m := handlerTestManager()
-			defer m.Close()
-
-			buf := &bytes.Buffer{}
-			conn := &mockConn{Buffer: buf}
-
-			req := models.Request{ID: 1, Method: tc.method, Params: tc.params}
-			HandleRequest(conn, req, m)
-
-			var resp models.Response[models.SuccessResult]
-			require.NoError(t, json.NewDecoder(buf).Decode(&resp))
-			assert.Equal(t, 1, resp.ID)
-			assert.Empty(t, resp.Error)
-			require.NotNil(t, resp.Result)
-			assert.True(t, resp.Result.Success)
-		})
-	}
-}
-
-func TestHandleAction_BackendError(t *testing.T) {
-	client := &mockClient{
-		watchFn:  blockingWatch,
-		statusFn: func(ctx context.Context) (*ipnstate.Status, error) { return runningStatus(), nil },
-		editPrefsFn: func(ctx context.Context, mp *ipn.MaskedPrefs) (*ipn.Prefs, error) {
-			return nil, fmt.Errorf("backend rejected edit")
-		},
-	}
-	m := newManager(client)
-	defer m.Close()
-
-	buf := &bytes.Buffer{}
-	conn := &mockConn{Buffer: buf}
-
-	req := models.Request{ID: 1, Method: "tailscale.connect"}
-	HandleRequest(conn, req, m)
-
-	var resp models.Response[models.SuccessResult]
-	require.NoError(t, json.NewDecoder(buf).Decode(&resp))
-	assert.Nil(t, resp.Result)
-	assert.Contains(t, resp.Error, "backend rejected edit")
-}
-
 func TestHandleRequest_UnknownMethod(t *testing.T) {
 	m := handlerTestManager()
 	defer m.Close()

core/internal/server/tailscale/manager.go

@@ -11,7 +11,6 @@ import (
 	"tailscale.com/client/local"
 	"tailscale.com/ipn"
 	"tailscale.com/ipn/ipnstate"
-	"tailscale.com/tailcfg"
 )
 
 const (
@@ -23,8 +22,6 @@ const (
 type tailscaleClient interface {
 	WatchIPNBus(ctx context.Context, mask ipn.NotifyWatchOpt) (ipnBusWatcher, error)
 	Status(ctx context.Context) (*ipnstate.Status, error)
-	GetPrefs(ctx context.Context) (*ipn.Prefs, error)
-	EditPrefs(ctx context.Context, mp *ipn.MaskedPrefs) (*ipn.Prefs, error)
 }
 
 // ipnBusWatcher abstracts the IPN bus watcher for testing.
@@ -46,14 +43,6 @@ func (w *localClientWrapper) Status(ctx context.Context) (*ipnstate.Status, erro
 	return w.client.Status(ctx)
 }
 
-func (w *localClientWrapper) GetPrefs(ctx context.Context) (*ipn.Prefs, error) {
-	return w.client.GetPrefs(ctx)
-}
-
-func (w *localClientWrapper) EditPrefs(ctx context.Context, mp *ipn.MaskedPrefs) (*ipn.Prefs, error) {
-	return w.client.EditPrefs(ctx, mp)
-}
-
 // Manager manages Tailscale state via IPN bus events and subscriber notifications.
 type Manager struct {
 	state                *TailscaleState
@@ -180,34 +169,14 @@ func (m *Manager) fetchAndBroadcast(ctx context.Context) {
 	statusCtx, cancel := context.WithTimeout(ctx, statusTimeout)
 	defer cancel()
 
-	state, err := m.fetchState(statusCtx)
+	status, err := m.client.Status(statusCtx)
 	if err != nil {
 		log.Warnf("[Tailscale] Failed to fetch status: %v", err)
 		return
 	}
 
-	m.updateState(state)
-}
-
-// fetchState fetches the current status and merges in pref-derived fields
-// (e.g. exit-node LAN access) that are not present in the IPN status itself.
-func (m *Manager) fetchState(ctx context.Context) (*TailscaleState, error) {
-	status, err := m.client.Status(ctx)
-	if err != nil {
-		return nil, err
-	}
-
 	state := convertStatus(status)
-
-	// Prefs carry the exit-node LAN-access toggle, which the status does not
-	// expose. Treat a prefs failure as non-fatal so status still updates.
-	if prefs, err := m.client.GetPrefs(ctx); err != nil {
-		log.Warnf("[Tailscale] Failed to fetch prefs: %v", err)
-	} else if prefs != nil {
-		state.ExitNodeAllowLANAccess = prefs.ExitNodeAllowLANAccess
-	}
-
-	return state, nil
+	m.updateState(state)
 }
 
 func (m *Manager) updateState(state *TailscaleState) {
@@ -297,62 +266,12 @@ func (m *Manager) RefreshState() {
 	ctx, cancel := context.WithTimeout(m.ctx, statusTimeout)
 	defer cancel()
 
-	state, err := m.fetchState(ctx)
+	status, err := m.client.Status(ctx)
 	if err != nil {
 		log.Warnf("[Tailscale] Failed to refresh state: %v", err)
 		return
 	}
 
+	state := convertStatus(status)
 	m.updateState(state)
 }
-
-// Connect brings the Tailscale backend up (WantRunning = true).
-func (m *Manager) Connect() error {
-	return m.editPrefs(&ipn.MaskedPrefs{
-		Prefs:          ipn.Prefs{WantRunning: true},
-		WantRunningSet: true,
-	})
-}
-
-// Disconnect brings the Tailscale backend down (WantRunning = false).
-func (m *Manager) Disconnect() error {
-	return m.editPrefs(&ipn.MaskedPrefs{
-		Prefs:          ipn.Prefs{WantRunning: false},
-		WantRunningSet: true,
-	})
-}
-
-// SetExitNode selects the exit node identified by its stable node ID. An empty
-// id clears the current exit node. Mirrors `tailscale set --exit-node=<id>`,
-// which also clears any legacy IP-based exit node so a stale ExitNodeIP cannot
-// silently take precedence over the now-empty ID.
-func (m *Manager) SetExitNode(id string) error {
-	return m.editPrefs(&ipn.MaskedPrefs{
-		Prefs:         ipn.Prefs{ExitNodeID: tailcfg.StableNodeID(id)},
-		ExitNodeIDSet: true,
-		ExitNodeIPSet: true,
-	})
-}
-
-// SetAllowLANAccess toggles whether locally accessible subnets remain
-// reachable while an exit node is in use.
-func (m *Manager) SetAllowLANAccess(enabled bool) error {
-	return m.editPrefs(&ipn.MaskedPrefs{
-		Prefs:                     ipn.Prefs{ExitNodeAllowLANAccess: enabled},
-		ExitNodeAllowLANAccessSet: true,
-	})
-}
-
-// editPrefs applies a masked prefs edit and refreshes state so subscribers see
-// the result immediately, in addition to the IPN bus notification it triggers.
-func (m *Manager) editPrefs(mp *ipn.MaskedPrefs) error {
-	ctx, cancel := context.WithTimeout(m.ctx, statusTimeout)
-	defer cancel()
-
-	if _, err := m.client.EditPrefs(ctx, mp); err != nil {
-		return err
-	}
-
-	m.RefreshState()
-	return nil
-}

core/internal/server/tailscale/manager_test.go

@@ -12,16 +12,8 @@ import (
 	"github.com/stretchr/testify/require"
 	"tailscale.com/ipn"
 	"tailscale.com/ipn/ipnstate"
-	"tailscale.com/tailcfg"
 )
 
-// blockingWatch is a watchFn that blocks until the context is cancelled, used
-// by tests that exercise direct manager calls rather than the watch loop.
-func blockingWatch(ctx context.Context, mask ipn.NotifyWatchOpt) (ipnBusWatcher, error) {
-	<-ctx.Done()
-	return nil, ctx.Err()
-}
-
 // mockWatcher yields canned Notify events, then returns err or blocks until Close/context cancel.
 type mockWatcher struct {
 	events []ipn.Notify
@@ -76,10 +68,8 @@ func (w *mockWatcher) Close() error {
 
 // mockClient implements tailscaleClient for testing.
 type mockClient struct {
-	watchFn     func(ctx context.Context, mask ipn.NotifyWatchOpt) (ipnBusWatcher, error)
-	statusFn    func(ctx context.Context) (*ipnstate.Status, error)
-	getPrefsFn  func(ctx context.Context) (*ipn.Prefs, error)
-	editPrefsFn func(ctx context.Context, mp *ipn.MaskedPrefs) (*ipn.Prefs, error)
+	watchFn  func(ctx context.Context, mask ipn.NotifyWatchOpt) (ipnBusWatcher, error)
+	statusFn func(ctx context.Context) (*ipnstate.Status, error)
 }
 
 func (c *mockClient) WatchIPNBus(ctx context.Context, mask ipn.NotifyWatchOpt) (ipnBusWatcher, error) {
@@ -90,20 +80,6 @@ func (c *mockClient) Status(ctx context.Context) (*ipnstate.Status, error) {
 	return c.statusFn(ctx)
 }
 
-func (c *mockClient) GetPrefs(ctx context.Context) (*ipn.Prefs, error) {
-	if c.getPrefsFn != nil {
-		return c.getPrefsFn(ctx)
-	}
-	return &ipn.Prefs{}, nil
-}
-
-func (c *mockClient) EditPrefs(ctx context.Context, mp *ipn.MaskedPrefs) (*ipn.Prefs, error) {
-	if c.editPrefsFn != nil {
-		return c.editPrefsFn(ctx, mp)
-	}
-	return &ipn.Prefs{}, nil
-}
-
 func runningStatus() *ipnstate.Status {
 	return &ipnstate.Status{
 		Version:        "1.94.2",
@@ -320,78 +296,3 @@ func TestManager_RefreshState(t *testing.T) {
 	assert.True(t, state.Connected)
 	assert.Equal(t, "cachyos", state.Self.Hostname)
 }
-
-func TestManager_RefreshState_MergesPrefs(t *testing.T) {
-	client := &mockClient{
-		watchFn:  blockingWatch,
-		statusFn: func(ctx context.Context) (*ipnstate.Status, error) { return runningStatus(), nil },
-		getPrefsFn: func(ctx context.Context) (*ipn.Prefs, error) {
-			return &ipn.Prefs{ExitNodeAllowLANAccess: true}, nil
-		},
-	}
-
-	m := newManager(client)
-	defer m.Close()
-
-	m.RefreshState()
-
-	assert.True(t, m.GetState().ExitNodeAllowLANAccess)
-}
-
-func TestManager_Actions_EditPrefs(t *testing.T) {
-	var captured *ipn.MaskedPrefs
-	client := &mockClient{
-		watchFn:  blockingWatch,
-		statusFn: func(ctx context.Context) (*ipnstate.Status, error) { return runningStatus(), nil },
-		editPrefsFn: func(ctx context.Context, mp *ipn.MaskedPrefs) (*ipn.Prefs, error) {
-			captured = mp
-			return &ipn.Prefs{}, nil
-		},
-	}
-
-	m := newManager(client)
-	defer m.Close()
-
-	require.NoError(t, m.Connect())
-	require.NotNil(t, captured)
-	assert.True(t, captured.WantRunningSet)
-	assert.True(t, captured.WantRunning)
-
-	require.NoError(t, m.Disconnect())
-	assert.True(t, captured.WantRunningSet)
-	assert.False(t, captured.WantRunning)
-
-	require.NoError(t, m.SetExitNode("nABC123"))
-	assert.True(t, captured.ExitNodeIDSet)
-	assert.Equal(t, tailcfg.StableNodeID("nABC123"), captured.ExitNodeID)
-	// ExitNodeIPSet must also be set so a stale legacy ExitNodeIP cannot
-	// override the ID-based selection (mirrors `tailscale set --exit-node`).
-	assert.True(t, captured.ExitNodeIPSet)
-
-	require.NoError(t, m.SetExitNode(""))
-	assert.True(t, captured.ExitNodeIDSet)
-	assert.Equal(t, tailcfg.StableNodeID(""), captured.ExitNodeID)
-	// Clearing must zero both the ID and any legacy IP-based exit node.
-	assert.True(t, captured.ExitNodeIPSet)
-
-	require.NoError(t, m.SetAllowLANAccess(true))
-	assert.True(t, captured.ExitNodeAllowLANAccessSet)
-	assert.True(t, captured.ExitNodeAllowLANAccess)
-}
-
-func TestManager_Actions_PropagateError(t *testing.T) {
-	client := &mockClient{
-		watchFn:  blockingWatch,
-		statusFn: func(ctx context.Context) (*ipnstate.Status, error) { return runningStatus(), nil },
-		editPrefsFn: func(ctx context.Context, mp *ipn.MaskedPrefs) (*ipn.Prefs, error) {
-			return nil, fmt.Errorf("backend rejected edit")
-		},
-	}
-
-	m := newManager(client)
-	defer m.Close()
-
-	assert.Error(t, m.Connect())
-	assert.Error(t, m.SetExitNode("nABC123"))
-	assert.Error(t, m.SetAllowLANAccess(true))
-}

core/internal/server/tailscale/types.go

@@ -2,32 +2,30 @@ package tailscale
 
 // TailscaleState represents the current state of the Tailscale daemon.
 type TailscaleState struct {
-	Connected              bool   `json:"connected"`
-	Version                string `json:"version"`
-	BackendState           string `json:"backendState"`
-	MagicDNSSuffix         string `json:"magicDnsSuffix"`
-	TailnetName            string `json:"tailnetName"`
-	ExitNodeAllowLANAccess bool   `json:"exitNodeAllowLanAccess"`
-	Self                   Peer   `json:"self"`
-	Peers                  []Peer `json:"peers"`
+	Connected      bool   `json:"connected"`
+	Version        string `json:"version"`
+	BackendState   string `json:"backendState"`
+	MagicDNSSuffix string `json:"magicDnsSuffix"`
+	TailnetName    string `json:"tailnetName"`
+	Self           Peer   `json:"self"`
+	Peers          []Peer `json:"peers"`
 }
 
 // Peer represents a single node in the Tailscale network.
 type Peer struct {
-	ID             string   `json:"id"`
-	Hostname       string   `json:"hostname"`
-	DNSName        string   `json:"dnsName"`
-	TailscaleIP    string   `json:"tailscaleIp"`
-	TailscaleIPv6  string   `json:"tailscaleIpv6,omitempty"`
-	OS             string   `json:"os"`
-	Online         bool     `json:"online"`
-	LastSeen       string   `json:"lastSeen,omitempty"`
-	ExitNode       bool     `json:"exitNode"`
-	ExitNodeOption bool     `json:"exitNodeOption"`
-	Tags           []string `json:"tags,omitempty"`
-	Owner          string   `json:"owner"`
-	Relay          string   `json:"relay,omitempty"`
-	Active         bool     `json:"active"`
-	RxBytes        int64    `json:"rxBytes"`
-	TxBytes        int64    `json:"txBytes"`
+	ID            string   `json:"id"`
+	Hostname      string   `json:"hostname"`
+	DNSName       string   `json:"dnsName"`
+	TailscaleIP   string   `json:"tailscaleIp"`
+	TailscaleIPv6 string   `json:"tailscaleIpv6,omitempty"`
+	OS            string   `json:"os"`
+	Online        bool     `json:"online"`
+	LastSeen      string   `json:"lastSeen,omitempty"`
+	ExitNode      bool     `json:"exitNode"`
+	Tags          []string `json:"tags,omitempty"`
+	Owner         string   `json:"owner"`
+	Relay         string   `json:"relay,omitempty"`
+	Active        bool     `json:"active"`
+	RxBytes       int64    `json:"rxBytes"`
+	TxBytes       int64    `json:"txBytes"`
 }

distro/scripts/ppa-build.sh

@@ -3,10 +3,10 @@
 # Usage: ./create-source.sh <package-dir> [ubuntu-series]
 #
 # Example:
-#   ./create-source.sh ../dms resolute     # Ubuntu 26.04 LTS (default series in ppa-upload)
-#   ./create-source.sh ../dms stonking     # Ubuntu 26.10
+#   ./create-source.sh ../dms questing    # Ubuntu 25.10 (default series in ppa-upload)
+#   ./create-source.sh ../dms resolute     # Ubuntu 26.04 LTS
+#   ./create-source.sh ../dms-git questing
 #   ./create-source.sh ../dms-git resolute
-#   ./create-source.sh ../dms-git stonking
 
 set -e
 
@@ -27,13 +27,13 @@ if [ $# -lt 1 ]; then
     echo "Arguments:"
     echo "  package-dir     : Path to package directory (e.g., ../dms)"
     echo "  ubuntu-series   : Ubuntu series (optional, default: noble)"
-    echo "                    Options: noble, jammy, oracular, mantic, resolute, stonking"
+    echo "                    Options: noble, jammy, oracular, mantic, questing, resolute"
     echo
     echo "Examples:"
+    echo "  $0 ../dms questing"
     echo "  $0 ../dms resolute"
-    echo "  $0 ../dms stonking"
+    echo "  $0 ../dms-git questing"
     echo "  $0 ../dms-git resolute"
-    echo "  $0 ../dms-git stonking"
     exit 1
 fi
 
@@ -135,7 +135,7 @@ check_ppa_version_exists() {
     local CHECK_MODE="${4:-commit}"
     local DISTRO_SERIES="${5:-}"
 
-    # Query Launchpad API (optionally scoped to one Ubuntu series so the same version can ship to resolute and stonking)
+    # Query Launchpad API (optionally scoped to one Ubuntu series so the same version can ship to questing and resolute)
     local API_URL="https://api.launchpad.net/1.0/~avengemedia/+archive/ubuntu/$PPA_NAME?ws.op=getPublishedSources&source_name=$SOURCE_NAME&status=Published"
     if [[ -n "$DISTRO_SERIES" ]]; then
         API_URL+="&distro_series=https://api.launchpad.net/1.0/ubuntu/${DISTRO_SERIES}"

distro/scripts/ppa-status.sh

@@ -10,8 +10,8 @@
 
 PPA_OWNER="avengemedia"
 LAUNCHPAD_API="https://api.launchpad.net/1.0"
-# Supported Ubuntu series for PPA builds (26.04 LTS resolute + 26.10 stonking)
-DISTRO_SERIES_LIST=(resolute stonking)
+# Supported Ubuntu series for PPA builds (25.10 questing + 26.04 LTS resolute)
+DISTRO_SERIES_LIST=(questing resolute)
 
 # Define packages (sync with ppa-upload.sh)
 ALL_PACKAGES=(dms dms-git dms-greeter)

distro/scripts/ppa-sync-plan.sh

@@ -5,7 +5,7 @@ set -euo pipefail
 
 PPA_OWNER="avengemedia"
 LAUNCHPAD_API="https://api.launchpad.net/1.0"
-SERIES_LIST=(resolute stonking)
+SERIES_LIST=(questing resolute)
 PACKAGE_FILTER="dms-git"
 REBUILD_RELEASE=""
 JSON=false
@@ -72,12 +72,12 @@ embedded_commit() {
 target_ppa() {
     local series="$1"
     if [[ -n "$REBUILD_RELEASE" ]]; then
-        if [[ "$series" == "stonking" ]]; then
+        if [[ "$series" == "resolute" ]]; then
             echo $((REBUILD_RELEASE + 1))
         else
             echo "$REBUILD_RELEASE"
         fi
-    elif [[ "$series" == "stonking" ]]; then
+    elif [[ "$series" == "resolute" ]]; then
         echo "2"
     else
         echo "1"

distro/scripts/ppa-upload.sh

@@ -3,13 +3,13 @@
 # Usage: ./ppa-upload.sh [package-name] [ppa-name] [ubuntu-series] [rebuild-number] [--keep-builds] [--rebuild=N]
 #
 # Examples:
-#   ./ppa-upload.sh dms                    # Upload to resolute + stonking (default)
-#   ./ppa-upload.sh dms 2                 # Native: resolute ppa2, stonking ppa3 (auto +1 on second series)
+#   ./ppa-upload.sh dms                    # Upload to questing + resolute (default)
+#   ./ppa-upload.sh dms 2                 # Native: questing ppa2, resolute ppa3 (auto +1 on second series)
 #   ./ppa-upload.sh dms --rebuild=2       # Rebuild with ppa2 (flag syntax)
 #   ./ppa-upload.sh dms-git               # Single package (both series)
 #   ./ppa-upload.sh all                   # All packages (each to both series)
 #   ./ppa-upload.sh dms resolute          # 26.04 LTS only (same as "dms dms resolute")
-#   ./ppa-upload.sh dms stonking          # 26.10 only
+#   ./ppa-upload.sh dms questing          # 25.10 only
 #   ./ppa-upload.sh dms dms resolute      # Explicit PPA name + one series (optional form)
 #   ./ppa-upload.sh dms dms resolute 2    # One series + rebuild number
 #   ./ppa-upload.sh distro/ubuntu/dms dms # Path-style (backward compatible)
@@ -70,8 +70,8 @@ if [[ ${#POSITIONAL_ARGS[@]} -gt 0 ]]; then
     fi
 fi
 
-# Shorthand: "dms resolute" / "dms stonking" (package + series; PPA inferred — no need for "dms dms resolute")
-if [[ ${#POSITIONAL_ARGS[@]} -eq 2 ]] && [[ "${POSITIONAL_ARGS[1]}" == "resolute" || "${POSITIONAL_ARGS[1]}" == "stonking" ]]; then
+# Shorthand: "dms resolute" / "dms questing" (package + series; PPA inferred — no need for "dms dms resolute")
+if [[ ${#POSITIONAL_ARGS[@]} -eq 2 ]] && [[ "${POSITIONAL_ARGS[1]}" == "questing" || "${POSITIONAL_ARGS[1]}" == "resolute" ]]; then
     PACKAGE_INPUT="${POSITIONAL_ARGS[0]}"
     PPA_NAME_INPUT=""
     UBUNTU_SERIES_RAW="${POSITIONAL_ARGS[1]}"
@@ -79,11 +79,11 @@ fi
 
 SERIES_LIST=()
 if [[ -z "$UBUNTU_SERIES_RAW" ]]; then
-    SERIES_LIST=(resolute stonking)
-elif [[ "$UBUNTU_SERIES_RAW" == "resolute" || "$UBUNTU_SERIES_RAW" == "stonking" ]]; then
+    SERIES_LIST=(questing resolute)
+elif [[ "$UBUNTU_SERIES_RAW" == "questing" || "$UBUNTU_SERIES_RAW" == "resolute" ]]; then
     SERIES_LIST=("$UBUNTU_SERIES_RAW")
 else
-    error "Invalid Ubuntu series: $UBUNTU_SERIES_RAW (use resolute, stonking, or omit for both)"
+    error "Invalid Ubuntu series: $UBUNTU_SERIES_RAW (use questing, resolute, or omit for both)"
     exit 1
 fi
 

distro/ubuntu/dms-greeter/debian/rules

@@ -40,17 +40,10 @@ override_dh_auto_install:
 	install -Dm644 DankMaterialShell-$(BASE_VERSION)/LICENSE \
 		debian/dms-greeter/usr/share/doc/dms-greeter/LICENSE
 
-	# Install systemd tmpfiles/sysusers fragments only when present in the fetched source.
-	# sysusers-dms-greeter.conf landed upstream after v1.4.6; guarding both lets older
-	# release tarballs build, while future tags that ship the files install them automatically.
-	if [ -f DankMaterialShell-$(BASE_VERSION)/quickshell/systemd/tmpfiles-dms-greeter.conf ]; then \
-		install -Dpm0644 DankMaterialShell-$(BASE_VERSION)/quickshell/systemd/tmpfiles-dms-greeter.conf \
-			debian/dms-greeter/usr/lib/tmpfiles.d/dms-greeter.conf; \
-	fi
-	if [ -f DankMaterialShell-$(BASE_VERSION)/quickshell/systemd/sysusers-dms-greeter.conf ]; then \
-		install -Dm644 DankMaterialShell-$(BASE_VERSION)/quickshell/systemd/sysusers-dms-greeter.conf \
-			debian/dms-greeter/usr/lib/sysusers.d/dms-greeter.conf; \
-	fi
+	install -Dpm0644 DankMaterialShell-$(BASE_VERSION)/quickshell/systemd/tmpfiles-dms-greeter.conf \
+		debian/dms-greeter/usr/lib/tmpfiles.d/dms-greeter.conf
+	install -Dm644 DankMaterialShell-$(BASE_VERSION)/quickshell/systemd/sysusers-dms-greeter.conf \
+		debian/dms-greeter/usr/lib/sysusers.d/dms-greeter.conf
 
 	# Create cache directory structure (will be created by postinst)
 	mkdir -p debian/dms-greeter/var/cache/dms-greeter

docs/IPC.md

@@ -6,18 +6,6 @@ DankMaterialShell provides comprehensive IPC (Inter-Process Communication) funct
 dms ipc call <target> <function> [parameters...]
 ```
 
-## Discovering IPC commands
-
-List all available targets and functions while DMS is running:
-
-```bash
-dms ipc list
-dms ipc          # same
-dms ipc --help   # same, plus usage text
-```
-
-Live listing requires DMS to be running. If listing fails, use this document or the [Keybinds & IPC docs](https://danklinux.com/docs/dankmaterialshell/keybinds-ipc) as an offline reference.
-
 ## Target: `audio`
 
 Audio system control and information.
@@ -719,7 +707,7 @@ File browser controls for selecting wallpapers and profile images.
   - Both browsers support common image formats (jpg, jpeg, png, bmp, gif, webp)
 
 ### Target: `color-picker`
-In-shell color picker modal for theme and settings color selection.
+Color picker modal control.
 
 **Functions:**
 - `open` - Show color picker modal
@@ -730,14 +718,6 @@ In-shell color picker modal for theme and settings color selection.
 - `toggle` - Toggle color picker modal visibility
 - `toggleInstant` - Toggle color picker modal visibility without animation on hide
 
-**Note:** This controls the in-shell modal. To pick a pixel from the screen via CLI, use `dms color pick` instead (see [Color Picker CLI](https://danklinux.com/docs/dankmaterialshell/cli-color-picker)).
-
-**Examples:**
-```bash
-dms ipc call color-picker toggle
-dms ipc call color-picker openColor "#3f51b5"
-```
-
 ### Target: `hypr`
 Hyprland-specific controls including keybinds cheatsheet and workspace overview (Hyprland only).
 

quickshell/Common/ConnectedModeState.qml

@@ -74,6 +74,10 @@ Singleton {
         }, descriptor);
     }
 
+    function legacySurfaceState(screenName, kind) {
+        return SurfaceDescriptor.toLegacyState(surfaceDescriptor(screenName, kind));
+    }
+
     function hasSurfaceDescriptor(screenName, kind, ownerId) {
         const descriptor = surfaceDescriptor(screenName, kind);
         return descriptor.phase !== "hidden" && (!ownerId || descriptor.ownerId === ownerId);
@@ -120,6 +124,20 @@ Singleton {
         return true;
     }
 
+    function _setSurfaceAnimation(screenName, kind, ownerId, x, y) {
+        const current = surfaceDescriptor(screenName, kind);
+        if (current.phase === "hidden" || (ownerId && current.ownerId !== ownerId))
+            return false;
+        return true;
+    }
+
+    function _setSurfaceBody(screenName, kind, ownerId, x, y, width, height) {
+        const current = surfaceDescriptor(screenName, kind);
+        if (current.phase === "hidden" || (ownerId && current.ownerId !== ownerId))
+            return false;
+        return true;
+    }
+
     readonly property var emptyDockState: ({
             "reveal": false,
             "barSide": "bottom",
@@ -131,6 +149,7 @@ Singleton {
             "slideY": 0
         })
 
+    // Popout state (updated by DankPopout when connectedFrameModeActive)
     property string popoutOwnerId: ""
     property bool popoutVisible: false
     property string popoutBarSide: "top"
@@ -144,10 +163,14 @@ Singleton {
     property bool popoutOmitStartConnector: false
     property bool popoutOmitEndConnector: false
 
+    // Dock state (updated by Dock when connectedFrameModeActive), keyed by screen.name
     property var dockStates: ({})
 
+    // Dock slide offsets — hot-path updates separated from full geometry state
     property var dockSlides: ({})
 
+    // Surfaces are keyed by screen.name. FrameWindow watches to refresh connected chrome
+    // after claim/release boundaries without tracking each animation frame
     property var surfaceRevisions: ({})
 
     function _cloneDict(src) {
@@ -266,6 +289,7 @@ Singleton {
             if (!isNaN(nextY) && popoutAnimY !== nextY)
                 popoutAnimY = nextY;
         }
+        _setSurfaceAnimation(popoutScreen, "popout", claimId, animX, animY);
         return true;
     }
 
@@ -292,6 +316,7 @@ Singleton {
             if (!isNaN(nextH) && popoutBodyH !== nextH)
                 popoutBodyH = nextH;
         }
+        _setSurfaceBody(popoutScreen, "popout", claimId, bodyX, bodyY, bodyW, bodyH);
         return true;
     }
 
@@ -327,8 +352,8 @@ Singleton {
             "phase": normalized.reveal ? (state.phase || "open") : "hidden"
         });
         const previous = dockStates[screenName] || emptyDockState;
-        const stateChanged = !_sameDockState(dockStates[screenName], normalized);
-        if (stateChanged) {
+        const legacyChanged = !_sameDockState(dockStates[screenName], normalized);
+        if (legacyChanged) {
             const next = _cloneDict(dockStates);
             next[screenName] = normalized;
             dockStates = next;
@@ -348,6 +373,7 @@ Singleton {
         dockStates = next;
         _clearSurfaceDescriptor(screenName, "dock");
 
+        // Also clear corresponding slide
         if (dockSlides[screenName]) {
             const nextSlides = _cloneDict(dockSlides);
             delete nextSlides[screenName];
@@ -371,6 +397,7 @@ Singleton {
             "y": numY
         };
         dockSlides = next;
+        _setSurfaceAnimation(screenName, "dock", "dock:" + screenName, numX, numY);
         return true;
     }
 
@@ -424,8 +451,8 @@ Singleton {
             "phase": normalized.visible ? (state.phase || "open") : "hidden"
         });
         const previous = notificationStates[screenName] || emptyNotificationState;
-        const stateChanged = !_sameNotificationState(notificationStates[screenName], normalized);
-        if (stateChanged) {
+        const legacyChanged = !_sameNotificationState(notificationStates[screenName], normalized);
+        if (legacyChanged) {
             const next = _cloneDict(notificationStates);
             next[screenName] = normalized;
             notificationStates = next;
@@ -448,6 +475,7 @@ Singleton {
         return true;
     }
 
+    // DankModal / DankLauncherV2Modal State
     readonly property var emptyModalState: ({
             "visible": false,
             "barSide": "bottom",
@@ -545,6 +573,10 @@ Singleton {
         return updateModalState(screenName, state, ownerId);
     }
 
+    function setModalState(screenName, state) {
+        return updateModalState(screenName, state, null);
+    }
+
     function clearModalState(screenName, ownerId) {
         if (!screenName)
             return false;
@@ -585,6 +617,7 @@ Singleton {
             "animY": nay
         });
         modalStates = next;
+        _setSurfaceAnimation(screenName, "modal", ownerId, animX, animY);
         return true;
     }
 
@@ -608,6 +641,7 @@ Singleton {
             "bodyH": nh
         });
         modalStates = next;
+        _setSurfaceBody(screenName, "modal", ownerId, bodyX, bodyY, bodyW, bodyH);
         return true;
     }
 
@@ -648,6 +682,9 @@ Singleton {
         return false;
     }
 
+    // Prune state for screens that are no longer connected. Stale entries
+    // accumulate across hotplug cycles otherwise — Frame's per-screen
+    // FrameInstance doesn't notice when its peer dicts go orphan.
     function _pruneToLiveScreens() {
         const live = {};
         const screens = Quickshell.screens || [];

quickshell/Common/ConnectedSurfaceDescriptor.js

@@ -157,3 +157,23 @@ function same(a, b, threshold) {
         && a.omitEndConnector === b.omitEndConnector
         && a.dockRetractSide === b.dockRetractSide;
 }
+
+function toLegacyState(descriptor) {
+    var d = normalize(descriptor);
+    return {
+        "visible": d.visible,
+        "reveal": d.visible,
+        "barSide": d.barSide,
+        "bodyX": d.bodyRect.x,
+        "bodyY": d.bodyRect.y,
+        "bodyW": d.bodyRect.width,
+        "bodyH": d.bodyRect.height,
+        "animX": d.animationOffset.x,
+        "animY": d.animationOffset.y,
+        "slideX": d.animationOffset.x,
+        "slideY": d.animationOffset.y,
+        "screen": d.screenName,
+        "omitStartConnector": d.omitStartConnector,
+        "omitEndConnector": d.omitEndConnector
+    };
+}

quickshell/Common/DankSocket.qml

@@ -7,31 +7,29 @@ Item {
     property alias path: socket.path
     property alias parser: socket.parser
     property bool connected: false
-    property bool linkUp: false
 
     property int reconnectBaseMs: 400
     property int reconnectMaxMs: 15000
 
     property int _reconnectAttempt: 0
 
-    signal connectionStateChanged
+    signal connectionStateChanged()
 
     onConnectedChanged: {
-        socket.connected = connected;
+        socket.connected = connected
     }
 
     Socket {
         id: socket
 
         onConnectionStateChanged: {
-            root.linkUp = connected;
-            root.connectionStateChanged();
+            root.connectionStateChanged()
             if (connected) {
-                root._reconnectAttempt = 0;
-                return;
+                root._reconnectAttempt = 0
+                return
             }
             if (root.connected) {
-                root._scheduleReconnect();
+                root._scheduleReconnect()
             }
         }
     }
@@ -41,24 +39,24 @@ Item {
         interval: 0
         repeat: false
         onTriggered: {
-            socket.connected = false;
-            Qt.callLater(() => socket.connected = true);
+            socket.connected = false
+            Qt.callLater(() => socket.connected = true)
         }
     }
 
     function send(data) {
-        const json = typeof data === "string" ? data : JSON.stringify(data);
-        const message = json.endsWith("\n") ? json : json + "\n";
-        socket.write(message);
-        socket.flush();
+        const json = typeof data === "string" ? data : JSON.stringify(data)
+        const message = json.endsWith("\n") ? json : json + "\n"
+        socket.write(message)
+        socket.flush()
     }
 
     function _scheduleReconnect() {
-        const pow = Math.min(_reconnectAttempt, 10);
-        const base = Math.min(reconnectBaseMs * Math.pow(2, pow), reconnectMaxMs);
-        const jitter = Math.floor(Math.random() * Math.floor(base / 4));
-        reconnectTimer.interval = base + jitter;
-        reconnectTimer.restart();
-        _reconnectAttempt++;
+        const pow = Math.min(_reconnectAttempt, 10)
+        const base = Math.min(reconnectBaseMs * Math.pow(2, pow), reconnectMaxMs)
+        const jitter = Math.floor(Math.random() * Math.floor(base / 4))
+        reconnectTimer.interval = base + jitter
+        reconnectTimer.restart()
+        _reconnectAttempt++
     }
 }

quickshell/Common/ElevationShadow.qml

@@ -19,6 +19,7 @@ Item {
     property color borderColor: "transparent"
     property real borderWidth: 0
 
+    // Rounded-rect geometry within the item; defaults fill the item.
     property real sourceX: 0
     property real sourceY: 0
     property real sourceWidth: width
@@ -35,6 +36,8 @@ Item {
     readonly property var _ambient: Theme.elevationAmbient(level)
     readonly property real _pad: shadowEnabled ? Math.ceil(Math.max(shadowBlurPx + shadowSpreadPx + Math.max(Math.abs(shadowOffsetX), Math.abs(shadowOffsetY)), _ambient.blurPx + _ambient.spreadPx) + 2) : 0
 
+    // Fill + border + key/ambient shadows drawn analytically on one oversized
+    // quad — no FBO, no blur passes.
     ShaderEffect {
         anchors.fill: parent
         anchors.margins: -root._pad

quickshell/Common/KeyUtils.js

@@ -126,40 +126,7 @@ const KEY_MAP = {
     161: "exclamdown"
 };
 
-// Numpad (keypad) keys. Qt reuses the same Qt::Key_* values for the numpad and
-// the main rows/nav cluster; only Qt.KeypadModifier distinguishes them. niri and
-// the other compositors bind against the xkb KP_* keysym names, so we must emit
-// those instead of the collapsed twin. With NumLock off the numpad sends the
-// navigation keysyms (KP_Home, KP_End, ...); with NumLock on it sends KP_0..KP_9
-// (handled by the digit range in xkbKeyFromQtKey). Operators/Enter are the same
-// in both states.
-const KP_MAP = {
-    16777232: "KP_Home",
-    16777235: "KP_Up",
-    16777238: "KP_Prior",
-    16777234: "KP_Left",
-    16777227: "KP_Begin",
-    16777236: "KP_Right",
-    16777233: "KP_End",
-    16777237: "KP_Down",
-    16777239: "KP_Next",
-    16777222: "KP_Insert",
-    16777223: "KP_Delete",
-    16777221: "KP_Enter",
-    43: "KP_Add",
-    45: "KP_Subtract",
-    42: "KP_Multiply",
-    47: "KP_Divide",
-    46: "KP_Decimal"
-};
-
-function xkbKeyFromQtKey(qk, isKeypad) {
-    if (isKeypad) {
-        if (qk >= 48 && qk <= 57)
-            return "KP_" + (qk - 48);
-        if (KP_MAP[qk])
-            return KP_MAP[qk];
-    }
+function xkbKeyFromQtKey(qk) {
     if (qk >= 65 && qk <= 90)
         return String.fromCharCode(qk);
     if (qk >= 97 && qk <= 122)

quickshell/Common/KeybindActions.js

@@ -56,9 +56,6 @@ const DMS_ACTIONS = [
     { id: "spawn dms ipc call dankdash wallpaper", label: "Wallpaper Browser" },
     { id: "spawn dms ipc call file browse wallpaper", label: "File: Browse Wallpaper" },
     { id: "spawn dms ipc call file browse profile", label: "File: Browse Profile" },
-    { id: "spawn dms ipc call color-picker toggle", label: "Color Picker: Toggle" },
-    { id: "spawn dms ipc call color-picker open", label: "Color Picker: Open" },
-    { id: "spawn dms ipc call color-picker close", label: "Color Picker: Close" },
     { id: "spawn dms ipc call keybinds toggle niri", label: "Keybinds Cheatsheet: Toggle", compositor: "niri" },
     { id: "spawn dms ipc call keybinds open niri", label: "Keybinds Cheatsheet: Open", compositor: "niri" },
     { id: "spawn dms ipc call keybinds close", label: "Keybinds Cheatsheet: Close" },

quickshell/Common/SettingsData.qml

@@ -108,7 +108,6 @@ Singleton {
     }
 
     property bool clipboardEnterToPaste: false
-    property var clipboardVisibleEntryActions: ["pin", "edit", "delete"]
 
     property var launcherPluginVisibility: ({})
 
@@ -164,8 +163,6 @@ Singleton {
     property real popupTransparency: 1.0
     property real dockTransparency: 1
     property string widgetBackgroundColor: "sch"
-    property string widgetBackgroundCustomColor: "#6750A4"
-    property real widgetBackgroundCustomStrength: 0.50
     property string widgetColorMode: "default"
     property string controlCenterTileColorMode: "primary"
     property string buttonColorMode: "primary"
@@ -184,7 +181,6 @@ Singleton {
 
     property int firstDayOfWeek: -1
     property bool showWeekNumber: false
-    property string calendarBackend: "auto"
     property bool use24HourClock: true
     property bool showSeconds: false
     property bool padHours12Hour: false
@@ -387,16 +383,11 @@ Singleton {
     property bool dwlShowAllTags: false
     property bool workspaceActiveAppHighlightEnabled: false
     property string workspaceColorMode: "default"
-    property string workspaceFocusedCustomColor: "#6750A4"
     property string workspaceOccupiedColorMode: "none"
-    property string workspaceOccupiedCustomColor: "#625B71"
     property string workspaceUnfocusedColorMode: "default"
-    property string workspaceUnfocusedCustomColor: "#49454E"
     property string workspaceUrgentColorMode: "default"
-    property string workspaceUrgentCustomColor: "#B3261E"
     property bool workspaceFocusedBorderEnabled: false
     property string workspaceFocusedBorderColor: "primary"
-    property string workspaceFocusedBorderCustomColor: "#6750A4"
     property int workspaceFocusedBorderThickness: 2
     property var workspaceNameIcons: ({})
     property bool waveProgressEnabled: true
@@ -405,7 +396,6 @@ Singleton {
     property bool audioVisualizerEnabled: true
     property string audioScrollMode: "volume"
     property int audioWheelScrollAmount: 5
-    property bool audioDeviceScrollVolumeEnabled: false
     property bool clockCompactMode: false
     property int focusedWindowSize: 1
     property bool focusedWindowCompactMode: false
@@ -413,9 +403,6 @@ Singleton {
     property int barMaxVisibleApps: 0
     property int barMaxVisibleRunningApps: 0
     property bool barShowOverflowBadge: true
-    property bool trayAutoOverflow: true
-    property bool trayPopupSingleLine: true
-    property int trayMaxVisibleItems: 0
     property bool appsDockHideIndicators: false
     property bool appsDockColorizeActive: false
     property string appsDockActiveColorMode: "primary"
@@ -472,8 +459,6 @@ Singleton {
     property bool launcherUseOverlayLayer: false
     property string launcherStyle: "full"
     property bool spotlightBarShowModeChips: false
-    property bool keybindsFloatingWindow: false
-    onKeybindsFloatingWindowChanged: saveSettings()
 
     property string _legacyWeatherLocation: "New York, NY"
     property string _legacyWeatherCoordinates: "40.7128,-74.0060"
@@ -504,6 +489,9 @@ Singleton {
                 "hideOnTouch": false,
                 "inactiveTimeout": 0
             },
+            "dwl": {
+                "cursorHideTimeout": 0
+            },
             "mango": {
                 "cursorHideTimeout": 0
             }
@@ -530,42 +518,14 @@ Singleton {
     property bool notepadUseMonospace: true
     property string notepadFontFamily: ""
     property real notepadFontSize: 14
-    property real notificationSummaryFontSize: Spec.SPEC.notificationSummaryFontSize.def
-    property real notificationBodyFontSize: Spec.SPEC.notificationBodyFontSize.def
     property bool notepadShowLineNumbers: false
-    property bool notepadAutoSave: false
-    property string notepadSlideoutSide: "right"
-    property string notepadDefaultMode: "slideout"
     property real notepadTransparencyOverride: -1
     property real notepadLastCustomTransparency: 0.7
-    property bool notepadUseCompositorGap: false
-    property int notepadEdgeGap: 0
-
-    // Compositor layout gap when enabled and available, else the manual value.
-    readonly property int notepadEffectiveEdgeGap: {
-        if (notepadUseCompositorGap) {
-            var g = -1;
-            if (CompositorService.isNiri)
-                g = niriLayoutGapsOverride;
-            else if (CompositorService.isHyprland)
-                g = hyprlandLayoutGapsOverride;
-            else if (CompositorService.isMango)
-                g = mangoLayoutGapsOverride;
-            if (g >= 0)
-                return g;
-        }
-        return Math.max(0, notepadEdgeGap);
-    }
 
     onNotepadUseMonospaceChanged: saveSettings()
     onNotepadFontFamilyChanged: saveSettings()
     onNotepadFontSizeChanged: saveSettings()
     onNotepadShowLineNumbersChanged: saveSettings()
-    onNotepadAutoSaveChanged: saveSettings()
-    onNotepadSlideoutSideChanged: saveSettings()
-    onNotepadDefaultModeChanged: saveSettings()
-    onNotepadUseCompositorGapChanged: saveSettings()
-    onNotepadEdgeGapChanged: saveSettings()
     // onCenteringModeChanged: saveSettings()
     onNotepadTransparencyOverrideChanged: {
         if (notepadTransparencyOverride > 0) {
@@ -581,7 +541,6 @@ Singleton {
     property bool soundVolumeChanged: true
     property bool soundPluggedIn: true
     property bool soundLogin: false
-    property bool muteSoundsWhenMediaPlaying: true
 
     property int acMonitorTimeout: 0
     property int acLockTimeout: 0
@@ -739,7 +698,6 @@ Singleton {
     property int notificationTimeoutNormal: 5000
     property int notificationTimeoutCritical: 0
     property bool notificationCompactMode: false
-    property bool notificationShowTimeoutBar: false
     property bool notificationDedupeEnabled: true
     property int notificationPopupPosition: SettingsData.Position.Top
     property int notificationAnimationSpeed: SettingsData.AnimationSpeed.Short
@@ -1266,6 +1224,8 @@ Singleton {
             NiriService.generateNiriLayoutConfig();
         if (CompositorService.isHyprland && typeof HyprlandService !== "undefined")
             HyprlandService.generateLayoutConfig();
+        if (CompositorService.isDwl && typeof DwlService !== "undefined")
+            DwlService.generateLayoutConfig();
         if (CompositorService.isMango && typeof MangoService !== "undefined")
             MangoService.generateLayoutConfig();
     }
@@ -1692,15 +1652,6 @@ Singleton {
         };
     }
 
-    function effectiveBarConfigForRender(config, usesFrameBarChrome) {
-        if (!config || !connectedFrameModeActive || usesFrameBarChrome)
-            return config;
-        const backup = connectedFrameBarStyleBackups[config.id];
-        if (!backup)
-            return config;
-        return Object.assign({}, config, backup);
-    }
-
     // Single entry point for connected-mode settings state.
     //   !active → restore backups
     function _reconcileConnectedFrameBarStyles() {
@@ -2500,6 +2451,10 @@ Singleton {
             HyprlandService.generateCursorConfig();
             return;
         }
+        if (CompositorService.isDwl && typeof DwlService !== "undefined") {
+            DwlService.generateCursorConfig();
+            return;
+        }
         if (CompositorService.isMango && typeof MangoService !== "undefined") {
             MangoService.generateCursorConfig();
             return;

quickshell/Common/Theme.qml

@@ -450,9 +450,7 @@ Singleton {
                 "primaryText": getMatugenColor("on_primary", "#ffffff"),
                 "primaryContainer": getMatugenColor("primary_container", "#1976d2"),
                 "secondary": getMatugenColor("secondary", "#8ab4f8"),
-                "secondaryContainer": getMatugenColor("secondary_container", getMatugenColor("surface_container_high", "#292b2f")),
                 "tertiary": getMatugenColor("tertiary", "#efb8c8"),
-                "tertiaryContainer": getMatugenColor("tertiary_container", getMatugenColor("surface_container_high", "#292b2f")),
                 "surface": getMatugenColor("surface", "#1a1c1e"),
                 "surfaceText": getMatugenColor("on_background", "#e3e8ef"),
                 "surfaceVariant": getMatugenColor("surface_variant", "#44464f"),
@@ -523,6 +521,7 @@ Singleton {
 
     property color primary: currentThemeData.primary
     property color primaryText: currentThemeData.primaryText
+    property color primaryContainer: currentThemeData.primaryContainer
     property color secondary: currentThemeData.secondary
     property color tertiary: currentThemeData.tertiary || currentThemeData.secondary
     property color surface: currentThemeData.surface
@@ -537,9 +536,6 @@ Singleton {
     property color surfaceContainer: currentThemeData.surfaceContainer
     property color surfaceContainerHigh: currentThemeData.surfaceContainerHigh
     property color surfaceContainerHighest: currentThemeData.surfaceContainerHighest || surfaceContainerHigh
-    property color primaryContainer: currentThemeData.primaryContainer || blend(surfaceContainerHigh, primary, 0.45)
-    property color secondaryContainer: currentThemeData.secondaryContainer || blend(surfaceContainerHigh, secondary, 0.35)
-    property color tertiaryContainer: currentThemeData.tertiaryContainer || blend(surfaceContainerHigh, tertiary, 0.35)
 
     property color onSurface: surfaceText
     property color onSurfaceVariant: surfaceVariantText
@@ -915,6 +911,9 @@ Singleton {
         }
         return Qt.rgba(r, g, b, alpha);
     }
+    // Non-directional ambient layer of the M3 two-part shadow model (key +
+    // ambient). Derived from the key level so user intensity/opacity settings
+    // scale both layers together.
     function elevationAmbient(level) {
         const blur = (level && level.blurPx !== undefined) ? Math.max(0, level.blurPx) : 0;
         const alpha = ((level && level.alpha !== undefined) ? level.alpha : 0.3) * 0.5;
@@ -1434,22 +1433,9 @@ Singleton {
 
     property bool widgetBackgroundHasAlpha: {
         const colorMode = typeof SettingsData !== "undefined" ? SettingsData.widgetBackgroundColor : "sch";
-        return colorMode === "sth" || colorMode === "custom";
+        return colorMode === "sth";
     }
 
-    function safeColor(value, fallback) {
-        try {
-            if (value === undefined || value === null || value === "")
-                return fallback;
-            return Qt.color(value);
-        } catch (e) {
-            return fallback;
-        }
-    }
-
-    readonly property color widgetBackgroundCustomBaseColor: safeColor(typeof SettingsData !== "undefined" ? SettingsData.widgetBackgroundCustomColor : "#6750A4", primaryContainer)
-    readonly property real widgetBackgroundCustomStrength: Math.max(0, Math.min(1, typeof SettingsData !== "undefined" ? (SettingsData.widgetBackgroundCustomStrength ?? 0.4) : 0.4))
-
     property var widgetBaseBackgroundColor: {
         const colorMode = typeof SettingsData !== "undefined" ? SettingsData.widgetBackgroundColor : "sch";
         switch (colorMode) {
@@ -1459,14 +1445,6 @@ Singleton {
             return surfaceContainer;
         case "sch":
             return surfaceContainerHigh;
-        case "primaryContainer":
-            return primaryContainer;
-        case "secondaryContainer":
-            return secondaryContainer;
-        case "tertiaryContainer":
-            return tertiaryContainer;
-        case "custom":
-            return blend(surfaceContainerHigh, widgetBackgroundCustomBaseColor, widgetBackgroundCustomStrength);
         case "sth":
         default:
             return surfaceTextHover;

quickshell/Common/settings/Processes.qml

@@ -570,7 +570,7 @@ Singleton {
         onExited: exitCode => {
             const enabling = root.settingsRoot && root.settingsRoot.greeterAutoLogin;
             if (exitCode === 0) {
-                ToastService.showWarning(enabling ? I18n.tr("Applying auto-login on startup...") : I18n.tr("Disabling auto-login on startup..."), "", "dms greeter sync --autologin", "greeter-autologin-sync");
+                ToastService.showWarning(enabling ? I18n.tr("Applying auto-login on startup…") : I18n.tr("Disabling auto-login on startup…"), "", "dms greeter sync --autologin", "greeter-autologin-sync");
                 root.greeterAutoLoginSyncProcess.running = true;
                 return;
             }
@@ -645,7 +645,7 @@ Singleton {
         onExited: exitCode => {
             const err = (root.authApplySudoProbeStderr || "").trim();
             if (exitCode === 0) {
-                ToastService.showInfo(I18n.tr("Applying authentication changes..."), "", "", "auth-sync");
+                ToastService.showInfo(I18n.tr("Applying authentication changes…"), "", "", "auth-sync");
                 root.authApplyProcess.running = true;
                 return;
             }

quickshell/Common/settings/SettingsSpec.js

@@ -19,8 +19,6 @@ var SPEC = {
     dockTransparency: { def: 1.0, coerce: percentToUnit },
 
     widgetBackgroundColor: { def: "sch" },
-    widgetBackgroundCustomColor: { def: "#6750A4" },
-    widgetBackgroundCustomStrength: { def: 0.50, coerce: percentToUnit },
     widgetColorMode: { def: "default" },
     controlCenterTileColorMode: { def: "primary" },
     buttonColorMode: { def: "primary" },
@@ -39,7 +37,6 @@ var SPEC = {
 
     firstDayOfWeek: { def: -1 },
     showWeekNumber: { def: false },
-    calendarBackend: { def: "auto" },
     use24HourClock: { def: true },
     showSeconds: { def: false },
     padHours12Hour: { def: false },
@@ -146,16 +143,11 @@ var SPEC = {
     dwlShowAllTags: { def: false },
     workspaceActiveAppHighlightEnabled: { def: false },
     workspaceColorMode: { def: "default" },
-    workspaceFocusedCustomColor: { def: "#6750A4" },
     workspaceOccupiedColorMode: { def: "none" },
-    workspaceOccupiedCustomColor: { def: "#625B71" },
     workspaceUnfocusedColorMode: { def: "default" },
-    workspaceUnfocusedCustomColor: { def: "#49454E" },
     workspaceUrgentColorMode: { def: "default" },
-    workspaceUrgentCustomColor: { def: "#B3261E" },
     workspaceFocusedBorderEnabled: { def: false },
     workspaceFocusedBorderColor: { def: "primary" },
-    workspaceFocusedBorderCustomColor: { def: "#6750A4" },
     workspaceFocusedBorderThickness: { def: 2 },
     workspaceNameIcons: { def: {} },
     waveProgressEnabled: { def: true },
@@ -164,7 +156,6 @@ var SPEC = {
     audioVisualizerEnabled: { def: true },
     audioScrollMode: { def: "volume" },
     audioWheelScrollAmount: { def: 5 },
-    audioDeviceScrollVolumeEnabled: { def: false },
     clockCompactMode: { def: false },
     focusedWindowCompactMode: { def: false },
     focusedWindowSize: { def: 1 },
@@ -172,9 +163,6 @@ var SPEC = {
     barMaxVisibleApps: { def: 0 },
     barMaxVisibleRunningApps: { def: 0 },
     barShowOverflowBadge: { def: true },
-    trayAutoOverflow: { def: true },
-    trayPopupSingleLine: { def: true },
-    trayMaxVisibleItems: { def: 0 },
     appsDockHideIndicators: { def: false },
     appsDockColorizeActive: { def: false },
     appsDockActiveColorMode: { def: "primary" },
@@ -237,7 +225,6 @@ var SPEC = {
     launcherUseOverlayLayer: { def: false },
     launcherStyle: { def: "full" },
     spotlightBarShowModeChips: { def: false },
-    keybindsFloatingWindow: { def: false },
 
     useAutoLocation: { def: false },
     weatherEnabled: { def: true },
@@ -273,16 +260,9 @@ var SPEC = {
     notepadUseMonospace: { def: true },
     notepadFontFamily: { def: "" },
     notepadFontSize: { def: 14 },
-    notificationSummaryFontSize: { def: 0 },
-    notificationBodyFontSize: { def: 0 },
     notepadShowLineNumbers: { def: false },
-    notepadAutoSave: { def: false },
-    notepadSlideoutSide: { def: "right" },
-    notepadDefaultMode: { def: "slideout" },
     notepadTransparencyOverride: { def: -1 },
     notepadLastCustomTransparency: { def: 0.7 },
-    notepadUseCompositorGap: { def: false },
-    notepadEdgeGap: { def: 0 },
 
     soundsEnabled: { def: true },
     useSystemSoundTheme: { def: false },
@@ -290,7 +270,6 @@ var SPEC = {
     soundNewNotification: { def: true },
     soundVolumeChanged: { def: true },
     soundPluggedIn: { def: true },
-    muteSoundsWhenMediaPlaying: { def: true },
 
     acMonitorTimeout: { def: 0 },
     acLockTimeout: { def: 0 },
@@ -427,7 +406,6 @@ var SPEC = {
     notificationTimeoutNormal: { def: 5000 },
     notificationTimeoutCritical: { def: 0 },
     notificationCompactMode: { def: false },
-    notificationShowTimeoutBar: { def: false },
     notificationDedupeEnabled: { def: true },
     notificationPopupPosition: { def: 0 },
     notificationAnimationSpeed: { def: 1 },
@@ -591,7 +569,6 @@ var SPEC = {
 
     builtInPluginSettings: { def: {} },
     clipboardEnterToPaste: { def: false },
-    clipboardVisibleEntryActions: { def: ["pin", "edit", "delete"] },
 
     launcherPluginVisibility: { def: {} },
     launcherPluginOrder: { def: [] },

quickshell/DMSShell.qml

@@ -64,15 +64,27 @@ Item {
         }
     }
 
+    property bool wallpaperSurfacesLoaded: true
+
     Loader {
         id: blurredWallpaperBackgroundLoader
-        active: SettingsData.blurredWallpaperLayer && CompositorService.isNiri
+        active: root.wallpaperSurfacesLoaded && SettingsData.blurredWallpaperLayer && CompositorService.isNiri
         asynchronous: false
 
         sourceComponent: BlurredWallpaperBackground {}
     }
 
-    WallpaperBackground {}
+    DeferredAction {
+        id: wallpaperSurfaceReloadAction
+        onTriggered: root.wallpaperSurfacesLoaded = true
+    }
+
+    Loader {
+        id: wallpaperBackgroundLoader
+        active: root.wallpaperSurfacesLoaded
+        asynchronous: false
+        sourceComponent: WallpaperBackground {}
+    }
 
     DesktopWidgetLayer {}
 
@@ -116,12 +128,6 @@ Item {
                         fadeWindowLoader.item.cancelFade();
                     }
                 }
-
-                function onDismissFadeToLock() {
-                    if (fadeWindowLoader.item) {
-                        fadeWindowLoader.item.dismiss();
-                    }
-                }
             }
         }
     }
@@ -323,9 +329,6 @@ Item {
 
     property bool hadRealScreen: true
     property var previousRealScreenNames: []
-    // Guards for the screen-reconnect recovery path (see scheduleScreenReconnectRecovery).
-    property bool _screenRecoveryCooldown: false
-    property bool _screenRecoveryPending: false
 
     function _getRealScreenNames() {
         const names = [];
@@ -368,60 +371,15 @@ Item {
             const partialReconnect = root.previousRealScreenNames.length > 0
                 && currentNames.some(name => !root.previousRealScreenNames.includes(name));
             if (fullReconnect || partialReconnect) {
-                log.info("Screen reconnect detected, scheduling surface recovery",
+                log.info("Screen reconnect detected, triggering surface recovery",
                          "full:", fullReconnect, "partial:", partialReconnect);
-                root.scheduleScreenReconnectRecovery();
+                root.triggerSurfaceRecovery("screen-reconnect");
             }
             root.hadRealScreen = hasReal;
             root.previousRealScreenNames = currentNames;
         }
     }
 
-    // A DPMS off/on cycle removes an output from the screen list and re-adds it,
-    // which is indistinguishable here from a hotplug. Recovering immediately on
-    // every such event lets a flapping monitor (or a recovery that itself perturbs
-    // the output) drive an endless recovery storm that power-cycles the display
-    // (#2642). Debounce a burst of changes into a single pass, then hold a cooldown
-    // so repeated flaps trigger at most one recovery per window. Recovery still runs
-    // once per resume, so a partial DPMS resume keeps redrawing its surfaces (#2579).
-    function scheduleScreenReconnectRecovery() {
-        if (root._screenRecoveryCooldown) {
-            root._screenRecoveryPending = true;
-            return;
-        }
-        screenReconnectDebounce.restart();
-    }
-
-    Timer {
-        id: screenReconnectDebounce
-        // Wide enough to collapse the output-remove + output-re-add pair that one
-        // DPMS off/on cycle emits as two near-simultaneous events into one recovery.
-        interval: 450
-        repeat: false
-        onTriggered: {
-            root._screenRecoveryCooldown = true;
-            root._screenRecoveryPending = false;
-            screenReconnectCooldown.restart();
-            root.triggerSurfaceRecovery("screen-reconnect");
-        }
-    }
-
-    Timer {
-        id: screenReconnectCooldown
-        // Must exceed the full two-pass surfaceResumeRecoveryTimer sequence
-        // (800 + 2000 ms) so the cooldown still covers an in-flight recovery;
-        // raise this if those passes are lengthened.
-        interval: 4000
-        repeat: false
-        onTriggered: {
-            root._screenRecoveryCooldown = false;
-            if (root._screenRecoveryPending) {
-                root._screenRecoveryPending = false;
-                screenReconnectDebounce.restart();
-            }
-        }
-    }
-
     Timer {
         id: surfaceResumeRecoveryTimer
         interval: 800
@@ -440,6 +398,11 @@ Item {
                 frameSurfaceReloadAction.schedule();
             }
 
+            if (root.wallpaperSurfacesLoaded) {
+                root.wallpaperSurfacesLoaded = false;
+                wallpaperSurfaceReloadAction.schedule();
+            }
+
             root.dockEnabled = false;
             Qt.callLater(() => {
                 root.dockEnabled = true;
@@ -707,7 +670,7 @@ Item {
             if (!wifiPasswordModalLoader.item)
                 return;
 
-            if (wifiPasswordModalLoader.item.shouldBeVisible && timeSinceLastPrompt < 1000) {
+            if (wifiPasswordModalLoader.item.visible && timeSinceLastPrompt < 1000) {
                 NetworkService.cancelCredentials(lastCredentialsToken);
                 lastCredentialsToken = token;
                 lastCredentialsTime = now;
@@ -1051,14 +1014,6 @@ Item {
             osdResumeRecreateTimer.interval = 400;
             osdResumeRecreateTimer.restart();
 
-            // This path runs its own recovery directly, so drop any queued or
-            // in-flight screen-reconnect recovery to avoid a redundant pass once
-            // its cooldown expires.
-            screenReconnectDebounce.stop();
-            screenReconnectCooldown.stop();
-            root._screenRecoveryCooldown = false;
-            root._screenRecoveryPending = false;
-
             root.triggerSurfaceRecovery("sessionResumed");
         }
     }
@@ -1155,22 +1110,11 @@ Item {
             slideoutWidth: 480
             expandable: true
             expandedWidthValue: 960
-            edgeGap: SettingsData.notepadEffectiveEdgeGap
-            slideEdge: SettingsData.notepadSlideoutSide
-
-            onIsVisibleChanged: {
-                if (isVisible)
-                    PopoutService.notepadPopout?.hide();
-            }
 
             content: Component {
                 Notepad {
                     slideout: notepadSlideout
                     onHideRequested: notepadSlideout.hide()
-                    onPopoutRequested: {
-                        notepadSlideout.hide();
-                        PopoutService.openNotepadPopout();
-                    }
                 }
             }
 
@@ -1187,24 +1131,6 @@ Item {
         Component.onCompleted: PopoutService.notepadSlideouts = instances
     }
 
-    LazyLoader {
-        id: notepadPopoutLoader
-        active: false
-
-        Component.onCompleted: {
-            PopoutService.notepadPopoutLoader = notepadPopoutLoader;
-        }
-
-        onActiveChanged: {
-            if (active && item) {
-                PopoutService.notepadPopout = item;
-                PopoutService._onNotepadPopoutLoaded();
-            }
-        }
-
-        NotepadPopoutWindow {}
-    }
-
     LazyLoader {
         id: powerMenuModalLoader
 

quickshell/DMSShellIPC.qml

@@ -337,6 +337,9 @@ Item {
                 const focusedWs = I3.workspaces.values.find(ws => ws.focused === true);
                 return focusedWs?.monitor?.name || "";
             }
+            if (CompositorService.isDwl && DwlService.activeOutput) {
+                return DwlService.activeOutput;
+            }
             if (CompositorService.isMango && MangoService.activeOutput) {
                 return MangoService.activeOutput;
             }
@@ -373,10 +376,6 @@ Item {
         }
 
         function open(): string {
-            if (SettingsData.notepadDefaultMode === "popout") {
-                PopoutService.openNotepadPopout();
-                return "NOTEPAD_OPEN_SUCCESS";
-            }
             var instance = getActiveNotepadInstance();
             if (instance) {
                 instance.show();
@@ -386,10 +385,6 @@ Item {
         }
 
         function close(): string {
-            if (SettingsData.notepadDefaultMode === "popout") {
-                PopoutService.notepadPopout?.hide();
-                return "NOTEPAD_CLOSE_SUCCESS";
-            }
             var instance = getActiveNotepadInstance();
             if (instance) {
                 instance.hide();
@@ -399,10 +394,6 @@ Item {
         }
 
         function toggle(): string {
-            if (SettingsData.notepadDefaultMode === "popout") {
-                PopoutService.toggleNotepadPopout();
-                return "NOTEPAD_TOGGLE_SUCCESS";
-            }
             var instance = getActiveNotepadInstance();
             if (instance) {
                 instance.toggle();
@@ -956,7 +947,7 @@ Item {
 
         function tabs(): string {
             if (!PopoutService.settingsModal)
-                return "wallpaper\ntheme\ntypography\ntime_weather\nsounds\ndankbar\ndankbar_settings\ndankbar_appearance\ndankbar_widgets\nframe\nworkspaces\ncompositor\nmedia_player\nnotifications\nosd\nrunning_apps\nupdater\ndock\nlauncher\nkeybinds\ndisplays\nnetwork\nnetwork_status\nnetwork_ethernet\nnetwork_wifi\nnetwork_vpn\nprinters\nlock_screen\npower_sleep\nplugins\nabout";
+                return "wallpaper\ntheme\ntypography\ntime_weather\nsounds\ndankbar\ndankbar_settings\ndankbar_appearance\ndankbar_widgets\nframe\nworkspaces\ncompositor\nmedia_player\nnotifications\nosd\nrunning_apps\nupdater\ndock\nlauncher\nkeybinds\ndisplays\nnetwork\nprinters\nlock_screen\npower_sleep\nplugins\nabout";
             var modal = PopoutService.settingsModal;
             var ids = [];
             var structure = modal.sidebar?.categoryStructure ?? [];

quickshell/Modals/Clipboard/ClipboardContent.qml

@@ -7,6 +7,7 @@ Item {
     id: clipboardContent
 
     required property var modal
+    required property var clearConfirmDialog
 
     property alias searchField: searchField
     property alias clipboardListView: clipboardListView
@@ -32,7 +33,14 @@ Item {
             pinnedCount: modal.pinnedCount
             onKeyboardHintsToggled: modal.showKeyboardHints = !modal.showKeyboardHints
             onTabChanged: tabName => modal.activeTab = tabName
-            onClearAllClicked: modal.confirmClearAll()
+            onClearAllClicked: {
+                const hasPinned = modal.pinnedCount > 0;
+                const message = hasPinned ? I18n.tr("This will delete all unpinned entries. %1 pinned entries will be kept.").arg(modal.pinnedCount) : I18n.tr("This will permanently delete all clipboard history.");
+                clearConfirmDialog.show(I18n.tr("Clear History?"), message, function () {
+                    modal.clearAll();
+                    modal.hide();
+                }, function () {});
+            }
             onCloseClicked: modal.hide()
         }
 
@@ -120,7 +128,7 @@ Item {
             }
 
             StyledText {
-                text: clipboardContent.modal.clipboardAvailable ? I18n.tr("No recent clipboard entries found") : I18n.tr("Connecting to clipboard service...")
+                text: clipboardContent.modal.clipboardAvailable ? I18n.tr("No recent clipboard entries found") : I18n.tr("Connecting to clipboard service…")
                 anchors.centerIn: parent
                 font.pixelSize: Theme.fontSizeMedium
                 color: Theme.surfaceVariantText
@@ -141,8 +149,8 @@ Item {
                 listView: clipboardListView
                 onCopyRequested: clipboardContent.modal.copyEntry(modelData)
                 onDeleteRequested: clipboardContent.modal.deleteEntry(modelData)
-                onPinRequested: targetEntry => clipboardContent.modal.pinEntry(targetEntry)
-                onUnpinRequested: targetEntry => clipboardContent.modal.unpinEntry(targetEntry)
+                onPinRequested: clipboardContent.modal.pinEntry(modelData)
+                onUnpinRequested: clipboardContent.modal.unpinEntry(modelData)
                 onEditRequested: clipboardContent.modal.editEntry(modelData)
             }
         }
@@ -194,7 +202,7 @@ Item {
             }
 
             StyledText {
-                text: clipboardContent.modal.clipboardAvailable ? I18n.tr("No saved clipboard entries") : I18n.tr("Connecting to clipboard service...")
+                text: clipboardContent.modal.clipboardAvailable ? I18n.tr("No saved clipboard entries") : I18n.tr("Connecting to clipboard service…")
                 anchors.centerIn: parent
                 font.pixelSize: Theme.fontSizeMedium
                 color: Theme.surfaceVariantText
@@ -215,8 +223,8 @@ Item {
                 listView: savedListView
                 onCopyRequested: clipboardContent.modal.copyEntry(modelData)
                 onDeleteRequested: clipboardContent.modal.deletePinnedEntry(modelData)
-                onPinRequested: targetEntry => clipboardContent.modal.pinEntry(targetEntry)
-                onUnpinRequested: targetEntry => clipboardContent.modal.unpinEntry(targetEntry)
+                onPinRequested: clipboardContent.modal.pinEntry(modelData)
+                onUnpinRequested: clipboardContent.modal.unpinEntry(modelData)
                 onEditRequested: clipboardContent.modal.editEntry(modelData)
             }
         }

quickshell/Modals/Clipboard/ClipboardEntry.qml

@@ -15,21 +15,13 @@ Rectangle {
 
     signal copyRequested
     signal deleteRequested
-    signal pinRequested(var targetEntry)
-    signal unpinRequested(var targetEntry)
+    signal pinRequested
+    signal unpinRequested
     signal editRequested
 
     readonly property string entryType: modal ? modal.getEntryType(entry) : "text"
     readonly property string entryPreview: modal ? modal.getEntryPreview(entry) : ""
-    readonly property var pinnedDuplicateEntry: !entry.pinned ? ClipboardService.getPinnedEntryByHash(entry.hash) : null
-    readonly property bool hasPinnedDuplicate: pinnedDuplicateEntry !== null
-    readonly property bool effectivePinned: entry.pinned || hasPinnedDuplicate
-    readonly property var visibleEntryActions: SettingsData.clipboardVisibleEntryActions || ["pin", "edit", "delete"]
-    readonly property bool showPinAction: visibleEntryActions.includes("pin")
-    readonly property bool showEditAction: visibleEntryActions.includes("edit")
-    readonly property bool showDeleteAction: visibleEntryActions.includes("delete")
-    readonly property bool showPinnedIndicator: hasPinnedDuplicate && !showPinAction
-    readonly property bool showAnyAction: showPinAction || showEditAction || showDeleteAction || showPinnedIndicator
+    readonly property bool hasPinnedDuplicate: !entry.pinned && ClipboardService.hashedPinnedEntry(entry.hash)
 
     radius: Theme.cornerRadius
     color: {
@@ -70,46 +62,19 @@ Rectangle {
         anchors.rightMargin: Theme.spacingS
         anchors.verticalCenter: parent.verticalCenter
         spacing: Theme.spacingXS
-        visible: root.showAnyAction
-
-        Item {
-            width: 40
-            height: 40
-            visible: root.showPinnedIndicator
-
-            // Status indicator only; the Pin action remains hidden.
-            DankIcon {
-                anchors.centerIn: parent
-                name: "push_pin"
-                size: Theme.iconSize - 6
-                color: Theme.primary
-            }
-        }
 
         DankActionButton {
             iconName: "push_pin"
             iconSize: Theme.iconSize - 6
             iconColor: (entry.pinned || hasPinnedDuplicate) ? Theme.primary : Theme.surfaceText
             backgroundColor: (entry.pinned || hasPinnedDuplicate) ? Theme.primarySelected : "transparent"
-            visible: root.showPinAction
-            onClicked: {
-                if (entry.pinned) {
-                    unpinRequested(entry);
-                    return;
-                }
-                if (pinnedDuplicateEntry) {
-                    unpinRequested(pinnedDuplicateEntry);
-                    return;
-                }
-                pinRequested(entry);
-            }
+            onClicked: entry.pinned ? unpinRequested() : pinRequested()
         }
 
         DankActionButton {
             iconName: "edit"
             iconSize: Theme.iconSize - 6
             iconColor: Theme.surfaceText
-            visible: root.showEditAction
 
             onClicked: {
                 if (entryType === "image") {
@@ -123,7 +88,6 @@ Rectangle {
             iconName: "close"
             iconSize: Theme.iconSize - 6
             iconColor: Theme.surfaceText
-            visible: root.showDeleteAction
             onClicked: deleteRequested()
         }
     }
@@ -131,8 +95,8 @@ Rectangle {
     Item {
         anchors.left: indexBadge.right
         anchors.leftMargin: Theme.spacingM
-        anchors.right: root.showAnyAction ? actionButtons.left : parent.right
-        anchors.rightMargin: root.showAnyAction ? Theme.spacingM : Theme.spacingS
+        anchors.right: actionButtons.left
+        anchors.rightMargin: Theme.spacingM
         anchors.verticalCenter: parent.verticalCenter
         // height: contentColumn.implicitHeight
         height: ClipboardConstants.itemHeight
@@ -193,8 +157,8 @@ Rectangle {
     MouseArea {
         id: mouseArea
         anchors.left: parent.left
-        anchors.right: root.showAnyAction ? actionButtons.left : parent.right
-        anchors.rightMargin: root.showAnyAction ? Theme.spacingS : 0
+        anchors.right: actionButtons.left
+        anchors.rightMargin: Theme.spacingS
         anchors.top: parent.top
         anchors.bottom: parent.bottom
         hoverEnabled: true

quickshell/Modals/Clipboard/ClipboardHistoryContent.qml

@@ -82,15 +82,6 @@ FocusScope {
         ClipboardService.clearAll();
     }
 
-    function confirmClearAll() {
-        const hasPinned = pinnedCount > 0;
-        const message = hasPinned ? I18n.tr("This will delete all unpinned entries. %1 pinned entries will be kept.").arg(pinnedCount) : I18n.tr("This will permanently delete all clipboard history.");
-        clearConfirmDialog.show(I18n.tr("Clear History?"), message, function () {
-            clearAll();
-            hide();
-        }, function () {});
-    }
-
     function getEntryPreview(entry) {
         return ClipboardService.getEntryPreview(entry);
     }
@@ -144,6 +135,7 @@ FocusScope {
             id: historyContent
             anchors.fill: parent
             modal: root
+            clearConfirmDialog: root.clearConfirmDialog
         }
     }
 

quickshell/Modals/Clipboard/ClipboardHistoryModal.qml

@@ -58,7 +58,6 @@ DankModal {
     readonly property bool clipboardAvailable: ClipboardService.clipboardAvailable
 
     visible: false
-    keepContentLoaded: true
     modalWidth: ClipboardConstants.modalWidth
     modalHeight: ClipboardConstants.modalHeight
     backgroundColor: Theme.withAlpha(Theme.surfaceContainer, Theme.popupTransparency)
@@ -77,35 +76,22 @@ DankModal {
         id: clearConfirmDialog
         confirmButtonText: I18n.tr("Clear All")
         confirmButtonColor: Theme.primary
-        onShouldBeVisibleChanged: {
-            if (shouldBeVisible) {
+        onVisibleChanged: {
+            if (visible) {
                 clipboardHistoryModal.shouldHaveFocus = false;
-                selectedButton = 0;
-                keyboardNavigation = true;
                 return;
             }
             Qt.callLater(function () {
                 if (!clipboardHistoryModal.shouldBeVisible) {
                     return;
                 }
-                clipboardHistoryModal.shouldHaveFocus = Qt.binding(() => clipboardHistoryModal.shouldBeVisible);
+                clipboardHistoryModal.shouldHaveFocus = true;
                 clipboardHistoryModal.modalFocusScope.forceActiveFocus();
                 if (clipboardHistoryModal.contentLoader.item?.searchField) {
                     clipboardHistoryModal.contentLoader.item.searchField.forceActiveFocus();
                 }
             });
         }
-        Connections {
-            target: clearConfirmDialog.modalFocusScope.Keys
-            function onPressed(event) {
-                if (!clearConfirmDialog.shouldBeVisible || event.key !== Qt.Key_Backtab) {
-                    return;
-                }
-                clearConfirmDialog.selectedButton = clearConfirmDialog.selectedButton === -1 ? 1 : (clearConfirmDialog.selectedButton - 1 + 2) % 2;
-                clearConfirmDialog.keyboardNavigation = true;
-                event.accepted = true;
-            }
-        }
     }
 
     content: Component {

quickshell/Modals/Clipboard/ClipboardHistoryPopout.qml

@@ -1,7 +1,6 @@
 pragma ComponentBehavior: Bound
 
 import QtQuick
-import Quickshell.Wayland
 import qs.Common
 import qs.Modals.Clipboard
 import qs.Modals.Common
@@ -96,35 +95,6 @@ DankPopout {
         id: clearConfirmDialog
         confirmButtonText: I18n.tr("Clear All")
         confirmButtonColor: Theme.primary
-        onShouldBeVisibleChanged: {
-            if (shouldBeVisible) {
-                root.customKeyboardFocus = WlrKeyboardFocus.None;
-                selectedButton = 0;
-                keyboardNavigation = true;
-                return;
-            }
-            root.customKeyboardFocus = null;
-            Qt.callLater(function () {
-                if (!root.shouldBeVisible || !root.contentLoader.item) {
-                    return;
-                }
-                root.contentLoader.item.forceActiveFocus();
-                if (root.contentLoader.item.searchField) {
-                    root.contentLoader.item.searchField.forceActiveFocus();
-                }
-            });
-        }
-        Connections {
-            target: clearConfirmDialog.modalFocusScope.Keys
-            function onPressed(event) {
-                if (!clearConfirmDialog.shouldBeVisible || event.key !== Qt.Key_Backtab) {
-                    return;
-                }
-                clearConfirmDialog.selectedButton = clearConfirmDialog.selectedButton === -1 ? 1 : (clearConfirmDialog.selectedButton - 1 + 2) % 2;
-                clearConfirmDialog.keyboardNavigation = true;
-                event.accepted = true;
-            }
-        }
     }
 
     content: Component {

quickshell/Modals/Clipboard/ClipboardKeyboardController.qml

@@ -59,13 +59,8 @@ QtObject {
             return;
         }
         const selectedEntry = entries[ClipboardService.selectedIndex];
-        if (selectedEntry.pinned) {
+        if (modal.activeTab === "saved") {
             modal.unpinEntry(selectedEntry);
-            return;
-        }
-        const pinnedDuplicate = ClipboardService.getPinnedEntryByHash(selectedEntry.hash);
-        if (pinnedDuplicate) {
-            modal.unpinEntry(pinnedDuplicate);
         } else {
             modal.pinEntry(selectedEntry);
         }
@@ -125,6 +120,8 @@ QtObject {
             if (!ClipboardService.keyboardNavigationActive) {
                 ClipboardService.keyboardNavigationActive = true;
                 ClipboardService.selectedIndex = 0;
+            } else if (ClipboardService.selectedIndex === 0) {
+                ClipboardService.keyboardNavigationActive = false;
             } else {
                 selectPrevious();
             }
@@ -153,6 +150,8 @@ QtObject {
                 if (!ClipboardService.keyboardNavigationActive) {
                     ClipboardService.keyboardNavigationActive = true;
                     ClipboardService.selectedIndex = 0;
+                } else if (ClipboardService.selectedIndex === 0) {
+                    ClipboardService.keyboardNavigationActive = false;
                 } else {
                     selectPrevious();
                 }
@@ -180,7 +179,8 @@ QtObject {
         if (event.modifiers & Qt.ShiftModifier) {
             switch (event.key) {
             case Qt.Key_Delete:
-                modal.confirmClearAll();
+                modal.clearAll();
+                modal.hide();
                 event.accepted = true;
                 return;
             case Qt.Key_Return:

quickshell/Modals/Common/DankModal.qml

@@ -54,12 +54,23 @@ Item {
         anchors.fill: parent
     }
 
-    // Hyprland OnDemand grab delivers keyboard focus to the modal content surface.
+    // One focus grab for every modal; on Hyprland this is what delivers
+    // keyboard focus to the OnDemand surface, identically in both modes.
+    // The clickCatcher is whitelisted so an outside click is delivered to
+    // it (closing the modal) instead of being consumed clearing the grab.
     HyprlandFocusGrab {
-        windows: root.contentWindow ? [root.contentWindow] : []
+        windows: {
+            const list = [];
+            if (root.contentWindow)
+                list.push(root.contentWindow);
+            if (root.clickCatcher)
+                list.push(root.clickCatcher);
+            return list;
+        }
         active: KeyboardFocus.wantsGrab(root.shouldHaveFocus, root.customKeyboardFocus)
     }
     readonly property var contentWindow: impl.item ? impl.item.contentWindow : null
+    readonly property var clickCatcher: impl.item ? impl.item.clickCatcher : null
     readonly property var effectiveScreen: impl.item ? impl.item.effectiveScreen : null
     readonly property real screenWidth: impl.item ? impl.item.screenWidth : 1920
     readonly property real screenHeight: impl.item ? impl.item.screenHeight : 1080
@@ -102,6 +113,8 @@ Item {
         }
     }
 
+    // Defer Loader source-component swap until impl is fully closed; avoids
+    // tearing down a modal mid-animation when frame mode is toggled.
     function _maybeResolveBackend() {
         if (_resolvedBackend === _desiredBackend)
             return;

quickshell/Modals/Common/DankModalConnected.qml

@@ -31,6 +31,7 @@ Item {
     property bool closeOnBackgroundClick: true
     property string animationType: "scale"
 
+    // Opposite side from the launcher by default; subclasses may override
     property string preferredConnectedBarSide: SettingsData.frameModalEmergeSide
 
     readonly property bool frameConnectedMode: SettingsData.frameEnabled && Theme.isConnectedEffect && !!effectiveScreen && SettingsData.isScreenInPreferences(effectiveScreen, SettingsData.frameScreenPreferences)
@@ -86,13 +87,16 @@ Item {
     property real frozenMotionOffsetX: 0
     property real frozenMotionOffsetY: 0
     readonly property alias contentWindow: contentWindow
+    readonly property alias clickCatcher: clickCatcher
     readonly property bool useHyprlandFocusGrab: CompositorService.useHyprlandFocusGrab
     readonly property bool useBackground: false
+    readonly property bool useSingleWindow: CompositorService.isHyprland
 
     signal opened
     signal dialogClosed
     signal backgroundClicked
 
+    // Coalesce per-channel dirty bits; one ConnectedModeState write per tick.
     Timer {
         id: _syncTimer
         interval: 0
@@ -240,16 +244,22 @@ Item {
         const focusedScreen = CompositorService.getFocusedScreen();
         if (focusedScreen) {
             contentWindow.screen = focusedScreen;
+            if (!useSingleWindow)
+                clickCatcher.screen = focusedScreen;
         }
 
         ModalManager.openModal(modalHandle);
         if (Theme.isDirectionalEffect || root.useBackground) {
+            if (!useSingleWindow)
+                clickCatcher.visible = true;
             contentWindow.visible = true;
         }
 
         Qt.callLater(() => {
             animationsEnabled = true;
             shouldBeVisible = true;
+            if (!useSingleWindow && !clickCatcher.visible)
+                clickCatcher.visible = true;
             if (!contentWindow.visible)
                 contentWindow.visible = true;
             opened();
@@ -276,6 +286,8 @@ Item {
         ModalManager.closeModal(modalHandle);
         closeTimer.stop();
         contentWindow.visible = false;
+        if (!useSingleWindow)
+            clickCatcher.visible = false;
         dialogClosed();
         Qt.callLater(() => animationsEnabled = true);
     }
@@ -314,6 +326,8 @@ Item {
             const newScreen = CompositorService.getFocusedScreen();
             if (newScreen) {
                 contentWindow.screen = newScreen;
+                if (!useSingleWindow)
+                    clickCatcher.screen = newScreen;
             }
         }
     }
@@ -325,12 +339,29 @@ Item {
             if (shouldBeVisible)
                 return;
             contentWindow.visible = false;
+            if (!useSingleWindow)
+                clickCatcher.visible = false;
             dialogClosed();
         }
     }
 
+    // shadowRenderPadding is zeroed when frame owns the chrome
+    // Wayland then clips any content translating past
     readonly property var shadowLevel: Theme.elevationLevel3
     readonly property real shadowFallbackOffset: 6
+    readonly property real shadowRenderPadding: (!frameOwnsConnectedChrome && root.enableShadow && Theme.elevationEnabled && SettingsData.modalElevationEnabled) ? Theme.elevationRenderPadding(shadowLevel, Theme.elevationLightDirection, shadowFallbackOffset, 8, 16) : 0
+    readonly property real shadowMotionPadding: {
+        if (frameOwnsConnectedChrome)
+            return 0;
+        if (animationType === "slide")
+            return 30;
+        if (Theme.isDirectionalEffect)
+            return Math.max(Math.max(0, animationOffset), Math.max(alignedWidth, alignedHeight) * 0.9);
+        if (Theme.isDepthEffect)
+            return Math.max(Math.max(0, animationOffset), Math.max(alignedWidth, alignedHeight) * 0.35);
+        return Math.max(0, animationOffset);
+    }
+    readonly property real shadowBuffer: Theme.snap(shadowRenderPadding + shadowMotionPadding, dpr)
     readonly property real alignedWidth: Theme.px(modalWidth, dpr)
     readonly property real alignedHeight: Theme.px(modalHeight, dpr)
 
@@ -340,6 +371,7 @@ Item {
         return SettingsData.frameEdgeInsetForSide(effectiveScreen, side);
     }
 
+    // frameEdgeInsetForSide is the full inset; do not add frameBarSize
     readonly property real _connectedAlignedX: {
         switch (resolvedConnectedBarSide) {
         case "top":
@@ -402,6 +434,57 @@ Item {
             }
         })(), dpr)
 
+    PanelWindow {
+        id: clickCatcher
+        visible: false
+        color: "transparent"
+
+        WlrLayershell.namespace: root.layerNamespace + ":clickcatcher"
+        WlrLayershell.layer: WlrLayershell.Top
+        WlrLayershell.exclusiveZone: -1
+        WlrLayershell.keyboardFocus: WlrKeyboardFocus.None
+
+        anchors {
+            top: true
+            left: true
+            right: true
+            bottom: true
+        }
+
+        mask: Region {
+            item: Rectangle {
+                x: root.alignedX
+                y: root.alignedY
+                width: root.alignedWidth
+                height: root.alignedHeight
+            }
+            intersection: Intersection.Xor
+        }
+
+        MouseArea {
+            anchors.fill: parent
+            enabled: !root.useSingleWindow && root.closeOnBackgroundClick && root.shouldBeVisible
+            onClicked: root.backgroundClicked()
+        }
+
+        Rectangle {
+            anchors.fill: parent
+            z: -1
+            color: "black"
+            opacity: (!root.useSingleWindow && root.useBackground) ? (root.shouldBeVisible ? root.backgroundOpacity : 0) : 0
+            visible: opacity > 0
+
+            Behavior on opacity {
+                enabled: root.animationsEnabled && (!Theme.isDirectionalEffect || Theme.isConnectedEffect)
+                NumberAnimation {
+                    duration: Math.round(Theme.variantDuration(root.animationDuration, root.shouldBeVisible) * Theme.variantOpacityDurationScale)
+                    easing.type: Easing.BezierSpline
+                    easing.bezierCurve: root.shouldBeVisible ? root.animationEnterCurve : root.animationExitCurve
+                }
+            }
+        }
+    }
+
     PanelWindow {
         id: contentWindow
         visible: false
@@ -411,8 +494,8 @@ Item {
             targetWindow: contentWindow
             blurEnabled: root.effectiveBlurEnabled && !root.frameOwnsConnectedChrome
             readonly property real s: Math.min(1, modalContainer.scaleValue)
-            blurX: connectedReveal.x + modalContainer.x + modalContainer.width * (1 - s) * 0.5 + Theme.snap(modalContainer.animX, root.dpr)
-            blurY: connectedReveal.y + modalContainer.y + modalContainer.height * (1 - s) * 0.5 + Theme.snap(modalContainer.animY, root.dpr)
+            blurX: modalContainer.x + modalContainer.width * (1 - s) * 0.5 + Theme.snap(modalContainer.animX, root.dpr)
+            blurY: modalContainer.y + modalContainer.height * (1 - s) * 0.5 + Theme.snap(modalContainer.animY, root.dpr)
             blurWidth: (root.shouldBeVisible && !root.frameOwnsConnectedChrome) ? modalContainer.width * s : 0
             blurHeight: (root.shouldBeVisible && !root.frameOwnsConnectedChrome) ? modalContainer.height * s : 0
             blurRadius: root.effectiveCornerRadius
@@ -431,10 +514,23 @@ Item {
         anchors {
             left: true
             top: true
-            right: true
-            bottom: true
+            right: root.useSingleWindow
+            bottom: root.useSingleWindow
         }
 
+        readonly property real actualMarginLeft: root.useSingleWindow ? 0 : Math.max(0, Theme.snap(root.alignedX - shadowBuffer, dpr))
+        readonly property real actualMarginTop: root.useSingleWindow ? 0 : Math.max(0, Theme.snap(root.alignedY - shadowBuffer, dpr))
+
+        WlrLayershell.margins {
+            left: actualMarginLeft
+            top: actualMarginTop
+            right: 0
+            bottom: 0
+        }
+
+        implicitWidth: root.useSingleWindow ? 0 : root.alignedWidth + (shadowBuffer * 2)
+        implicitHeight: root.useSingleWindow ? 0 : root.alignedHeight + (shadowBuffer * 2)
+
         onVisibleChanged: {
             if (visible)
                 return;
@@ -446,7 +542,7 @@ Item {
 
         MouseArea {
             anchors.fill: parent
-            enabled: root.closeOnBackgroundClick && root.shouldBeVisible
+            enabled: root.useSingleWindow && root.closeOnBackgroundClick && root.shouldBeVisible
             z: -2
             onClicked: root.backgroundClicked()
         }
@@ -455,7 +551,7 @@ Item {
             anchors.fill: parent
             z: -1
             color: "black"
-            opacity: root.useBackground ? (root.shouldBeVisible ? root.backgroundOpacity : 0) : 0
+            opacity: (root.useSingleWindow && root.useBackground) ? (root.shouldBeVisible ? root.backgroundOpacity : 0) : 0
             visible: opacity > 0
 
             Behavior on opacity {
@@ -469,256 +565,249 @@ Item {
         }
 
         Item {
-            id: connectedReveal
-            // Clip to final footprint while frame-owned chrome grows from the bar edge.
-            x: root.alignedX
-            y: root.alignedY
+            id: modalContainer
+            x: (root.useSingleWindow ? root.alignedX : (root.alignedX - contentWindow.actualMarginLeft)) + Theme.snap(animX, root.dpr)
+            y: (root.useSingleWindow ? root.alignedY : (root.alignedY - contentWindow.actualMarginTop)) + Theme.snap(animY, root.dpr)
+
             width: root.alignedWidth
             height: root.alignedHeight
-            clip: root.frameOwnsConnectedChrome
 
-            Item {
-                id: modalContainer
-                x: Theme.snap(animX, root.dpr)
-                y: Theme.snap(animY, root.dpr)
+            MouseArea {
+                anchors.fill: parent
+                enabled: root.useSingleWindow && root.shouldBeVisible
+                hoverEnabled: false
+                acceptedButtons: Qt.AllButtons
+                onPressed: mouse.accepted = true
+                onClicked: mouse.accepted = true
+                z: -1
+            }
 
-                width: root.alignedWidth
-                height: root.alignedHeight
-
-                MouseArea {
-                    anchors.fill: parent
-                    enabled: root.shouldBeVisible
-                    hoverEnabled: false
-                    acceptedButtons: Qt.AllButtons
-                    onPressed: mouse.accepted = true
-                    onClicked: mouse.accepted = true
-                    z: -1
-                }
-
-                readonly property bool slide: root.animationType === "slide"
-                readonly property bool directionalEffect: Theme.isDirectionalEffect
-                readonly property bool depthEffect: Theme.isDepthEffect
-                readonly property real directionalTravel: Math.max(root.animationOffset, Math.max(root.alignedWidth, root.alignedHeight) * 0.8)
-                readonly property real depthTravel: Math.max(root.animationOffset * 0.8, 36)
-                readonly property real customAnchorX: root.alignedX + root.alignedWidth * 0.5
-                readonly property real customAnchorY: root.alignedY + root.alignedHeight * 0.5
-                readonly property real customDistLeft: customAnchorX
-                readonly property real customDistRight: root.screenWidth - customAnchorX
-                readonly property real customDistTop: customAnchorY
-                readonly property real customDistBottom: root.screenHeight - customAnchorY
-                readonly property real connectedEmergenceTravelX: Math.max(root.animationOffset, root.alignedWidth + Theme.spacingL)
-                readonly property real connectedEmergenceTravelY: Math.max(root.animationOffset, root.alignedHeight + Theme.spacingL)
-                readonly property real offsetX: {
-                    if (root.frameOwnsConnectedChrome) {
-                        switch (root.resolvedConnectedBarSide) {
-                        case "left":
-                            return -connectedEmergenceTravelX;
-                        case "right":
-                            return connectedEmergenceTravelX;
-                        }
-                        return 0;
-                    }
-                    if (slide && !directionalEffect && !depthEffect)
-                        return 15;
-                    if (directionalEffect) {
-                        switch (root.positioning) {
-                        case "top-right":
-                            return 0;
-                        case "custom":
-                            if (customDistLeft <= customDistRight && customDistLeft <= customDistTop && customDistLeft <= customDistBottom)
-                                return -directionalTravel;
-                            if (customDistRight <= customDistTop && customDistRight <= customDistBottom)
-                                return directionalTravel;
-                            return 0;
-                        default:
-                            return 0;
-                        }
-                    }
-                    if (depthEffect) {
-                        switch (root.positioning) {
-                        case "top-right":
-                            return 0;
-                        case "custom":
-                            if (customDistLeft <= customDistRight && customDistLeft <= customDistTop && customDistLeft <= customDistBottom)
-                                return -depthTravel;
-                            if (customDistRight <= customDistTop && customDistRight <= customDistBottom)
-                                return depthTravel;
-                            return 0;
-                        default:
-                            return 0;
-                        }
+            readonly property bool slide: root.animationType === "slide"
+            readonly property bool directionalEffect: Theme.isDirectionalEffect
+            readonly property bool depthEffect: Theme.isDepthEffect
+            readonly property real directionalTravel: Math.max(root.animationOffset, Math.max(root.alignedWidth, root.alignedHeight) * 0.8)
+            readonly property real depthTravel: Math.max(root.animationOffset * 0.8, 36)
+            readonly property real customAnchorX: root.alignedX + root.alignedWidth * 0.5
+            readonly property real customAnchorY: root.alignedY + root.alignedHeight * 0.5
+            readonly property real customDistLeft: customAnchorX
+            readonly property real customDistRight: root.screenWidth - customAnchorX
+            readonly property real customDistTop: customAnchorY
+            readonly property real customDistBottom: root.screenHeight - customAnchorY
+            // Connected emergence: travel from the resolved bar edge, matching DankPopout cadence.
+            readonly property real connectedEmergenceTravelX: Math.max(root.animationOffset, root.alignedWidth + Theme.spacingL)
+            readonly property real connectedEmergenceTravelY: Math.max(root.animationOffset, root.alignedHeight + Theme.spacingL)
+            readonly property real offsetX: {
+                if (root.frameOwnsConnectedChrome) {
+                    switch (root.resolvedConnectedBarSide) {
+                    case "left":
+                        return -connectedEmergenceTravelX;
+                    case "right":
+                        return connectedEmergenceTravelX;
                     }
                     return 0;
                 }
-                readonly property real offsetY: {
-                    if (root.frameOwnsConnectedChrome) {
-                        switch (root.resolvedConnectedBarSide) {
-                        case "top":
-                            return -connectedEmergenceTravelY;
-                        case "bottom":
-                            return connectedEmergenceTravelY;
-                        }
+                if (slide && !directionalEffect && !depthEffect)
+                    return 15;
+                if (directionalEffect) {
+                    switch (root.positioning) {
+                    case "top-right":
+                        return 0;
+                    case "custom":
+                        if (customDistLeft <= customDistRight && customDistLeft <= customDistTop && customDistLeft <= customDistBottom)
+                            return -directionalTravel;
+                        if (customDistRight <= customDistTop && customDistRight <= customDistBottom)
+                            return directionalTravel;
+                        return 0;
+                    default:
                         return 0;
                     }
-                    if (slide && !directionalEffect && !depthEffect)
-                        return -30;
-                    if (directionalEffect) {
-                        switch (root.positioning) {
-                        case "top-right":
-                            return -Math.max(directionalTravel * 0.65, 96);
-                        case "custom":
-                            if (customDistTop <= customDistBottom && customDistTop <= customDistLeft && customDistTop <= customDistRight)
-                                return -directionalTravel;
-                            if (customDistBottom <= customDistLeft && customDistBottom <= customDistRight)
-                                return directionalTravel;
-                            return 0;
-                        default:
-                            return -Math.max(directionalTravel, root.screenHeight * 0.24);
-                        }
-                    }
-                    if (depthEffect) {
-                        switch (root.positioning) {
-                        case "top-right":
-                            return -depthTravel * 0.75;
-                        case "custom":
-                            if (customDistTop <= customDistBottom && customDistTop <= customDistLeft && customDistTop <= customDistRight)
-                                return -depthTravel;
-                            if (customDistBottom <= customDistLeft && customDistBottom <= customDistRight)
-                                return depthTravel;
-                            return depthTravel * 0.45;
-                        default:
-                            return -depthTravel;
-                        }
-                    }
-                    return root.animationOffset;
                 }
+                if (depthEffect) {
+                    switch (root.positioning) {
+                    case "top-right":
+                        return 0;
+                    case "custom":
+                        if (customDistLeft <= customDistRight && customDistLeft <= customDistTop && customDistLeft <= customDistBottom)
+                            return -depthTravel;
+                        if (customDistRight <= customDistTop && customDistRight <= customDistBottom)
+                            return depthTravel;
+                        return 0;
+                    default:
+                        return 0;
+                    }
+                }
+                return 0;
+            }
+            readonly property real offsetY: {
+                if (root.frameOwnsConnectedChrome) {
+                    switch (root.resolvedConnectedBarSide) {
+                    case "top":
+                        return -connectedEmergenceTravelY;
+                    case "bottom":
+                        return connectedEmergenceTravelY;
+                    }
+                    return 0;
+                }
+                if (slide && !directionalEffect && !depthEffect)
+                    return -30;
+                if (directionalEffect) {
+                    switch (root.positioning) {
+                    case "top-right":
+                        return -Math.max(directionalTravel * 0.65, 96);
+                    case "custom":
+                        if (customDistTop <= customDistBottom && customDistTop <= customDistLeft && customDistTop <= customDistRight)
+                            return -directionalTravel;
+                        if (customDistBottom <= customDistLeft && customDistBottom <= customDistRight)
+                            return directionalTravel;
+                        return 0;
+                    default:
+                        // Default to sliding down from top when centered
+                        return -Math.max(directionalTravel, root.screenHeight * 0.24);
+                    }
+                }
+                if (depthEffect) {
+                    switch (root.positioning) {
+                    case "top-right":
+                        return -depthTravel * 0.75;
+                    case "custom":
+                        if (customDistTop <= customDistBottom && customDistTop <= customDistLeft && customDistTop <= customDistRight)
+                            return -depthTravel;
+                        if (customDistBottom <= customDistLeft && customDistBottom <= customDistRight)
+                            return depthTravel;
+                        return depthTravel * 0.45;
+                    default:
+                        return -depthTravel;
+                    }
+                }
+                return root.animationOffset;
+            }
 
-                readonly property real computedScaleCollapsed: root.animationScaleCollapsed
+            readonly property real computedScaleCollapsed: root.animationScaleCollapsed
 
-                QtObject {
-                    id: morph
-                    property real openProgress: root.shouldBeVisible ? 1 : 0
-                    Behavior on openProgress {
-                        enabled: root.animationsEnabled
+            // openProgress: 0 = closed (at frozenMotionOffset, scaleCollapsed), 1 = open (at 0, scale 1).
+            QtObject {
+                id: morph
+                property real openProgress: root.shouldBeVisible ? 1 : 0
+                Behavior on openProgress {
+                    enabled: root.animationsEnabled
+                    NumberAnimation {
+                        duration: Theme.variantDuration(root.animationDuration, root.shouldBeVisible)
+                        easing.type: Easing.BezierSpline
+                        easing.bezierCurve: root.shouldBeVisible ? root.animationEnterCurve : root.animationExitCurve
+                    }
+                }
+            }
+
+            readonly property real animX: root.frozenMotionOffsetX * (1 - morph.openProgress)
+            readonly property real animY: root.frozenMotionOffsetY * (1 - morph.openProgress)
+            readonly property real scaleValue: computedScaleCollapsed + (1.0 - computedScaleCollapsed) * morph.openProgress
+
+            onAnimXChanged: if (root.frameOwnsConnectedChrome)
+                root._queueAnimSync()
+            onAnimYChanged: if (root.frameOwnsConnectedChrome)
+                root._queueAnimSync()
+
+            Item {
+                id: contentContainer
+                anchors.centerIn: parent
+                width: parent.width
+                height: parent.height
+                clip: false
+
+                Item {
+                    id: animatedContent
+                    anchors.fill: parent
+                    clip: false
+
+                    property real publishedOpacity: (Theme.isDirectionalEffect && !Theme.isConnectedEffect) ? 1 : (root.shouldBeVisible ? 1 : 0)
+
+                    opacity: (Theme.isDirectionalEffect && !Theme.isConnectedEffect) ? 1 : (root.shouldBeVisible ? 1 : 0)
+                    scale: modalContainer.scaleValue
+                    transformOrigin: Item.Center
+
+                    Behavior on opacity {
+                        enabled: root.animationsEnabled && (!Theme.isDirectionalEffect || Theme.isConnectedEffect)
                         NumberAnimation {
-                            duration: Theme.variantDuration(root.animationDuration, root.shouldBeVisible)
+                            duration: Math.round(Theme.variantDuration(animationDuration, root.shouldBeVisible) * Theme.variantOpacityDurationScale)
                             easing.type: Easing.BezierSpline
                             easing.bezierCurve: root.shouldBeVisible ? root.animationEnterCurve : root.animationExitCurve
                         }
                     }
-                }
 
-                readonly property real animX: root.frozenMotionOffsetX * (1 - morph.openProgress)
-                readonly property real animY: root.frozenMotionOffsetY * (1 - morph.openProgress)
-                readonly property real scaleValue: computedScaleCollapsed + (1.0 - computedScaleCollapsed) * morph.openProgress
+                    Behavior on publishedOpacity {
+                        enabled: root.animationsEnabled && (!Theme.isDirectionalEffect || Theme.isConnectedEffect)
+                        NumberAnimation {
+                            duration: Math.round(Theme.variantDuration(animationDuration, root.shouldBeVisible) * Theme.variantOpacityDurationScale)
+                            easing.type: Easing.BezierSpline
+                            easing.bezierCurve: root.shouldBeVisible ? root.animationEnterCurve : root.animationExitCurve
+                        }
+                    }
 
-                onAnimXChanged: if (root.frameOwnsConnectedChrome)
-                    root._queueAnimSync()
-                onAnimYChanged: if (root.frameOwnsConnectedChrome)
-                    root._queueAnimSync()
-
-                Item {
-                    id: contentContainer
-                    anchors.centerIn: parent
-                    width: parent.width
-                    height: parent.height
-                    clip: false
-
-                    Item {
-                        id: animatedContent
+                    ElevationShadow {
+                        id: modalShadowLayer
                         anchors.fill: parent
+                        level: root.shadowLevel
+                        fallbackOffset: root.shadowFallbackOffset
+                        targetRadius: root.effectiveCornerRadius
+                        targetColor: root.frameOwnsConnectedChrome ? "transparent" : root.effectiveBackgroundColor
+                        borderColor: root.frameOwnsConnectedChrome ? "transparent" : root.effectiveBorderColor
+                        borderWidth: root.frameOwnsConnectedChrome ? 0 : root.effectiveBorderWidth
+                        shadowEnabled: !root.frameOwnsConnectedChrome && root.enableShadow && Theme.elevationEnabled && SettingsData.modalElevationEnabled && Quickshell.env("DMS_DISABLE_LAYER") !== "true" && Quickshell.env("DMS_DISABLE_LAYER") !== "1"
+                    }
+
+                    Rectangle {
+                        anchors.fill: parent
+                        radius: root.effectiveCornerRadius
+                        color: "transparent"
+                        border.color: (root.connectedSurfaceOverride || root.frameOwnsConnectedChrome) ? "transparent" : BlurService.borderColor
+                        border.width: (root.connectedSurfaceOverride || root.frameOwnsConnectedChrome) ? 0 : BlurService.borderWidth
+                        z: 100
+                    }
+
+                    FocusScope {
+                        anchors.fill: parent
+                        focus: root.shouldBeVisible
                         clip: false
 
-                        property real publishedOpacity: (Theme.isDirectionalEffect && !Theme.isConnectedEffect) ? 1 : (root.shouldBeVisible ? 1 : 0)
-
-                        opacity: (Theme.isDirectionalEffect && !Theme.isConnectedEffect) ? 1 : (root.shouldBeVisible ? 1 : 0)
-                        scale: modalContainer.scaleValue
-                        transformOrigin: Item.Center
-
-                        Behavior on opacity {
-                            enabled: root.animationsEnabled && (!Theme.isDirectionalEffect || Theme.isConnectedEffect)
-                            NumberAnimation {
-                                duration: Math.round(Theme.variantDuration(animationDuration, root.shouldBeVisible) * Theme.variantOpacityDurationScale)
-                                easing.type: Easing.BezierSpline
-                                easing.bezierCurve: root.shouldBeVisible ? root.animationEnterCurve : root.animationExitCurve
-                            }
-                        }
-
-                        Behavior on publishedOpacity {
-                            enabled: root.animationsEnabled && (!Theme.isDirectionalEffect || Theme.isConnectedEffect)
-                            NumberAnimation {
-                                duration: Math.round(Theme.variantDuration(animationDuration, root.shouldBeVisible) * Theme.variantOpacityDurationScale)
-                                easing.type: Easing.BezierSpline
-                                easing.bezierCurve: root.shouldBeVisible ? root.animationEnterCurve : root.animationExitCurve
-                            }
-                        }
-
-                        ElevationShadow {
-                            id: modalShadowLayer
+                        Item {
+                            id: directContentWrapper
                             anchors.fill: parent
-                            level: root.shadowLevel
-                            fallbackOffset: root.shadowFallbackOffset
-                            targetRadius: root.effectiveCornerRadius
-                            targetColor: root.frameOwnsConnectedChrome ? "transparent" : root.effectiveBackgroundColor
-                            borderColor: root.frameOwnsConnectedChrome ? "transparent" : root.effectiveBorderColor
-                            borderWidth: root.frameOwnsConnectedChrome ? 0 : root.effectiveBorderWidth
-                            shadowEnabled: !root.frameOwnsConnectedChrome && root.enableShadow && Theme.elevationEnabled && SettingsData.modalElevationEnabled && Quickshell.env("DMS_DISABLE_LAYER") !== "true" && Quickshell.env("DMS_DISABLE_LAYER") !== "1"
-                        }
-
-                        Rectangle {
-                            anchors.fill: parent
-                            radius: root.effectiveCornerRadius
-                            color: "transparent"
-                            border.color: (root.connectedSurfaceOverride || root.frameOwnsConnectedChrome) ? "transparent" : BlurService.borderColor
-                            border.width: (root.connectedSurfaceOverride || root.frameOwnsConnectedChrome) ? 0 : BlurService.borderWidth
-                            z: 100
-                        }
-
-                        FocusScope {
-                            anchors.fill: parent
-                            focus: root.shouldBeVisible
+                            visible: root.directContent !== null
+                            focus: true
                             clip: false
 
-                            Item {
-                                id: directContentWrapper
-                                anchors.fill: parent
-                                visible: root.directContent !== null
-                                focus: true
-                                clip: false
+                            Component.onCompleted: {
+                                if (root.directContent) {
+                                    root.directContent.parent = directContentWrapper;
+                                    root.directContent.anchors.fill = directContentWrapper;
+                                    Qt.callLater(() => root.directContent.forceActiveFocus());
+                                }
+                            }
 
-                                Component.onCompleted: {
+                            Connections {
+                                target: root
+                                function onDirectContentChanged() {
                                     if (root.directContent) {
                                         root.directContent.parent = directContentWrapper;
                                         root.directContent.anchors.fill = directContentWrapper;
                                         Qt.callLater(() => root.directContent.forceActiveFocus());
                                     }
                                 }
-
-                                Connections {
-                                    target: root
-                                    function onDirectContentChanged() {
-                                        if (root.directContent) {
-                                            root.directContent.parent = directContentWrapper;
-                                            root.directContent.anchors.fill = directContentWrapper;
-                                            Qt.callLater(() => root.directContent.forceActiveFocus());
-                                        }
-                                    }
-                                }
                             }
+                        }
 
-                            Loader {
-                                id: contentLoader
-                                anchors.fill: parent
-                                active: root.directContent === null && (root.keepContentLoaded || root.shouldBeVisible || contentWindow.visible)
-                                asynchronous: false
-                                focus: true
-                                clip: false
-                                visible: root.directContent === null
+                        Loader {
+                            id: contentLoader
+                            anchors.fill: parent
+                            active: root.directContent === null && (root.keepContentLoaded || root.shouldBeVisible || contentWindow.visible)
+                            asynchronous: false
+                            focus: true
+                            clip: false
+                            visible: root.directContent === null
 
-                                onLoaded: {
-                                    if (item) {
-                                        Qt.callLater(() => item.forceActiveFocus());
-                                    }
+                            onLoaded: {
+                                if (item) {
+                                    Qt.callLater(() => item.forceActiveFocus());
                                 }
                             }
                         }

quickshell/Modals/Common/DankModalStandalone.qml

@@ -205,7 +205,6 @@ Item {
         id: clickCatcher
         visible: false
         color: "transparent"
-        updatesEnabled: false
 
         WlrLayershell.namespace: root.layerNamespace + ":clickcatcher"
         WlrLayershell.layer: WlrLayershell.Top

quickshell/Modals/DankLauncherV2/DankLauncherV2ModalConnected.qml

@@ -30,6 +30,7 @@ Item {
     property string _pendingMode: ""
     readonly property bool unloadContentOnClose: SettingsData.dankLauncherV2UnloadOnClose
 
+    // Animation state — matches DankPopout/DankModal pattern
     property bool animationsEnabled: true
     property bool _motionActive: false
     property real _frozenMotionX: 0
@@ -107,6 +108,8 @@ Item {
         return SettingsData.frameEdgeInsetForSide(effectiveScreen, side);
     }
 
+    // frameEdgeInsetForSide is the full inset; do not add frameBarSize.
+    // Positions the modal flush to the emerge side, centered on the cross axis.
     readonly property var _connectedModalPos: {
         const fallback = {
             "x": (screenWidth - modalWidth) / 2,
@@ -172,6 +175,8 @@ Item {
     readonly property int effectiveBorderWidth: connectedSurfaceOverride ? 0 : borderWidth
     readonly property bool effectiveBlurEnabled: Theme.connectedSurfaceBlurEnabled
 
+    // Shadow padding for the content window (render padding only, no motion padding).
+    // Zeroed when frame owns the chrome and Wayland clips past the bar edge
     readonly property var shadowLevel: Theme.elevationLevel3
     readonly property real shadowFallbackOffset: 6
     readonly property real shadowRenderPadding: (!frameOwnsConnectedChrome && Theme.elevationEnabled && SettingsData.modalElevationEnabled) ? Theme.elevationRenderPadding(shadowLevel, Theme.elevationLightDirection, shadowFallbackOffset, 8, 16) : 0
@@ -198,11 +203,29 @@ Item {
     }
     readonly property real contentSurfaceHeight: launcherArcExtenderActive ? _connectedChromeHeight : alignedHeight
 
-    readonly property real _ccX: _connectedChromeX
-    readonly property real _ccY: _connectedChromeY
+    // For directional/depth: window extends from screen top (content slides within)
+    // For standard: small window tightly around the modal + shadow padding
+    readonly property bool _needsExtendedWindow: (Theme.isDirectionalEffect && !Theme.isConnectedEffect) || Theme.isDepthEffect
+    // Content window geometry
+    readonly property real _cwMarginLeft: Theme.snap(alignedX - shadowPad, dpr)
+    readonly property real _cwMarginTop: launcherArcExtenderActive ? _connectedChromeY : (_needsExtendedWindow ? 0 : Theme.snap(alignedY - shadowPad, dpr))
+    readonly property real _cwWidth: alignedWidth + shadowPad * 2
+    readonly property real _cwHeight: {
+        if (launcherArcExtenderActive)
+            return _connectedChromeHeight;
+        if (Theme.isDirectionalEffect && !Theme.isConnectedEffect)
+            return screenHeight + shadowPad;
+        if (Theme.isDepthEffect)
+            return alignedY + alignedHeight + shadowPad;
+        return alignedHeight + shadowPad * 2;
+    }
+    // Where the content container sits inside the content window
+    readonly property real _ccX: shadowPad
+    readonly property real _ccY: launcherArcExtenderActive ? 0 : (_needsExtendedWindow ? alignedY : shadowPad)
 
     signal dialogClosed
 
+    // Coalesce per-channel dirty bits; one ConnectedModeState write per tick.
     Timer {
         id: _syncTimer
         interval: 0
@@ -358,6 +381,8 @@ Item {
             return;
         contentVisible = true;
         spotlightContent.closeTransientUi?.();
+        // NOTE: forceActiveFocus() is deliberately NOT called here.
+        // It is deferred to after animation starts to avoid compositor IPC stalls.
 
         if (spotlightContent.searchField) {
             spotlightContent.searchField.text = query;
@@ -395,29 +420,38 @@ Item {
         isClosing = false;
         openedFromOverview = false;
 
+        // Disable animations so the snap is instant
         animationsEnabled = false;
 
+        // Freeze the collapsed offsets (they depend on height which could change)
         _frozenMotionX = contentContainer ? contentContainer.collapsedMotionX : 0;
         _frozenMotionY = contentContainer ? contentContainer.collapsedMotionY : (Theme.isDirectionalEffect ? Math.max(root.screenHeight - root._ccY + root.shadowPad, Theme.effectAnimOffset * 1.1) : -Theme.effectAnimOffset);
 
         var focusedScreen = CompositorService.getFocusedScreen();
         if (focusedScreen) {
+            backgroundWindow.screen = focusedScreen;
             contentWindow.screen = focusedScreen;
         }
 
+        // _motionActive = false ensures motionX/Y snap to frozen collapsed position
         _motionActive = false;
 
+        // Make windows visible but do NOT request keyboard focus yet
         ModalManager.openModal(modalHandle);
         spotlightOpen = true;
+        backgroundWindow.visible = true;
         contentWindow.visible = true;
 
+        // Load content and initialize (but no forceActiveFocus — that's deferred)
         _ensureContentLoadedAndInitialize(query || "", mode || "");
 
-        // Defer focus until after enter motion starts (avoids compositor IPC stalls).
+        // Frame 1: enable animations and trigger enter motion
         Qt.callLater(() => {
             root.animationsEnabled = true;
             root._motionActive = true;
 
+            // Frame 2: request keyboard focus + activate search field
+            // Double-deferred to avoid compositor IPC competing with animation frames
             Qt.callLater(() => {
                 root.keyboardActive = true;
                 if (root.spotlightContent && root.spotlightContent.searchField)
@@ -440,9 +474,11 @@ Item {
         spotlightContent?.closeTransientUi?.();
         openedFromOverview = false;
         isClosing = true;
+        // For directional effects, defer contentVisible=false so content stays rendered during exit slide
         if (!Theme.isDirectionalEffect)
             contentVisible = false;
 
+        // Trigger exit animation — Behaviors will animate motionX/Y to frozen collapsed position
         _motionActive = false;
 
         keyboardActive = false;
@@ -483,6 +519,7 @@ Item {
             isClosing = false;
             contentVisible = false;
             contentWindow.visible = false;
+            backgroundWindow.visible = false;
             if (root.unloadContentOnClose)
                 launcherContentLoader.active = false;
             dialogClosed();
@@ -551,6 +588,7 @@ Item {
 
             root._releaseModalChrome();
             root._windowEnabled = false;
+            backgroundWindow.screen = newScreen;
             contentWindow.screen = newScreen;
             Qt.callLater(() => {
                 root._windowEnabled = true;
@@ -558,6 +596,73 @@ Item {
         }
     }
 
+    PanelWindow {
+        id: backgroundWindow
+        visible: false
+        color: "transparent"
+
+        readonly property real _topMargin: contentContainer.dockTop ? contentContainer.dockThickness : (typeof SettingsData !== "undefined" && SettingsData.barPosition === 0 ? Theme.px(42, root.dpr) : 0)
+        readonly property real _bottomMargin: contentContainer.dockBottom ? contentContainer.dockThickness : (typeof SettingsData !== "undefined" && SettingsData.barPosition === 1 ? Theme.px(42, root.dpr) : 0)
+        readonly property real _leftMargin: contentContainer.dockLeft ? contentContainer.dockThickness : (typeof SettingsData !== "undefined" && SettingsData.barPosition === 2 ? Theme.px(42, root.dpr) : 0)
+        readonly property real _rightMargin: contentContainer.dockRight ? contentContainer.dockThickness : (typeof SettingsData !== "undefined" && SettingsData.barPosition === 3 ? Theme.px(42, root.dpr) : 0)
+
+        WlrLayershell.namespace: "dms:spotlight:bg"
+        WlrLayershell.layer: root.effectiveLauncherLayer
+        WlrLayershell.exclusiveZone: -1
+        WlrLayershell.keyboardFocus: WlrKeyboardFocus.None
+
+        WlrLayershell.margins {
+            top: backgroundWindow._topMargin
+            bottom: backgroundWindow._bottomMargin
+            left: backgroundWindow._leftMargin
+            right: backgroundWindow._rightMargin
+        }
+
+        anchors {
+            top: true
+            bottom: true
+            left: true
+            right: true
+        }
+
+        mask: Region {
+            item: (spotlightOpen || isClosing) ? bgFullScreenMask : null
+
+            Region {
+                item: bgContentHole
+                intersection: Intersection.Subtract
+            }
+        }
+
+        Item {
+            id: bgFullScreenMask
+            anchors.fill: parent
+        }
+
+        Item {
+            id: bgContentHole
+            visible: false
+            x: root._cwMarginLeft + contentContainer.x - backgroundWindow._leftMargin
+            y: root._cwMarginTop + contentContainer.y - backgroundWindow._topMargin
+            width: root.alignedWidth
+            height: root.contentSurfaceHeight
+        }
+
+        Rectangle {
+            id: backgroundDarken
+            anchors.fill: parent
+            color: "black"
+            opacity: 0
+            visible: false
+        }
+
+        MouseArea {
+            anchors.fill: parent
+            enabled: spotlightOpen
+            onClicked: root.hide()
+        }
+    }
+
     PanelWindow {
         id: contentWindow
         visible: false
@@ -582,26 +687,18 @@ Item {
         anchors {
             left: true
             top: true
-            right: true
-            bottom: true
         }
 
+        WlrLayershell.margins {
+            left: root._cwMarginLeft
+            top: root._cwMarginTop
+        }
+
+        implicitWidth: root._cwWidth
+        implicitHeight: root._cwHeight
+
         mask: Region {
-            item: (root.spotlightOpen || root.isClosing) ? dismissArea : contentInputMask
-
-            Region {
-                item: (root.spotlightOpen || root.isClosing) ? contentInputMask : null
-            }
-        }
-
-        Item {
-            id: dismissArea
-            visible: false
-            anchors.fill: parent
-            anchors.topMargin: contentContainer.dockTop ? contentContainer.dockThickness : (typeof SettingsData !== "undefined" && SettingsData.barPosition === 0 ? Theme.px(42, root.dpr) : 0)
-            anchors.bottomMargin: contentContainer.dockBottom ? contentContainer.dockThickness : (typeof SettingsData !== "undefined" && SettingsData.barPosition === 1 ? Theme.px(42, root.dpr) : 0)
-            anchors.leftMargin: contentContainer.dockLeft ? contentContainer.dockThickness : (typeof SettingsData !== "undefined" && SettingsData.barPosition === 2 ? Theme.px(42, root.dpr) : 0)
-            anchors.rightMargin: contentContainer.dockRight ? contentContainer.dockThickness : (typeof SettingsData !== "undefined" && SettingsData.barPosition === 3 ? Theme.px(42, root.dpr) : 0)
+            item: contentInputMask
         }
 
         Item {
@@ -613,31 +710,16 @@ Item {
             height: root.contentSurfaceHeight
         }
 
-        MouseArea {
-            anchors.fill: dismissArea
-            enabled: root.spotlightOpen
-            z: -2
-            onClicked: root.hide()
-        }
-
         Item {
             id: contentContainer
 
+            // For directional/depth: contentContainer is at alignedY from window top (window starts at screen top)
+            // For standard: contentContainer is at shadowPad from window top (window starts near modal)
             x: root._ccX
             y: root._ccY
             width: root.alignedWidth
             height: root.contentSurfaceHeight
 
-            MouseArea {
-                anchors.fill: parent
-                enabled: root.spotlightOpen
-                hoverEnabled: false
-                acceptedButtons: Qt.AllButtons
-                onPressed: mouse.accepted = true
-                onClicked: mouse.accepted = true
-                z: -1
-            }
-
             readonly property int dockEdge: typeof SettingsData !== "undefined" ? SettingsData.dockPosition : 1
             readonly property bool dockTop: dockEdge === 0
             readonly property bool dockBottom: dockEdge === 1
@@ -692,6 +774,7 @@ Item {
                 return -Math.max((root.shadowPad || 0) + Theme.effectAnimOffset, 40);
             }
 
+            // openProgress: 0 = closed (at frozenMotion, scaleCollapsed), 1 = open (at 0, scale 1).
             QtObject {
                 id: morph
                 property real openProgress: root._motionActive ? 1 : 0
@@ -750,6 +833,7 @@ Item {
                     width: contentContainer.width
                     height: contentContainer.height
 
+                    // Shadow mirrors contentWrapper position/scale/opacity
                     ElevationShadow {
                         id: launcherShadowLayer
                         width: parent.width
@@ -767,6 +851,7 @@ Item {
                         shadowEnabled: !root.frameOwnsConnectedChrome && Theme.elevationEnabled && SettingsData.modalElevationEnabled && Quickshell.env("DMS_DISABLE_LAYER") !== "true" && Quickshell.env("DMS_DISABLE_LAYER") !== "1"
                     }
 
+                    // contentWrapper moves inside static contentContainer — DankPopout pattern
                     Item {
                         id: contentWrapper
                         width: parent.width

quickshell/Modals/DankLauncherV2/DankLauncherV2ModalSpotlight.qml

@@ -84,14 +84,14 @@ Item {
     readonly property real alignedX: Theme.snap(modalX, dpr)
     readonly property real alignedY: Theme.snap(modalY, dpr)
 
-    // Extra headroom above the content for the slide-in animation
+    // Extra headroom above the window for the slide-in animation
     readonly property real _animHeadroom: 16
     readonly property real windowX: Math.max(0, Theme.snap(alignedX - shadowPad, dpr))
     readonly property real windowY: Math.max(0, Theme.snap(alignedY - shadowPad - _animHeadroom, dpr))
     readonly property real contentX: Theme.snap(alignedX - windowX, dpr)
     readonly property real contentY: Theme.snap(alignedY - windowY, dpr)
-    readonly property real _animatedContentH: Theme.snap(_contentImplicitH, dpr)
     readonly property real windowWidth: alignedWidth + contentX + shadowPad
+    readonly property real _animatedContentH: Theme.snap(_contentImplicitH, dpr)
     readonly property real windowHeight: _animatedContentH + contentY + shadowPad + _animHeadroom
 
     readonly property color backgroundColor: Theme.withAlpha(Theme.surfaceContainer, Theme.popupTransparency)
@@ -114,7 +114,6 @@ Item {
         }
     }
     readonly property int borderWidth: SettingsData.dankLauncherV2BorderEnabled ? SettingsData.dankLauncherV2BorderThickness : 0
-    readonly property bool useSingleWindow: CompositorService.isHyprland || useBackgroundDarken
 
     signal dialogClosed
 
@@ -268,9 +267,8 @@ Item {
     PanelWindow {
         id: clickCatcher
         screen: launcherWindow.screen
-        visible: (spotlightOpen || isClosing) && !root.useSingleWindow
+        visible: (spotlightOpen || isClosing) && !root.useBackgroundDarken
         color: "transparent"
-        updatesEnabled: false
 
         WlrLayershell.namespace: "dms:spotlight:clickcatcher"
         WlrLayershell.layer: root.effectiveLauncherLayer
@@ -341,19 +339,19 @@ Item {
         anchors {
             top: true
             left: true
-            right: root.useSingleWindow
-            bottom: root.useSingleWindow
+            right: root.useBackgroundDarken
+            bottom: root.useBackgroundDarken
         }
 
         WlrLayershell.margins {
-            left: root.useSingleWindow ? 0 : root.windowX
-            top: root.useSingleWindow ? 0 : root.windowY
+            left: root.useBackgroundDarken ? 0 : root.windowX
+            top: root.useBackgroundDarken ? 0 : root.windowY
             right: 0
             bottom: 0
         }
 
-        implicitWidth: root.useSingleWindow ? 0 : root.windowWidth
-        implicitHeight: root.useSingleWindow ? 0 : root.windowHeight
+        implicitWidth: root.useBackgroundDarken ? 0 : root.windowWidth
+        implicitHeight: root.useBackgroundDarken ? 0 : root.windowHeight
 
         mask: Region {
             item: inputMask
@@ -363,15 +361,15 @@ Item {
             id: inputMask
             visible: false
             color: "transparent"
-            x: root.useSingleWindow ? 0 : modalContainer.x
-            y: root.useSingleWindow ? 0 : modalContainer.y + modalContainer.slideOffset
-            width: root.useSingleWindow ? launcherWindow.width : root.alignedWidth
-            height: root.useSingleWindow ? launcherWindow.height : root._contentImplicitH
+            x: root.useBackgroundDarken ? 0 : modalContainer.x
+            y: root.useBackgroundDarken ? 0 : modalContainer.y + modalContainer.slideOffset
+            width: root.useBackgroundDarken ? launcherWindow.width : root.alignedWidth
+            height: root.useBackgroundDarken ? launcherWindow.height : root._contentImplicitH
         }
 
         MouseArea {
             anchors.fill: parent
-            enabled: root.useSingleWindow && spotlightOpen
+            enabled: root.useBackgroundDarken && spotlightOpen
             z: -2
             onClicked: root.hide()
         }
@@ -395,23 +393,13 @@ Item {
 
         Item {
             id: modalContainer
-            x: root.useSingleWindow ? root.alignedX : root.contentX
-            y: root.useSingleWindow ? root.alignedY : root.contentY
+            x: root.useBackgroundDarken ? root.alignedX : root.contentX
+            y: root.useBackgroundDarken ? root.alignedY : root.contentY
             width: root.alignedWidth
             height: root._animatedContentH
             visible: _renderActive
             z: 0
 
-            MouseArea {
-                anchors.fill: parent
-                enabled: spotlightOpen
-                hoverEnabled: false
-                acceptedButtons: Qt.AllButtons
-                onPressed: mouse.accepted = true
-                onClicked: mouse.accepted = true
-                z: -1
-            }
-
             property bool _renderActive: contentVisible
             property real slideOffset: contentVisible ? 0 : -root._animHeadroom
 

quickshell/Modals/DankLauncherV2/DankLauncherV2ModalStandalone.qml

@@ -80,7 +80,6 @@ Item {
 
     readonly property color backgroundColor: Theme.withAlpha(Theme.surfaceContainer, Theme.popupTransparency)
     readonly property bool useBackgroundDarken: !SettingsData.frameEnabled && SettingsData.modalDarkenBackground
-    readonly property bool useSingleWindow: CompositorService.isHyprland || useBackgroundDarken
     readonly property bool usesOverlayLayer: useBackgroundDarken || SettingsData.launcherUseOverlayLayer || triggerUsesOverlayLayer
     readonly property var effectiveLauncherLayer: LayerShell.fromEnv("DMS_MODAL_LAYER", root.usesOverlayLayer ? WlrLayer.Overlay : WlrLayer.Top, {
         "allow": ["top", "overlay"],
@@ -304,9 +303,8 @@ Item {
     PanelWindow {
         id: clickCatcher
         screen: launcherWindow.screen
-        visible: (spotlightOpen || isClosing) && !root.useSingleWindow
+        visible: (spotlightOpen || isClosing) && !root.useBackgroundDarken
         color: "transparent"
-        updatesEnabled: false
 
         WlrLayershell.namespace: "dms:spotlight:clickcatcher"
         WlrLayershell.layer: root.effectiveLauncherLayer
@@ -377,19 +375,19 @@ Item {
         anchors {
             top: true
             left: true
-            right: root.useSingleWindow
-            bottom: root.useSingleWindow
+            right: root.useBackgroundDarken
+            bottom: root.useBackgroundDarken
         }
 
         WlrLayershell.margins {
-            left: root.useSingleWindow ? 0 : root.windowX
-            top: root.useSingleWindow ? 0 : root.windowY
+            left: root.useBackgroundDarken ? 0 : root.windowX
+            top: root.useBackgroundDarken ? 0 : root.windowY
             right: 0
             bottom: 0
         }
 
-        implicitWidth: root.useSingleWindow ? 0 : root.windowWidth
-        implicitHeight: root.useSingleWindow ? 0 : root.windowHeight
+        implicitWidth: root.useBackgroundDarken ? 0 : root.windowWidth
+        implicitHeight: root.useBackgroundDarken ? 0 : root.windowHeight
 
         mask: Region {
             item: launcherInputMask
@@ -399,15 +397,15 @@ Item {
             id: launcherInputMask
             visible: false
             color: "transparent"
-            x: root.useSingleWindow ? 0 : modalContainer.x
-            y: root.useSingleWindow ? 0 : modalContainer.y
-            width: root.useSingleWindow ? launcherWindow.width : modalContainer.width
-            height: root.useSingleWindow ? launcherWindow.height : modalContainer.height
+            x: root.useBackgroundDarken ? 0 : modalContainer.x
+            y: root.useBackgroundDarken ? 0 : modalContainer.y
+            width: root.useBackgroundDarken ? launcherWindow.width : modalContainer.width
+            height: root.useBackgroundDarken ? launcherWindow.height : modalContainer.height
         }
 
         MouseArea {
             anchors.fill: parent
-            enabled: root.useSingleWindow && spotlightOpen
+            enabled: root.useBackgroundDarken && spotlightOpen
             z: -2
             onClicked: root.hide()
         }
@@ -431,23 +429,13 @@ Item {
 
         Item {
             id: modalContainer
-            x: root.useSingleWindow ? root.alignedX : root.contentX
-            y: root.useSingleWindow ? root.alignedY : root.contentY
+            x: root.useBackgroundDarken ? root.alignedX : root.contentX
+            y: root.useBackgroundDarken ? root.alignedY : root.contentY
             width: root.alignedWidth
             height: root.alignedHeight
             visible: _renderActive
             z: 0
 
-            MouseArea {
-                anchors.fill: parent
-                enabled: spotlightOpen
-                hoverEnabled: false
-                acceptedButtons: Qt.AllButtons
-                onPressed: mouse.accepted = true
-                onClicked: mouse.accepted = true
-                z: -1
-            }
-
             property bool _renderActive: contentVisible
             property real publishedScale: contentVisible ? 1 : 0.96
             property real publishedOpacity: contentVisible ? 1 : 0

quickshell/Modals/FileBrowser/FileBrowserContent.qml

@@ -201,21 +201,6 @@ FocusScope {
         keyboardSelectionRequested = true;
     }
 
-    function activateFile(path, name, isDir) {
-        if (isDir) {
-            navigateTo(path);
-            return;
-        }
-        if (saveMode) {
-            saveRow.fileName = name;
-            pendingFilePath = path;
-            showOverwriteConfirmation = true;
-        } else {
-            fileSelected(path);
-            closeRequested();
-        }
-    }
-
     function handleSaveFile(filePath) {
         var normalizedPath = filePath;
         if (!normalizedPath.startsWith("file://")) {
@@ -667,7 +652,6 @@ FocusScope {
 
             Row {
                 anchors.fill: parent
-                anchors.bottomMargin: root.saveMode ? 40 + Theme.spacingL * 2 : 0
                 spacing: 0
 
                 Row {
@@ -772,7 +756,12 @@ FocusScope {
                                 onItemClicked: (index, path, name, isDir) => {
                                     selectedIndex = index;
                                     setSelectedFileData(path, name, isDir);
-                                    root.activateFile(path, name, isDir);
+                                    if (isDir) {
+                                        navigateTo(path);
+                                    } else {
+                                        fileSelected(path);
+                                        root.closeRequested();
+                                    }
                                 }
                                 onItemSelected: (index, path, name, isDir) => {
                                     setSelectedFileData(path, name, isDir);
@@ -787,7 +776,12 @@ FocusScope {
                                             root.keyboardSelectionRequested = false;
                                             selectedIndex = index;
                                             setSelectedFileData(filePath, fileName, fileIsDir);
-                                            root.activateFile(filePath, fileName, fileIsDir);
+                                            if (fileIsDir) {
+                                                navigateTo(filePath);
+                                            } else {
+                                                fileSelected(filePath);
+                                                root.closeRequested();
+                                            }
                                         }
                                     }
 
@@ -823,7 +817,12 @@ FocusScope {
                                 onItemClicked: (index, path, name, isDir) => {
                                     selectedIndex = index;
                                     setSelectedFileData(path, name, isDir);
-                                    root.activateFile(path, name, isDir);
+                                    if (isDir) {
+                                        navigateTo(path);
+                                    } else {
+                                        fileSelected(path);
+                                        root.closeRequested();
+                                    }
                                 }
                                 onItemSelected: (index, path, name, isDir) => {
                                     setSelectedFileData(path, name, isDir);
@@ -838,7 +837,12 @@ FocusScope {
                                             root.keyboardSelectionRequested = false;
                                             selectedIndex = index;
                                             setSelectedFileData(filePath, fileName, fileIsDir);
-                                            root.activateFile(filePath, fileName, fileIsDir);
+                                            if (fileIsDir) {
+                                                navigateTo(filePath);
+                                            } else {
+                                                fileSelected(filePath);
+                                                root.closeRequested();
+                                            }
                                         }
                                     }
 
@@ -851,7 +855,6 @@ FocusScope {
             }
 
             FileBrowserSaveRow {
-                id: saveRow
                 anchors.bottom: parent.bottom
                 anchors.left: parent.left
                 anchors.right: parent.right
@@ -910,21 +913,21 @@ FocusScope {
                 }
             }
         }
-    }
 
-    FileBrowserOverwriteDialog {
-        anchors.fill: parent
-        showDialog: showOverwriteConfirmation
-        pendingFilePath: root.pendingFilePath
-        onConfirmed: filePath => {
-            showOverwriteConfirmation = false;
-            fileSelected(filePath);
-            pendingFilePath = "";
-            Qt.callLater(() => root.closeRequested());
-        }
-        onCancelled: {
-            showOverwriteConfirmation = false;
-            pendingFilePath = "";
+        FileBrowserOverwriteDialog {
+            anchors.fill: parent
+            showDialog: showOverwriteConfirmation
+            pendingFilePath: root.pendingFilePath
+            onConfirmed: filePath => {
+                showOverwriteConfirmation = false;
+                fileSelected(filePath);
+                pendingFilePath = "";
+                Qt.callLater(() => root.closeRequested());
+            }
+            onCancelled: {
+                showOverwriteConfirmation = false;
+                pendingFilePath = "";
+            }
         }
     }
 

quickshell/Modals/FileBrowser/FileBrowserOverwriteDialog.qml

@@ -74,7 +74,7 @@ Item {
                     width: 80
                     height: 36
                     radius: Theme.cornerRadius
-                    color: cancelArea.containsMouse ? Qt.lighter(Theme.surfaceVariant, 1.2) : Theme.surfaceVariant
+                    color: cancelArea.containsMouse ? Theme.surfaceVariantHover : Theme.surfaceVariant
                     border.color: Theme.outline
                     border.width: 1
 

quickshell/Modals/FileBrowser/FileBrowserSaveRow.qml

@@ -8,7 +8,6 @@ Row {
     property bool saveMode: false
     property string defaultFileName: ""
     property string currentPath: ""
-    property alias fileName: fileNameInput.text
 
     signal saveRequested(string filePath)
 

quickshell/Modals/Greeter/GreeterCompletePage.qml

@@ -320,6 +320,8 @@ Item {
                                     url = "https://danklinux.com/docs/dankmaterialshell/compositors#dms-keybindings";
                                 else if (CompositorService.isHyprland)
                                     url = "https://danklinux.com/docs/dankmaterialshell/compositors#dms-keybindings-1";
+                                else if (CompositorService.isDwl)
+                                    url = "https://danklinux.com/docs/dankmaterialshell/compositors#dms-keybindings-2";
                                 else if (CompositorService.isMango)
                                     url = "https://danklinux.com/docs/dankmaterialshell/compositors#dms-keybindings-2";
                                 Qt.openUrlExternally(url);

quickshell/Modals/Greeter/GreeterWelcomePage.qml

@@ -130,7 +130,7 @@ Item {
                     title: I18n.tr("Multi-Monitor", "greeter feature card title")
                     description: I18n.tr("Per-screen config", "greeter feature card description")
                     onClicked: {
-                        const hasDisplayConfig = CompositorService.isNiri || CompositorService.isHyprland || CompositorService.isMango;
+                        const hasDisplayConfig = CompositorService.isNiri || CompositorService.isHyprland || CompositorService.isDwl || CompositorService.isMango;
                         PopoutService.openSettingsWithTab(hasDisplayConfig ? "display_config" : "display_widgets");
                     }
                 }

quickshell/Modals/KeybindsContent.qml

@@ -1,336 +0,0 @@
-import QtQml
-import QtQuick
-import QtQuick.Layouts
-import qs.Common
-import qs.Services
-import qs.Widgets
-
-FocusScope {
-    id: content
-
-    property real scrollStep: 60
-    property var activeFlickable: mainFlickable
-    property bool showFloatingToggle: true
-    property bool floating: false
-    property alias searchField: searchField
-
-    signal closeRequested
-    signal floatingToggleRequested
-
-    function scrollDown() {
-        if (!activeFlickable)
-            return;
-        let newY = activeFlickable.contentY + scrollStep;
-        newY = Math.min(newY, activeFlickable.contentHeight - activeFlickable.height);
-        activeFlickable.contentY = newY;
-    }
-
-    function scrollUp() {
-        if (!activeFlickable)
-            return;
-        let newY = activeFlickable.contentY - scrollStep;
-        newY = Math.max(0, newY);
-        activeFlickable.contentY = newY;
-    }
-
-    Keys.onPressed: event => {
-        switch (event.key) {
-        case Qt.Key_J:
-            if (event.modifiers & Qt.ControlModifier) {
-                scrollDown();
-                event.accepted = true;
-            }
-            return;
-        case Qt.Key_K:
-            if (event.modifiers & Qt.ControlModifier) {
-                scrollUp();
-                event.accepted = true;
-            }
-            return;
-        case Qt.Key_Down:
-            scrollDown();
-            event.accepted = true;
-            return;
-        case Qt.Key_Up:
-            scrollUp();
-            event.accepted = true;
-            return;
-        }
-    }
-
-    Column {
-        anchors.fill: parent
-        anchors.margins: Theme.spacingL
-        spacing: Theme.spacingL
-
-        RowLayout {
-            width: parent.width
-            spacing: Theme.spacingM
-
-            StyledText {
-                Layout.alignment: Qt.AlignLeft
-                text: KeybindsService.cheatsheet.title || I18n.tr("Keybinds")
-                font.pixelSize: Theme.fontSizeLarge
-                font.weight: Font.Bold
-                color: Theme.primary
-            }
-
-            Item {
-                Layout.fillWidth: true
-            }
-
-            DankActionButton {
-                visible: content.showFloatingToggle
-                iconName: content.floating ? "close_fullscreen" : "open_in_new"
-                tooltipText: content.floating ? I18n.tr("Dock window") : I18n.tr("Open as window")
-                onClicked: content.floatingToggleRequested()
-            }
-
-            DankTextField {
-                id: searchField
-                Layout.alignment: Qt.AlignRight
-                leftIconName: "search"
-                keyForwardTargets: [content]
-                onTextEdited: searchDebounce.restart()
-                Keys.onEscapePressed: event => {
-                    content.closeRequested();
-                    event.accepted = true;
-                }
-            }
-        }
-
-        Timer {
-            id: searchDebounce
-            interval: 50
-            repeat: false
-            onTriggered: {
-                mainFlickable.categories = mainFlickable.generateCategories(searchField.text);
-            }
-        }
-
-        DankFlickable {
-            id: mainFlickable
-            width: parent.width
-            height: parent.height - parent.spacing - 40
-            contentWidth: rowLayout.implicitWidth
-            contentHeight: rowLayout.implicitHeight
-            clip: true
-
-            property var rawBinds: KeybindsService.cheatsheet.binds || {}
-
-            function generateCategories(query) {
-                const lowerQuery = query ? query.toLowerCase().trim() : "";
-                const lowerQueryWords = query.split(/\s+/);
-                const processed = {};
-
-                for (const cat in rawBinds) {
-                    const binds = rawBinds[cat];
-                    const catLower = cat.toLowerCase();
-                    const subcats = {};
-                    let hasSubcats = false;
-                    for (let i = 0; i < binds.length; i++) {
-                        const bind = binds[i];
-                        const keyLower = (bind.key || "").toLowerCase();
-                        const descLower = (bind.desc || "").toLowerCase();
-                        const actionLower = (bind.action || "").toLowerCase();
-
-                        if (bind.hideOnOverlay)
-                            continue;
-                        let shouldContinue = false;
-                        for (let j = 0; j < lowerQueryWords.length; j++) {
-                            const word = lowerQueryWords[j];
-                            if (!(word.length === 0 || keyLower.includes(word) || descLower.includes(word) || catLower.includes(word) || actionLower.includes(word))) {
-                                shouldContinue = true;
-                                break;
-                            }
-                        }
-                        if (shouldContinue)
-                            continue;
-
-                        if (bind.subcat) {
-                            hasSubcats = true;
-                            if (!subcats[bind.subcat])
-                                subcats[bind.subcat] = [];
-                            subcats[bind.subcat].push(bind);
-                        } else {
-                            if (!subcats["_root"])
-                                subcats["_root"] = [];
-                            subcats["_root"].push(bind);
-                        }
-                    }
-
-                    if (Object.keys(subcats).length === 0)
-                        continue;
-
-                    processed[cat] = {
-                        hasSubcats: hasSubcats,
-                        subcats: subcats,
-                        subcatKeys: Object.keys(subcats)
-                    };
-                }
-
-                return processed;
-            }
-
-            property var categories: generateCategories("")
-
-            function estimateCategoryHeight(catName) {
-                const catData = categories[catName];
-                if (!catData)
-                    return 0;
-                let bindCount = 0;
-                for (const key of catData.subcatKeys) {
-                    bindCount += catData.subcats[key]?.length || 0;
-                    if (key !== "_root")
-                        bindCount += 1;
-                }
-                return 40 + bindCount * 28;
-            }
-
-            property var categoryKeys: Object.keys(categories)
-
-            function distributeCategories(cols) {
-                const columns = [];
-                const heights = [];
-                for (let i = 0; i < cols; i++) {
-                    columns.push([]);
-                    heights.push(0);
-                }
-                const sorted = [...categoryKeys].sort((a, b) => estimateCategoryHeight(b) - estimateCategoryHeight(a));
-                for (const cat of sorted) {
-                    let minIdx = 0;
-                    for (let i = 1; i < cols; i++) {
-                        if (heights[i] < heights[minIdx])
-                            minIdx = i;
-                    }
-                    columns[minIdx].push(cat);
-                    heights[minIdx] += estimateCategoryHeight(cat);
-                }
-                return columns;
-            }
-
-            Row {
-                id: rowLayout
-                width: mainFlickable.width
-                spacing: Theme.spacingM
-
-                property int numColumns: Math.max(1, Math.min(3, Math.floor(width / 350)))
-                property var columnCategories: mainFlickable.distributeCategories(numColumns)
-
-                Repeater {
-                    model: rowLayout.numColumns
-
-                    Column {
-                        id: masonryColumn
-                        width: (rowLayout.width - rowLayout.spacing * (rowLayout.numColumns - 1)) / rowLayout.numColumns
-                        spacing: Theme.spacingXL
-
-                        Repeater {
-                            model: rowLayout.columnCategories[index] || []
-
-                            Column {
-                                id: categoryColumn
-                                width: parent.width
-                                spacing: Theme.spacingXS
-
-                                property string catName: modelData
-                                property var catData: mainFlickable.categories[catName]
-
-                                StyledText {
-                                    text: categoryColumn.catName
-                                    font.pixelSize: Theme.fontSizeMedium
-                                    font.weight: Font.Bold
-                                    color: Theme.primary
-                                }
-
-                                Rectangle {
-                                    width: parent.width
-                                    height: 1
-                                    color: Theme.primary
-                                    opacity: 0.3
-                                }
-
-                                Item {
-                                    width: 1
-                                    height: Theme.spacingXS
-                                }
-
-                                Column {
-                                    width: parent.width
-                                    spacing: Theme.spacingM
-
-                                    Repeater {
-                                        model: categoryColumn.catData?.subcatKeys || []
-
-                                        Column {
-                                            width: parent.width
-                                            spacing: Theme.spacingXS
-
-                                            property string subcatName: modelData
-                                            property var subcatBinds: categoryColumn.catData?.subcats?.[subcatName] || []
-
-                                            StyledText {
-                                                visible: parent.subcatName !== "_root"
-                                                text: parent.subcatName
-                                                font.pixelSize: Theme.fontSizeSmall
-                                                font.weight: Font.DemiBold
-                                                color: Theme.primary
-                                                opacity: 0.7
-                                            }
-
-                                            Column {
-                                                width: parent.width
-                                                spacing: Theme.spacingXS
-
-                                                Repeater {
-                                                    model: parent.parent.subcatBinds
-
-                                                    Item {
-                                                        width: parent.width
-                                                        height: 24
-
-                                                        StyledRect {
-                                                            id: keyBadge
-                                                            width: Math.min(keyText.implicitWidth + 12, 160)
-                                                            height: 22
-                                                            radius: 4
-                                                            anchors.verticalCenter: parent.verticalCenter
-
-                                                            StyledText {
-                                                                id: keyText
-                                                                anchors.centerIn: parent
-                                                                color: Theme.secondary
-                                                                text: (modelData.key || "").replace(/\+/g, " + ")
-                                                                font.pixelSize: Theme.fontSizeSmall
-                                                                font.weight: Font.Medium
-                                                                isMonospace: true
-                                                                elide: Text.ElideRight
-                                                                width: Math.min(implicitWidth, 148)
-                                                            }
-                                                        }
-
-                                                        StyledText {
-                                                            anchors.left: parent.left
-                                                            anchors.leftMargin: 170
-                                                            anchors.right: parent.right
-                                                            anchors.verticalCenter: parent.verticalCenter
-                                                            text: modelData.desc || modelData.action || ""
-                                                            font.pixelSize: Theme.fontSizeSmall
-                                                            opacity: 0.9
-                                                            elide: Text.ElideRight
-                                                            wrapMode: Text.NoWrap
-                                                        }
-                                                    }
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}

quickshell/Modals/KeybindsModal.qml

@@ -1,78 +1,334 @@
+import QtQml
 import QtQuick
+import QtQuick.Layouts
 import qs.Common
-import qs.Modals
+import qs.Modals.Common
 import qs.Services
+import qs.Widgets
 
-Item {
+DankModal {
     id: root
 
-    readonly property bool floating: SettingsData.keybindsFloatingWindow
-    readonly property bool shouldBeVisible: floating ? (windowLoader.item ? windowLoader.item.visible : false) : (overlayLoader.item ? overlayLoader.item.shouldBeVisible : false)
+    layerNamespace: "dms:keybinds"
+    useOverlayLayer: true
+    property real scrollStep: 60
+    property var activeFlickable: null
+    property real _maxW: Math.min(root.screenWidth * 0.92, 1200)
+    property real _maxH: Math.min(root.screenHeight * 0.92, 900)
+    modalWidth: _maxW
+    modalHeight: _maxH
+    onBackgroundClicked: close()
+    onOpened: {
+        Qt.callLater(() => {
+            modalFocusScope.forceActiveFocus();
+            if (contentLoader.item?.searchField)
+                contentLoader.item.searchField.forceActiveFocus();
+        });
+        if (!Object.keys(KeybindsService.cheatsheet).length && KeybindsService.cheatsheetAvailable)
+            KeybindsService.loadCheatsheet();
+    }
 
-    function open() {
-        if (floating) {
-            windowLoader.active = true;
-            windowLoader.item.show();
+    function scrollDown() {
+        if (!root.activeFlickable)
             return;
-        }
-        overlayLoader.active = true;
-        overlayLoader.item.open();
+        let newY = root.activeFlickable.contentY + scrollStep;
+        newY = Math.min(newY, root.activeFlickable.contentHeight - root.activeFlickable.height);
+        root.activeFlickable.contentY = newY;
     }
 
-    function close() {
-        if (windowLoader.item)
-            windowLoader.item.hide();
-        if (overlayLoader.item)
-            overlayLoader.item.close();
-    }
-
-    function toggle() {
-        if (shouldBeVisible)
-            close();
-        else
-            open();
-    }
-
-    function _switchFloating(toFloating) {
-        if (toFloating) {
-            if (overlayLoader.item)
-                overlayLoader.item.close();
-            SettingsData.keybindsFloatingWindow = true;
-            windowLoader.active = true;
-            windowLoader.item.show();
+    function scrollUp() {
+        if (!root.activeFlickable)
             return;
-        }
-        if (windowLoader.item)
-            windowLoader.item.hide();
-        SettingsData.keybindsFloatingWindow = false;
-        overlayLoader.active = true;
-        overlayLoader.item.open();
+        let newY = root.activeFlickable.contentY - root.scrollStep;
+        newY = Math.max(0, newY);
+        root.activeFlickable.contentY = newY;
     }
 
-    Loader {
-        id: overlayLoader
-        active: false
-        asynchronous: false
-
-        sourceComponent: KeybindsModalOverlay {
-            onFloatingToggleRequested: root._switchFloating(true)
-            onDialogClosed: Qt.callLater(() => {
-                if (!shouldBeVisible)
-                    overlayLoader.active = false;
-            })
+    modalFocusScope.Keys.onPressed: event => {
+        if (event.key === Qt.Key_J && event.modifiers & Qt.ControlModifier) {
+            scrollDown();
+            event.accepted = true;
+        } else if (event.key === Qt.Key_K && event.modifiers & Qt.ControlModifier) {
+            scrollUp();
+            event.accepted = true;
+        } else if (event.key === Qt.Key_Down) {
+            scrollDown();
+            event.accepted = true;
+        } else if (event.key === Qt.Key_Up) {
+            scrollUp();
+            event.accepted = true;
         }
     }
 
-    Loader {
-        id: windowLoader
-        active: false
-        asynchronous: false
+    content: Component {
+        Item {
+            anchors.fill: parent
+            property alias searchField: searchField
 
-        sourceComponent: KeybindsModalWindow {
-            onFloatingToggleRequested: root._switchFloating(false)
-            onVisibleChanged: {
-                if (!visible)
-                    Qt.callLater(() => windowLoader.active = false);
+            Column {
+                anchors.fill: parent
+                anchors.margins: Theme.spacingL
+                spacing: Theme.spacingL
+
+                RowLayout {
+                    width: parent.width
+
+                    StyledText {
+                        Layout.alignment: Qt.AlignLeft
+                        text: KeybindsService.cheatsheet.title || I18n.tr("Keybinds")
+                        font.pixelSize: Theme.fontSizeLarge
+                        font.weight: Font.Bold
+                        color: Theme.primary
+                    }
+
+                    DankTextField {
+                        id: searchField
+                        Layout.alignment: Qt.AlignRight
+                        leftIconName: "search"
+                        keyForwardTargets: [root.modalFocusScope]
+                        onTextEdited: searchDebounce.restart()
+                        Keys.onEscapePressed: event => {
+                            root.close();
+                            event.accepted = true;
+                        }
+                    }
+                }
+
+                Timer {
+                    id: searchDebounce
+                    interval: 50
+                    repeat: false
+                    onTriggered: {
+                        mainFlickable.categories = mainFlickable.generateCategories(searchField.text);
+                    }
+                }
+
+                DankFlickable {
+                    id: mainFlickable
+                    width: parent.width
+                    height: parent.height - parent.spacing - 40
+                    contentWidth: rowLayout.implicitWidth
+                    contentHeight: rowLayout.implicitHeight
+                    clip: true
+
+                    Component.onCompleted: root.activeFlickable = mainFlickable
+
+                    property var rawBinds: KeybindsService.cheatsheet.binds || {}
+
+                    function generateCategories(query) {
+                        const lowerQuery = query ? query.toLowerCase().trim() : "";
+                        const lowerQueryWords = query.split(/\s+/);
+                        const processed = {};
+
+                        for (const cat in rawBinds) {
+                            const binds = rawBinds[cat];
+                            const catLower = cat.toLowerCase();
+                            const subcats = {};
+                            let hasSubcats = false;
+                            for (let i = 0; i < binds.length; i++) {
+                                const bind = binds[i];
+                                const keyLower = (bind.key || "").toLowerCase();
+                                const descLower = (bind.desc || "").toLowerCase();
+                                const actionLower = (bind.action || "").toLowerCase();
+
+                                if (bind.hideOnOverlay)
+                                    continue;
+                                let shouldContinue = false;
+                                for (let j = 0; j < lowerQueryWords.length; j++) {
+                                    const word = lowerQueryWords[j];
+                                    if (!(word.length === 0 || keyLower.includes(word) || descLower.includes(word) || catLower.includes(word) || actionLower.includes(word))) {
+                                        shouldContinue = true;
+                                        break;
+                                    }
+                                }
+                                if (shouldContinue)
+                                    continue;
+
+                                if (bind.subcat) {
+                                    hasSubcats = true;
+                                    if (!subcats[bind.subcat])
+                                        subcats[bind.subcat] = [];
+                                    subcats[bind.subcat].push(bind);
+                                } else {
+                                    if (!subcats["_root"])
+                                        subcats["_root"] = [];
+                                    subcats["_root"].push(bind);
+                                }
+                            }
+
+                            if (Object.keys(subcats).length === 0)
+                                continue;
+
+                            processed[cat] = {
+                                hasSubcats: hasSubcats,
+                                subcats: subcats,
+                                subcatKeys: Object.keys(subcats)
+                            };
+                        }
+
+                        return processed;
+                    }
+
+                    property var categories: generateCategories("")
+
+                    function estimateCategoryHeight(catName) {
+                        const catData = categories[catName];
+                        if (!catData)
+                            return 0;
+                        let bindCount = 0;
+                        for (const key of catData.subcatKeys) {
+                            bindCount += catData.subcats[key]?.length || 0;
+                            if (key !== "_root")
+                                bindCount += 1;
+                        }
+                        return 40 + bindCount * 28;
+                    }
+
+                    property var categoryKeys: Object.keys(categories)
+
+                    function distributeCategories(cols) {
+                        const columns = [];
+                        const heights = [];
+                        for (let i = 0; i < cols; i++) {
+                            columns.push([]);
+                            heights.push(0);
+                        }
+                        const sorted = [...categoryKeys].sort((a, b) => estimateCategoryHeight(b) - estimateCategoryHeight(a));
+                        for (const cat of sorted) {
+                            let minIdx = 0;
+                            for (let i = 1; i < cols; i++) {
+                                if (heights[i] < heights[minIdx])
+                                    minIdx = i;
+                            }
+                            columns[minIdx].push(cat);
+                            heights[minIdx] += estimateCategoryHeight(cat);
+                        }
+                        return columns;
+                    }
+
+                    Row {
+                        id: rowLayout
+                        width: mainFlickable.width
+                        spacing: Theme.spacingM
+
+                        property int numColumns: Math.max(1, Math.min(3, Math.floor(width / 350)))
+                        property var columnCategories: mainFlickable.distributeCategories(numColumns)
+
+                        Repeater {
+                            model: rowLayout.numColumns
+
+                            Column {
+                                id: masonryColumn
+                                width: (rowLayout.width - rowLayout.spacing * (rowLayout.numColumns - 1)) / rowLayout.numColumns
+                                spacing: Theme.spacingXL
+
+                                Repeater {
+                                    model: rowLayout.columnCategories[index] || []
+
+                                    Column {
+                                        id: categoryColumn
+                                        width: parent.width
+                                        spacing: Theme.spacingXS
+
+                                        property string catName: modelData
+                                        property var catData: mainFlickable.categories[catName]
+
+                                        StyledText {
+                                            text: categoryColumn.catName
+                                            font.pixelSize: Theme.fontSizeMedium
+                                            font.weight: Font.Bold
+                                            color: Theme.primary
+                                        }
+
+                                        Rectangle {
+                                            width: parent.width
+                                            height: 1
+                                            color: Theme.primary
+                                            opacity: 0.3
+                                        }
+
+                                        Item {
+                                            width: 1
+                                            height: Theme.spacingXS
+                                        }
+
+                                        Column {
+                                            width: parent.width
+                                            spacing: Theme.spacingM
+
+                                            Repeater {
+                                                model: categoryColumn.catData?.subcatKeys || []
+
+                                                Column {
+                                                    width: parent.width
+                                                    spacing: Theme.spacingXS
+
+                                                    property string subcatName: modelData
+                                                    property var subcatBinds: categoryColumn.catData?.subcats?.[subcatName] || []
+
+                                                    StyledText {
+                                                        visible: parent.subcatName !== "_root"
+                                                        text: parent.subcatName
+                                                        font.pixelSize: Theme.fontSizeSmall
+                                                        font.weight: Font.DemiBold
+                                                        color: Theme.primary
+                                                        opacity: 0.7
+                                                    }
+
+                                                    Column {
+                                                        width: parent.width
+                                                        spacing: Theme.spacingXS
+
+                                                        Repeater {
+                                                            model: parent.parent.subcatBinds
+
+                                                            Item {
+                                                                width: parent.width
+                                                                height: 24
+
+                                                                StyledRect {
+                                                                    id: keyBadge
+                                                                    width: Math.min(keyText.implicitWidth + 12, 160)
+                                                                    height: 22
+                                                                    radius: 4
+                                                                    anchors.verticalCenter: parent.verticalCenter
+
+                                                                    StyledText {
+                                                                        id: keyText
+                                                                        anchors.centerIn: parent
+                                                                        color: Theme.secondary
+                                                                        text: (modelData.key || "").replace(/\+/g, " + ")
+                                                                        font.pixelSize: Theme.fontSizeSmall
+                                                                        font.weight: Font.Medium
+                                                                        isMonospace: true
+                                                                        elide: Text.ElideRight
+                                                                        width: Math.min(implicitWidth, 148)
+                                                                    }
+                                                                }
+
+                                                                StyledText {
+                                                                    anchors.left: parent.left
+                                                                    anchors.leftMargin: 170
+                                                                    anchors.right: parent.right
+                                                                    anchors.verticalCenter: parent.verticalCenter
+                                                                    text: modelData.desc || modelData.action || ""
+                                                                    font.pixelSize: Theme.fontSizeSmall
+                                                                    opacity: 0.9
+                                                                    elide: Text.ElideRight
+                                                                    wrapMode: Text.NoWrap
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
             }
         }
     }

quickshell/Modals/KeybindsModalOverlay.qml

@@ -1,38 +0,0 @@
-import QtQml
-import QtQuick
-import qs.Common
-import qs.Modals
-import qs.Modals.Common
-import qs.Services
-
-DankModal {
-    id: overlay
-
-    signal floatingToggleRequested
-
-    layerNamespace: "dms:keybinds"
-    useOverlayLayer: true
-    property real _maxW: Math.min(overlay.screenWidth * 0.92, 1200)
-    property real _maxH: Math.min(overlay.screenHeight * 0.92, 900)
-    modalWidth: _maxW
-    modalHeight: _maxH
-    onBackgroundClicked: close()
-    onOpened: {
-        Qt.callLater(() => {
-            modalFocusScope.forceActiveFocus();
-            if (contentLoader.item?.searchField)
-                contentLoader.item.searchField.forceActiveFocus();
-        });
-        if (!Object.keys(KeybindsService.cheatsheet).length && KeybindsService.cheatsheetAvailable)
-            KeybindsService.loadCheatsheet();
-    }
-
-    content: Component {
-        KeybindsContent {
-            showFloatingToggle: true
-            floating: false
-            onCloseRequested: overlay.close()
-            onFloatingToggleRequested: overlay.floatingToggleRequested()
-        }
-    }
-}

quickshell/Modals/KeybindsModalWindow.qml

@@ -1,140 +0,0 @@
-import QtQuick
-import Quickshell
-import qs.Common
-import qs.Modals
-import qs.Services
-import qs.Widgets
-
-FloatingWindow {
-    id: win
-
-    property bool disablePopupTransparency: true
-    property alias shouldBeVisible: win.visible
-
-    signal floatingToggleRequested
-
-    function show() {
-        visible = true;
-    }
-
-    function hide() {
-        visible = false;
-    }
-
-    function toggle() {
-        visible = !visible;
-    }
-
-    objectName: "keybindsModalWindow"
-    title: I18n.tr("Keybinds")
-    minimumSize: Qt.size(Math.min(560, Screen.width), Math.min(400, Screen.height))
-    implicitWidth: 1000
-    implicitHeight: screen ? Math.min(820, screen.height - 100) : 820
-    color: Theme.surfaceContainer
-    visible: false
-
-    onVisibleChanged: {
-        if (!visible)
-            return;
-        if (!Object.keys(KeybindsService.cheatsheet).length && KeybindsService.cheatsheetAvailable)
-            KeybindsService.loadCheatsheet();
-        Qt.callLater(() => {
-            keybindsContent.forceActiveFocus();
-            keybindsContent.searchField.forceActiveFocus();
-        });
-    }
-
-    onClosed: win.visible = false
-
-    Column {
-        anchors.fill: parent
-        spacing: 0
-
-        Item {
-            width: parent.width
-            height: 48
-            z: 10
-
-            MouseArea {
-                anchors.fill: parent
-                onPressed: windowControls.tryStartMove()
-                onDoubleClicked: windowControls.tryToggleMaximize()
-            }
-
-            Rectangle {
-                anchors.fill: parent
-                color: Theme.surfaceContainer
-                opacity: 0.5
-            }
-
-            Row {
-                anchors.left: parent.left
-                anchors.leftMargin: Theme.spacingL
-                anchors.verticalCenter: parent.verticalCenter
-                spacing: Theme.spacingM
-
-                DankIcon {
-                    name: "keyboard"
-                    size: Theme.iconSize
-                    color: Theme.primary
-                    anchors.verticalCenter: parent.verticalCenter
-                }
-
-                StyledText {
-                    text: KeybindsService.cheatsheet.title || I18n.tr("Keybinds")
-                    font.pixelSize: Theme.fontSizeXLarge
-                    color: Theme.surfaceText
-                    font.weight: Font.Medium
-                    anchors.verticalCenter: parent.verticalCenter
-                }
-            }
-
-            Row {
-                anchors.right: parent.right
-                anchors.rightMargin: Theme.spacingM
-                anchors.verticalCenter: parent.verticalCenter
-                spacing: Theme.spacingXS
-
-                DankActionButton {
-                    circular: false
-                    iconName: "close_fullscreen"
-                    iconSize: Theme.iconSize - 4
-                    iconColor: Theme.surfaceText
-                    tooltipText: I18n.tr("Dock window")
-                    onClicked: win.floatingToggleRequested()
-                }
-
-                DankActionButton {
-                    visible: windowControls.canMaximize
-                    circular: false
-                    iconName: win.maximized ? "fullscreen_exit" : "fullscreen"
-                    iconSize: Theme.iconSize - 4
-                    iconColor: Theme.surfaceText
-                    onClicked: windowControls.tryToggleMaximize()
-                }
-
-                DankActionButton {
-                    circular: false
-                    iconName: "close"
-                    iconSize: Theme.iconSize - 4
-                    iconColor: Theme.surfaceText
-                    onClicked: win.hide()
-                }
-            }
-        }
-
-        KeybindsContent {
-            id: keybindsContent
-            width: parent.width
-            height: parent.height - 48
-            showFloatingToggle: false
-            floating: true
-            onCloseRequested: win.hide()
-        }
-    }
-
-    FloatingWindowControls {
-        id: windowControls
-        targetWindow: win
-    }
-}

quickshell/Modals/PowerMenuModal.qml

@@ -11,7 +11,6 @@ DankModal {
 
     layerNamespace: "dms:power-menu"
     keepPopoutsOpen: true
-    useOverlayLayer: true
 
     property int selectedIndex: 0
     property int selectedRow: 0

quickshell/Modals/Settings/SettingsContent.qml

@@ -1,7 +1,6 @@
 import QtQuick
 import qs.Common
 import qs.Modules.Settings
-import qs.Services
 import qs.Widgets
 
 FocusScope {
@@ -99,7 +98,7 @@ FocusScope {
             visible: active
             focus: active
 
-            sourceComponent: WorkspacesTab {}
+            sourceComponent: CompositorTab {}
 
             onActiveChanged: {
                 if (active && item)
@@ -107,44 +106,6 @@ FocusScope {
             }
         }
 
-        Loader {
-            id: compositorLayoutLoader
-            anchors.fill: parent
-            active: root.currentIndex === 37
-            visible: active
-            focus: active
-
-            sourceComponent: CompositorLayoutTab {}
-
-            onActiveChanged: {
-                if (active && item)
-                    Qt.callLater(() => item.forceActiveFocus());
-            }
-        }
-
-        Loader {
-            id: windowRulesLoader
-
-            property bool loadedOnce: false
-
-            anchors.fill: parent
-            active: root.currentIndex === 38 || loadedOnce
-            visible: root.currentIndex === 38 && status === Loader.Ready
-            focus: visible
-            asynchronous: true
-
-            sourceComponent: WindowRulesTab {
-                pageActive: root.currentIndex === 38
-            }
-
-            onLoaded: loadedOnce = true
-        }
-
-        DankSpinner {
-            anchors.centerIn: parent
-            visible: root.currentIndex === 38 && windowRulesLoader.status === Loader.Loading
-        }
-
         Loader {
             id: dankBarAppearanceLoader
             anchors.fill: parent
@@ -233,52 +194,7 @@ FocusScope {
             visible: active
             focus: active
 
-            sourceComponent: NetworkStatusTab {}
-
-            onActiveChanged: {
-                if (active && item)
-                    Qt.callLater(() => item.forceActiveFocus());
-            }
-        }
-
-        Loader {
-            id: networkEthernetLoader
-            anchors.fill: parent
-            active: root.currentIndex === 39
-            visible: active
-            focus: active
-
-            sourceComponent: NetworkEthernetTab {}
-
-            onActiveChanged: {
-                if (active && item)
-                    Qt.callLater(() => item.forceActiveFocus());
-            }
-        }
-
-        Loader {
-            id: networkWifiLoader
-            anchors.fill: parent
-            active: root.currentIndex === 40
-            visible: active
-            focus: active
-
-            sourceComponent: NetworkWifiTab {}
-
-            onActiveChanged: {
-                if (active && item)
-                    Qt.callLater(() => item.forceActiveFocus());
-            }
-        }
-
-        Loader {
-            id: networkVpnLoader
-            anchors.fill: parent
-            active: root.currentIndex === 41
-            visible: active
-            focus: active
-
-            sourceComponent: NetworkVpnTab {}
+            sourceComponent: NetworkTab {}
 
             onActiveChanged: {
                 if (active && item)
@@ -472,7 +388,7 @@ FocusScope {
             }
         }
 
-        Loader {
+		Loader {
             id: defaultAppsLoader
             anchors.fill: parent
             active: root.currentIndex === 34
@@ -558,9 +474,12 @@ FocusScope {
             }
         }
 
-        DankSpinner {
+        StyledText {
             anchors.centerIn: parent
             visible: root.currentIndex === 22 && widgetsLoader.status === Loader.Loading
+            text: I18n.tr("Loading...", "loading indicator")
+            color: Theme.surfaceVariantText
+            font.pixelSize: Theme.fontSizeMedium
         }
 
         Loader {

quickshell/Modals/Settings/SettingsModal.qml

@@ -53,21 +53,20 @@ FloatingWindow {
         visible = !visible;
     }
 
-    function setTabIndex(tabIndex: int) {
-        if (tabIndex < 0)
-            return;
-        currentTabIndex = tabIndex;
-        sidebar.autoExpandForTab(tabIndex);
-    }
-
     function showWithTab(tabIndex: int) {
-        setTabIndex(tabIndex);
+        if (tabIndex >= 0) {
+            currentTabIndex = tabIndex;
+            sidebar.autoExpandForTab(tabIndex);
+        }
         visible = true;
     }
 
     function showWithTabName(tabName: string) {
         var idx = sidebar.resolveTabIndex(tabName);
-        setTabIndex(idx);
+        if (idx >= 0) {
+            currentTabIndex = idx;
+            sidebar.autoExpandForTab(idx);
+        }
         visible = true;
     }
 

quickshell/Modals/Settings/SettingsSidebar.qml

@@ -102,13 +102,6 @@ Rectangle {
                     "icon": "volume_up",
                     "tabIndex": 15,
                     "soundsOnly": true
-                },
-                {
-                    "id": "compositor_layout",
-                    "text": CompositorService.isNiri ? "Niri" : (CompositorService.isHyprland ? "Hyprland" : "MangoWC"),
-                    "icon": "layers",
-                    "tabIndex": 37,
-                    "layoutCapable": true
                 }
             ]
         },
@@ -117,30 +110,24 @@ Rectangle {
             "text": I18n.tr("Dank Bar"),
             "icon": "toolbar",
             "children": [
-                {
-                    "id": "dankbar_appearance",
-                    "text": I18n.tr("Appearance"),
-                    "icon": "palette",
-                    "tabIndex": 6
-                },
                 {
                     "id": "dankbar_settings",
                     "text": I18n.tr("Settings"),
                     "icon": "tune",
                     "tabIndex": 3
                 },
+                {
+                    "id": "dankbar_appearance",
+                    "text": I18n.tr("Appearance"),
+                    "icon": "palette",
+                    "tabIndex": 6
+                },
                 {
                     "id": "dankbar_widgets",
                     "text": I18n.tr("Widgets"),
                     "icon": "widgets",
                     "tabIndex": 22
                 },
-                {
-                    "id": "workspaces",
-                    "text": I18n.tr("Workspaces"),
-                    "icon": "view_module",
-                    "tabIndex": 4
-                },
                 {
                     "id": "frame",
                     "text": I18n.tr("Frame"),
@@ -201,6 +188,12 @@ Rectangle {
                 }
             ]
         },
+        {
+            "id": "compositor",
+            "text": I18n.tr("Compositor"),
+            "icon": "layers",
+            "tabIndex": 4
+        },
         {
             "id": "keybinds",
             "text": I18n.tr("Keyboard Shortcuts"),
@@ -238,33 +231,8 @@ Rectangle {
             "id": "network",
             "text": I18n.tr("Network"),
             "icon": "wifi",
-            "dmsOnly": true,
-            "children": [
-                {
-                    "id": "network_status",
-                    "text": I18n.tr("Status"),
-                    "icon": "lan",
-                    "tabIndex": 7
-                },
-                {
-                    "id": "network_ethernet",
-                    "text": I18n.tr("Ethernet"),
-                    "icon": "settings_ethernet",
-                    "tabIndex": 39
-                },
-                {
-                    "id": "network_wifi",
-                    "text": I18n.tr("WiFi"),
-                    "icon": "wifi",
-                    "tabIndex": 40
-                },
-                {
-                    "id": "network_vpn",
-                    "text": I18n.tr("VPN"),
-                    "icon": "vpn_key",
-                    "tabIndex": 41
-                }
-            ]
+            "tabIndex": 7,
+            "dmsOnly": true
         },
         {
             "id": "applications",
@@ -291,13 +259,6 @@ Rectangle {
                     "icon": "line_start",
                     "tabIndex": 36,
                     "autostartOnly": true
-                },
-                {
-                    "id": "window_rules",
-                    "text": I18n.tr("Window Rules"),
-                    "icon": "select_window",
-                    "tabIndex": 38,
-                    "windowRulesCapable": true
                 }
             ]
         },
@@ -411,8 +372,6 @@ Rectangle {
             return false;
         if (item.windowRulesCapable && !CompositorService.isNiri && !CompositorService.isHyprland && !CompositorService.isMango)
             return false;
-        if (item.layoutCapable && !CompositorService.isNiri && !CompositorService.isHyprland && !CompositorService.isMango)
-            return false;
         if (item.niriOnly && !CompositorService.isNiri)
             return false;
         if (item.clipboardOnly && (!DMSService.isConnected || DMSService.apiVersion < 23))
@@ -585,8 +544,8 @@ Rectangle {
             return -1;
 
         var normalized = name.toLowerCase().replace(/[_\-\s]/g, "");
-        if (normalized === "compositor")
-            normalized = "workspaces";
+        if (normalized === "workspaces")
+            normalized = "compositor";
 
         for (var i = 0; i < categoryStructure.length; i++) {
             var cat = categoryStructure[i];

quickshell/Modals/WifiPasswordModal.qml

@@ -1,22 +1,12 @@
 import QtQuick
+import Quickshell
 import qs.Common
-import qs.Modals.Common
 import qs.Services
 import qs.Widgets
 
-DankModal {
+FloatingWindow {
     id: root
 
-    layerNamespace: "dms:wifi-password"
-    keepPopoutsOpen: true
-    allowStacking: true
-    shouldBeVisible: false
-    modalWidth: 420
-    modalHeight: calculatedHeight
-    enableShadow: true
-    onBackgroundClicked: clearAndClose()
-    directContent: contentFocusScope
-
     property bool disablePopupTransparency: true
     property string wifiPasswordSSID: ""
     property string wifiPasswordInput: ""
@@ -112,7 +102,7 @@ DankModal {
         const network = NetworkService.wifiNetworks.find(n => n.ssid === ssid);
         requiresEnterprise = network?.enterprise || false;
 
-        open();
+        visible = true;
         Qt.callLater(focusFirstField);
     }
 
@@ -136,7 +126,7 @@ DankModal {
         secretValues = {};
         requiresEnterprise = false;
 
-        open();
+        visible = true;
         Qt.callLater(focusFirstField);
     }
 
@@ -154,7 +144,6 @@ DankModal {
 
         isVpnPrompt = (connectionType === "vpn" || connectionType === "wireguard");
         wifiPasswordSSID = isVpnPrompt ? connectionName : ssid;
-        savePasswordCheckbox.checked = !isVpnPrompt;
 
         requiresEnterprise = setting === "802-1x";
 
@@ -163,7 +152,7 @@ DankModal {
         wifiAnonymousIdentityInput = "";
         wifiDomainInput = "";
 
-        open();
+        visible = true;
         Qt.callLater(() => {
             if (reason === "wrong-password" && fieldsInfo.length === 0) {
                 passwordInput.text = "";
@@ -173,7 +162,7 @@ DankModal {
     }
 
     function hide() {
-        close();
+        visible = false;
     }
 
     function getFieldLabel(fieldName) {
@@ -253,8 +242,23 @@ DankModal {
         secretValues = {};
     }
 
-    onShouldBeVisibleChanged: {
-        if (shouldBeVisible) {
+    objectName: "wifiPasswordModal"
+    title: {
+        if (promptReason === "pkcs11")
+            return I18n.tr("Smartcard PIN");
+        if (isVpnPrompt)
+            return I18n.tr("VPN Password");
+        if (isHiddenNetwork)
+            return I18n.tr("Hidden Network");
+        return I18n.tr("Wi-Fi Password");
+    }
+    minimumSize: Qt.size(420, calculatedHeight)
+    maximumSize: Qt.size(420, calculatedHeight)
+    color: Theme.surfaceContainer
+    visible: false
+
+    onVisibleChanged: {
+        if (visible) {
             Qt.callLater(focusFirstField);
             return;
         }
@@ -283,7 +287,7 @@ DankModal {
                 return;
             wifiPasswordSSID = NetworkService.connectingSSID;
             wifiPasswordInput = "";
-            open();
+            visible = true;
             NetworkService.passwordDialogShouldReopen = false;
         }
     }
@@ -292,7 +296,7 @@ DankModal {
         id: contentFocusScope
 
         anchors.fill: parent
-        focus: root.shouldBeVisible
+        focus: true
 
         Keys.onEscapePressed: event => {
             clearAndClose();
@@ -314,6 +318,8 @@ DankModal {
                     anchors.right: buttonRow.left
                     anchors.rightMargin: Theme.spacingM
                     height: headerCol.height
+                    onPressed: windowControls.tryStartMove()
+                    onDoubleClicked: windowControls.tryToggleMaximize()
 
                     Column {
                         id: headerCol
@@ -374,6 +380,14 @@ DankModal {
                     anchors.right: parent.right
                     spacing: Theme.spacingXS
 
+                    DankActionButton {
+                        visible: windowControls.canMaximize
+                        iconName: root.maximized ? "fullscreen_exit" : "fullscreen"
+                        iconSize: Theme.iconSize - 4
+                        iconColor: Theme.surfaceText
+                        onClicked: windowControls.tryToggleMaximize()
+                    }
+
                     DankActionButton {
                         iconName: "close"
                         iconSize: Theme.iconSize - 4
@@ -405,7 +419,7 @@ DankModal {
                     textColor: Theme.surfaceText
                     placeholderText: I18n.tr("Network Name (SSID)")
                     backgroundColor: "transparent"
-                    enabled: root.shouldBeVisible
+                    enabled: root.visible
                     keyNavigationTab: passwordInput
                     onAccepted: passwordInput.forceActiveFocus()
                 }
@@ -435,7 +449,7 @@ DankModal {
                         echoMode: modelData.isSecret && !passwordVisible ? TextInput.Password : TextInput.Normal
                         placeholderText: getFieldLabel(modelData.name)
                         backgroundColor: "transparent"
-                        enabled: root.shouldBeVisible
+                        enabled: root.visible
 
                         Keys.onTabPressed: event => {
                             if (index < fieldsInfo.length - 1) {
@@ -505,7 +519,7 @@ DankModal {
                     text: wifiUsernameInput
                     placeholderText: I18n.tr("Username")
                     backgroundColor: "transparent"
-                    enabled: root.shouldBeVisible
+                    enabled: root.visible
                     keyNavigationTab: passwordInput
                     keyNavigationBacktab: domainMatchInput
                     onTextEdited: wifiUsernameInput = text
@@ -538,7 +552,7 @@ DankModal {
                     echoMode: passwordVisible ? TextInput.Normal : TextInput.Password
                     placeholderText: (requiresEnterprise && !isVpnPrompt) ? I18n.tr("Password") : ""
                     backgroundColor: "transparent"
-                    enabled: root.shouldBeVisible
+                    enabled: root.visible
                     keyNavigationTab: (requiresEnterprise && !isVpnPrompt) ? anonInput : null
                     keyNavigationBacktab: (requiresEnterprise && !isVpnPrompt) ? usernameInput : null
                     onTextEdited: wifiPasswordInput = text
@@ -575,7 +589,7 @@ DankModal {
                     text: wifiAnonymousIdentityInput
                     placeholderText: I18n.tr("Anonymous Identity (optional)")
                     backgroundColor: "transparent"
-                    enabled: root.shouldBeVisible
+                    enabled: root.visible
                     keyNavigationTab: domainMatchInput
                     keyNavigationBacktab: passwordInput
                     onTextEdited: wifiAnonymousIdentityInput = text
@@ -606,7 +620,7 @@ DankModal {
                     text: wifiDomainInput
                     placeholderText: I18n.tr("Domain (optional)")
                     backgroundColor: "transparent"
-                    enabled: root.shouldBeVisible
+                    enabled: root.visible
                     keyNavigationTab: usernameInput
                     keyNavigationBacktab: anonInput
                     onTextEdited: wifiDomainInput = text
@@ -743,5 +757,8 @@ DankModal {
         }
     }
 
-    onOpened: Qt.callLater(() => contentFocusScope.forceActiveFocus())
+    FloatingWindowControls {
+        id: windowControls
+        targetWindow: root
+    }
 }

quickshell/Modules/BlurredWallpaperBackground.qml

@@ -7,7 +7,6 @@ import qs.Widgets
 import qs.Services
 
 Variants {
-    readonly property var log: Log.scoped("BlurredWallpaperBackground")
     model: {
         if (SessionData.isGreeterMode) {
             return Quickshell.screens;
@@ -33,8 +32,6 @@ Variants {
 
         color: "transparent"
 
-        updatesEnabled: root.renderActive || root._settleFrames > 0
-
         mask: Region {
             item: Item {}
         }
@@ -88,6 +85,7 @@ Variants {
             }
 
             Component.onCompleted: {
+                blurWallpaperWindow.updatesEnabled = Qt.binding(() => !root.source || root.effectActive || root._renderSettling || currentWallpaper.status === Image.Loading || nextWallpaper.status === Image.Loading);
                 isInitialized = true;
             }
 
@@ -95,67 +93,51 @@ Variants {
             property real transitionProgress: 0
             readonly property bool transitioning: transitionAnimation.running
             property bool effectActive: false
+            property bool _renderSettling: true
             property bool useNextForEffect: false
-            readonly property var backingWindow: Window.window
-            readonly property bool renderActive: !source || effectActive || currentWallpaper.status === Image.Loading || nextWallpaper.status === Image.Loading
-            property int _settleFrames: 3
-
-            function invalidate() {
-                _settleFrames = 3;
-                backingWindow?.update();
-            }
-
-            onRenderActiveChanged: invalidate()
-            onBackingWindowChanged: invalidate()
 
             Connections {
-                target: root.backingWindow
-                function onFrameSwapped() {
-                    if (root._settleFrames > 0)
-                        root._settleFrames--;
-                }
-                function onVisibleChanged() {
-                    root.invalidate();
+                target: currentWallpaper
+                function onStatusChanged() {
+                    if (currentWallpaper.status !== Image.Ready && currentWallpaper.status !== Image.Error)
+                        return;
+                    root._renderSettling = true;
+                    renderSettleTimer.restart();
                 }
+            }
+
+            Connections {
+                target: blurWallpaperWindow
                 function onWidthChanged() {
-                    root.invalidate();
+                    root._renderSettling = true;
+                    renderSettleTimer.restart();
                 }
                 function onHeightChanged() {
-                    root.invalidate();
+                    root._renderSettling = true;
+                    renderSettleTimer.restart();
                 }
             }
 
             Connections {
                 target: Quickshell
                 function onScreensChanged() {
-                    root.invalidate();
+                    root._renderSettling = true;
+                    renderSettleTimer.restart();
                 }
             }
 
             Connections {
                 target: SettingsData
                 function onWallpaperFillModeChanged() {
-                    root.invalidate();
+                    root._renderSettling = true;
+                    renderSettleTimer.restart();
                 }
             }
 
-            Connections {
-                target: IdleService
-                function onIsShellLockedChanged() {
-                    if (IdleService.isShellLocked)
-                        return;
-                    root.invalidate();
-                }
-            }
-
-            function handleTransitionLoadError(failedSource) {
-                log.warn("failed to load candidate wallpaper for", modelData.name + ":", failedSource);
-                transitionDelayTimer.stop();
-                transitionAnimation.stop();
-                root.useNextForEffect = false;
-                root.effectActive = false;
-                root.transitionProgress = 0.0;
-                nextWallpaper.source = "";
+            Timer {
+                id: renderSettleTimer
+                interval: 1000
+                onTriggered: root._renderSettling = false
             }
 
             onSourceChanged: {
@@ -182,6 +164,8 @@ Variants {
                 transitionAnimation.stop();
                 root.transitionProgress = 0.0;
                 root.effectActive = false;
+                root._renderSettling = true;
+                renderSettleTimer.restart();
                 currentWallpaper.source = newSource;
                 nextWallpaper.source = "";
             }
@@ -210,6 +194,8 @@ Variants {
                     transitionAnimation.stop();
                     root.transitionProgress = 0;
                     root.effectActive = false;
+                    root._renderSettling = true;
+                    renderSettleTimer.restart();
                     currentWallpaper.source = nextWallpaper.source;
                     nextWallpaper.source = "";
                 }
@@ -218,6 +204,9 @@ Variants {
                     return;
                 }
 
+                root._renderSettling = true;
+                renderSettleTimer.restart();
+
                 nextWallpaper.source = newPath;
 
                 if (nextWallpaper.status === Image.Ready)
@@ -226,7 +215,7 @@ Variants {
 
             Loader {
                 anchors.fill: parent
-                active: !root.source || root.isColorSource || currentWallpaper.status === Image.Error
+                active: !root.source || root.isColorSource
                 asynchronous: true
 
                 sourceComponent: DankBackdrop {
@@ -249,12 +238,6 @@ Variants {
                 cache: true
                 sourceSize: Qt.size(root.textureWidth, root.textureHeight)
                 fillMode: root.getFillMode(SessionData.isGreeterMode ? GreetdSettings.wallpaperFillMode : SessionData.getMonitorWallpaperFillMode(modelData.name))
-
-                onStatusChanged: {
-                    if (status === Image.Error) {
-                        log.warn("failed to load active wallpaper for", modelData.name + ":", source);
-                    }
-                }
             }
 
             Image {
@@ -270,10 +253,6 @@ Variants {
                 fillMode: root.getFillMode(SessionData.isGreeterMode ? GreetdSettings.wallpaperFillMode : SessionData.getMonitorWallpaperFillMode(modelData.name))
 
                 onStatusChanged: {
-                    if (status === Image.Error) {
-                        root.handleTransitionLoadError(source);
-                        return;
-                    }
                     if (status !== Image.Ready)
                         return;
                     if (!root.transitioning) {
@@ -350,6 +329,8 @@ Variants {
                     root.useNextForEffect = false;
                     nextWallpaper.source = "";
                     root.transitionProgress = 0.0;
+                    root._renderSettling = true;
+                    renderSettleTimer.restart();
                     root.effectActive = false;
                 }
             }

quickshell/Modules/ControlCenter/BuiltinPlugins/TailscaleWidget.qml

@@ -25,14 +25,7 @@ PluginComponent {
     }
     ccWidgetIsActive: TailscaleService.connected
 
-    onCcWidgetToggled: {
-        if (!TailscaleService.available)
-            return;
-        if (TailscaleService.connected)
-            TailscaleService.disconnectTailscale(null);
-        else
-            TailscaleService.connectTailscale(null);
-    }
+    onCcWidgetToggled: {}
 
     ccDetailContent: Component {
         Rectangle {
@@ -95,122 +88,6 @@ PluginComponent {
                         width: parent.width
                         spacing: Theme.spacingS
 
-                        // Connection status + connect/disconnect. Always shown
-                        // (when available) so the connection can be toggled from
-                        // the detail, including while disconnected.
-                        RowLayout {
-                            width: parent.width
-                            spacing: Theme.spacingS
-
-                            Column {
-                                Layout.fillWidth: true
-                                Layout.alignment: Qt.AlignVCenter
-                                spacing: 1
-
-                                StyledText {
-                                    text: TailscaleService.connected ? I18n.tr("Connected", "Tailscale connection status: connected") : I18n.tr("Disconnected", "Tailscale connection status: disconnected")
-                                    font.pixelSize: Theme.fontSizeMedium
-                                    font.weight: Font.Medium
-                                    color: Theme.surfaceText
-                                }
-
-                                StyledText {
-                                    visible: TailscaleService.connected && TailscaleService.tailnetName.length > 0
-                                    text: TailscaleService.tailnetName
-                                    font.pixelSize: Theme.fontSizeSmall
-                                    color: Theme.surfaceVariantText
-                                    width: parent.width
-                                    elide: Text.ElideRight
-                                }
-                            }
-
-                            Rectangle {
-                                id: connButton
-                                Layout.alignment: Qt.AlignVCenter
-                                height: 28
-                                radius: 14
-                                width: connButtonRow.implicitWidth + Theme.spacingM * 2
-
-                                readonly property bool isConnected: TailscaleService.connected
-                                color: isConnected ? (connButtonArea.containsMouse ? Theme.errorHover : Theme.surfaceLight) : (connButtonArea.containsMouse ? Theme.primaryHoverLight : Theme.surfaceLight)
-
-                                Row {
-                                    id: connButtonRow
-                                    anchors.centerIn: parent
-                                    spacing: Theme.spacingXS
-
-                                    DankIcon {
-                                        name: connButton.isConnected ? "link_off" : "link"
-                                        size: Theme.fontSizeSmall
-                                        color: connButton.isConnected ? Theme.surfaceText : Theme.primary
-                                        anchors.verticalCenter: parent.verticalCenter
-                                    }
-
-                                    StyledText {
-                                        text: connButton.isConnected ? I18n.tr("Disconnect", "Tailscale disconnect button") : I18n.tr("Connect", "Tailscale connect button")
-                                        font.pixelSize: Theme.fontSizeSmall
-                                        font.weight: Font.Medium
-                                        color: connButton.isConnected ? Theme.surfaceText : Theme.primary
-                                        anchors.verticalCenter: parent.verticalCenter
-                                    }
-                                }
-
-                                MouseArea {
-                                    id: connButtonArea
-                                    anchors.fill: parent
-                                    hoverEnabled: true
-                                    cursorShape: Qt.PointingHandCursor
-                                    onClicked: {
-                                        if (TailscaleService.connected)
-                                            TailscaleService.disconnectTailscale(null);
-                                        else
-                                            TailscaleService.connectTailscale(null);
-                                    }
-                                }
-                            }
-                        }
-
-                        // Connection controls: exit node picker + LAN access.
-                        // Only meaningful while the backend is connected.
-                        Column {
-                            id: controlsColumn
-                            width: parent.width
-                            spacing: Theme.spacingS
-                            visible: TailscaleService.connected
-
-                            readonly property string noneLabel: I18n.tr("None", "Tailscale exit node: none selected")
-
-                            DankDropdown {
-                                width: parent.width
-                                text: I18n.tr("Exit node", "Tailscale exit node selector label")
-                                currentValue: TailscaleService.currentExitNode ? TailscaleService.currentExitNode.hostname : controlsColumn.noneLabel
-                                options: {
-                                    const opts = [controlsColumn.noneLabel];
-                                    for (const p of TailscaleService.exitNodeOptions)
-                                        opts.push(p.hostname);
-                                    return opts;
-                                }
-                                onValueChanged: value => {
-                                    if (value === controlsColumn.noneLabel) {
-                                        TailscaleService.clearExitNode(null);
-                                        return;
-                                    }
-                                    const peer = TailscaleService.exitNodeOptions.find(p => p.hostname === value);
-                                    if (peer)
-                                        TailscaleService.setExitNode(peer.id, null);
-                                }
-                            }
-
-                            DankToggle {
-                                width: parent.width
-                                text: I18n.tr("Allow LAN access", "Tailscale allow LAN access toggle")
-                                description: I18n.tr("Reach local network devices while using an exit node", "Tailscale allow LAN access description")
-                                visible: TailscaleService.currentExitNode !== null
-                                checked: TailscaleService.exitNodeAllowLanAccess
-                                onToggled: value => TailscaleService.setAllowLanAccess(value, null)
-                            }
-                        }
-
                         // Search bar + refresh button
                         RowLayout {
                             width: parent.width

quickshell/Modules/ControlCenter/Components/HeaderPane.qml

@@ -60,7 +60,7 @@ Rectangle {
             }
 
             Typography {
-                text: DgopService.uptime ? I18n.tr("up", "uptime prefix, e.g. 'up 4h 2m'") + " " + DgopService.uptime.slice(3) : I18n.tr("Unknown")
+                text: DgopService.uptime ? I18n.tr("up") + " " + DgopService.uptime.slice(3) : I18n.tr("Unknown")
                 style: Typography.Style.Caption
                 color: Theme.surfaceVariantText
             }

quickshell/Modules/ControlCenter/ControlCenterPopout.qml

@@ -93,7 +93,7 @@ DankPopout {
     shouldBeVisible: false
 
     property bool credentialsPromptOpen: NetworkService.credentialsRequested
-    property bool wifiPasswordModalOpen: PopoutService.wifiPasswordModal?.shouldBeVisible ?? false
+    property bool wifiPasswordModalOpen: PopoutService.wifiPasswordModal?.visible ?? false
     property bool polkitModalOpen: PopoutService.polkitAuthModal?.visible ?? false
     property bool anyModalOpen: credentialsPromptOpen || wifiPasswordModalOpen || polkitModalOpen || powerMenuOpen
 

quickshell/Modules/ControlCenter/Details/NetworkDetail.qml

@@ -2,7 +2,6 @@ import QtQuick
 import QtQuick.Controls
 import Quickshell
 import qs.Common
-import qs.Modules.Network
 import qs.Services
 import qs.Widgets
 import qs.Modals
@@ -152,7 +151,7 @@ Rectangle {
                 iconColor: Theme.surfaceVariantText
                 onClicked: {
                     PopoutService.closeControlCenter();
-                    PopoutService.openSettingsWithTab(currentPreferenceIndex === 0 ? "network_ethernet" : "network_wifi");
+                    PopoutService.openSettingsWithTab("network");
                 }
             }
         }
@@ -722,7 +721,7 @@ Rectangle {
 
             DankActionButton {
                 id: qrCodeButton
-                visible: modelData.secured && modelData.saved && !(modelData.enterprise || false)
+                visible: modelData.secured && modelData.saved
                 anchors.right: parent.right
                 anchors.rightMargin: optionsButton.width + pinWifiRow.width + 3 * Theme.spacingM + Theme.spacingS
                 anchors.verticalCenter: parent.verticalCenter
@@ -750,9 +749,11 @@ Rectangle {
                         event.accepted = true;
                         return;
                     }
-                    WifiConnectionActions.connectToNetwork(modelData, {
-                        connected: wifiDelegate.isConnected
-                    });
+                    if (modelData.secured && !modelData.saved && (DMSService.apiVersion < 7 || modelData.enterprise)) {
+                        PopoutService.showWifiPasswordModal(modelData.ssid);
+                    } else {
+                        NetworkService.connectToWifi(modelData.ssid);
+                    }
                     event.accepted = true;
                 }
             }
@@ -803,9 +804,15 @@ Rectangle {
             }
 
             onTriggered: {
-                WifiConnectionActions.connectToNetworkFromDetails(networkContextMenu.currentSSID, networkContextMenu.currentSecured, networkContextMenu.currentSaved, networkContextMenu.currentEnterprise, networkContextMenu.currentConnected, {
-                    disconnectWhenConnected: true
-                });
+                if (networkContextMenu.currentConnected) {
+                    NetworkService.disconnectWifi();
+                    return;
+                }
+                if (networkContextMenu.currentSecured && !networkContextMenu.currentSaved && (DMSService.apiVersion < 7 || networkContextMenu.currentEnterprise)) {
+                    PopoutService.showWifiPasswordModal(networkContextMenu.currentSSID);
+                    return;
+                }
+                NetworkService.connectToWifi(networkContextMenu.currentSSID);
             }
         }
 

quickshell/Modules/DankBar/CenterSection.qml

@@ -15,7 +15,6 @@ Item {
     property real barSpacing: 4
     property var barConfig: null
     property var blurBarWindow: null
-    property real sectionAvailablePrimarySize: 0
     property bool overrideAxisLayout: false
     property bool forceVerticalLayout: false
 
@@ -360,7 +359,6 @@ Item {
                 barSpacing: root.barSpacing
                 barConfig: root.barConfig
                 blurBarWindow: root.blurBarWindow
-                sectionAvailablePrimarySize: root.sectionAvailablePrimarySize
                 isFirst: index === 0
                 isLast: index === centerRepeater.count - 1
                 sectionSpacing: parent.itemSpacing

quickshell/Modules/DankBar/DankBar.qml

@@ -108,6 +108,8 @@ Item {
         } else if (CompositorService.isSway || CompositorService.isScroll || CompositorService.isMiracle) {
             const focusedWs = I3.workspaces?.values?.find(ws => ws.focused === true);
             focusedScreenName = focusedWs?.monitor?.name || "";
+        } else if (CompositorService.isDwl && DwlService.activeOutput) {
+            focusedScreenName = DwlService.activeOutput;
         } else if (CompositorService.isMango && MangoService.activeOutput) {
             focusedScreenName = MangoService.activeOutput;
         }
@@ -137,6 +139,8 @@ Item {
         } else if (CompositorService.isSway || CompositorService.isScroll || CompositorService.isMiracle) {
             const focusedWs = I3.workspaces?.values?.find(ws => ws.focused === true);
             focusedScreenName = focusedWs?.monitor?.name || "";
+        } else if (CompositorService.isDwl && DwlService.activeOutput) {
+            focusedScreenName = DwlService.activeOutput;
         } else if (CompositorService.isMango && MangoService.activeOutput) {
             focusedScreenName = MangoService.activeOutput;
         }

quickshell/Modules/DankBar/DankBarContent.qml

@@ -29,6 +29,7 @@ Item {
     readonly property real _frameEdgeFloorInset: (SettingsData.frameEnabled && _usesFrameBarChrome) ? Math.max(0, SettingsData.frameThickness - _edgeBaseMargin) : 0
     readonly property bool _barIsVertical: _hasBarWindow ? barWindow.isVertical : false
     readonly property string _barScreenName: _hasBarWindow ? (barWindow.screenName || "") : ""
+    readonly property var dwlSvc: CompositorService.isMango ? MangoService : DwlService
     readonly property bool hasAdjacentTopBarLive: _hasBarWindow && barWindow.hasAdjacentTopBar
     readonly property bool hasAdjacentBottomBarLive: _hasBarWindow && barWindow.hasAdjacentBottomBar
     readonly property bool hasAdjacentLeftBarLive: _hasBarWindow && barWindow.hasAdjacentLeftBar
@@ -189,16 +190,16 @@ Item {
             }
 
             return monitorWorkspaces.sort((a, b) => a.id - b.id);
-        } else if (CompositorService.isMango) {
-            if (!MangoService.available) {
+        } else if (CompositorService.isDwl || CompositorService.isMango) {
+            if (!dwlSvc.available) {
                 return [0];
             }
             if (SettingsData.dwlShowAllTags) {
                 return Array.from({
-                    length: MangoService.tagCount
+                    length: dwlSvc.tagCount
                 }, (_, i) => i);
             }
-            return MangoService.getVisibleTags(screenName);
+            return dwlSvc.getVisibleTags(screenName);
         } else if (CompositorService.isSway || CompositorService.isScroll || CompositorService.isMiracle) {
             const workspaces = I3.workspaces?.values || [];
             if (workspaces.length === 0)
@@ -234,13 +235,13 @@ Item {
             const monitors = Hyprland.monitors?.values || [];
             const currentMonitor = monitors.find(monitor => monitor.name === screenName);
             return currentMonitor?.activeWorkspace?.id ?? 1;
-        } else if (CompositorService.isMango) {
-            if (!MangoService.available)
+        } else if (CompositorService.isDwl || CompositorService.isMango) {
+            if (!dwlSvc.available)
                 return 0;
-            const outputState = MangoService.getOutputState(screenName);
+            const outputState = dwlSvc.getOutputState(screenName);
             if (!outputState || !outputState.tags)
                 return 0;
-            const activeTags = MangoService.getActiveTags(screenName);
+            const activeTags = dwlSvc.getActiveTags(screenName);
             return activeTags.length > 0 ? activeTags[0] : 0;
         } else if (CompositorService.isSway || CompositorService.isScroll || CompositorService.isMiracle) {
             if (!screenName || SettingsData.workspaceFollowFocus) {
@@ -282,14 +283,14 @@ Item {
             if (nextIndex !== validIndex) {
                 HyprlandService.focusWorkspace(realWorkspaces[nextIndex].id);
             }
-        } else if (CompositorService.isMango) {
+        } else if (CompositorService.isDwl || CompositorService.isMango) {
             const currentTag = getCurrentWorkspace();
             const currentIndex = realWorkspaces.findIndex(tag => tag === currentTag);
             const validIndex = currentIndex === -1 ? 0 : currentIndex;
             const nextIndex = direction > 0 ? Math.min(validIndex + 1, realWorkspaces.length - 1) : Math.max(validIndex - 1, 0);
 
             if (nextIndex !== validIndex) {
-                MangoService.switchToTag(_barScreenName, realWorkspaces[nextIndex]);
+                dwlSvc.switchToTag(_barScreenName, realWorkspaces[nextIndex]);
             }
         } else if (CompositorService.isSway || CompositorService.isScroll || CompositorService.isMiracle) {
             const currentWs = getCurrentWorkspace();
@@ -497,7 +498,6 @@ Item {
                 widgetThickness: barWindow.widgetThickness
                 barThickness: barWindow.effectiveBarThickness
                 barSpacing: barConfig?.spacing ?? 4
-                sectionAvailablePrimarySize: Math.max(1, hCenterSection.x > 0 ? hCenterSection.x : parent.width / 3)
             }
 
             Binding {
@@ -530,7 +530,6 @@ Item {
                 widgetThickness: barWindow.widgetThickness
                 barThickness: barWindow.effectiveBarThickness
                 barSpacing: barConfig?.spacing ?? 4
-                sectionAvailablePrimarySize: Math.max(1, hCenterSection.x > 0 ? parent.width - (hCenterSection.x + hCenterSection.width) : parent.width / 3)
             }
 
             Binding {
@@ -563,7 +562,6 @@ Item {
                 widgetThickness: barWindow.widgetThickness
                 barThickness: barWindow.effectiveBarThickness
                 barSpacing: barConfig?.spacing ?? 4
-                sectionAvailablePrimarySize: Math.max(1, hRightSection.x > 0 ? hRightSection.x - (hLeftSection.x + hLeftSection.width) : parent.width / 3)
             }
 
             Binding {
@@ -603,7 +601,6 @@ Item {
                 widgetThickness: barWindow.widgetThickness
                 barThickness: barWindow.effectiveBarThickness
                 barSpacing: barConfig?.spacing ?? 4
-                sectionAvailablePrimarySize: Math.max(1, vCenterSection.y > 0 ? vCenterSection.y : parent.height / 3)
             }
 
             Binding {
@@ -637,7 +634,6 @@ Item {
                 widgetThickness: barWindow.widgetThickness
                 barThickness: barWindow.effectiveBarThickness
                 barSpacing: barConfig?.spacing ?? 4
-                sectionAvailablePrimarySize: Math.max(1, vRightSection.y > 0 ? vRightSection.y - (vLeftSection.y + vLeftSection.height) : parent.height / 3)
             }
 
             Binding {
@@ -672,7 +668,6 @@ Item {
                 widgetThickness: barWindow.widgetThickness
                 barThickness: barWindow.effectiveBarThickness
                 barSpacing: barConfig?.spacing ?? 4
-                sectionAvailablePrimarySize: Math.max(1, vCenterSection.y > 0 ? parent.height - (vCenterSection.y + vCenterSection.height) : parent.height / 3)
             }
 
             Binding {

quickshell/Modules/DankBar/DankBarWindow.qml

@@ -286,6 +286,9 @@ PanelWindow {
 
     readonly property bool isVertical: axis.isVertical
 
+    property bool gothCornersEnabled: barConfig?.gothCornersEnabled ?? false
+    property real wingtipsRadius: barConfig?.gothCornerRadiusOverride ? (barConfig?.gothCornerRadiusValue ?? 12) : Theme.cornerRadius
+    readonly property real _wingR: Math.max(0, wingtipsRadius)
     readonly property color _surfaceContainer: Theme.surfaceContainer
     readonly property string _barId: barConfig?.id ?? "default"
     property real _backgroundAlpha: barConfig?.transparency ?? 1.0
@@ -297,30 +300,25 @@ PanelWindow {
     }
     readonly property real _dpr: CompositorService.getScreenScale(barWindow.screen)
 
-    property string screenName: modelData.name
-
-    readonly property bool usesConnectedFrameChrome: CompositorService.usesConnectedFrameChromeForScreen(screenName)
-    readonly property bool usesFrameBarChrome: CompositorService.frameWindowVisibleForScreen(screenName)
-    readonly property var renderBarConfig: SettingsData.effectiveBarConfigForRender(barConfig, usesFrameBarChrome)
-
-    property bool gothCornersEnabled: renderBarConfig?.gothCornersEnabled ?? false
-    property real wingtipsRadius: renderBarConfig?.gothCornerRadiusOverride ? (renderBarConfig?.gothCornerRadiusValue ?? 12) : Theme.cornerRadius
-    readonly property real _wingR: Math.max(0, wingtipsRadius)
-
     // Shadow buffer: extra window space for shadow to render beyond bar bounds
-    readonly property bool _shadowActive: (Theme.elevationEnabled && (typeof SettingsData !== "undefined" ? (SettingsData.barElevationEnabled ?? true) : false)) || (renderBarConfig?.shadowIntensity ?? 0) > 0
+    readonly property bool _shadowActive: (Theme.elevationEnabled && (typeof SettingsData !== "undefined" ? (SettingsData.barElevationEnabled ?? true) : false)) || (barConfig?.shadowIntensity ?? 0) > 0
     readonly property real _shadowBuffer: {
         if (!_shadowActive)
             return 0;
-        const hasOverride = (renderBarConfig?.shadowIntensity ?? 0) > 0;
+        const hasOverride = (barConfig?.shadowIntensity ?? 0) > 0;
         if (hasOverride) {
-            const blur = (renderBarConfig.shadowIntensity ?? 0) * 0.2;
+            const blur = (barConfig.shadowIntensity ?? 0) * 0.2;
             const offset = blur * 0.5;
             return Theme.snap(Math.max(16, blur + offset + 8), _dpr);
         }
         return Theme.snap(Theme.elevationRenderPadding(Theme.elevationLevel2, "top", 4, 8, 16), _dpr);
     }
 
+    property string screenName: modelData.name
+
+    readonly property bool usesConnectedFrameChrome: CompositorService.usesConnectedFrameChromeForScreen(screenName)
+    readonly property bool usesFrameBarChrome: CompositorService.frameWindowVisibleForScreen(screenName)
+
     // Flatten/spacing collapse for maximized windows is only for frame-integrated layout.
     // When the bar draws its own pill, keep rounded corners and spacing like the dock.
     readonly property bool flattenForMaximizedWindow: !SettingsData.frameEnabled || usesFrameBarChrome
@@ -556,8 +554,8 @@ PanelWindow {
     }
 
     screen: modelData
-    implicitHeight: !isVertical ? Theme.px(effectiveBarThickness + effectiveSpacing + ((renderBarConfig?.gothCornersEnabled ?? false) && !hasMaximizedToplevel ? _wingR : 0), _dpr) + _shadowBuffer : 0
-    implicitWidth: isVertical ? Theme.px(effectiveBarThickness + effectiveSpacing + ((renderBarConfig?.gothCornersEnabled ?? false) && !hasMaximizedToplevel ? _wingR : 0), _dpr) + _shadowBuffer : 0
+    implicitHeight: !isVertical ? Theme.px(effectiveBarThickness + effectiveSpacing + ((barConfig?.gothCornersEnabled ?? false) && !hasMaximizedToplevel ? _wingR : 0), _dpr) + _shadowBuffer : 0
+    implicitWidth: isVertical ? Theme.px(effectiveBarThickness + effectiveSpacing + ((barConfig?.gothCornersEnabled ?? false) && !hasMaximizedToplevel ? _wingR : 0), _dpr) + _shadowBuffer : 0
     color: "transparent"
 
     Component.onCompleted: {
@@ -954,7 +952,7 @@ PanelWindow {
                         id: barBackground
                         barWindow: barWindow
                         axis: axis
-                        barConfig: barWindow.renderBarConfig
+                        barConfig: barWindow.barConfig
                     }
 
                     MouseArea {

quickshell/Modules/DankBar/LeftSection.qml

@@ -14,7 +14,6 @@ Item {
     property real barSpacing: 4
     property var barConfig: null
     property var blurBarWindow: null
-    property real sectionAvailablePrimarySize: 0
     property bool overrideAxisLayout: false
     property bool forceVerticalLayout: false
 
@@ -62,7 +61,6 @@ Item {
                         barSpacing: root.barSpacing
                         barConfig: root.barConfig
                         blurBarWindow: root.blurBarWindow
-                        sectionAvailablePrimarySize: root.sectionAvailablePrimarySize
                         isFirst: index === 0
                         isLast: index === rowRepeater.count - 1
                         sectionSpacing: parent.rowSpacing
@@ -108,7 +106,6 @@ Item {
                         barSpacing: root.barSpacing
                         barConfig: root.barConfig
                         blurBarWindow: root.blurBarWindow
-                        sectionAvailablePrimarySize: root.sectionAvailablePrimarySize
                         isFirst: index === 0
                         isLast: index === columnRepeater.count - 1
                         sectionSpacing: parent.columnSpacing

quickshell/Modules/DankBar/Popouts/DWLLayoutPopout.qml

@@ -10,7 +10,9 @@ DankPopout {
 
     property var triggerScreen: null
 
-    readonly property bool isMango: CompositorService.isMango
+    // mango shares dwl's layout model; route to the right service.
+    readonly property bool isDwlLike: CompositorService.isDwl || CompositorService.isMango
+    readonly property var dwlSvc: CompositorService.isMango ? MangoService : DwlService
 
     function setTriggerPosition(x, y, width, section, screen, barPosition, barThickness, barSpacing, barConfig) {
         triggerX = x;
@@ -35,8 +37,8 @@ DankPopout {
     onScreenChanged: updateOutputState()
 
     function updateOutputState() {
-        if (screen && MangoService.available) {
-            outputState = MangoService.getOutputState(screen.name);
+        if (screen && root.dwlSvc.available) {
+            outputState = root.dwlSvc.getOutputState(screen.name);
         } else {
             outputState = null;
         }
@@ -82,7 +84,7 @@ DankPopout {
     }
 
     Connections {
-        target: MangoService
+        target: DwlService
         function onStateChanged() {
             updateOutputState();
         }
@@ -217,7 +219,7 @@ DankPopout {
                     spacing: Theme.spacingS
 
                     Repeater {
-                        model: MangoService.layouts
+                        model: root.dwlSvc.layouts
 
                         delegate: Rectangle {
                             required property string modelData
@@ -271,11 +273,11 @@ DankPopout {
                                     if (!root.triggerScreen) {
                                         return;
                                     }
-                                    if (!MangoService.available) {
+                                    if (!root.dwlSvc.available) {
                                         return;
                                     }
 
-                                    MangoService.setLayout(root.triggerScreen.name, index);
+                                    root.dwlSvc.setLayout(root.triggerScreen.name, index);
                                     root.close();
                                 }
                             }

quickshell/Modules/DankBar/RightSection.qml

@@ -14,7 +14,6 @@ Item {
     property real barSpacing: 4
     property var barConfig: null
     property var blurBarWindow: null
-    property real sectionAvailablePrimarySize: 0
     property bool overrideAxisLayout: false
     property bool forceVerticalLayout: false
 
@@ -64,7 +63,6 @@ Item {
                         barSpacing: root.barSpacing
                         barConfig: root.barConfig
                         blurBarWindow: root.blurBarWindow
-                        sectionAvailablePrimarySize: root.sectionAvailablePrimarySize
                         isFirst: index === 0
                         isLast: index === rowRepeater.count - 1
                         sectionSpacing: parent.rowSpacing
@@ -110,7 +108,6 @@ Item {
                         barSpacing: root.barSpacing
                         barConfig: root.barConfig
                         blurBarWindow: root.blurBarWindow
-                        sectionAvailablePrimarySize: root.sectionAvailablePrimarySize
                         isFirst: index === 0
                         isLast: index === columnRepeater.count - 1
                         sectionSpacing: parent.columnSpacing

quickshell/Modules/DankBar/WidgetHost.qml

@@ -17,7 +17,6 @@ Loader {
     property real barSpacing: 4
     property var barConfig: null
     property var blurBarWindow: null
-    property real sectionAvailablePrimarySize: 0
     property bool isFirst: false
     property bool isLast: false
     property real sectionSpacing: 0
@@ -142,14 +141,6 @@ Loader {
         restoreMode: Binding.RestoreNone
     }
 
-    Binding {
-        target: root.item
-        when: root.item && "sectionAvailablePrimarySize" in root.item
-        property: "sectionAvailablePrimarySize"
-        value: root.sectionAvailablePrimarySize
-        restoreMode: Binding.RestoreNone
-    }
-
     Binding {
         target: root.item
         when: root.item && "isLeftBarEdge" in root.item
@@ -291,7 +282,7 @@ Loader {
             "cpuTemp": dgopAvailable,
             "gpuTemp": dgopAvailable,
             "network_speed_monitor": dgopAvailable,
-            "layout": CompositorService.isMango && MangoService.available
+            "layout": (CompositorService.isDwl && DwlService.dwlAvailable) || (CompositorService.isMango && MangoService.available)
         };
 
         return widgetVisibility[widgetId] ?? true;

quickshell/Modules/DankBar/Widgets/DWLLayout.qml

@@ -13,11 +13,12 @@ BasePill {
     signal toggleLayoutPopup
 
     // mango shares dwl's tag/layout model; route to the right service.
-    readonly property bool isMango: CompositorService.isMango
+    readonly property bool isDwlLike: CompositorService.isDwl || CompositorService.isMango
+    readonly property var dwlSvc: CompositorService.isMango ? MangoService : DwlService
 
-    visible: layout.isMango && MangoService.available
+    visible: layout.isDwlLike && layout.dwlSvc.available
 
-    property var outputState: parentScreen ? MangoService.getOutputState(parentScreen.name) : null
+    property var outputState: parentScreen ? layout.dwlSvc.getOutputState(parentScreen.name) : null
     property string currentLayoutSymbol: outputState?.layoutSymbol || ""
     property int currentLayoutIndex: outputState?.layout || 0
 
@@ -40,9 +41,9 @@ BasePill {
     }
 
     Connections {
-        target: MangoService
+        target: layout.dwlSvc
         function onStateChanged() {
-            outputState = parentScreen ? MangoService.getOutputState(parentScreen.name) : null;
+            outputState = parentScreen ? layout.dwlSvc.getOutputState(parentScreen.name) : null;
         }
     }
 
@@ -100,13 +101,13 @@ BasePill {
     }
 
     onRightClicked: {
-        if (!parentScreen || !MangoService.available || MangoService.layouts.length === 0) {
+        if (!parentScreen || !layout.dwlSvc.available || layout.dwlSvc.layouts.length === 0) {
             return;
         }
 
         const currentIndex = layout.currentLayoutIndex;
-        const nextIndex = (currentIndex + 1) % MangoService.layouts.length;
+        const nextIndex = (currentIndex + 1) % layout.dwlSvc.layouts.length;
 
-        MangoService.setLayout(parentScreen.name, nextIndex);
+        layout.dwlSvc.setLayout(parentScreen.name, nextIndex);
     }
 }

quickshell/Modules/DankBar/Widgets/KeyboardLayoutName.qml

@@ -112,6 +112,8 @@ BasePill {
     property string currentLayout: {
         if (CompositorService.isNiri) {
             return NiriService.getCurrentKeyboardLayoutName();
+        } else if (CompositorService.isDwl) {
+            return DwlService.currentKeyboardLayout;
         } else if (CompositorService.isMango) {
             return MangoService.currentKeyboardLayout;
         }
@@ -207,6 +209,8 @@ BasePill {
                 NiriService.cycleKeyboardLayout();
             } else if (CompositorService.isHyprland) {
                 Quickshell.execDetached(["hyprctl", "switchxkblayout", root.hyprlandKeyboard, "next"]);
+            } else if (CompositorService.isDwl) {
+                Quickshell.execDetached(["mmsg", "dispatch", "switch_keyboard_layout"]);
             } else if (CompositorService.isMango) {
                 MangoService.cycleKeyboardLayout();
             }