25 changed files with 1001 additions and 5438 deletions
--- a/.gitea/issue_template/bug_report.yml
+++ b/.gitea/issue_template/bug_report.yml
@ -1,62 +0,0 @@
 name: Bug Report
 about: Something in dwl isn't working correctly
 title:
 labels:
    - 'Kind/Bug'
 body:
    - type: markdown
      attributes:
          value: |
              - Only report bugs that can be reproduced on the main (or wlroots-next) branch without patches.
              - Proprietary graphics drivers, including nvidia, are not supported. Please use the open source equivalents, such as nouveau, if you would like to use dwl.
              - Report patch issues to their respective authors.
    - type: input
      id: dwl_version
      attributes:
          label: 'dwl version:'
          placeholder: '`dwl -v`'
      validations:
          required: true
    - type: input
      id: wlroots_version
      attributes:
          label: 'wlroots version:'
      validations:
          required: true
    - type: input
      id: distro
      attributes:
          label: What distro (and version) are you using?
      validations:
          required: false
    - type: textarea
      attributes:
          label: Description
          value: |
              The steps you took to reproduce the problem.
      validations:
          required: false
    - type: textarea
      id: debug_log
      attributes:
          label: Debug Log
          value: |
              Run `dwl -d 2> ~/dwl.log` from a TTY and attach the **full** (do not truncate it) file here, or upload it to a pastebin.
              Please try to keep the reproduction as brief as possible and exit dwl.
      validations:
          required: false
    - type: textarea
      id: backtrace
      attributes:
          label: Stack Trace
          value: |
              - Only required if dwl crashes.
              - If the lines mentioning dwl or wlroots have `??`. Please compile both dwl and wlroots from source (enabling debug symbols) and try to reproduce.
      validations:
          required: false
--- a/.gitea/issue_template/enhancement-idea.yml
+++ b/.gitea/issue_template/enhancement-idea.yml
@ -1,9 +0,0 @@
 name: Enhancement idea
 about: Suggest a feature or improvement
 title:
 labels:
    - 'Kind/Feature'
 body:
    - type: textarea
      attributes:
          label: Description
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@ -0,0 +1,10 @@
 ---
 name: Bug report
 about: Something in dwl isn't working correctly
 title: ''
 labels: 'Type: bug'
 assignees: ''
 ---
--- a/.github/ISSUE_TEMPLATE/enhancement-idea.md
+++ b/.github/ISSUE_TEMPLATE/enhancement-idea.md
@ -0,0 +1,10 @@
 ---
 name: Enhancement idea
 about: Suggest a feature or improvement
 title: ''
 labels: 'Type: enhancement'
 assignees: ''
 ---
--- a/.gitignore
+++ b/.gitignore
@ -3,4 +3,3 @@ dwl
 *-protocol.c
 *-protocol.h
 .ccls-cache
 config.h
--- a/.mailmap
+++ b/.mailmap
@ -1,3 +0,0 @@
 Lennart Jablonka <humm@ljabl.com> <hummsmith42@gmail.com>
 Leonardo Hernández Hernández <leohdz172@proton.me> <leohdz172@outlook.com>
 Leonardo Hernández Hernández <leohdz172@proton.me> <leohdz172@protonmail.com>
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,217 +0,0 @@
 # Changelog
 * [Unreleased](#unreleased)
 * [0.7](#0.7)
 * [0.6](#0.6)
 * [0.5](#0.5)
 ## Unreleased
 ### Added
 * Support for the linux-drm-syncobj-v1 protocol ([wlroots!4715][wlroots!4715], [#685][685])
 * Allow the use of non-system wlroots library ([#646][646])
 [wlroots!4715]: https://gitlab.freedesktop.org/wlroots/wlroots/-/merge_requests/4715
 [685]: https://codeberg.org/dwl/dwl/pulls/685
 [646]: https://codeberg.org/dwl/dwl/pulls/646
 ### Changed
 ### Deprecated
 ### Removed
 ### Fixed
 * Crash when a client is created while all outputs are disabled.
 ### Security
 ### Contributors
 ## 0.7
 This version is just 0.6 with wlroots 0.18 compatibility.
 ### Added
 * Add support for the alpha-modifier-v1 protocol ([wlroots!4616][wlroots!4616]).
 * dwl now will survive GPU resets ([#601][601]).
 [wlroots!4616]: https://gitlab.freedesktop.org/wlroots/wlroots/-/merge_requests/4616
 [601]: https://codeberg.org/dwl/dwl/issues/601
 ### Contributors
 Guido Cella
 ## 0.6
 ### Added
 * Add `rootcolor` to change the default background color ([#544][544]).
 * Implement the wlr-virtual-pointer-unstable-v1 protocol ([#574][574]).
 * Implement the pointer-constraints and relative-pointer protocols ([#317][317])
 * Implement the wlr-output-power-management protocol ([#599][599])
 [544]: https://codeberg.org/dwl/dwl/pulls/544
 [574]: https://codeberg.org/dwl/dwl/pulls/574
 [317]: https://codeberg.org/dwl/dwl/issues/317
 [599]: https://codeberg.org/dwl/dwl/issues/559
 ### Changed
 * Keyboards are now managed through keyboard groups ([#549][549]).
 * Only the first matched keybinding is executed.
 * Allow toggling the layout before selecting a different one ([#570][570]).
 * Fullscreen clients are now rendered above wlr_layer_surfaces in the top layer
  ([#609][609]).
 * The default menu was changed from `bemenu-run` to `wmenu-run` ([#553][553]).
 * The option `sloppyfocus` now replicates the dwm behavior ([#599][599]).
 * Allow configure position of monitors with negative values. (-1, -1) is
  used to auto-configure them ([#635][635]).
 * dwl now kills the entire process group of `startup_cmd`
 * The O_NONBLOCK flag is set for stdout.
 [549]: https://codeberg.org/dwl/dwl/pulls/549
 [570]: https://codeberg.org/dwl/dwl/pulls/570
 [609]: https://codeberg.org/dwl/dwl/pulls/609
 [553]: https://codeberg.org/dwl/dwl/issues/553
 [599]: https://codeberg.org/dwl/dwl/pulls/599
 [635]: https://codeberg.org/dwl/dwl/pulls/635
 ### Removed
 * The SLOC limit is now removed ([#497][497]).
 [497]: https://codeberg.org/dwl/dwl/pulls/497
 ### Fixed
 * Clients not having the correct border color when mapping.
 * Compliance with the xdg-decoration-unstable-v1 ([#546][546]).
 * dwl no longer sends negative values in xdg_toplevel.configure events.
 * Crashes with disabled monitors ([#472][472]).
 [546]: https://codeberg.org/dwl/dwl/pulls/546
 [472]: https://codeberg.org/dwl/dwl/issues/472
 ### Contributors
 Ben Jargowsky
 Benjamin Chausse
 David Donahue
 Devin J. Pohly
 Dima Krasner
 Emil Miler
 Forrest Bushstone
 Guido Cella
 Peter Hofmann
 Rutherther
 Squibid
 choc
 fictitiousexistence
 korei999
 sewn
 thanatos
 ## 0.5
 ### Added
 * Allow configure x and y position of outputs ([#301][301])
 * Implement repeatable keybindings ([#368][368])
 * Print app id in printstatus() output ([#381][381])
 * Display client count in monocle symbol ([#387][387])
 * Export XCURSOR_SIZE to fix apps using an older version of Qt ([#425][425])
 * Support for wp-fractional-scale-v1 (through wlr_scene: [wlroots!3511][wlroots!3511])
 * dwl now sends `wl_surface.preferred_buffer_scale` (through wlr_scene: [wlroots!4269][wlroots!4269])
 * Add support for xdg-shell v6 ([#465][465])
 * Add support for wp-cursor-shape-v1 ([#444][444])
 * Add desktop file ([#484][484])
 * Add macro to easily configure colors ([#466][466])
 * Color of urgent clients are now red ([#494][494])
 * New flag `-d` and option `log_level` to change the wlroots debug level
 * Add CHANGELOG.md ([#501][501])
 [301]: https://github.com/djpohly/dwl/pull/301
 [368]: https://github.com/djpohly/dwl/pull/368
 [381]: https://github.com/djpohly/dwl/pull/381
 [387]: https://github.com/djpohly/dwl/issues/387
 [425]: https://github.com/djpohly/dwl/pull/425
 [wlroots!4269]: https://gitlab.freedesktop.org/wlroots/wlroots/-/merge_requests/4269
 [wlroots!3511]: https://gitlab.freedesktop.org/wlroots/wlroots/-/merge_requests/3511
 [465]: https://github.com/djpohly/dwl/pull/465
 [444]: https://github.com/djpohly/dwl/pull/444
 [484]: https://github.com/djpohly/dwl/pull/484
 [466]: https://github.com/djpohly/dwl/issues/466
 [494]: https://github.com/djpohly/dwl/pull/494
 [501]: https://github.com/djpohly/dwl/pull/501
 ### Changed
 * Replace `tags` with `TAGCOUNT` in config.def.h ([#403][403])
 * Pop ups are now destroyed when focusing another client ([#408][408])
 * dwl does not longer respect size hints, instead clip windows if they are
  larger than they should be ([#455][455])
 * The version of wlr-layer-shell-unstable-v1 was lowered to 3 (from 4)
 * Use the same border color as dwm ([#494][494])
 [403]: https://github.com/djpohly/dwl/pull/403
 [408]: https://github.com/djpohly/dwl/pull/409
 [455]: https://github.com/djpohly/dwl/pull/455
 [494]: https://github.com/djpohly/dwl/pull/494
 ### Removed
 * Remove unused `rootcolor` option ([#401][401])
 * Remove support for wlr-input-inhibitor-unstable-v1 ([#430][430])
 * Remove support for KDE idle protocol ([#431][431])
 [401]: https://github.com/djpohly/dwl/pull/401
 [430]: https://github.com/djpohly/dwl/pull/430
 [431]: https://github.com/djpohly/dwl/pull/431
 ### Fixed
 * Fix crash when creating a layer surface with all outputs disabled
  ([#421][421])
 * Fix other clients being shown as focused if the focused client have pop ups
  open ([#408][408])
 * Resize fullscreen clients when updating monitor mode
 * dwl no longer crash at exit like sometimes did
 * Fullscreen background appearing above clients ([#487][487])
 * Fix a segfault when user provides invalid xkb_rules ([#518][518])
 [421]: https://github.com/djpohly/dwl/pull/421
 [408]: https://github.com/djpohly/dwl/issues/408
 [487]: https://github.com/djpohly/dwl/issues/487
 [518]: https://github.com/djpohly/dwl/pull/518
 ### Contributors
 * A Frederick Christensen
 * Angelo Antony
 * Ben Collerson
 * Devin J. Pohly
 * Forrest Bushstone
 * gan-of-culture
 * godalming123
 * Job79
 * link2xt
 * Micah Gorrell
 * Nikita Ivanov
 * Palanix
 * pino-desktop
 * Weiseguy
 * Yves Zoundi
--- a/4
+++ b/4
@ -1,8 +1,8 @@
 dwl - dwm for Wayland
-Copyright © 2020 dwl team
+Copyright © 2020 Devin J. Pohly
-See also the files LICENSE.tinywl, LICENSE.dwm and LICENSE.sway.
+See also the files LICENSE.tinywl and LICENSE.dwm.
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
--- a/LICENSE.sway
+++ b/LICENSE.sway
@ -1,19 +0,0 @@
 Copyright (c) 2016-2017 Drew DeVault
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
 the Software without restriction, including without limitation the rights to
 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 of the Software, and to permit persons to whom the Software is furnished to do
 so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
--- a/93
+++ b/93
@ -1,86 +1,37 @@
 .POSIX:
 .SUFFIXES:
 include config.mk
-# flags for compiling
+CFLAGS += -I. -DWLR_USE_UNSTABLE -std=c99 -Werror=declaration-after-statement
 DWLCPPFLAGS = -I. -DWLR_USE_UNSTABLE -D_POSIX_C_SOURCE=200809L \
 	-DVERSION=\"$(VERSION)\" $(XWAYLAND)
 DWLDEVCFLAGS = -g -Wpedantic -Wall -Wextra -Wdeclaration-after-statement \
 	-Wno-unused-parameter -Wshadow -Wunused-macros -Werror=strict-prototypes \
 	-Werror=implicit -Werror=return-type -Werror=incompatible-pointer-types \
 	-Wfloat-conversion
-# CFLAGS / LDFLAGS
+WAYLAND_PROTOCOLS=$(shell pkg-config --variable=pkgdatadir wayland-protocols)
-PKGS      = wayland-server xkbcommon libinput $(XLIBS)
+WAYLAND_SCANNER=$(shell pkg-config --variable=wayland_scanner wayland-scanner)
-DWLCFLAGS = `$(PKG_CONFIG) --cflags $(PKGS)` $(WLR_INCS) $(DWLCPPFLAGS) $(DWLDEVCFLAGS) $(CFLAGS)
+
-LDLIBS    = `$(PKG_CONFIG) --libs $(PKGS)` $(WLR_LIBS) -lm $(LIBS)
+PKGS = wlroots wayland-server xcb xkbcommon
 CFLAGS += $(foreach p,$(PKGS),$(shell pkg-config --cflags $(p)))
 LDLIBS += $(foreach p,$(PKGS),$(shell pkg-config --libs $(p)))
 all: dwl
 dwl: dwl.o util.o dwl-ipc-unstable-v2-protocol.o
 	$(CC) dwl.o util.o $(DWLCFLAGS) $(LDFLAGS) $(LDLIBS) dwl-ipc-unstable-v2-protocol.o -o $@
 dwl.o: dwl.c client.h config.h config.mk cursor-shape-v1-protocol.h \
 	pointer-constraints-unstable-v1-protocol.h wlr-layer-shell-unstable-v1-protocol.h \
 	wlr-output-power-management-unstable-v1-protocol.h xdg-shell-protocol.h dwl-ipc-unstable-v2-protocol.h
 util.o: util.c util.h
 dwl-ipc-unstable-v2-protocol.o: dwl-ipc-unstable-v2-protocol.h
 # wayland-scanner is a tool which generates C headers and rigging for Wayland
 # protocols, which are specified in XML. wlroots requires you to rig these up
 # to your build system yourself and provide them in the include path.
 WAYLAND_SCANNER   = `$(PKG_CONFIG) --variable=wayland_scanner wayland-scanner`
 WAYLAND_PROTOCOLS = `$(PKG_CONFIG) --variable=pkgdatadir wayland-protocols`
 cursor-shape-v1-protocol.h:
 	$(WAYLAND_SCANNER) enum-header \
 		$(WAYLAND_PROTOCOLS)/staging/cursor-shape/cursor-shape-v1.xml $@
 dwl-ipc-unstable-v2-protocol.h:
 	$(WAYLAND_SCANNER) server-header \
 		protocols/dwl-ipc-unstable-v2.xml $@
 dwl-ipc-unstable-v2-protocol.c:
 	$(WAYLAND_SCANNER) private-code \
 		protocols/dwl-ipc-unstable-v2.xml $@
 pointer-constraints-unstable-v1-protocol.h:
 	$(WAYLAND_SCANNER) enum-header \
 		$(WAYLAND_PROTOCOLS)/unstable/pointer-constraints/pointer-constraints-unstable-v1.xml $@
 wlr-layer-shell-unstable-v1-protocol.h:
 	$(WAYLAND_SCANNER) enum-header \
 		protocols/wlr-layer-shell-unstable-v1.xml $@
 wlr-output-power-management-unstable-v1-protocol.h:
 	$(WAYLAND_SCANNER) server-header \
 		protocols/wlr-output-power-management-unstable-v1.xml $@
 xdg-shell-protocol.h:
 	$(WAYLAND_SCANNER) server-header \
 		$(WAYLAND_PROTOCOLS)/stable/xdg-shell/xdg-shell.xml $@
-config.h:
+xdg-shell-protocol.c:
 	$(WAYLAND_SCANNER) private-code \
 		$(WAYLAND_PROTOCOLS)/stable/xdg-shell/xdg-shell.xml $@
 xdg-shell-protocol.o: xdg-shell-protocol.h
 config.h: | config.def.h
 	cp config.def.h $@
 dwl.o: config.h xdg-shell-protocol.h
 dwl: xdg-shell-protocol.o
 clean:
-	rm -f dwl *.o *-protocol.h
+	rm -f dwl *.o xdg-shell-protocol.h xdg-shell-protocol.c
-dist: clean
+.DEFAULT_GOAL=dwl
-	mkdir -p dwl-$(VERSION)
+.PHONY: clean
 	cp -R LICENSE* Makefile CHANGELOG.md README.md client.h config.def.h \
 		config.mk protocols dwl.1 dwl.c util.c util.h dwl.desktop \
 		dwl-$(VERSION)
 	tar -caf dwl-$(VERSION).tar.gz dwl-$(VERSION)
 	rm -rf dwl-$(VERSION)
 install: dwl
 	mkdir -p $(DESTDIR)$(PREFIX)/bin
 	rm -f $(DESTDIR)$(PREFIX)/bin/dwl
 	cp -f dwl $(DESTDIR)$(PREFIX)/bin
 	chmod 755 $(DESTDIR)$(PREFIX)/bin/dwl
 	mkdir -p $(DESTDIR)$(MANDIR)/man1
 	cp -f dwl.1 $(DESTDIR)$(MANDIR)/man1
 	chmod 644 $(DESTDIR)$(MANDIR)/man1/dwl.1
 	mkdir -p $(DESTDIR)$(DATADIR)/wayland-sessions
 	cp -f dwl.desktop $(DESTDIR)$(DATADIR)/wayland-sessions/dwl.desktop
 	chmod 644 $(DESTDIR)$(DATADIR)/wayland-sessions/dwl.desktop
 uninstall:
 	rm -f $(DESTDIR)$(PREFIX)/bin/dwl $(DESTDIR)$(MANDIR)/man1/dwl.1 \
 		$(DESTDIR)$(DATADIR)/wayland-sessions/dwl.desktop
 .SUFFIXES: .c .o
 .c.o:
 	$(CC) $(CPPFLAGS) $(DWLCFLAGS) -o $@ -c $<
--- a/README.md
+++ b/README.md
@ -1,199 +1,79 @@
 # dwl - dwm for Wayland
-Join us on our IRC channel: [#dwl on Libera Chat]  
+dwl is a compact, hackable compositor for Wayland based on [wlroots](https://github.com/swaywm/wlroots).  It is intended to fill the same space in the Wayland world that dwm does in X11, primarily in terms of philosophy, and secondarily in terms of functionality.  Like dwm, dwl is:
 Or on the community-maintained [Discord server].
 dwl is a compact, hackable compositor for [Wayland] based on [wlroots]. It is
 intended to fill the same space in the Wayland world that dwm does in X11,
 primarily in terms of functionality, and secondarily in terms of
 philosophy. Like dwm, dwl is:
 - Easy to understand, hack on, and extend with patches
 - One C source file (or a very small number) configurable via `config.h`
 - Limited to a maximum number of SLOC (to be determined)
 - Tied to as few external dependencies as possible
 ## Getting Started:
-### Latest semi-stable [release]
+dwl is not meant to provide every feature under the sun.  Instead, like dwm, it sticks to features which are necessary, simple, and straightforward to implement given the base on which it is built.  Since wlroots provides a number of features that are more complicated to accomplish with Xlib and select extensions, dwl can be in some ways more featureful than dwm *while remaining just as simple.*  Intended default features are:
 This is probably where you want to start. This builds against the dependent
 packages' versions currently shipping in major distributions. If your
 distribution's wlroots version is older, use an earlier dwl [release] or [0.x
 branch].
-### Development branch [main]
+- Any features provided by dwm/Xlib: simple window borders, tags, keybindings, client rules, mouse move/resize (see below for why the built-in status bar is a possible exception)
-Active development progresses on the `main` branch. The `main` branch is built
+- Configurable multi-monitor layout support, including position and rotation
-against a late (and often changing) git commit of wlroots. While the adventurous
+- Configurable HiDPI/multi-DPI support
-are welcome to use `main`, it is a rocky road. Using `main` requires that the
+- Wayland protocols needed for daily life in the tiling world: at a minimum, xdg-shell and layer-shell (for bars/menus).  Protocols trivially provided by wlroots may also be added.
-user be willing to chase git commits of wlroots. Testing development pull
+- XWayland support as provided by wlroots
-requests may involve merging unmerged pull requests in [wlroots]' git repository
+- Zero flickering - Wayland users naturally expect that "every frame is perfect"
-and/or git commits of wayland.
+- Basic yes/no damage tracking to avoid needless redraws (if it can be done simply and has an impact on power consumption)
 ### Building dwl
 dwl has the following dependencies:
 - libinput
 - wayland
 - wlroots (compiled with the libinput backend)
 - xkbcommon
 - wayland-protocols (compile-time only)
 - pkg-config (compile-time only)
 dwl has the following additional dependencies if XWayland support is enabled:
 - libxcb
 - libxcb-wm
 - wlroots (compiled with X11 support)
 - Xwayland (runtime only)
-Install these (and their `-devel` versions if your distro has separate
+Other features under consideration are:
-development packages) and run `make`. If you wish to build against a released
+
-version of wlroots (*you probably do*), use a [release] or a [0.x branch]. If
+- Additional Wayland compositor protocols which are trivially provided by wlroots or can be conditionally included via `config.h` settings (e.g. screen capture)
-you want to use the unstable development `main` branch, you need to use the git
+- External bar support instead of a built-in status bar, to avoid taking a dependency on FreeType or Pango
-version of [wlroots].
+- Buffering of input when spawning a client so you don't have to wait for the window (use `wl_client_get_credentials` to get the PID) - would this require passing through something like dmenu?  Extension protocol?
 - More in-depth damage region tracking
 Feature *non-goals* include:
 - Client-side decoration (any more than is necessary to tell the clients not to)
 - Client-initiated window management, such as move, resize, and close, which can be done through the compositor
 ## Building dwl
 dwl has only two dependencies: wlroots (git version currently required) and wayland-protocols.  Simply install these and run `make`.
 To enable XWayland, you should uncomment its flags in `config.mk`.
 ## Configuration
-All configuration is done by editing `config.h` and recompiling, in the same
+All configuration is done by editing `config.h` and recompiling, in the same manner as dwm.  There is no way to separately restart the window manager in Wayland without restarting the entire display server, so any changes will take effect the next time dwl is executed.
 manner as dwm. There is no way to separately restart the window manager in
 Wayland without restarting the entire display server, so any changes will take
 effect the next time dwl is executed.
 As in the dwm community, we encourage users to share patches they have
 created. Check out the [dwl-patches] repository!
 ## Running dwl
-dwl can be run on any of the backends supported by wlroots. This means you can
+dwl can be run as-is, with no arguments. In an existing Wayland or X11 session, this will open a window to act as a virtual display.  When run from a TTY, the Wayland server will take over the entire virtual terminal.  Clients started by dwl will have `WAYLAND_DISPLAY` set in their environment, and other clients can be started from outside the session by setting this variable accordingly.
 run it as a separate window inside either an X11 or Wayland session, as well as
 directly from a VT console. Depending on your distro's setup, you may need to
 add your user to the `video` and `input` groups before you can run dwl on a
 VT. If you are using `elogind` or `systemd-logind` you need to install polkit;
 otherwise you need to add yourself in the `seat` group and enable/start the
 seatd daemon.
-When dwl is run with no arguments, it will launch the server and begin handling
+You can also specify a startup program using the `-s` option.  The argument to this option will be run at startup as a shell command (using `sh -c`) and can serve a similar function to `.xinitrc`: starting a service manager or other startup applications.  Unlike `.xinitrc`, the display server will not shut down when this process terminates.  Instead, as dwl is shutting down, it will send this process a SIGTERM and wait for it to terminate (if it hasn't already).  This makes it ideal not only for initialization but also for execing into a user-level service manager like s6 or `systemd --user`.
 any shortcuts configured in `config.h`. There is no status bar or other
 decoration initially; these are instead clients that can be run within the
 Wayland session. Do note that the default background color is black. This can be
 modified in `config.h`.
-If you would like to run a script or command automatically at startup, you can
+More/less verbose output can be requested with flags as well:
 specify the command using the `-s` option. This command will be executed as a
 shell command using `/bin/sh -c`.  It serves a similar function to `.xinitrc`,
 but differs in that the display server will not shut down when this process
 terminates. Instead, dwl will send this process a SIGTERM at shutdown and wait
 for it to terminate (if it hasn't already). This makes it ideal for execing into
 a user service manager like [s6], [anopa], [runit], [dinit], or [`systemd
 --user`].
-Note: The `-s` command is run as a *child process* of dwl, which means that it
+* `-q`: quiet (log level WLR_SILENT)
-does not have the ability to affect the environment of dwl or of any processes
+* `-v`: verbose (log level WLR_INFO)
-that it spawns. If you need to set environment variables that affect the entire
+* `-d`: debug (log level WLR_DEBUG)
-dwl session, these must be set prior to running dwl. For example, Wayland
+
-requires a valid `XDG_RUNTIME_DIR`, which is usually set up by a session manager
+Note: Wayland requires a valid `XDG_RUNTIME_DIR`, which is usually set up by a session manager such as `elogind` or `systemd-logind`.  If your system doesn't do this automatically, you will need to configure it prior to launching `dwl`, e.g.:
 such as `elogind` or `systemd-logind`.  If your system doesn't do this
 automatically, you will need to configure it prior to launching `dwl`, e.g.:
    export XDG_RUNTIME_DIR=/tmp/xdg-runtime-$(id -u)
    mkdir -p $XDG_RUNTIME_DIR
    dwl
 ### Status information
-Information about selected layouts, current window title, app-id, and
+## Known limitations and issues
 selected/occupied/urgent tags is written to the stdin of the `-s` command (see
 the `printstatus()` function for details).  This information can be used to
 populate an external status bar with a script that parses the
 information. Failing to read this information will cause dwl to block, so if you
 do want to run a startup command that does not consume the status information,
 you can close standard input with the `<&-` shell redirection, for example:
-    dwl -s 'foot --server <&-'
+dwl is a work in progress, and it has not yet reached its feature goals in a number of ways:
-If your startup command is a shell script, you can achieve the same inside the
+- A window's texture is scaled for its "home" monitor only (noticeable when window sits across a monitor boundary)
-script with the line
+- XWayland support is new and could use testing
 - Urgent/attention/focus-request ([not yet supported](https://gitlab.freedesktop.org/wayland/wayland-protocols/-/merge_requests/9) by xdg-shell protocol)
 - Statusbar support (built-in or external)
 - layer-shell
 - Damage tracking
 - Fullscreen/fixed windows (or whatever the Wayland analogues are)
    exec <&-
 To get a list of status bars that work with dwl consult our [wiki].
 ## Replacements for X applications
 You can find a [list of useful resources on our wiki].
 ## Background
 dwl is not meant to provide every feature under the sun. Instead, like dwm, it
 sticks to features which are necessary, simple, and straightforward to implement
 given the base on which it is built. Implemented default features are:
 - Any features provided by dwm/Xlib: simple window borders, tags, keybindings,
  client rules, mouse move/resize. Providing a built-in status bar is an
  exception to this goal, to avoid dependencies on font rendering and/or drawing
  libraries when an external bar could work well.
 - Configurable multi-monitor layout support, including position and rotation
 - Configurable HiDPI/multi-DPI support
 - Idle-inhibit protocol which lets applications such as mpv disable idle
  monitoring
 - Provide information to external status bars via stdout/stdin
 - Urgency hints via xdg-activate protocol
 - Support screen lockers via ext-session-lock-v1 protocol
 - Various Wayland protocols
 - XWayland support as provided by wlroots (can be enabled in `config.mk`)
 - Zero flickering - Wayland users naturally expect that "every frame is perfect"
 - Layer shell popups (used by Waybar)
 - Damage tracking provided by scenegraph API
 Given the Wayland architecture, dwl has to implement features from dwm **and**
 the xorg-server. Because of this, it is impossible to maintain the original
 project goal of 2000 SLOC and have a reasonably complete compositor with
 features comparable to dwm. However, this does not mean that the code will grow
 indiscriminately. We will try to keep the code as small as possible.
 Features under consideration (possibly as patches) are:
 - Protocols made trivial by wlroots
 - Implement the text-input and input-method protocols to support IME once ibus
  implements input-method v2 (see https://github.com/ibus/ibus/pull/2256 and
  https://codeberg.org/dwl/dwl/pulls/235)
 Feature *non-goals* for the main codebase include:
 - Client-side decoration (any more than is necessary to tell the clients not to)
 - Client-initiated window management, such as move, resize, and close, which can
  be done through the compositor
 - Animations and visual effects
 ## Acknowledgements
-dwl began by extending the TinyWL example provided (CC0) by the sway/wlroots
+dwl began by extending the TinyWL example provided (CC0) by the sway/wlroots developers.  This was made possible in many cases by looking at how sway accomplished something, then trying to do the same in as suckless a way as possible.  Speaking of which, many thanks to suckless.org and the dwm developers and community for the inspiration.
 developers. This was made possible in many cases by looking at how sway
 accomplished something, then trying to do the same in as suckless a way as
 possible.
 Many thanks to suckless.org and the dwm developers and community for the
 inspiration, and to the various contributors to the project, including:
 - **Devin J. Pohly for creating and nurturing the fledgling project**
 - Alexander Courtis for the XWayland implementation
 - Guido Cella for the layer-shell protocol implementation, patch maintenance,
  and for helping to keep the project running
 - Stivvo for output management and fullscreen support, and patch maintenance
 [`systemd --user`]: https://wiki.archlinux.org/title/Systemd/User
 [#dwl on Libera Chat]: https://web.libera.chat/?channels=#dwl
 [0.7-rc1]: https://codeberg.org/dwl/dwl/releases/tag/v0.7-rc1
 [0.x branch]: https://codeberg.org/dwl/dwl/branches
 [anopa]: https://jjacky.com/anopa/
 [dinit]: https://davmac.org/projects/dinit/
 [dwl-patches]: https://codeberg.org/dwl/dwl-patches
 [list of useful resources on our wiki]: https://codeberg.org/dwl/dwl/wiki/Home#migrating-from-x
 [main]: https://codeberg.org/dwl/dwl/src/branch/main
 [release]: https://codeberg.org/dwl/dwl/releases
 [runit]: http://smarden.org/runit/faq.html#userservices
 [s6]: https://skarnet.org/software/s6/
 [wlroots]: https://gitlab.freedesktop.org/wlroots/wlroots/
 [wiki]: https://codeberg.org/dwl/dwl/wiki/Home#compatible-status-bars
 [Discord server]: https://discord.gg/jJxZnrGPWN
 [Wayland]: https://wayland.freedesktop.org/
--- a/client.h
+++ b/client.h
@ -1,404 +0,0 @@
 /*
 * Attempt to consolidate unavoidable suck into one file, away from dwl.c.  This
 * file is not meant to be pretty.  We use a .h file with static inline
 * functions instead of a separate .c module, or function pointers like sway, so
 * that they will simply compile out if the chosen #defines leave them unused.
 */
 /* Leave these functions first; they're used in the others */
 static inline int
 client_is_x11(Client *c)
 {
 #ifdef XWAYLAND
 	return c->type == X11;
 #endif
 	return 0;
 }
 static inline struct wlr_surface *
 client_surface(Client *c)
 {
 #ifdef XWAYLAND
 	if (client_is_x11(c))
 		return c->surface.xwayland->surface;
 #endif
 	return c->surface.xdg->surface;
 }
 static inline int
 toplevel_from_wlr_surface(struct wlr_surface *s, Client **pc, LayerSurface **pl)
 {
 	struct wlr_xdg_surface *xdg_surface, *tmp_xdg_surface;
 	struct wlr_surface *root_surface;
 	struct wlr_layer_surface_v1 *layer_surface;
 	Client *c = NULL;
 	LayerSurface *l = NULL;
 	int type = -1;
 #ifdef XWAYLAND
 	struct wlr_xwayland_surface *xsurface;
 #endif
 	if (!s)
 		return -1;
 	root_surface = wlr_surface_get_root_surface(s);
 #ifdef XWAYLAND
 	if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(root_surface))) {
 		c = xsurface->data;
 		type = c->type;
 		goto end;
 	}
 #endif
 	if ((layer_surface = wlr_layer_surface_v1_try_from_wlr_surface(root_surface))) {
 		l = layer_surface->data;
 		type = LayerShell;
 		goto end;
 	}
 	xdg_surface = wlr_xdg_surface_try_from_wlr_surface(root_surface);
 	while (xdg_surface) {
 		tmp_xdg_surface = NULL;
 		switch (xdg_surface->role) {
 		case WLR_XDG_SURFACE_ROLE_POPUP:
 			if (!xdg_surface->popup || !xdg_surface->popup->parent)
 				return -1;
 			tmp_xdg_surface = wlr_xdg_surface_try_from_wlr_surface(xdg_surface->popup->parent);
 			if (!tmp_xdg_surface)
 				return toplevel_from_wlr_surface(xdg_surface->popup->parent, pc, pl);
 			xdg_surface = tmp_xdg_surface;
 			break;
 		case WLR_XDG_SURFACE_ROLE_TOPLEVEL:
 			c = xdg_surface->data;
 			type = c->type;
 			goto end;
 		case WLR_XDG_SURFACE_ROLE_NONE:
 			return -1;
 		}
 	}
 end:
 	if (pl)
 		*pl = l;
 	if (pc)
 		*pc = c;
 	return type;
 }
 /* The others */
 static inline void
 client_activate_surface(struct wlr_surface *s, int activated)
 {
 	struct wlr_xdg_toplevel *toplevel;
 #ifdef XWAYLAND
 	struct wlr_xwayland_surface *xsurface;
 	if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(s))) {
 		wlr_xwayland_surface_activate(xsurface, activated);
 		return;
 	}
 #endif
 	if ((toplevel = wlr_xdg_toplevel_try_from_wlr_surface(s)))
 		wlr_xdg_toplevel_set_activated(toplevel, activated);
 }
 static inline uint32_t
 client_set_bounds(Client *c, int32_t width, int32_t height)
 {
 #ifdef XWAYLAND
 	if (client_is_x11(c))
 		return 0;
 #endif
 	if (wl_resource_get_version(c->surface.xdg->toplevel->resource) >=
 			XDG_TOPLEVEL_CONFIGURE_BOUNDS_SINCE_VERSION && width >= 0 && height >= 0
 			&& (c->bounds.width != width || c->bounds.height != height)) {
 		c->bounds.width = width;
 		c->bounds.height = height;
 		return wlr_xdg_toplevel_set_bounds(c->surface.xdg->toplevel, width, height);
 	}
 	return 0;
 }
 static inline const char *
 client_get_appid(Client *c)
 {
 #ifdef XWAYLAND
 	if (client_is_x11(c))
 		return c->surface.xwayland->class ? c->surface.xwayland->class : "broken";
 #endif
 	return c->surface.xdg->toplevel->app_id ? c->surface.xdg->toplevel->app_id : "broken";
 }
 static inline void
 client_get_clip(Client *c, struct wlr_box *clip)
 {
 	*clip = (struct wlr_box){
 		.x = 0,
 		.y = 0,
 		.width = c->geom.width - c->bw,
 		.height = c->geom.height - c->bw,
 	};
 #ifdef XWAYLAND
 	if (client_is_x11(c))
 		return;
 #endif
 	clip->x = c->surface.xdg->geometry.x;
 	clip->y = c->surface.xdg->geometry.y;
 }
 static inline void
 client_get_geometry(Client *c, struct wlr_box *geom)
 {
 #ifdef XWAYLAND
 	if (client_is_x11(c)) {
 		geom->x = c->surface.xwayland->x;
 		geom->y = c->surface.xwayland->y;
 		geom->width = c->surface.xwayland->width;
 		geom->height = c->surface.xwayland->height;
 		return;
 	}
 #endif
 	*geom = c->surface.xdg->geometry;
 }
 static inline Client *
 client_get_parent(Client *c)
 {
 	Client *p = NULL;
 #ifdef XWAYLAND
 	if (client_is_x11(c)) {
 		if (c->surface.xwayland->parent)
 			toplevel_from_wlr_surface(c->surface.xwayland->parent->surface, &p, NULL);
 		return p;
 	}
 #endif
 	if (c->surface.xdg->toplevel->parent)
 		toplevel_from_wlr_surface(c->surface.xdg->toplevel->parent->base->surface, &p, NULL);
 	return p;
 }
 static inline int
 client_has_children(Client *c)
 {
 #ifdef XWAYLAND
 	if (client_is_x11(c))
 		return !wl_list_empty(&c->surface.xwayland->children);
 #endif
 	/* surface.xdg->link is never empty because it always contains at least the
 	 * surface itself. */
 	return wl_list_length(&c->surface.xdg->link) > 1;
 }
 static inline const char *
 client_get_title(Client *c)
 {
 #ifdef XWAYLAND
 	if (client_is_x11(c))
 		return c->surface.xwayland->title ? c->surface.xwayland->title : "broken";
 #endif
 	return c->surface.xdg->toplevel->title ? c->surface.xdg->toplevel->title : "broken";
 }
 static inline int
 client_is_float_type(Client *c)
 {
 	struct wlr_xdg_toplevel *toplevel;
 	struct wlr_xdg_toplevel_state state;
 #ifdef XWAYLAND
 	if (client_is_x11(c)) {
 		struct wlr_xwayland_surface *surface = c->surface.xwayland;
 		xcb_size_hints_t *size_hints = surface->size_hints;
 		if (surface->modal)
 			return 1;
 		if (wlr_xwayland_surface_has_window_type(surface, WLR_XWAYLAND_NET_WM_WINDOW_TYPE_DIALOG)
 				|| wlr_xwayland_surface_has_window_type(surface, WLR_XWAYLAND_NET_WM_WINDOW_TYPE_SPLASH)
 				|| wlr_xwayland_surface_has_window_type(surface, WLR_XWAYLAND_NET_WM_WINDOW_TYPE_TOOLBAR)
 				|| wlr_xwayland_surface_has_window_type(surface, WLR_XWAYLAND_NET_WM_WINDOW_TYPE_UTILITY)) {
 			return 1;
 		}
 		return size_hints && size_hints->min_width > 0 && size_hints->min_height > 0
 			&& (size_hints->max_width == size_hints->min_width
 				|| size_hints->max_height == size_hints->min_height);
 	}
 #endif
 	toplevel = c->surface.xdg->toplevel;
 	state = toplevel->current;
 	return toplevel->parent || (state.min_width != 0 && state.min_height != 0
 		&& (state.min_width == state.max_width
 			|| state.min_height == state.max_height));
 }
 static inline int
 client_is_rendered_on_mon(Client *c, Monitor *m)
 {
 	/* This is needed for when you don't want to check formal assignment,
 	 * but rather actual displaying of the pixels.
 	 * Usually VISIBLEON suffices and is also faster. */
 	struct wlr_surface_output *s;
 	int unused_lx, unused_ly;
 	if (!wlr_scene_node_coords(&c->scene->node, &unused_lx, &unused_ly))
 		return 0;
 	wl_list_for_each(s, &client_surface(c)->current_outputs, link)
 		if (s->output == m->wlr_output)
 			return 1;
 	return 0;
 }
 static inline int
 client_is_stopped(Client *c)
 {
 	int pid;
 	siginfo_t in = {0};
 #ifdef XWAYLAND
 	if (client_is_x11(c))
 		return 0;
 #endif
 	wl_client_get_credentials(c->surface.xdg->client->client, &pid, NULL, NULL);
 	if (waitid(P_PID, pid, &in, WNOHANG|WCONTINUED|WSTOPPED|WNOWAIT) < 0) {
 		/* This process is not our child process, while is very unluckely that
 		 * it is stopped, in order to do not skip frames assume that it is. */
 		if (errno == ECHILD)
 			return 1;
 	} else if (in.si_pid) {
 		if (in.si_code == CLD_STOPPED || in.si_code == CLD_TRAPPED)
 			return 1;
 		if (in.si_code == CLD_CONTINUED)
 			return 0;
 	}
 	return 0;
 }
 static inline int
 client_is_unmanaged(Client *c)
 {
 #ifdef XWAYLAND
 	if (client_is_x11(c))
 		return c->surface.xwayland->override_redirect;
 #endif
 	return 0;
 }
 static inline void
 client_notify_enter(struct wlr_surface *s, struct wlr_keyboard *kb)
 {
 	if (kb)
 		wlr_seat_keyboard_notify_enter(seat, s, kb->keycodes,
 				kb->num_keycodes, &kb->modifiers);
 	else
 		wlr_seat_keyboard_notify_enter(seat, s, NULL, 0, NULL);
 }
 static inline void
 client_send_close(Client *c)
 {
 #ifdef XWAYLAND
 	if (client_is_x11(c)) {
 		wlr_xwayland_surface_close(c->surface.xwayland);
 		return;
 	}
 #endif
 	wlr_xdg_toplevel_send_close(c->surface.xdg->toplevel);
 }
 static inline void
 client_set_border_color(Client *c, const float color[static 4])
 {
 	int i;
 	for (i = 0; i < 4; i++)
 		wlr_scene_rect_set_color(c->border[i], color);
 }
 static inline void
 client_set_fullscreen(Client *c, int fullscreen)
 {
 #ifdef XWAYLAND
 	if (client_is_x11(c)) {
 		wlr_xwayland_surface_set_fullscreen(c->surface.xwayland, fullscreen);
 		return;
 	}
 #endif
 	wlr_xdg_toplevel_set_fullscreen(c->surface.xdg->toplevel, fullscreen);
 }
 static inline void
 client_set_scale(struct wlr_surface *s, float scale)
 {
 	wlr_fractional_scale_v1_notify_scale(s, scale);
 	wlr_surface_set_preferred_buffer_scale(s, (int32_t)ceilf(scale));
 }
 static inline uint32_t
 client_set_size(Client *c, uint32_t width, uint32_t height)
 {
 #ifdef XWAYLAND
 	if (client_is_x11(c)) {
 		wlr_xwayland_surface_configure(c->surface.xwayland,
 				c->geom.x + c->bw, c->geom.y + c->bw, width, height);
 		return 0;
 	}
 #endif
 	if ((int32_t)width == c->surface.xdg->toplevel->current.width
 			&& (int32_t)height == c->surface.xdg->toplevel->current.height)
 		return 0;
 	return wlr_xdg_toplevel_set_size(c->surface.xdg->toplevel, (int32_t)width, (int32_t)height);
 }
 static inline void
 client_set_tiled(Client *c, uint32_t edges)
 {
 #ifdef XWAYLAND
 	if (client_is_x11(c)) {
 		wlr_xwayland_surface_set_maximized(c->surface.xwayland,
 				edges != WLR_EDGE_NONE, edges != WLR_EDGE_NONE);
 		return;
  }
 #endif
 	if (wl_resource_get_version(c->surface.xdg->toplevel->resource)
 			>= XDG_TOPLEVEL_STATE_TILED_RIGHT_SINCE_VERSION) {
 		wlr_xdg_toplevel_set_tiled(c->surface.xdg->toplevel, edges);
 	} else {
 		wlr_xdg_toplevel_set_maximized(c->surface.xdg->toplevel, edges != WLR_EDGE_NONE);
 	}
 }
 static inline void
 client_set_suspended(Client *c, int suspended)
 {
 #ifdef XWAYLAND
 	if (client_is_x11(c))
 		return;
 #endif
 	wlr_xdg_toplevel_set_suspended(c->surface.xdg->toplevel, suspended);
 }
 static inline int
 client_wants_focus(Client *c)
 {
 #ifdef XWAYLAND
 	return client_is_unmanaged(c)
 		&& wlr_xwayland_surface_override_redirect_wants_focus(c->surface.xwayland)
 		&& wlr_xwayland_surface_icccm_input_model(c->surface.xwayland) != WLR_ICCCM_INPUT_MODEL_NONE;
 #endif
 	return 0;
 }
 static inline int
 client_wants_fullscreen(Client *c)
 {
 #ifdef XWAYLAND
 	if (client_is_x11(c))
 		return c->surface.xwayland->fullscreen;
 #endif
 	return c->surface.xdg->toplevel->requested.fullscreen;
 }
--- a/config.def.h
+++ b/config.def.h
@ -1,31 +1,19 @@
 /* Taken from https://github.com/djpohly/dwl/issues/466 */
 #define COLOR(hex)    { ((hex >> 24) & 0xFF) / 255.0f, \
                        ((hex >> 16) & 0xFF) / 255.0f, \
                        ((hex >> 8) & 0xFF) / 255.0f, \
                        (hex & 0xFF) / 255.0f }
 /* appearance */
-static const int sloppyfocus               = 1;  /* focus follows mouse */
+static const int sloppyfocus        = 1;  /* focus follows mouse */
-static const int bypass_surface_visibility = 0;  /* 1 means idle inhibitors will disable idle tracking even if it's surface isn't visible  */
+static const unsigned int borderpx  = 1;  /* border pixel of windows */
-static const unsigned int borderpx         = 1;  /* border pixel of windows */
+static const float rootcolor[]      = {0.3, 0.3, 0.3, 1.0};
-static const float rootcolor[]             = COLOR(0x222222ff);
+static const float bordercolor[]    = {0.5, 0.5, 0.5, 1.0};
-static const float bordercolor[]           = COLOR(0x444444ff);
+static const float focuscolor[]     = {1.0, 0.0, 0.0, 1.0};
 static const float focuscolor[]            = COLOR(0x005577ff);
 static const float urgentcolor[]           = COLOR(0xff0000ff);
 /* This conforms to the xdg-protocol. Set the alpha to zero to restore the old behavior */
 static const float fullscreen_bg[]         = {0.1f, 0.1f, 0.1f, 1.0f}; /* You can also use glsl colors */
-/* tagging - TAGCOUNT must be no greater than 31 */
+/* tagging */
-#define TAGCOUNT (9)
+static const char *tags[] = { "1", "2", "3", "4", "5", "6", "7", "8", "9" };
 /* logging */
 static int log_level = WLR_ERROR;
 /* NOTE: ALWAYS keep a rule declared even if you don't use rules (e.g leave at least one example) */
 static const Rule rules[] = {
-	/* app_id             title       tags mask     isfloating   monitor */
+	/* app_id     title       tags mask     isfloating   monitor */
-	/* examples: */
+	/* examples:
-	{ "Gimp_EXAMPLE",     NULL,       0,            1,           -1 }, /* Start on currently visible tags floating, not tiled */
+	{ "Gimp",     NULL,       0,            1,           -1 },
-	{ "firefox_EXAMPLE",  NULL,       1 << 8,       0,           -1 }, /* Start on ONLY tag "9" */
+	{ "firefox",  NULL,       1 << 8,       0,           -1 },
 	*/
 };
 /* layout(s) */
@ -37,18 +25,13 @@ static const Layout layouts[] = {
 };
 /* monitors */
 /* (x=-1, y=-1) is reserved as an "autoconfigure" monitor position indicator
 * WARNING: negative values other than (-1, -1) cause problems with Xwayland clients
 * https://gitlab.freedesktop.org/xorg/xserver/-/issues/899
 */
 /* NOTE: ALWAYS add a fallback rule, even if you are completely sure it won't be used */
 static const MonitorRule monrules[] = {
-	/* name       mfact  nmaster scale layout       rotate/reflect                x    y */
+	/* name       mfact nmaster scale layout       rotate/reflect */
 	/* example of a HiDPI laptop monitor:
-	{ "eDP-1",    0.5f,  1,      2,    &layouts[0], WL_OUTPUT_TRANSFORM_NORMAL,   -1,  -1 },
+	{ "eDP-1",    0.5,  1,      2,    &layouts[0], WL_OUTPUT_TRANSFORM_NORMAL },
 	*/
 	/* defaults */
-	{ NULL,       0.55f, 1,      1,    &layouts[0], WL_OUTPUT_TRANSFORM_NORMAL,   -1,  -1 },
+	{ NULL,       0.55, 1,      1,    &layouts[0], WL_OUTPUT_TRANSFORM_NORMAL },
 };
 /* keyboard */
@ -57,58 +40,11 @@ static const struct xkb_rule_names xkb_rules = {
 	/* example:
 	.options = "ctrl:nocaps",
 	*/
 	.options = NULL,
 };
 static const int repeat_rate = 25;
 static const int repeat_delay = 600;
 /* Trackpad */
 static const int tap_to_click = 1;
 static const int tap_and_drag = 1;
 static const int drag_lock = 1;
 static const int natural_scrolling = 0;
 static const int disable_while_typing = 1;
 static const int left_handed = 0;
 static const int middle_button_emulation = 0;
 /* You can choose between:
 LIBINPUT_CONFIG_SCROLL_NO_SCROLL
 LIBINPUT_CONFIG_SCROLL_2FG
 LIBINPUT_CONFIG_SCROLL_EDGE
 LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN
 */
 static const enum libinput_config_scroll_method scroll_method = LIBINPUT_CONFIG_SCROLL_2FG;
 /* You can choose between:
 LIBINPUT_CONFIG_CLICK_METHOD_NONE
 LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS
 LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER
 */
 static const enum libinput_config_click_method click_method = LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS;
 /* You can choose between:
 LIBINPUT_CONFIG_SEND_EVENTS_ENABLED
 LIBINPUT_CONFIG_SEND_EVENTS_DISABLED
 LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE
 */
 static const uint32_t send_events_mode = LIBINPUT_CONFIG_SEND_EVENTS_ENABLED;
 /* You can choose between:
 LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT
 LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE
 */
 static const enum libinput_config_accel_profile accel_profile = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE;
 static const double accel_speed = 0.0;
 /* You can choose between:
 LIBINPUT_CONFIG_TAP_MAP_LRM -- 1/2/3 finger tap maps to left/right/middle
 LIBINPUT_CONFIG_TAP_MAP_LMR -- 1/2/3 finger tap maps to left/middle/right
 */
 static const enum libinput_config_tap_button_map button_map = LIBINPUT_CONFIG_TAP_MAP_LRM;
 /* If you want to use the windows key for MODKEY, use WLR_MODIFIER_LOGO */
 #define MODKEY WLR_MODIFIER_ALT
 #define TAGKEYS(KEY,SKEY,TAG) \
 	{ MODKEY,                    KEY,            view,            {.ui = 1 << TAG} }, \
 	{ MODKEY|WLR_MODIFIER_CTRL,  KEY,            toggleview,      {.ui = 1 << TAG} }, \
@ -119,20 +55,18 @@ static const enum libinput_config_tap_button_map button_map = LIBINPUT_CONFIG_TA
 #define SHCMD(cmd) { .v = (const char*[]){ "/bin/sh", "-c", cmd, NULL } }
 /* commands */
-static const char *termcmd[] = { "foot", NULL };
+static const char *termcmd[]  = { "alacritty", NULL };
 static const char *menucmd[] = { "wmenu-run", NULL };
 static const Key keys[] = {
 	/* Note that Shift changes certain key codes: c -> C, 2 -> at, etc. */
 	/* modifier                  key                 function        argument */
 	{ MODKEY,                    XKB_KEY_p,          spawn,          {.v = menucmd} },
 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_Return,     spawn,          {.v = termcmd} },
 	{ MODKEY,                    XKB_KEY_j,          focusstack,     {.i = +1} },
 	{ MODKEY,                    XKB_KEY_k,          focusstack,     {.i = -1} },
 	{ MODKEY,                    XKB_KEY_i,          incnmaster,     {.i = +1} },
 	{ MODKEY,                    XKB_KEY_d,          incnmaster,     {.i = -1} },
-	{ MODKEY,                    XKB_KEY_h,          setmfact,       {.f = -0.05f} },
+	{ MODKEY,                    XKB_KEY_h,          setmfact,       {.f = -0.05} },
-	{ MODKEY,                    XKB_KEY_l,          setmfact,       {.f = +0.05f} },
+	{ MODKEY,                    XKB_KEY_l,          setmfact,       {.f = +0.05} },
 	{ MODKEY,                    XKB_KEY_Return,     zoom,           {0} },
 	{ MODKEY,                    XKB_KEY_Tab,        view,           {0} },
 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_C,          killclient,     {0} },
@ -141,29 +75,23 @@ static const Key keys[] = {
 	{ MODKEY,                    XKB_KEY_m,          setlayout,      {.v = &layouts[2]} },
 	{ MODKEY,                    XKB_KEY_space,      setlayout,      {0} },
 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_space,      togglefloating, {0} },
 	{ MODKEY,                    XKB_KEY_e,         togglefullscreen, {0} },
 	{ MODKEY,                    XKB_KEY_0,          view,           {.ui = ~0} },
 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_parenright, tag,            {.ui = ~0} },
-	{ MODKEY,                    XKB_KEY_comma,      focusmon,       {.i = WLR_DIRECTION_LEFT} },
+	{ MODKEY,                    XKB_KEY_comma,      focusmon,       {.i = -1} },
-	{ MODKEY,                    XKB_KEY_period,     focusmon,       {.i = WLR_DIRECTION_RIGHT} },
+	{ MODKEY,                    XKB_KEY_period,     focusmon,       {.i = +1} },
-	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_less,       tagmon,         {.i = WLR_DIRECTION_LEFT} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_less,       tagmon,         {.i = -1} },
-	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_greater,    tagmon,         {.i = WLR_DIRECTION_RIGHT} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_greater,    tagmon,         {.i = +1} },
 	TAGKEYS(          XKB_KEY_1, XKB_KEY_exclam,                     0),
 	TAGKEYS(          XKB_KEY_2, XKB_KEY_at,                         1),
 	TAGKEYS(          XKB_KEY_3, XKB_KEY_numbersign,                 2),
 	TAGKEYS(          XKB_KEY_4, XKB_KEY_dollar,                     3),
 	TAGKEYS(          XKB_KEY_5, XKB_KEY_percent,                    4),
-	TAGKEYS(          XKB_KEY_6, XKB_KEY_asciicircum,                5),
+	TAGKEYS(          XKB_KEY_6, XKB_KEY_caret,                      5),
 	TAGKEYS(          XKB_KEY_7, XKB_KEY_ampersand,                  6),
 	TAGKEYS(          XKB_KEY_8, XKB_KEY_asterisk,                   7),
 	TAGKEYS(          XKB_KEY_9, XKB_KEY_parenleft,                  8),
 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_Q,          quit,           {0} },
 	/* Ctrl-Alt-Backspace and Ctrl-Alt-Fx used to be handled by X server */
 	{ WLR_MODIFIER_CTRL|WLR_MODIFIER_ALT,XKB_KEY_Terminate_Server, quit, {0} },
 	/* Ctrl-Alt-Fx is used to switch to another VT, if you don't know what a VT is
 	 * do not remove them.
 	 */
 #define CHVT(n) { WLR_MODIFIER_CTRL|WLR_MODIFIER_ALT,XKB_KEY_XF86Switch_VT_##n, chvt, {.ui = (n)} }
 	CHVT(1), CHVT(2), CHVT(3), CHVT(4), CHVT(5), CHVT(6),
 	CHVT(7), CHVT(8), CHVT(9), CHVT(10), CHVT(11), CHVT(12),
--- a/config.mk
+++ b/config.mk
@ -1,36 +1,5 @@
-_VERSION = 0.8-dev
+# Default compile flags (overridable by environment)
-VERSION  = `git describe --tags --dirty 2>/dev/null || echo $(_VERSION)`
+CFLAGS ?= -g -Wall -Wextra -Werror -Wno-unused-parameter -Wno-sign-compare -Wno-error=unused-function
 PKG_CONFIG = pkg-config
 # paths
 PREFIX = /usr/local
 MANDIR = $(PREFIX)/share/man
 DATADIR = $(PREFIX)/share
 WLR_INCS = `$(PKG_CONFIG) --cflags wlroots-0.19`
 WLR_LIBS = `$(PKG_CONFIG) --libs wlroots-0.19`
 # Allow using an alternative wlroots installations
 # This has to have all the includes required by wlroots, e.g:
 # Assuming wlroots git repo is "${PWD}/wlroots" and you only ran "meson setup build && ninja -C build"
 #WLR_INCS = -I/usr/include/pixman-1 -I/usr/include/elogind -I/usr/include/libdrm \
 #	-I$(PWD)/wlroots/include
 # Set -rpath to avoid using the wrong library.
 #WLR_LIBS = -Wl,-rpath,$(PWD)/wlroots/build -L$(PWD)/wlroots/build -lwlroots-0.19
 # Assuming you ran "meson setup --prefix ${PWD}/0.19 build && ninja -C build install"
 #WLR_INCS = -I/usr/include/pixman-1 -I/usr/include/elogind -I/usr/include/libdrm \
 #	-I$(PWD)/wlroots/0.19/include/wlroots-0.19
 #WLR_LIBS = -Wl,-rpath,$(PWD)/wlroots/0.19/lib64 -L$(PWD)/wlroots/0.19/lib64 -lwlroots-0.19
 XWAYLAND =
 XLIBS =
 # Uncomment to build XWayland support
-#XWAYLAND = -DXWAYLAND
+#CFLAGS += -DXWAYLAND
 #XLIBS = xcb xcb-icccm
 # dwl itself only uses C99 features, but wlroots' headers use anonymous unions (C11).
 # To avoid warnings about them, we do not use -std=c99 and instead of using the
 # gmake default 'CC=c99', we use cc.
 CC = cc
--- a/config.mma.def.h
+++ b/config.mma.def.h
@ -1,258 +0,0 @@
 /* Taken from https://github.com/djpohly/dwl/issues/466 */
 #define COLOR(hex)    { ((hex >> 24) & 0xFF) / 255.0f, \
                        ((hex >> 16) & 0xFF) / 255.0f, \
                        ((hex >> 8) & 0xFF) / 255.0f, \
                        (hex & 0xFF) / 255.0f }
 /* appearance */
 static const int sloppyfocus                = 0;  /* focus follows mouse */
 static const int bypass_surface_visibility  = 0;  /* 1 means idle inhibitors will disable idle tracking even if it's surface isn't visible  */
 static const unsigned int borderpx          = 10;  /* border pixel of windows */
 static const int lockfullscreen             = 1;  /* 1 will force focus on the fullscreen window */
 static const float rootcolor[]              = COLOR(0x4d4d4d66);
 static const float bordercolor[]            = COLOR(0x00000000);
 static const float focuscolor[]             = COLOR(0x12121212);
 static const float urgentcolor[]            = COLOR(0xff0000ff);
 /* To conform the xdg-protocol, set the alpha to zero to restore the old behavior */
 static const float fullscreen_bg[]          = COLOR(0x121212ff);
 /* tagging - TAGCOUNT must be no greater than 31 */
 #define TAGCOUNT (9)
 /* control variables */
 static int cfg_disable_touchpad = 1;
 static const char *cfg_touchpad_device_str = "Synaptic";
 /* logging */
 static int log_level = WLR_ERROR;
 static const Rule rules[] = {
 	/* app_id     title       tags mask     isfloating   monitor */
 	/* examples:
 	{ "firefox",  NULL,       1 << 8,       0,           -1 },
 	*/
 	{ "Gimp",     NULL,       0,            1,           -1 },
 };
 /* layout(s) */
 static const Layout layouts[] = {
 	/* symbol     arrange function */
 	{ "[]=",      tile },
 	{ "><>",      NULL },    /* no layout function means floating behavior */
 	{ "[M]",      monocle },
 };
 /* monitors */
 /* NOTE: ALWAYS add a fallback rule, even if you are completely sure it won't be used */
 static const MonitorRule monrules[] = {
 	/* name       mfact  nmaster scale layout       rotate/reflect                x    y */
 	/* example of a HiDPI laptop monitor:
 	{ "eDP-1",    0.5f,  1,      2,    &layouts[0], WL_OUTPUT_TRANSFORM_NORMAL,   -1,  -1 },
 	*/
 	/* defaults */
 	{ NULL,       0.55f, 1,      1,    &layouts[0], WL_OUTPUT_TRANSFORM_NORMAL,   -1,  -1 },
 };
 /* keyboard */
 static const struct xkb_rule_names xkb_rules = {
 	/* can specify fields: rules, model, layout, variant, options
     * Base rules in /usr/share/X11/xkb/rules/base.lst */
 	/* example:
 	.options = "ctrl:nocaps",
 	*/
 	.options = "caps:none,compose:rctrl",
 };
 static const int repeat_rate = 25;
 static const int repeat_delay = 600;
 /* Trackpad */
 static const int tap_to_click = 1;
 static const int tap_and_drag = 1;
 static const int drag_lock = 1;
 static const int natural_scrolling = 1;
 static const int disable_while_typing = 1;
 static const int left_handed = 0;
 static const int middle_button_emulation = 0;
 /* You can choose between:
 LIBINPUT_CONFIG_SCROLL_NO_SCROLL
 LIBINPUT_CONFIG_SCROLL_2FG
 LIBINPUT_CONFIG_SCROLL_EDGE
 LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN
 */
 static const enum libinput_config_scroll_method scroll_method = LIBINPUT_CONFIG_SCROLL_2FG;
 /* You can choose between:
 LIBINPUT_CONFIG_CLICK_METHOD_NONE
 LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS
 LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER
 */
 static const enum libinput_config_click_method click_method = LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS;
 /* You can choose between:
 LIBINPUT_CONFIG_SEND_EVENTS_ENABLED
 LIBINPUT_CONFIG_SEND_EVENTS_DISABLED
 LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE
 */
 static const uint32_t send_events_mode = LIBINPUT_CONFIG_SEND_EVENTS_ENABLED;
 /* You can choose between:
 LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT
 LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE
 */
 static const enum libinput_config_accel_profile accel_profile = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE;
 static const double accel_speed = 0.0;
 /* You can choose between:
 LIBINPUT_CONFIG_TAP_MAP_LRM -- 1/2/3 finger tap maps to left/right/middle
 LIBINPUT_CONFIG_TAP_MAP_LMR -- 1/2/3 finger tap maps to left/middle/right
 */
 static const enum libinput_config_tap_button_map button_map = LIBINPUT_CONFIG_TAP_MAP_LRM;
 /* If you want to use the windows key for MODKEY, use WLR_MODIFIER_LOGO */
 /* #define MODKEY WLR_MODIFIER_LOGO */
 #define MODKEY WLR_MODIFIER_ALT
 #define TAGKEYS(KEY,SKEY,TAG) \
 	{ MODKEY,                    KEY,            view,            {.ui = 1 << TAG} }, \
 	{ MODKEY|WLR_MODIFIER_CTRL,  KEY,            toggleview,      {.ui = 1 << TAG} }, \
 	{ MODKEY|WLR_MODIFIER_SHIFT, SKEY,           tag,             {.ui = 1 << TAG} }, \
 	{ MODKEY|WLR_MODIFIER_CTRL|WLR_MODIFIER_SHIFT,SKEY,toggletag, {.ui = 1 << TAG} }
 #define AD_STR(a) #a
 #define AD_CONCAT(a, b) AD_STR(a ## b)
 #define ACTKEYS_DECL(FUNCP) \
 	static const char *key_cmd_ ## FUNCP[]      = { "dwl_act", #FUNCP,     NULL }; \
 	static const char *key_cmd_S_ ## FUNCP[]    = { "dwl_act", AD_CONCAT(S_,FUNCP),   NULL }; \
 	static const char *key_cmd_C_ ## FUNCP[]    = { "dwl_act", AD_CONCAT(C_,FUNCP),   NULL }; \
 	static const char *key_cmd_SC_ ## FUNCP[]   = { "dwl_act", AD_CONCAT(SC_,FUNCP),  NULL }
 #define ACTKEYS_MAP(KEY,FUNCP) \
 	{ 0,                                     KEY,    spawn,  {.v =  key_cmd_ ## FUNCP} }, \
 	{ WLR_MODIFIER_CTRL,                     KEY,    spawn,  {.v =  key_cmd_C_ ## FUNCP} }, \
 	{ WLR_MODIFIER_SHIFT,                    KEY,    spawn,  {.v =  key_cmd_S_ ## FUNCP} }, \
 	{ WLR_MODIFIER_CTRL|WLR_MODIFIER_SHIFT,  KEY,    spawn,  {.v =  key_cmd_SC_ ## FUNCP} }
 /* helper for spawning shell commands in the pre dwm-5.0 fashion */
 #define SHCMD(cmd) { .v = (const char*[]){ "/bin/sh", "-c", cmd, NULL } }
 /* commands */
 static const char *webcmd[]                 = { "dwl_web",                  NULL };
 static const char *mailcmd[]                = { "dwl_email",                NULL };
 static const char *termcmd[]                = { "dwl_term",                 NULL };
 static const char *alttermcmd[]             = { "dwl_alt_term",             NULL };
 static const char *launchcmd[]              = { "dwl_dmenu",                NULL };
 static const char *dispcmd[]                = { "wdisplays",                NULL };
 static const char *lockcmd[]                = { "swaylock",                 NULL };
 /* Function key commands */
 ACTKEYS_DECL(vol_mute);
 ACTKEYS_DECL(vol_lower);
 ACTKEYS_DECL(vol_raise);
 ACTKEYS_DECL(mic_mute);
 ACTKEYS_DECL(bright_low);
 ACTKEYS_DECL(bright_high);
 ACTKEYS_DECL(disp);
 ACTKEYS_DECL(wlan);
 ACTKEYS_DECL(webcam);
 ACTKEYS_DECL(tools);
 ACTKEYS_DECL(search);
 ACTKEYS_DECL(launch);
 ACTKEYS_DECL(explore);
 ACTKEYS_DECL(print);
 ACTKEYS_DECL(media_toggle);
 ACTKEYS_DECL(media_stop);
 ACTKEYS_DECL(media_prev);
 ACTKEYS_DECL(media_next);
 static const Key keys[] = {
 	/* Note that Shift changes certain key codes: c -> C, 2 -> at, etc. */
 	/* modifier                  key                                function            argument */
 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_Return,                    spawn,              {.v = termcmd} },
 	{ MODKEY|WLR_MODIFIER_CTRL|WLR_MODIFIER_SHIFT,
                                 XKB_KEY_Return,                    spawn,              {.v = alttermcmd} },
 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_P,                         spawn,              {.v = launchcmd} },
 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_N,                         spawn,              {.v = dispcmd} },
 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_W,                         spawn,              {.v = webcmd} },
 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_E,                         spawn,              {.v = mailcmd} },
 	{ MODKEY,                    XKB_KEY_b,                         togglebar,          {0}},
 	{ MODKEY,                    XKB_KEY_j,                         focusstack,         {.i = +1} },
 	{ MODKEY,                    XKB_KEY_k,                         focusstack,         {.i = -1} },
 	{ MODKEY,                    XKB_KEY_i,                         incnmaster,         {.i = +1} },
 	{ MODKEY,                    XKB_KEY_d,                         incnmaster,         {.i = -1} },
 	{ MODKEY,                    XKB_KEY_h,                         setmfact,           {.f = -0.05f} },
 	{ MODKEY,                    XKB_KEY_l,                         setmfact,           {.f = +0.05f} },
 	{ MODKEY,                    XKB_KEY_Return,                    zoom,               {0} },
 	{ MODKEY,                    XKB_KEY_Tab,                       view,               {0} },
 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_C,                         killclient,         {0} },
 	{ MODKEY,                    XKB_KEY_t,                         setlayout,          {.v = &layouts[0]} },
 	{ MODKEY,                    XKB_KEY_f,                         setlayout,          {.v = &layouts[1]} },
 	{ MODKEY,                    XKB_KEY_m,                         setlayout,          {.v = &layouts[2]} },
 	{ MODKEY,                    XKB_KEY_space,                     setlayout,          {0} },
 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_space,                     togglefloating,     {0} },
 	{ MODKEY,                    XKB_KEY_e,                         togglefullscreen,
                                                                                        {0} },
 	{ MODKEY,                    XKB_KEY_0,                         view,               {.ui = ~0} },
 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_parenright,                tag,                {.ui = ~0} },
 	{ MODKEY,                    XKB_KEY_comma,                     focusmon,           {.i = WLR_DIRECTION_LEFT} },
 	{ MODKEY,                    XKB_KEY_period,                    focusmon,           {.i = WLR_DIRECTION_RIGHT} },
 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_less,                      tagmon,             {.i = WLR_DIRECTION_LEFT} },
 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_greater,                   tagmon,             {.i = WLR_DIRECTION_RIGHT} },
 	{ MODKEY|WLR_MODIFIER_CTRL|WLR_MODIFIER_SHIFT, XKB_KEY_Q,       quit,               {0} },
 	{ MODKEY|WLR_MODIFIER_CTRL|WLR_MODIFIER_SHIFT, XKB_KEY_L,       spawn,              {.v = lockcmd} },
 	{ WLR_MODIFIER_LOGO, XKB_KEY_l,                                 spawn,              {.v = lockcmd } },
 	{ WLR_MODIFIER_LOGO, XKB_KEY_p,                                 spawn,              {.v = key_cmd_disp } },
 	/* Ctrl-Alt-Backspace and Ctrl-Alt-Fx used to be handled by X server */
 	{ WLR_MODIFIER_CTRL|WLR_MODIFIER_ALT,XKB_KEY_Terminate_Server,  quit,               {0} },
    /* Media control keys without device specific action buttons */
 	{ WLR_MODIFIER_LOGO, XKB_KEY_space,                             spawn,              {.v = key_cmd_media_toggle } },
 	{ WLR_MODIFIER_LOGO, XKB_KEY_s,                                 spawn,              {.v = key_cmd_media_stop } },
 	{ WLR_MODIFIER_LOGO, XKB_KEY_period,                            spawn,              {.v = key_cmd_media_next } },
 	{ WLR_MODIFIER_LOGO, XKB_KEY_comma,                             spawn,              {.v = key_cmd_media_prev } },
 	{ WLR_MODIFIER_LOGO, XKB_KEY_a,                                 spawn,              {.v = key_cmd_vol_mute } },
 	{ WLR_MODIFIER_LOGO, XKB_KEY_z,                                 spawn,              {.v = key_cmd_vol_lower } },
 	{ WLR_MODIFIER_LOGO, XKB_KEY_q,                                 spawn,              {.v = key_cmd_vol_raise } },
 	/* Action buttons */
 	ACTKEYS_MAP(XKB_KEY_XF86AudioMute,                              vol_mute),
 	ACTKEYS_MAP(XKB_KEY_XF86AudioLowerVolume,                       vol_lower),
 	ACTKEYS_MAP(XKB_KEY_XF86AudioRaiseVolume,                       vol_raise),
 	ACTKEYS_MAP(XKB_KEY_XF86AudioMicMute,                           mic_mute),
 	ACTKEYS_MAP(XKB_KEY_XF86MonBrightnessDown,                      bright_low),
 	ACTKEYS_MAP(XKB_KEY_XF86MonBrightnessUp,                        bright_high),
 	ACTKEYS_MAP(XKB_KEY_XF86Display,                                disp),
 	ACTKEYS_MAP(XKB_KEY_XF86WLAN,                                   wlan),
 	ACTKEYS_MAP(XKB_KEY_XF86WebCam,                                 webcam),
 	ACTKEYS_MAP(XKB_KEY_XF86Tools,                                  tools),
 	ACTKEYS_MAP(XKB_KEY_XF86Search,                                 search),
 	ACTKEYS_MAP(XKB_KEY_XF86LaunchA,                                launch),
 	ACTKEYS_MAP(XKB_KEY_XF86Explorer,                               explore),
 	ACTKEYS_MAP(XKB_KEY_Print,                                      print),
 	ACTKEYS_MAP(XKB_KEY_XF86AudioPlay,                              media_toggle),
 	ACTKEYS_MAP(XKB_KEY_XF86AudioStop,                              media_stop),
 	ACTKEYS_MAP(XKB_KEY_XF86AudioPrev,                              media_prev),
 	ACTKEYS_MAP(XKB_KEY_XF86AudioNext,                              media_next),
 	/* { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_space,      toggle_touch_input_device,
                                                                    {0} },*/
 	TAGKEYS(          XKB_KEY_1, XKB_KEY_exclam,                    0),
 	TAGKEYS(          XKB_KEY_2, XKB_KEY_at,                        1),
 	TAGKEYS(          XKB_KEY_3, XKB_KEY_numbersign,                2),
 	TAGKEYS(          XKB_KEY_4, XKB_KEY_dollar,                    3),
 	TAGKEYS(          XKB_KEY_5, XKB_KEY_percent,                   4),
 	TAGKEYS(          XKB_KEY_6, XKB_KEY_asciicircum,               5),
 	TAGKEYS(          XKB_KEY_7, XKB_KEY_ampersand,                 6),
 	TAGKEYS(          XKB_KEY_8, XKB_KEY_asterisk,                  7),
 	TAGKEYS(          XKB_KEY_9, XKB_KEY_parenleft,                 8),
 	/* Ctrl-Alt-Fx is used to switch to another VT, if you don't know what a VT is
 	 * do not remove them.
 	 */
 #define CHVT(n) { WLR_MODIFIER_CTRL|WLR_MODIFIER_ALT,XKB_KEY_XF86Switch_VT_##n, chvt, {.ui = (n)} }
 	CHVT(1), CHVT(2), CHVT(3), CHVT(4), CHVT(5), CHVT(6),
 	CHVT(7), CHVT(8), CHVT(9), CHVT(10), CHVT(11), CHVT(12),
 };
 static const Button buttons[] = {
 	{ MODKEY, BTN_LEFT,   moveresize,     {.ui = CurMove} },
 	{ MODKEY, BTN_MIDDLE, togglefloating, {0} },
 	{ MODKEY, BTN_RIGHT,  moveresize,     {.ui = CurResize} },
 };
--- a/dwl.1
+++ b/dwl.1
@ -1,158 +0,0 @@
 .Dd January 8, 2021
 .Dt DWL 1
 .Os
 .Sh NAME
 .Nm dwl
 .Nd dwm for Wayland
 .Sh SYNOPSIS
 .Nm
 .Op Fl v
 .Op Fl d
 .Op Fl s Ar startup command
 .Sh DESCRIPTION
 .Nm
 is a Wayland compositor based on wlroots.
 It is intended to fill the same space in the Wayland world that
 .Nm dwm
 does for X11.
 .Pp
 When given the
 .Fl v
 option,
 .Nm
 writes its name and version to standard error and exits unsuccessfully.
 .Pp
 When given the
 .Fl d
 option,
 .Nm
 enables full wlroots logging, including debug information.
 .Pp
 When given the
 .Fl s
 option,
 .Nm
 starts a shell process running
 .Ar command
 when starting.
 When stopping, it sends
 .Dv SIGTERM
 to the child process and waits for it to exit.
 .Pp
 Users are encouraged to customize
 .Nm
 by editing the sources, in particular
 .Pa config.h .
 The default key bindings are as follows:
 .Bl -tag -width 20n -offset indent -compact
 .It Mod-[1-9]
 Show only all windows with a tag.
 .It Mod-Ctrl-[1-9]
 Show all windows with a tag.
 .It Mod-Shift-[1-9]
 Move window to a single tag.
 .It Mod-Ctrl-Shift-[1-9]
 Toggle tag for window.
 .It Mod-p
 Spawn
 .Nm wmenu-run .
 .It Mod-Shift-Return
 Spawn
 .Nm foot .
 .It Mod-[jk]
 Move focus down/up the stack.
 .It Mod-[id]
 Increase/decrease number of windows in master area.
 .It Mod-[hl]
 Decrease/increase master area.
 .It Mod-Return
 Move window on top of stack or switch top of stack with second window.
 .It Mod-Tab
 Show only all windows with previous tag.
 .It Mod-Shift-c
 Close window.
 .It Mod-t
 Switch to tabbed layout.
 .It Mod-f
 Switch to floating layout.
 .It Mod-m
 Switch to monocle layout.
 .It Mod-Space
 Switch to previous layout.
 .It Mod-Shift-Space
 Toggle floating state of window.
 .It Mod-e
 Toggle fullscreen state of window.
 .It Mod-0
 Show all windows.
 .It Mod-Shift-0
 Set all tags for window.
 .It Mod-,
 Move focus to previous monitor.
 .It Mod-.
 Move focus to next monitor.
 .It Mod-Shift-,
 Move window to previous monitor.
 .It Mod-Shift-.
 Move window to next monitor.
 .It Mod-Shift-q
 Quit
 .Nm .
 .El
 These might differ depending on your keyboard layout.
 .Sh ENVIRONMENT
 These environment variables are used by
 .Nm :
 .Bl -tag -width XDG_RUNTIME_DIR
 .It Ev XDG_RUNTIME_DIR
 A directory where temporary user files, such as the Wayland socket,
 are stored.
 .It Ev XDG_CONFIG_DIR
 A directory containing configuration of various programs and
 libraries, including libxkbcommon.
 .It Ev DISPLAY , WAYLAND_DISPLAY , WAYLAND_SOCKET
 Tell how to connect to an underlying X11 or Wayland server.
 .It Ev WLR_*
 Various variables specific to wlroots.
 .It Ev XKB_* , XLOCALEDIR , XCOMPOSEFILE
 Various variables specific to libxkbcommon.
 .It Ev XCURSOR_PATH
 List of directories to search for XCursor themes in.
 .It Ev HOME
 A directory where there are always dear files there for you.
 Waiting for you to clean them up.
 .El
 .Pp
 These are set by
 .Nm :
 .Bl -tag -width WAYLAND_DISPLAY
 .It Ev WAYLAND_DISPLAY
 Tell how to connect to
 .Nm .
 .It Ev DISPLAY
 If using
 .Nm Xwayland ,
 tell how to connect to the
 .Nm Xwayland
 server.
 .El
 .Sh EXAMPLES
 Start
 .Nm
 with s6 in the background:
 .Dl dwl \-s \(aqs6\-svscan <&\-\(aq
 .Sh SEE ALSO
 .Xr foot 1 ,
 .Xr wmenu 1 ,
 .Xr dwm 1 ,
 .Xr xkeyboard-config 7
 .Sh CAVEATS
 The child process's standard input is connected with a pipe to
 .Nm .
 If the child process neither reads from the pipe nor closes its
 standard input,
 .Nm
 will freeze after a while due to it blocking when writing to the full
 pipe buffer.
 .Sh BUGS
 All of them.
--- a/dwl.c
+++ b/dwl.c
--- a/dwl.desktop
+++ b/dwl.desktop
@ -1,5 +0,0 @@
 [Desktop Entry]
 Name=dwl
 Comment=dwm for Wayland
 Exec=dwl
 Type=Application
--- a/ipc-v2-fixed.patch
+++ b/ipc-v2-fixed.patch
@ -1,575 +0,0 @@
 diff --git a/Makefile b/Makefile
 index 5320e42..c13557c 100644
 --- a/Makefile
 +++ b/Makefile
@@ -14,10 +14,11 @@ DWLCFLAGS = `$(PKG_CONFIG) --cflags $(PKGS)` $(DWLCPPFLAGS) $(DWLDEVCFLAGS) $(CF
 LDLIBS    = `$(PKG_CONFIG) --libs $(PKGS)` $(LIBS)
 all: dwl
 -dwl: dwl.o util.o
 -	$(CC) dwl.o util.o $(LDLIBS) $(LDFLAGS) $(DWLCFLAGS) -o $@
 -dwl.o: dwl.c config.mk config.h client.h xdg-shell-protocol.h wlr-layer-shell-unstable-v1-protocol.h
 +dwl: dwl.o util.o dwl-ipc-unstable-v2-protocol.o
 +	$(CC) dwl.o util.o dwl-ipc-unstable-v2-protocol.o $(LDLIBS) $(LDFLAGS) $(DWLCFLAGS) -o $@
 +dwl.o: dwl.c config.mk config.h client.h xdg-shell-protocol.h wlr-layer-shell-unstable-v1-protocol.h dwl-ipc-unstable-v2-protocol.h
 util.o: util.c util.h
 +dwl-ipc-unstable-v2-protocol.o: dwl-ipc-unstable-v2-protocol.h
 # wayland-scanner is a tool which generates C headers and rigging for Wayland
 # protocols, which are specified in XML. wlroots requires you to rig these up
@@ -31,6 +32,12 @@ xdg-shell-protocol.h:
 wlr-layer-shell-unstable-v1-protocol.h:
 	$(WAYLAND_SCANNER) server-header \
 		protocols/wlr-layer-shell-unstable-v1.xml $@
 +dwl-ipc-unstable-v2-protocol.h:
 +	$(WAYLAND_SCANNER) server-header \
 +		protocols/dwl-ipc-unstable-v2.xml $@
 +dwl-ipc-unstable-v2-protocol.c:
 +	$(WAYLAND_SCANNER) private-code \
 +		protocols/dwl-ipc-unstable-v2.xml $@
 config.h:
 	cp config.def.h $@
 diff --git a/config.def.h b/config.def.h
 index 4e30885..f285840 100644
 --- a/config.def.h
 +++ b/config.def.h
@@ -120,6 +120,7 @@ static const Key keys[] = {
 	/* modifier                  key                 function        argument */
 	{ MODKEY,                    XKB_KEY_p,          spawn,          {.v = menucmd} },
 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_Return,     spawn,          {.v = termcmd} },
 +	{ MODKEY,                    XKB_KEY_b,          togglebar,      {0}},
 	{ MODKEY,                    XKB_KEY_j,          focusstack,     {.i = +1} },
 	{ MODKEY,                    XKB_KEY_k,          focusstack,     {.i = -1} },
 	{ MODKEY,                    XKB_KEY_i,          incnmaster,     {.i = +1} },
 diff --git a/dwl.c b/dwl.c
 index a7d41b0..e507e31 100644
 --- a/dwl.c
 +++ b/dwl.c
@@ -58,6 +58,7 @@
 #include <xcb/xcb_icccm.h>
 #endif
 +#include "dwl-ipc-unstable-v2-protocol.h"
 #include "util.h"
 /* macros */
@@ -128,6 +129,12 @@ typedef struct {
 	uint32_t resize; /* configure serial of a pending resize */
 } Client;
 +typedef struct {
 +	struct wl_list link;
 +	struct wl_resource *resource;
 +	Monitor *mon;
 +} DwlIpcOutput;
 +
 typedef struct {
 	uint32_t mod;
 	xkb_keysym_t keysym;
@@ -174,6 +181,7 @@ typedef struct {
 struct Monitor {
 	struct wl_list link;
 +	struct wl_list dwl_ipc_outputs;
 	struct wlr_output *wlr_output;
 	struct wlr_scene_output *scene_output;
 	struct wlr_scene_rect *fullscreen_bg; /* See createmon() for info */
@@ -255,6 +263,17 @@ static void destroynotify(struct wl_listener *listener, void *data);
 static void destroysessionlock(struct wl_listener *listener, void *data);
 static void destroysessionmgr(struct wl_listener *listener, void *data);
 static Monitor *dirtomon(enum wlr_direction dir);
 +static void dwl_ipc_manager_bind(struct wl_client *client, void *data, uint32_t version, uint32_t id);
 +static void dwl_ipc_manager_destroy(struct wl_resource *resource);
 +static void dwl_ipc_manager_get_output(struct wl_client *client, struct wl_resource *resource, uint32_t id, struct wl_resource *output);
 +static void dwl_ipc_manager_release(struct wl_client *client, struct wl_resource *resource);
 +static void dwl_ipc_output_destroy(struct wl_resource *resource);
 +static void dwl_ipc_output_printstatus(Monitor *monitor);
 +static void dwl_ipc_output_printstatus_to(DwlIpcOutput *ipc_output);
 +static void dwl_ipc_output_set_client_tags(struct wl_client *client, struct wl_resource *resource, uint32_t and_tags, uint32_t xor_tags);
 +static void dwl_ipc_output_set_layout(struct wl_client *client, struct wl_resource *resource, uint32_t index);
 +static void dwl_ipc_output_set_tags(struct wl_client *client, struct wl_resource *resource, uint32_t tagmask, uint32_t toggle_tagset);
 +static void dwl_ipc_output_release(struct wl_client *client, struct wl_resource *resource);
 static void focusclient(Client *c, int lift);
 static void focusmon(const Arg *arg);
 static void focusstack(const Arg *arg);
@@ -302,6 +321,7 @@ static void startdrag(struct wl_listener *listener, void *data);
 static void tag(const Arg *arg);
 static void tagmon(const Arg *arg);
 static void tile(Monitor *m);
 +static void togglebar(const Arg *arg);
 static void togglefloating(const Arg *arg);
 static void togglefullscreen(const Arg *arg);
 static void toggletag(const Arg *arg);
@@ -374,6 +394,8 @@ static struct wl_listener cursor_frame = {.notify = cursorframe};
 static struct wl_listener cursor_motion = {.notify = motionrelative};
 static struct wl_listener cursor_motion_absolute = {.notify = motionabsolute};
 static struct wl_listener drag_icon_destroy = {.notify = destroydragicon};
 +static struct zdwl_ipc_manager_v2_interface dwl_manager_implementation = {.release = dwl_ipc_manager_release, .get_output = dwl_ipc_manager_get_output};
 +static struct zdwl_ipc_output_v2_interface dwl_output_implementation = {.release = dwl_ipc_output_release, .set_tags = dwl_ipc_output_set_tags, .set_layout = dwl_ipc_output_set_layout, .set_client_tags = dwl_ipc_output_set_client_tags};
 static struct wl_listener idle_inhibitor_create = {.notify = createidleinhibitor};
 static struct wl_listener idle_inhibitor_destroy = {.notify = destroyidleinhibitor};
 static struct wl_listener layout_change = {.notify = updatemons};
@@ -691,6 +713,9 @@ cleanupmon(struct wl_listener *listener, void *data)
 	LayerSurface *l, *tmp;
 	int i;
 +	DwlIpcOutput *ipc_output, *ipc_output_tmp;
 +	wl_list_for_each_safe(ipc_output, ipc_output_tmp, &m->dwl_ipc_outputs, link)
 +		wl_resource_destroy(ipc_output->resource);
 	for (i = 0; i <= ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY; i++)
 		wl_list_for_each_safe(l, tmp, &m->layers[i], link)
 			wlr_layer_surface_v1_destroy(l->layer_surface);
@@ -902,6 +927,7 @@ createmon(struct wl_listener *listener, void *data)
 	Monitor *m = wlr_output->data = ecalloc(1, sizeof(*m));
 	m->wlr_output = wlr_output;
 +	wl_list_init(&m->dwl_ipc_outputs);
 	wlr_output_init_render(wlr_output, alloc, drw);
 	/* Initialize monitor state using configured rules */
@@ -1195,6 +1221,190 @@ dirtomon(enum wlr_direction dir)
 	return selmon;
 }
 +void
 +dwl_ipc_manager_bind(struct wl_client *client, void *data, uint32_t version, uint32_t id)
 +{
 +	struct wl_resource *manager_resource = wl_resource_create(client, &zdwl_ipc_manager_v2_interface, version, id);
 +	if (!manager_resource) {
 +		wl_client_post_no_memory(client);
 +		return;
 +	}
 +	wl_resource_set_implementation(manager_resource, &dwl_manager_implementation, NULL, dwl_ipc_manager_destroy);
 +
 +	zdwl_ipc_manager_v2_send_tags(manager_resource, TAGCOUNT);
 +
 +	for (int i = 0; i < LENGTH(layouts); i++)
 +		zdwl_ipc_manager_v2_send_layout(manager_resource, layouts[i].symbol);
 +}
 +
 +void
 +dwl_ipc_manager_destroy(struct wl_resource *resource)
 +{
 +	/* No state to destroy */
 +}
 +
 +void
 +dwl_ipc_manager_get_output(struct wl_client *client, struct wl_resource *resource, uint32_t id, struct wl_resource *output)
 +{
 +	DwlIpcOutput *ipc_output;
 +	Monitor *monitor = wlr_output_from_resource(output)->data;
 +	struct wl_resource *output_resource = wl_resource_create(client, &zdwl_ipc_output_v2_interface, wl_resource_get_version(resource), id);
 +	if (!output_resource)
 +		return;
 +
 +	ipc_output = ecalloc(1, sizeof(*ipc_output));
 +	ipc_output->resource = output_resource;
 +	ipc_output->mon = monitor;
 +	wl_resource_set_implementation(output_resource, &dwl_output_implementation, ipc_output, dwl_ipc_output_destroy);
 +	wl_list_insert(&monitor->dwl_ipc_outputs, &ipc_output->link);
 +	dwl_ipc_output_printstatus_to(ipc_output);
 +}
 +
 +void
 +dwl_ipc_manager_release(struct wl_client *client, struct wl_resource *resource)
 +{
 +	wl_resource_destroy(resource);
 +}
 +
 +static void
 +dwl_ipc_output_destroy(struct wl_resource *resource)
 +{
 +	DwlIpcOutput *ipc_output = wl_resource_get_user_data(resource);
 +	wl_list_remove(&ipc_output->link);
 +	free(ipc_output);
 +}
 +
 +void
 +dwl_ipc_output_printstatus(Monitor *monitor)
 +{
 +	DwlIpcOutput *ipc_output;
 +	wl_list_for_each(ipc_output, &monitor->dwl_ipc_outputs, link)
 +		dwl_ipc_output_printstatus_to(ipc_output);
 +}
 +
 +void
 +dwl_ipc_output_printstatus_to(DwlIpcOutput *ipc_output)
 +{
 +	Monitor *monitor = ipc_output->mon;
 +	Client *c, *focused;
 +	int tagmask, state, numclients, focused_client, tag;
 +	const char *title, *appid;
 +	focused = focustop(monitor);
 +	zdwl_ipc_output_v2_send_active(ipc_output->resource, monitor == selmon);
 +
 +	for (tag = 0 ; tag < TAGCOUNT; tag++) {
 +		numclients = state = focused_client = 0;
 +		tagmask = 1 << tag;
 +		if ((tagmask & monitor->tagset[monitor->seltags]) != 0)
 +			state |= ZDWL_IPC_OUTPUT_V2_TAG_STATE_ACTIVE;
 +
 +		wl_list_for_each(c, &clients, link) {
 +			if (c->mon != monitor)
 +				continue;
 +			if (!(c->tags & tagmask))
 +				continue;
 +			if (c == focused)
 +				focused_client = 1;
 +			if (c->isurgent)
 +				state |= ZDWL_IPC_OUTPUT_V2_TAG_STATE_URGENT;
 +
 +			numclients++;
 +		}
 +		zdwl_ipc_output_v2_send_tag(ipc_output->resource, tag, state, numclients, focused_client);
 +	}
 +	title = focused ? client_get_title(focused) : "";
 +	appid = focused ? client_get_appid(focused) : "";
 +
 +	zdwl_ipc_output_v2_send_layout(ipc_output->resource, monitor->lt[monitor->sellt] - layouts);
 +	zdwl_ipc_output_v2_send_title(ipc_output->resource, title ? title : broken);
 +	zdwl_ipc_output_v2_send_appid(ipc_output->resource, appid ? appid : broken);
 +	zdwl_ipc_output_v2_send_layout_symbol(ipc_output->resource, monitor->ltsymbol);
 +	if (wl_resource_get_version(ipc_output->resource) >= ZDWL_IPC_OUTPUT_V2_FULLSCREEN_SINCE_VERSION) {
 +		zdwl_ipc_output_v2_send_fullscreen(ipc_output->resource, focused ? focused->isfullscreen : 0);
 +	}
 +	if (wl_resource_get_version(ipc_output->resource) >= ZDWL_IPC_OUTPUT_V2_FLOATING_SINCE_VERSION) {
 +		zdwl_ipc_output_v2_send_floating(ipc_output->resource, focused ? focused->isfloating : 0);
 +	}
 +	zdwl_ipc_output_v2_send_frame(ipc_output->resource);
 +}
 +
 +void
 +dwl_ipc_output_set_client_tags(struct wl_client *client, struct wl_resource *resource, uint32_t and_tags, uint32_t xor_tags)
 +{
 +	DwlIpcOutput *ipc_output;
 +	Monitor *monitor;
 +	Client *selected_client;
 +	unsigned int newtags = 0;
 +
 +	ipc_output = wl_resource_get_user_data(resource);
 +	if (!ipc_output)
 +		return;
 +
 +	monitor = ipc_output->mon;
 +	selected_client = focustop(monitor);
 +	if (!selected_client)
 +		return;
 +
 +	newtags = (selected_client->tags & and_tags) ^ xor_tags;
 +	if (!newtags)
 +		return;
 +
 +	selected_client->tags = newtags;
 +	focusclient(focustop(selmon), 1);
 +	arrange(selmon);
 +	printstatus();
 +}
 +
 +void
 +dwl_ipc_output_set_layout(struct wl_client *client, struct wl_resource *resource, uint32_t index)
 +{
 +	DwlIpcOutput *ipc_output;
 +	Monitor *monitor;
 +
 +	ipc_output = wl_resource_get_user_data(resource);
 +	if (!ipc_output)
 +		return;
 +
 +	monitor = ipc_output->mon;
 +	if (index >= LENGTH(layouts))
 +		return;
 +	if (index != monitor->lt[monitor->sellt] - layouts)
 +		monitor->sellt ^= 1;
 +
 +	monitor->lt[monitor->sellt] = &layouts[index];
 +	arrange(monitor);
 +	printstatus();
 +}
 +
 +void
 +dwl_ipc_output_set_tags(struct wl_client *client, struct wl_resource *resource, uint32_t tagmask, uint32_t toggle_tagset)
 +{
 +	DwlIpcOutput *ipc_output;
 +	Monitor *monitor;
 +	unsigned int newtags = tagmask & TAGMASK;
 +
 +	ipc_output = wl_resource_get_user_data(resource);
 +	if (!ipc_output)
 +		return;
 +	monitor = ipc_output->mon;
 +
 +	if (!newtags || newtags == monitor->tagset[monitor->seltags])
 +		return;
 +	if (toggle_tagset)
 +		monitor->seltags ^= 1;
 +
 +	monitor->tagset[monitor->seltags] = newtags;
 +	focusclient(focustop(monitor), 1);
 +	arrange(monitor);
 +	printstatus();
 +}
 +
 +void
 +dwl_ipc_output_release(struct wl_client *client, struct wl_resource *resource)
 +{
 +	wl_resource_destroy(resource);
 +}
 +
 void
 focusclient(Client *c, int lift)
 {
@@ -1846,41 +2056,9 @@ void
 printstatus(void)
 {
 	Monitor *m = NULL;
 -	Client *c;
 -	uint32_t occ, urg, sel;
 -	const char *appid, *title;
 -	wl_list_for_each(m, &mons, link) {
 -		occ = urg = 0;
 -		wl_list_for_each(c, &clients, link) {
 -			if (c->mon != m)
 -				continue;
 -			occ |= c->tags;
 -			if (c->isurgent)
 -				urg |= c->tags;
 -		}
 -		if ((c = focustop(m))) {
 -			title = client_get_title(c);
 -			appid = client_get_appid(c);
 -			printf("%s title %s\n", m->wlr_output->name, title ? title : broken);
 -			printf("%s appid %s\n", m->wlr_output->name, appid ? appid : broken);
 -			printf("%s fullscreen %u\n", m->wlr_output->name, c->isfullscreen);
 -			printf("%s floating %u\n", m->wlr_output->name, c->isfloating);
 -			sel = c->tags;
 -		} else {
 -			printf("%s title \n", m->wlr_output->name);
 -			printf("%s appid \n", m->wlr_output->name);
 -			printf("%s fullscreen \n", m->wlr_output->name);
 -			printf("%s floating \n", m->wlr_output->name);
 -			sel = 0;
 -		}
 -
 -		printf("%s selmon %u\n", m->wlr_output->name, m == selmon);
 -		printf("%s tags %u %u %u %u\n", m->wlr_output->name, occ, m->tagset[m->seltags],
 -				sel, urg);
 -		printf("%s layout %s\n", m->wlr_output->name, m->ltsymbol);
 -	}
 -	fflush(stdout);
 +	wl_list_for_each(m, &mons, link)
 +		dwl_ipc_output_printstatus(m);
 }
 void
@@ -2295,6 +2473,7 @@ setup(void)
 	wl_signal_add(&output_mgr->events.test, &output_mgr_test);
 	wlr_scene_set_presentation(scene, wlr_presentation_create(dpy, backend));
 +	wl_global_create(dpy, &zdwl_ipc_manager_v2_interface, 2, NULL, dwl_ipc_manager_bind);
 #ifdef XWAYLAND
 	/*
@@ -2389,6 +2568,13 @@ tile(Monitor *m)
 	}
 }
 +void
 +togglebar(const Arg *arg) {
 +	DwlIpcOutput *ipc_output;
 +	wl_list_for_each(ipc_output, &selmon->dwl_ipc_outputs, link)
 +		zdwl_ipc_output_v2_send_toggle_visibility(ipc_output->resource);
 +}
 +
 void
 togglefloating(const Arg *arg)
 {
 diff --git a/protocols/dwl-ipc-unstable-v2.xml b/protocols/dwl-ipc-unstable-v2.xml
 new file mode 100644
 index 0000000..0a6e7e5
 --- /dev/null
 +++ b/protocols/dwl-ipc-unstable-v2.xml
@@ -0,0 +1,181 @@
 +<?xml version="1.0" encoding="utf-8"?>
 +<!--
 +This is largely ripped from somebar's ipc patchset; just with some personal modifications.
 +I would probably just submit raphi's patchset but I don't think that would be polite.
 +-->
 +<protocol name="dwl_ipc_unstable_v2">
 +  <description summary="inter-proccess-communication about dwl's state">
 +      This protocol allows clients to update and get updates from dwl.
 +
 +      Warning! The protocol described in this file is experimental and
 +      backward incompatible changes may be made. Backward compatible
 +      changes may be added together with the corresponding interface
 +      version bump.
 +      Backward incompatible changes are done by bumping the version
 +      number in the protocol and interface names and resetting the
 +      interface version. Once the protocol is to be declared stable,
 +      the 'z' prefix and the version number in the protocol and
 +      interface names are removed and the interface version number is
 +      reset.
 +  </description>
 +
 +  <interface name="zdwl_ipc_manager_v2" version="2">
 +    <description summary="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.
 +    </description>
 +
 +    <request name="release" type="destructor">
 +      <description summary="release dwl_ipc_manager">
 +        Indicates that the client will not the dwl_ipc_manager object anymore.
 +        Objects created through this instance are not affected.
 +      </description>
 +    </request>
 +
 +    <request name="get_output">
 +      <description summary="get a dwl_ipc_outout for a wl_output">
 +        Get a dwl_ipc_outout for the specified wl_output.
 +      </description>
 +      <arg name="id" type="new_id" interface="zdwl_ipc_output_v2"/>
 +      <arg name="output" type="object" interface="wl_output"/>
 +    </request>
 +
 +    <event name="tags">
 +      <description summary="Announces tag amount">
 +        This event is sent after binding.
 +        A roundtrip after binding guarantees the client recieved all tags.
 +      </description>
 +      <arg name="amount" type="uint"/>
 +    </event>
 +
 +    <event name="layout">
 +      <description summary="Announces a layout">
 +        This event is sent after binding.
 +        A roundtrip after binding guarantees the client recieved all layouts.
 +      </description>
 +      <arg name="name" type="string"/>
 +    </event>
 +  </interface>
 +
 +  <interface name="zdwl_ipc_output_v2" version="2">
 +    <description summary="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.
 +    </description>
 +
 +    <enum name="tag_state">
 +      <entry name="none" value="0" summary="no state"/>
 +      <entry name="active" value="1" summary="tag is active"/>
 +      <entry name="urgent" value="2" summary="tag has at least one urgent client"/>
 +    </enum>
 +
 +    <request name="release" type="destructor">
 +      <description summary="release dwl_ipc_outout">
 +        Indicates to that the client no longer needs this dwl_ipc_output.
 +      </description>
 +    </request>
 +
 +    <event name="toggle_visibility">
 +      <description summary="Toggle client visibilty">
 +        Indicates the client should hide or show themselves.
 +        If the client is visible then hide, if hidden then show.
 +      </description>
 +    </event>
 +
 +    <event name="active">
 +      <description summary="Update the selected output.">
 +        Indicates if the output is active. Zero is invalid, nonzero is valid.
 +      </description>
 +      <arg name="active" type="uint"/>
 +    </event>
 +
 +    <event name="tag">
 +      <description summary="Update the state of a tag.">
 +        Indicates that a tag has been updated.
 +      </description>
 +      <arg name="tag" type="uint" summary="Index of the tag"/>
 +      <arg name="state" type="uint" enum="tag_state" summary="The state of the tag."/>
 +      <arg name="clients" type="uint" summary="The number of clients in the tag."/>
 +      <arg name="focused" type="uint" summary="If there is a focused client. Nonzero being valid, zero being invalid."/>
 +    </event>
 +
 +    <event name="layout">
 +      <description summary="Update the layout.">
 +        Indicates a new layout is selected.
 +      </description>
 +      <arg name="layout" type="uint" summary="Index of the layout."/>
 +    </event>
 +
 +    <event name="title">
 +      <description summary="Update the title.">
 +        Indicates the title has changed.
 +      </description>
 +      <arg name="title" type="string" summary="The new title name."/>
 +    </event>
 +
 +    <event name="appid" since="1">
 +      <description summary="Update the appid.">
 +        Indicates the appid has changed.
 +      </description>
 +      <arg name="appid" type="string" summary="The new appid."/>
 +    </event>
 +
 +    <event name="layout_symbol" since="1">
 +      <description summary="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.
 +      </description>
 +      <arg name="layout" type="string" summary="The new layout"/>
 +    </event>
 +
 +    <event name="frame">
 +      <description summary="The update sequence is done.">
 +        Indicates that a sequence of status updates have finished and the client should redraw.
 +      </description>
 +    </event>
 +
 +    <request name="set_tags">
 +      <description summary="Set the active tags of this output"/>
 +      <arg name="tagmask" type="uint" summary="bitmask of the tags that should be set."/>
 +      <arg name="toggle_tagset" type="uint" summary="toggle the selected tagset, zero for invalid, nonzero for valid."/>
 +    </request>
 +
 +    <request name="set_client_tags">
 +      <description summary="Set the tags of the focused client.">
 +        The tags are updated as follows:
 +        new_tags = (current_tags AND and_tags) XOR xor_tags
 +      </description>
 +      <arg name="and_tags" type="uint"/>
 +      <arg name="xor_tags" type="uint"/>
 +    </request>
 +
 +    <request name="set_layout">
 +      <description summary="Set the layout of this output"/>
 +      <arg name="index" type="uint" summary="index of a layout recieved by dwl_ipc_manager.layout"/>
 +    </request>
 +
 +    <!-- Version 2 -->
 +    <event name="fullscreen" since="2">
 +      <description summary="Update fullscreen status">
 +          Indicates if the selected client on this output is fullscreen.
 +      </description>
 +      <arg name="is_fullscreen" type="uint" summary="If the selected client is fullscreen. Nonzero is valid, zero invalid"/>
 +    </event>
 +
 +    <event name="floating" since="2">
 +      <description summary="Update the floating status">
 +          Indicates if the selected client on this output is floating.
 +      </description>
 +      <arg name="is_floating" type="uint" summary="If the selected client is floating. Nonzero is valid, zero invalid"/>
 +    </event>
 +  </interface>
 +</protocol>
--- a/protocols/dwl-ipc-unstable-v2.xml
+++ b/protocols/dwl-ipc-unstable-v2.xml
@ -1,181 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!--
 This is largely ripped from somebar's ipc patchset; just with some personal modifications.
 I would probably just submit raphi's patchset but I don't think that would be polite.
 -->
 <protocol name="dwl_ipc_unstable_v2">
  <description summary="inter-proccess-communication about dwl's state">
      This protocol allows clients to update and get updates from dwl.
      Warning! The protocol described in this file is experimental and
      backward incompatible changes may be made. Backward compatible
      changes may be added together with the corresponding interface
      version bump.
      Backward incompatible changes are done by bumping the version
      number in the protocol and interface names and resetting the
      interface version. Once the protocol is to be declared stable,
      the 'z' prefix and the version number in the protocol and
      interface names are removed and the interface version number is
      reset.
  </description>
  <interface name="zdwl_ipc_manager_v2" version="2">
    <description summary="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.
    </description>
    <request name="release" type="destructor">
      <description summary="release dwl_ipc_manager">
        Indicates that the client will not the dwl_ipc_manager object anymore.
        Objects created through this instance are not affected.
      </description>
    </request>
    <request name="get_output">
      <description summary="get a dwl_ipc_outout for a wl_output">
        Get a dwl_ipc_outout for the specified wl_output.
      </description>
      <arg name="id" type="new_id" interface="zdwl_ipc_output_v2"/>
      <arg name="output" type="object" interface="wl_output"/>
    </request>
    <event name="tags">
      <description summary="Announces tag amount">
        This event is sent after binding.
        A roundtrip after binding guarantees the client recieved all tags.
      </description>
      <arg name="amount" type="uint"/>
    </event>
    <event name="layout">
      <description summary="Announces a layout">
        This event is sent after binding.
        A roundtrip after binding guarantees the client recieved all layouts.
      </description>
      <arg name="name" type="string"/>
    </event>
  </interface>
  <interface name="zdwl_ipc_output_v2" version="2">
    <description summary="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.
    </description>
    <enum name="tag_state">
      <entry name="none" value="0" summary="no state"/>
      <entry name="active" value="1" summary="tag is active"/>
      <entry name="urgent" value="2" summary="tag has at least one urgent client"/>
    </enum>
    <request name="release" type="destructor">
      <description summary="release dwl_ipc_outout">
        Indicates to that the client no longer needs this dwl_ipc_output.
      </description>
    </request>
    <event name="toggle_visibility">
      <description summary="Toggle client visibilty">
        Indicates the client should hide or show themselves.
        If the client is visible then hide, if hidden then show.
      </description>
    </event>
    <event name="active">
      <description summary="Update the selected output.">
        Indicates if the output is active. Zero is invalid, nonzero is valid.
      </description>
      <arg name="active" type="uint"/>
    </event>
    <event name="tag">
      <description summary="Update the state of a tag.">
        Indicates that a tag has been updated.
      </description>
      <arg name="tag" type="uint" summary="Index of the tag"/>
      <arg name="state" type="uint" enum="tag_state" summary="The state of the tag."/>
      <arg name="clients" type="uint" summary="The number of clients in the tag."/>
      <arg name="focused" type="uint" summary="If there is a focused client. Nonzero being valid, zero being invalid."/>
    </event>
    <event name="layout">
      <description summary="Update the layout.">
        Indicates a new layout is selected.
      </description>
      <arg name="layout" type="uint" summary="Index of the layout."/>
    </event>
    <event name="title">
      <description summary="Update the title.">
        Indicates the title has changed.
      </description>
      <arg name="title" type="string" summary="The new title name."/>
    </event>
    <event name="appid" since="1">
      <description summary="Update the appid.">
        Indicates the appid has changed.
      </description>
      <arg name="appid" type="string" summary="The new appid."/>
    </event>
    <event name="layout_symbol" since="1">
      <description summary="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.
      </description>
      <arg name="layout" type="string" summary="The new layout"/>
    </event>
    <event name="frame">
      <description summary="The update sequence is done.">
        Indicates that a sequence of status updates have finished and the client should redraw.
      </description>
    </event>
    <request name="set_tags">
      <description summary="Set the active tags of this output"/>
      <arg name="tagmask" type="uint" summary="bitmask of the tags that should be set."/>
      <arg name="toggle_tagset" type="uint" summary="toggle the selected tagset, zero for invalid, nonzero for valid."/>
    </request>
    <request name="set_client_tags">
      <description summary="Set the tags of the focused client.">
        The tags are updated as follows:
        new_tags = (current_tags AND and_tags) XOR xor_tags
      </description>
      <arg name="and_tags" type="uint"/>
      <arg name="xor_tags" type="uint"/>
    </request>
    <request name="set_layout">
      <description summary="Set the layout of this output"/>
      <arg name="index" type="uint" summary="index of a layout recieved by dwl_ipc_manager.layout"/>
    </request>
    <!-- Version 2 -->
    <event name="fullscreen" since="2">
      <description summary="Update fullscreen status">
          Indicates if the selected client on this output is fullscreen.
      </description>
      <arg name="is_fullscreen" type="uint" summary="If the selected client is fullscreen. Nonzero is valid, zero invalid"/>
    </event>
    <event name="floating" since="2">
      <description summary="Update the floating status">
          Indicates if the selected client on this output is floating.
      </description>
      <arg name="is_floating" type="uint" summary="If the selected client is floating. Nonzero is valid, zero invalid"/>
    </event>
  </interface>
 </protocol>
--- a/protocols/net-tapesoftware-dwl-wm-unstable-v1.xml
+++ b/protocols/net-tapesoftware-dwl-wm-unstable-v1.xml
@ -1,164 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <protocol name="net_tapesoftware_dwl_wm_unstable_v1">
    <copyright>
        Copyright (c) 2021 Raphael Robatsch
        Permission is hereby granted, free of charge, to any person obtaining a
        copy of this software and associated documentation files (the
        "Software"), to deal in the Software without restriction, including
        without limitation the rights to use, copy, modify, merge, publish,
        distribute, sublicense, and/or sell copies of the Software, and to
        permit persons to whom the Software is furnished to do so, subject to
        the following conditions:
        The above copyright notice and this permission notice (including the
        next paragraph) shall be included in all copies or substantial portions
        of the Software.
        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
        OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
        MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
        IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
        CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
        TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
        SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    </copyright>
    <interface name="znet_tapesoftware_dwl_wm_v1" version="1">
        <description summary="control the dwl state">
            This interface is exposed as a global in the wl_registry.
            Clients can use this protocol to receive updates of the window manager
            state (active tags, active layout, and focused window).
            Clients can also control this state.
            After binding, the client will receive the available tags and layouts
            with the 'tag' and 'layout' events. These can be used in subsequent
            dwl_wm_monitor_v1.set_tags/set_layout requests, and to interpret the
            dwl_wm_monitor_v1.layout/tag events.
        </description>
        <request name="release" type="destructor">
            <description summary="release dwl_wm">
                This request indicates that the client will not use the dwl_wm
                object any more. Objects that have been created through this instance
                are not affected.
            </description>
        </request>
        <request name="get_monitor">
            <description summary="gets a dwl monitor from an output">
                Gets a dwl monitor for the specified output. The window manager
                state on the output can be controlled using the monitor.
            </description>
            <arg name="id" type="new_id" interface="znet_tapesoftware_dwl_wm_monitor_v1" />
            <arg name="output" type="object" interface="wl_output" />
        </request>
        <event name="tag">
            <description summary="announces the presence of a tag">
                This event is sent immediately after binding.
                A roundtrip after binding guarantees that the client has received all tags.
            </description>
            <arg name="name" type="string"/>
        </event>
        <event name="layout">
            <description summary="announces the presence of a layout">
                This event is sent immediately after binding.
                A roundtrip after binding guarantees that the client has received all layouts.
            </description>
            <arg name="name" type="string"/>
        </event>
    </interface>
    <interface name="znet_tapesoftware_dwl_wm_monitor_v1" version="1">
        <description summary="control one monitor">
            Observes and controls one monitor.
            Events are double-buffered: Clients should cache all events and only
            redraw themselves once the 'frame' event is sent.
            Requests are not double-buffered: The compositor will update itself
            immediately.
        </description>
        <enum name="tag_state">
            <entry name="none" value="0" summary="no state"/>
            <entry name="active" value="1" summary="tag is active"/>
            <entry name="urgent" value="2" summary="tag has at least one urgent client"/>
        </enum>
        <request name="release" type="destructor">
            <description summary="release dwl_monitor">
                This request indicates that the client is done with this dwl_monitor.
                All further requests are ignored.
            </description>
        </request>
        <event name="selected">
            <description summary="updates the selected state of the monitor">
                If 'selected' is nonzero, this monitor is the currently selected one.
            </description>
            <arg name="selected" type="uint"/>
        </event>
        <event name="tag">
            <description summary="updates the state of one tag">
                Announces the update of a tag. num_clients and focused_client can be
                used to draw client indicators.
            </description>
            <arg name="tag" type="uint" summary="index of a tag received by the dwl_wm_v1.tag event." />
            <arg name="state" type="uint" enum="tag_state"/>
            <arg name="num_clients" type="uint" summary="number of clients on this tag"/>
            <arg name="focused_client" type="int" summary="out of num_clients. -1 if there is no focused client"/>
        </event>
        <event name="layout">
            <description summary="updates the selected layout">
                Announces the update of the selected layout.
            </description>
            <arg name="layout" type="uint" summary="index of a layout received by the dwl_wm_v1.layout event."/>
        </event>
        <event name="title">
            <description summary="updates the focused client">
                Announces the update of the selected client.
            </description>
            <arg name="title" type="string"/>
        </event>
        <event name="frame">
            <description summary="end of status update sequence">
                Sent after all other events belonging to the status update has been sent.
                Clients should redraw themselves now.
            </description>
        </event>
        <request name="set_tags">
            <description summary="sets the active tags on this monitor.">
                Changes are applied immediately.
            </description>
            <arg name="tagmask" type="uint" summary="bitmask of the tags that should be set."/>
            <arg name="toggle_tagset" type="uint"/>
        </request>
        <request name="set_client_tags">
            <description summary="updates the tags of the focused client.">
                tags are updated as follows:
                new_tags = (current_tags AND and_tags) XOR xor_tags
                Changes are applied immediately.
            </description>
            <arg name="and_tags" type="uint"/>
            <arg name="xor_tags" type="uint"/>
        </request>
        <request name="set_layout">
            <description summary="sets the active layout on this monitor.">
                Changes are applied immediately.
            </description>
            <arg name="layout" type="uint" summary="index of a layout received by the dwl_wm_v1.layout event."/>
        </request>
    </interface>
 </protocol>
--- a/protocols/wlr-layer-shell-unstable-v1.xml
+++ b/protocols/wlr-layer-shell-unstable-v1.xml
@ -1,390 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <protocol name="wlr_layer_shell_unstable_v1">
  <copyright>
    Copyright © 2017 Drew DeVault
    Permission to use, copy, modify, distribute, and sell this
    software and its documentation for any purpose is hereby granted
    without fee, provided that the above copyright notice appear in
    all copies and that both that copyright notice and this permission
    notice appear in supporting documentation, and that the name of
    the copyright holders not be used in advertising or publicity
    pertaining to distribution of the software without specific,
    written prior permission.  The copyright holders make no
    representations about the suitability of this software for any
    purpose.  It is provided "as is" without express or implied
    warranty.
    THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
    SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
    FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
    SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
    ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
    THIS SOFTWARE.
  </copyright>
  <interface name="zwlr_layer_shell_v1" version="4">
    <description summary="create surfaces that are layers of the desktop">
      Clients can use this interface to assign the surface_layer role to
      wl_surfaces. Such surfaces are assigned to a "layer" of the output and
      rendered with a defined z-depth respective to each other. They may also be
      anchored to the edges and corners of a screen and specify input handling
      semantics. This interface should be suitable for the implementation of
      many desktop shell components, and a broad number of other applications
      that interact with the desktop.
    </description>
    <request name="get_layer_surface">
      <description summary="create a layer_surface from a surface">
        Create a layer surface for an existing surface. This assigns the role of
        layer_surface, or raises a protocol error if another role is already
        assigned.
        Creating a layer surface from a wl_surface which has a buffer attached
        or committed is a client error, and any attempts by a client to attach
        or manipulate a buffer prior to the first layer_surface.configure call
        must also be treated as errors.
        After creating a layer_surface object and setting it up, the client
        must perform an initial commit without any buffer attached.
        The compositor will reply with a layer_surface.configure event.
        The client must acknowledge it and is then allowed to attach a buffer
        to map the surface.
        You may pass NULL for output to allow the compositor to decide which
        output to use. Generally this will be the one that the user most
        recently interacted with.
        Clients can specify a namespace that defines the purpose of the layer
        surface.
      </description>
      <arg name="id" type="new_id" interface="zwlr_layer_surface_v1"/>
      <arg name="surface" type="object" interface="wl_surface"/>
      <arg name="output" type="object" interface="wl_output" allow-null="true"/>
      <arg name="layer" type="uint" enum="layer" summary="layer to add this surface to"/>
      <arg name="namespace" type="string" summary="namespace for the layer surface"/>
    </request>
    <enum name="error">
      <entry name="role" value="0" summary="wl_surface has another role"/>
      <entry name="invalid_layer" value="1" summary="layer value is invalid"/>
      <entry name="already_constructed" value="2" summary="wl_surface has a buffer attached or committed"/>
    </enum>
    <enum name="layer">
      <description summary="available layers for surfaces">
        These values indicate which layers a surface can be rendered in. They
        are ordered by z depth, bottom-most first. Traditional shell surfaces
        will typically be rendered between the bottom and top layers.
        Fullscreen shell surfaces are typically rendered at the top layer.
        Multiple surfaces can share a single layer, and ordering within a
        single layer is undefined.
      </description>
      <entry name="background" value="0"/>
      <entry name="bottom" value="1"/>
      <entry name="top" value="2"/>
      <entry name="overlay" value="3"/>
    </enum>
    <!-- Version 3 additions -->
    <request name="destroy" type="destructor" since="3">
      <description summary="destroy the layer_shell object">
        This request indicates that the client will not use the layer_shell
        object any more. Objects that have been created through this instance
        are not affected.
      </description>
    </request>
  </interface>
  <interface name="zwlr_layer_surface_v1" version="4">
    <description summary="layer metadata interface">
      An interface that may be implemented by a wl_surface, for surfaces that
      are designed to be rendered as a layer of a stacked desktop-like
      environment.
      Layer surface state (layer, size, anchor, exclusive zone,
      margin, interactivity) is double-buffered, and will be applied at the
      time wl_surface.commit of the corresponding wl_surface is called.
      Attaching a null buffer to a layer surface unmaps it.
      Unmapping a layer_surface means that the surface cannot be shown by the
      compositor until it is explicitly mapped again. The layer_surface
      returns to the state it had right after layer_shell.get_layer_surface.
      The client can re-map the surface by performing a commit without any
      buffer attached, waiting for a configure event and handling it as usual.
    </description>
    <request name="set_size">
      <description summary="sets the size of the surface">
        Sets the size of the surface in surface-local coordinates. The
        compositor will display the surface centered with respect to its
        anchors.
        If you pass 0 for either value, the compositor will assign it and
        inform you of the assignment in the configure event. You must set your
        anchor to opposite edges in the dimensions you omit; not doing so is a
        protocol error. Both values are 0 by default.
        Size is double-buffered, see wl_surface.commit.
      </description>
      <arg name="width" type="uint"/>
      <arg name="height" type="uint"/>
    </request>
    <request name="set_anchor">
      <description summary="configures the anchor point of the surface">
        Requests that the compositor anchor the surface to the specified edges
        and corners. If two orthogonal edges are specified (e.g. 'top' and
        'left'), then the anchor point will be the intersection of the edges
        (e.g. the top left corner of the output); otherwise the anchor point
        will be centered on that edge, or in the center if none is specified.
        Anchor is double-buffered, see wl_surface.commit.
      </description>
      <arg name="anchor" type="uint" enum="anchor"/>
    </request>
    <request name="set_exclusive_zone">
      <description summary="configures the exclusive geometry of this surface">
        Requests that the compositor avoids occluding an area with other
        surfaces. The compositor's use of this information is
        implementation-dependent - do not assume that this region will not
        actually be occluded.
        A positive value is only meaningful if the surface is anchored to one
        edge or an edge and both perpendicular edges. If the surface is not
        anchored, anchored to only two perpendicular edges (a corner), anchored
        to only two parallel edges or anchored to all edges, a positive value
        will be treated the same as zero.
        A positive zone is the distance from the edge in surface-local
        coordinates to consider exclusive.
        Surfaces that do not wish to have an exclusive zone may instead specify
        how they should interact with surfaces that do. If set to zero, the
        surface indicates that it would like to be moved to avoid occluding
        surfaces with a positive exclusive zone. If set to -1, the surface
        indicates that it would not like to be moved to accommodate for other
        surfaces, and the compositor should extend it all the way to the edges
        it is anchored to.
        For example, a panel might set its exclusive zone to 10, so that
        maximized shell surfaces are not shown on top of it. A notification
        might set its exclusive zone to 0, so that it is moved to avoid
        occluding the panel, but shell surfaces are shown underneath it. A
        wallpaper or lock screen might set their exclusive zone to -1, so that
        they stretch below or over the panel.
        The default value is 0.
        Exclusive zone is double-buffered, see wl_surface.commit.
      </description>
      <arg name="zone" type="int"/>
    </request>
    <request name="set_margin">
      <description summary="sets a margin from the anchor point">
        Requests that the surface be placed some distance away from the anchor
        point on the output, in surface-local coordinates. Setting this value
        for edges you are not anchored to has no effect.
        The exclusive zone includes the margin.
        Margin is double-buffered, see wl_surface.commit.
      </description>
      <arg name="top" type="int"/>
      <arg name="right" type="int"/>
      <arg name="bottom" type="int"/>
      <arg name="left" type="int"/>
    </request>
    <enum name="keyboard_interactivity">
      <description summary="types of keyboard interaction possible for a layer shell surface">
        Types of keyboard interaction possible for layer shell surfaces. The
        rationale for this is twofold: (1) some applications are not interested
        in keyboard events and not allowing them to be focused can improve the
        desktop experience; (2) some applications will want to take exclusive
        keyboard focus.
      </description>
      <entry name="none" value="0">
        <description summary="no keyboard focus is possible">
          This value indicates that this surface is not interested in keyboard
          events and the compositor should never assign it the keyboard focus.
          This is the default value, set for newly created layer shell surfaces.
          This is useful for e.g. desktop widgets that display information or
          only have interaction with non-keyboard input devices.
        </description>
      </entry>
      <entry name="exclusive" value="1">
        <description summary="request exclusive keyboard focus">
          Request exclusive keyboard focus if this surface is above the shell surface layer.
          For the top and overlay layers, the seat will always give
          exclusive keyboard focus to the top-most layer which has keyboard
          interactivity set to exclusive. If this layer contains multiple
          surfaces with keyboard interactivity set to exclusive, the compositor
          determines the one receiving keyboard events in an implementation-
          defined manner. In this case, no guarantee is made when this surface
          will receive keyboard focus (if ever).
          For the bottom and background layers, the compositor is allowed to use
          normal focus semantics.
          This setting is mainly intended for applications that need to ensure
          they receive all keyboard events, such as a lock screen or a password
          prompt.
        </description>
      </entry>
      <entry name="on_demand" value="2" since="4">
        <description summary="request regular keyboard focus semantics">
          This requests the compositor to allow this surface to be focused and
          unfocused by the user in an implementation-defined manner. The user
          should be able to unfocus this surface even regardless of the layer
          it is on.
          Typically, the compositor will want to use its normal mechanism to
          manage keyboard focus between layer shell surfaces with this setting
          and regular toplevels on the desktop layer (e.g. click to focus).
          Nevertheless, it is possible for a compositor to require a special
          interaction to focus or unfocus layer shell surfaces (e.g. requiring
          a click even if focus follows the mouse normally, or providing a
          keybinding to switch focus between layers).
          This setting is mainly intended for desktop shell components (e.g.
          panels) that allow keyboard interaction. Using this option can allow
          implementing a desktop shell that can be fully usable without the
          mouse.
        </description>
      </entry>
    </enum>
    <request name="set_keyboard_interactivity">
      <description summary="requests keyboard events">
        Set how keyboard events are delivered to this surface. By default,
        layer shell surfaces do not receive keyboard events; this request can
        be used to change this.
        This setting is inherited by child surfaces set by the get_popup
        request.
        Layer surfaces receive pointer, touch, and tablet events normally. If
        you do not want to receive them, set the input region on your surface
        to an empty region.
        Keyboard interactivity is double-buffered, see wl_surface.commit.
      </description>
      <arg name="keyboard_interactivity" type="uint" enum="keyboard_interactivity"/>
    </request>
    <request name="get_popup">
      <description summary="assign this layer_surface as an xdg_popup parent">
        This assigns an xdg_popup's parent to this layer_surface.  This popup
        should have been created via xdg_surface::get_popup with the parent set
        to NULL, and this request must be invoked before committing the popup's
        initial state.
        See the documentation of xdg_popup for more details about what an
        xdg_popup is and how it is used.
      </description>
      <arg name="popup" type="object" interface="xdg_popup"/>
    </request>
    <request name="ack_configure">
      <description summary="ack a configure event">
        When a configure event is received, if a client commits the
        surface in response to the configure event, then the client
        must make an ack_configure request sometime before the commit
        request, passing along the serial of the configure event.
        If the client receives multiple configure events before it
        can respond to one, it only has to ack the last configure event.
        A client is not required to commit immediately after sending
        an ack_configure request - it may even ack_configure several times
        before its next surface commit.
        A client may send multiple ack_configure requests before committing, but
        only the last request sent before a commit indicates which configure
        event the client really is responding to.
      </description>
      <arg name="serial" type="uint" summary="the serial from the configure event"/>
    </request>
    <request name="destroy" type="destructor">
      <description summary="destroy the layer_surface">
        This request destroys the layer surface.
      </description>
    </request>
    <event name="configure">
      <description summary="suggest a surface change">
        The configure event asks the client to resize its surface.
        Clients should arrange their surface for the new states, and then send
        an ack_configure request with the serial sent in this configure event at
        some point before committing the new surface.
        The client is free to dismiss all but the last configure event it
        received.
        The width and height arguments specify the size of the window in
        surface-local coordinates.
        The size is a hint, in the sense that the client is free to ignore it if
        it doesn't resize, pick a smaller size (to satisfy aspect ratio or
        resize in steps of NxM pixels). If the client picks a smaller size and
        is anchored to two opposite anchors (e.g. 'top' and 'bottom'), the
        surface will be centered on this axis.
        If the width or height arguments are zero, it means the client should
        decide its own window dimension.
      </description>
      <arg name="serial" type="uint"/>
      <arg name="width" type="uint"/>
      <arg name="height" type="uint"/>
    </event>
    <event name="closed">
      <description summary="surface should be closed">
        The closed event is sent by the compositor when the surface will no
        longer be shown. The output may have been destroyed or the user may
        have asked for it to be removed. Further changes to the surface will be
        ignored. The client should destroy the resource after receiving this
        event, and create a new surface if they so choose.
      </description>
    </event>
    <enum name="error">
      <entry name="invalid_surface_state" value="0" summary="provided surface state is invalid"/>
      <entry name="invalid_size" value="1" summary="size is invalid"/>
      <entry name="invalid_anchor" value="2" summary="anchor bitfield is invalid"/>
      <entry name="invalid_keyboard_interactivity" value="3" summary="keyboard interactivity is invalid"/>
    </enum>
    <enum name="anchor" bitfield="true">
      <entry name="top" value="1" summary="the top edge of the anchor rectangle"/>
      <entry name="bottom" value="2" summary="the bottom edge of the anchor rectangle"/>
      <entry name="left" value="4" summary="the left edge of the anchor rectangle"/>
      <entry name="right" value="8" summary="the right edge of the anchor rectangle"/>
    </enum>
    <!-- Version 2 additions -->
    <request name="set_layer" since="2">
      <description summary="change the layer of the surface">
        Change the layer that the surface is rendered on.
        Layer is double-buffered, see wl_surface.commit.
      </description>
      <arg name="layer" type="uint" enum="zwlr_layer_shell_v1.layer" summary="layer to move this surface to"/>
    </request>
  </interface>
 </protocol>
--- a/protocols/wlr-output-power-management-unstable-v1.xml
+++ b/protocols/wlr-output-power-management-unstable-v1.xml
@ -1,128 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <protocol name="wlr_output_power_management_unstable_v1">
  <copyright>
    Copyright © 2019 Purism SPC
    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
    the rights to use, copy, modify, merge, publish, distribute, sublicense,
    and/or sell copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following conditions:
    The above copyright notice and this permission notice (including the next
    paragraph) shall be included in all copies or substantial portions of the
    Software.
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.
  </copyright>
  <description summary="Control power management modes of outputs">
    This protocol allows clients to control power management modes
    of outputs that are currently part of the compositor space. The
    intent is to allow special clients like desktop shells to power
    down outputs when the system is idle.
    To modify outputs not currently part of the compositor space see
    wlr-output-management.
    Warning! The protocol described in this file is experimental and
    backward incompatible changes may be made. Backward compatible changes
    may be added together with the corresponding interface version bump.
    Backward incompatible changes are done by bumping the version number in
    the protocol and interface names and resetting the interface version.
    Once the protocol is to be declared stable, the 'z' prefix and the
    version number in the protocol and interface names are removed and the
    interface version number is reset.
  </description>
  <interface name="zwlr_output_power_manager_v1" version="1">
    <description summary="manager to create per-output power management">
      This interface is a manager that allows creating per-output power
      management mode controls.
    </description>
    <request name="get_output_power">
      <description summary="get a power management for an output">
        Create a output power management mode control that can be used to
        adjust the power management mode for a given output.
      </description>
      <arg name="id" type="new_id" interface="zwlr_output_power_v1"/>
      <arg name="output" type="object" interface="wl_output"/>
    </request>
    <request name="destroy" type="destructor">
      <description summary="destroy the manager">
        All objects created by the manager will still remain valid, until their
        appropriate destroy request has been called.
      </description>
    </request>
  </interface>
  <interface name="zwlr_output_power_v1" version="1">
    <description summary="adjust power management mode for an output">
      This object offers requests to set the power management mode of
      an output.
    </description>
    <enum name="mode">
      <entry name="off" value="0"
             summary="Output is turned off."/>
      <entry name="on" value="1"
             summary="Output is turned on, no power saving"/>
    </enum>
    <enum name="error">
      <entry name="invalid_mode" value="1" summary="inexistent power save mode"/>
    </enum>
    <request name="set_mode">
      <description summary="Set an outputs power save mode">
        Set an output's power save mode to the given mode. The mode change
        is effective immediately. If the output does not support the given
        mode a failed event is sent.
      </description>
      <arg name="mode" type="uint" enum="mode" summary="the power save mode to set"/>
    </request>
    <event name="mode">
      <description summary="Report a power management mode change">
        Report the power management mode change of an output.
        The mode event is sent after an output changed its power
        management mode. The reason can be a client using set_mode or the
        compositor deciding to change an output's mode.
        This event is also sent immediately when the object is created
        so the client is informed about the current power management mode.
      </description>
      <arg name="mode" type="uint" enum="mode"
           summary="the output's new power management mode"/>
    </event>
    <event name="failed">
      <description summary="object no longer valid">
        This event indicates that the output power management mode control
        is no longer valid. This can happen for a number of reasons,
        including:
        - The output doesn't support power management
        - Another client already has exclusive power management mode control
          for this output
        - The output disappeared
        Upon receiving this event, the client should destroy this object.
      </description>
    </event>
    <request name="destroy" type="destructor">
      <description summary="destroy this power management">
        Destroys the output power management mode control object.
      </description>
    </request>
  </interface>
 </protocol>
--- a/util.c
+++ b/util.c
@ -1,51 +0,0 @@
 /* See LICENSE.dwm file for copyright and license details. */
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <fcntl.h>
 #include "util.h"
 void
 die(const char *fmt, ...) {
 	va_list ap;
 	va_start(ap, fmt);
 	vfprintf(stderr, fmt, ap);
 	va_end(ap);
 	if (fmt[0] && fmt[strlen(fmt)-1] == ':') {
 		fputc(' ', stderr);
 		perror(NULL);
 	} else {
 		fputc('\n', stderr);
 	}
 	exit(1);
 }
 void *
 ecalloc(size_t nmemb, size_t size)
 {
 	void *p;
 	if (!(p = calloc(nmemb, size)))
 		die("calloc:");
 	return p;
 }
 int
 fd_set_nonblock(int fd) {
 	int flags = fcntl(fd, F_GETFL);
 	if (flags < 0) {
 		perror("fcntl(F_GETFL):");
 		return -1;
 	}
 	if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {
 		perror("fcntl(F_SETFL):");
 		return -1;
 	}
 	return 0;
 }
--- a/util.h
+++ b/util.h
@ -1,5 +0,0 @@
 /* See LICENSE.dwm file for copyright and license details. */
 void die(const char *fmt, ...);
 void *ecalloc(size_t nmemb, size_t size);
 int fd_set_nonblock(int fd);