Applybounds doesn't move client when it overlays
only with border with monitor to the right.
Apparently, c->geom.width already includes the border
as well.
Previously we didn't take into account their borders requiring us to add
`borderpx` to override_redirect clients.
Fixes: https://codeberg.org/dwl/dwl/issues/651
This patch is based on the original stale patch by Guido Cella @guidocella.
It has been modified to apply cleanly to the latest v5.0 tag. Since the SLOC
limit is now lifted, this core feature should be merged into dwl upstream.
Thanks to Dima Krasner @dimkr for the cherry-pick.
Closes: #559, #525
When a user's startup_cmd is a little more complex, e.g. a shell script,
and forks off several processes, then killing only the main child pid
might leave unwanted processes behind on exit. Not all children will
notice when their parent or the compositor has quit.
To fix this, put startup_cmd into its own session and process group, and
kill the entire group on exit.
bemenu is very bloated, turning itself into a library, which makes it
7489 SLOC.
wmenu on the other hand, looks suckless by default, and is only 2000
SLOC, which i also find alot nicer to use, since bemenu does nothing
to replicate the original dmenu feel.
Make example rules be actual EXAMPLES.
Now newcomers should not have to ask, "When I start firefox, nothing
happens. What is going on?"
Also clarified a minor typo and a consistency in spacing.
When motionabsolute() is called from warpd, event->time_msec is 0, so
motionnotify() doesn't call wlr_cursor_move(). Fix this by explicitly
warping the cursor in this case, like it was done before implementing
pointer constraints.
I don't know if this is a bug in warpd or time_msec is always 0 with
virtual pointers, since the only other software that uses the virtual
pointer protocol I know of is wl-kbptr, and I can't get that to work
with dwl at all.
When a child window of a fullscreen client is mapped, the fullscreen is
disabled, and if the previously fullscreen client is floating the child
window is rendered below it and cannot be seen, causing confusion,
though it is still focused and interactable.
Fix this by putting children of fullscreen clients in LyrFS instead of
LyrFloat, and by returning before the unset_fullscreen code is called
when they are mapped.
focusstack() now lets you switch focus from a fullscreen client to its
child windows, otherwise if you switch focus from the child window to
the fullscreen client you could not focus the child window again and the
fullscreen client would stay unresponsive.
Child clients are not reparented to LyrFloat after leaving fullscreen,
so you could spawn a child window, focus back the fullscreen client,
unfullscreen it, and the child window would still be drawn above other
floating clients. Avoid dealing with this edge case to keep the line
count low.
These cases can be tested by pressing Ctrl+o in applications with an
open file dialog.
Revert 3213088 because the linked bug can no longer be reproduced with
wlroots 0.17, and update client_get_parent() so it doesn't segfault with
XWayland surfaces. This also allows reusing the p variable in the next
commit.
These don't do anything because wlr_scene_node_reparent() is immediately
called again by setfloating() through setmon(). They are also a source
of confusion because if you change the wlr_scene_node_reparent() call in
applyrules() it takes a while to understand why it doesn't work.
For wine clients often configurex11() is called before mapnotify() and
therefore c->mon is NULL. configurex11 just returns early in that case,
letting these clients stay in the wrong size. For example only the top
left part of winecfg and wine uninstaller is drawn, or confirmation
dialogs like when closing wine notepad are too big. Fix this by
configuring their surfaces like before 88d386b.
The compositor must respond to the client requesting a change to the decoration
mode, it does not matter if the compositor chooses a different mode.
This reverts commit 9071ce6c84.
previously it worked because we checked in every commit the layer
in a353eee2ca and
b100b446b8
we changed the way it's handled and now if the layer surface does not change
the layer we don't it either. meaning that if it was created in the bottom
layer and did not change the layer the popups would show behind xdg clients
Passing NULL to wlr_keyboard_set_keymap results in a segfault.
Example:
Thread 1 "dwl" received signal SIGSEGV, Segmentation fault.
0x00007ffff7e49b64 in xkb_keymap_ref () from /usr/lib/libxkbcommon.so.0
(gdb) bt
#0 0x00007ffff7e49b64 in xkb_keymap_ref () at /usr/lib/libxkbcommon.so.0
#1 0x00007ffff7f06389 in wlr_keyboard_set_keymap () at /usr/lib/libwlroots.so.11
#2 0x000055555555bc54 in createkeyboard ()
#3 0x000055555555c283 in inputdevice ()
#4 0x00007ffff7e8101e in wl_signal_emit_mutable () at /usr/lib/libwayland-server.so.0
#5 0x00007ffff7e8101e in wl_signal_emit_mutable () at /usr/lib/libwayland-server.so.0
#6 0x00007ffff7edb52c in () at /usr/lib/libwlroots.so.11
#7 0x00007ffff7ee44b6 in () at /usr/lib/libwlroots.so.11
#8 0x000055555555fe66 in main ()
the artifacts were caused because we tried to set the gamma right after
receiving the event, this resulted in two pending page-flips, which
not always play well together.
This also seems to fix a screen freeze when turning on a monitor that has
gamma.
Additionally the current method won't work once [0] is merged
[0]: https://gitlab.freedesktop.org/wlroots/wlroots/-/merge_requests/4423
Note that previous df131cdb78 libX11 headers
were also required for building (but not for runtime)
Also, I want to apologize to the packagers for do not list *all* the required
dependencies before.
For some reason brave configured for as a wayland client triggers this code on startup and segfaults.
Checking if the client is mapped fixes this, like with the previous fix for urgent border colour.
References: 887fde65a3
Fixes: 72a7d78a1a
Use an early return to avoid indenting the main logic instead of
wrapping the tail of a function in an if statement.
No functional change, except for a handful of places where printstatus()
was being called spuriously (tag, toggletag, toggleview).
ΔSLOC: 0
The scene graph implementation sends these for us, and it does so more
accurately than our overly-simplified approach. Layer shell surfaces
don't appear to receive these events at all, according to my
WAYLAND_DEBUG experiments with bemenu and dtao.
ΔSLOC: -4
If there is no current drag icon, this node will be empty, but we now
have `drag_icon != NULL` as an invariant. This allows us to eliminate a
conditional, since there's no harm in moving an empty node's coordinates
around with the pointer.
ΔSLOC: -1
This parallels the LISTEN macro for statically allocated listeners, and
it allows us to remove almost all of the global wl_listener
declarations.
This also fixes a bug with the axisnotify listener, which was declared
with a compound literal. At block scope, these have automatic storage
duration [1], so the listener was no longer valid after setup()
returned. (The option to declare it static explicitly was standardized
in C23, if that ever gains suckless traction.)
ΔSLOC: -27
[1]: https://en.cppreference.com/w/c/language/compound_literal#Explanation
If we treat the drag icon as distinct from other layers (it doesn't have
contents that are interactive, focusable, etc.), then we can iterate
over layers meaningfully with a simple for loop.
ΔSLOC: -8
while the size of `int` in most compilers is 32-bits, the size of int and all
other integer types are implementation defined, so make sure we can use up to
32-bits
- Replicate missing functionality from dwl to display the client count in monocle mode
- Add ltsymbol field to Monitor struct
- Display client count in monocle mode when greater than zero
- Tested with somebar and dwlb
selclient() does not work well when dealing newly mapped
clients (specifically those mapped on invisible tags).
This fixes various bugs related to things not working because selclient() would
return NULL.
References: 94c8bd6048
this also changes our policy about when we unset fullscreen:
dwl will unset fullscreen for clients who share tags (and monitor) with a newly
mapped client, it does not matter if the clients are visible or not
checking `bypass_surface_visibility` first, could cause that even if the idle
inhibitor is being destroyed it will disable idle tracking
and if we couldn't get its scene tree, then assume that the surface is visible
This reverts commit 035bb99d67.
Not checking `tree != NULL` result in a segfault if the surface doesn't have a
role (for example because it is a newly created surface)
Closes: https://github.com/djpohly/dwl/issues/359
When c->bw is 0, the right side of the MAX functions gets turned into an unsigned integer and that results in -1 being the outcome.
This causes big issues in xwayland clients.
this fixes another issue where the cursor doesn't change when selecting text
but there is still an issue about not changing border color of clients during
dnd operations
Bug: https://github.com/djpohly/dwl/issues/318
- allow user to use a different pkg-config binary
- restore almost all (and add other ones) warning flags (-Werror is not set)
- $(XWAYLAND) is added to our CPPFLAGS
- remove useless comments
- don't generate idle-protocol.h (not used)
it is closer to the suckless philosophy (foot implements things that the suckless
guys would say that should be done by tmux or something else, but I have no
desire to create a new terminal emulator, and the best fit is foot)
also alacritty uses +100Mb of memory, more that dwl itself (~90Mb)
and foot only ~20Mb
when using wlr_output_layout_move() wlroots internally
change the state of the output to manually configured and
when updating the layout these outputs aren't ignored by
wlroots, leaving us at our own
previously we tried to get a client from the surface and then compare it with
the excluded surface, if we cannot get a client from the surface (e.g: a layer
surface) it just ignored all the next idle inhibitors no matter what
What I have should done is just checking if the excluded surface is equal to
the current idle inhibitor's surface and continue in case it is.
this will help when sending to another monitor a fullscreen client
and also will prevent a crash when a client request fullscreen when it has no monitor
When the dwl executable is in use, cp fails without the -f flag.
POSIX defines this flag with:
> If a file descriptor for a destination file cannot be obtained,
> as described in step 3.a.ii., attempt to unlink the destination
> file and proceed.
dwl.c: In function ‘unmaplayersurface’:
dwl.c:2253:9: error: suggest parentheses around assignment used as truth value [-Werror=parentheses]
2253 | layersurface->layer_surface->mapped = layersurface->mapped = 0;
| ^~~~~~~~~~~~
cc1: all warnings being treated as errors
make: *** [<builtin>: dwl.o] Error 1
clang not affected
Initializing it to an empty string had broken configuring xkbcommon
through the environment (XKB_DEFAULT_OPTIONS).
Fixes: ae31391115 ("initialize rules and xkb_rules")
now client_surface()->data is a pointer to the wlr_scene_tree of clients
which allows us to not call wlr_scene_node_lower_to_bottom() for every clients
Check the wlr_layer_surface_v1_state.committed bitmask to see if we need
to rearrange. This is also what sway does.
Without this check, every commit request (even if only the attached buffer
changed) will lead to another configure event, which will lead to another
commit, etc.
This loop results in swaybg consuming 100% CPU.
Co-authored-by: Owen Rafferty <owen@owenrafferty.com>
On SIGCHLD, check to make sure the terminated process is not the
XWayland process before reaping it, allowing wlroots to waitpid() for it
successfully.
Fixes#177.
Prior to this change, if a client whose tag(s) are not currently
selected is launched or killed, no update to status was printed and
status bars being fed by printstatus() did not update newly active
or newly inactive (but unselected) tags.
SDL2 calls xdg_toplevel.unset_fullscreen() before the surface is
mapped. This causes a segfault in dwl because setfullscreen() expects
the surface to be mapped already.
Therefore, delay the setfullscreen call until the surface is mapped.
dup2 doesn’t close fds, it only duplicates them. The old ones weren’t
closed, causing problems (like dwl blocking due to the child process
never reading from the reading end, even if stdin has been closed).
- 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.
Join us on our [Discord server](https://discord.gg/jJxZnrGPWN)!
Join us on our IRC channel: [#dwl on Libera Chat]
Or on our [Discord server].
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:
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 2000 SLOC to promote hackability
- Tied to as few external dependencies as possible
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:
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.
- 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 input-inhibitor protocol to support screen lockers
- Implement the idle-inhibit protocol which lets applications such as mpv disable idle monitoring
- Layer shell popups (used by Waybar)
- Basic yes/no damage tracking to avoid needless redraws
- More in-depth damage region tracking ([which may improve power usage](https://mozillagfx.wordpress.com/2019/10/22/dramatically-reduced-power-usage-in-firefox-70-on-macos-with-core-animation/))
- 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://github.com/djpohly/dwl/pull/12)
- 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
- Client-initiated window management, such as move, resize, and close, which can
be done through the compositor
- Animations and visual effects
## Building dwl
dwl has only two dependencies: wlroots and wayland-protocols. Simply install these (and their `-devel` versions if your distro has separate development packages) and run `make`. If you wish to build against a Git version of wlroots, check out the [wlroots-next branch](https://github.com/djpohly/dwl/tree/wlroots-next).
dwl has the following dependencies:
```
libinput
wayland
wlroots (compiled with the libinput backend)
xkbcommon
wayland-protocols (compile-time only)
pkg-config (compile-time only)
```
If you enable X11 support:
```
libxcb
libxcb-wm
wlroots (compiled with X11 support)
Xwayland (runtime only)
```
To enable XWayland, you should also install xorg-xwayland and uncomment its flag in `config.mk`.
Simply install these (and their `-devel` versions if your distro has separate
development packages) and run `make`. If you wish to build against a Git
version of wlroots, check out the [wlroots-next branch].
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 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.
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.
As in the dwm community, we encourage users to share patches they have created. Check out the [patches page on our wiki](https://github.com/djpohly/dwl/wiki/Patches)!
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 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.
dwl can be run on any of the backends supported by wlroots. This means you can
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 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.
When dwl is run with no arguments, it will launch the server and begin handling
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 background color is black.
If you would like to run a script or command automatically at startup, you can 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](https://skarnet.org/software/s6/), [anopa](https://jjacky.com/anopa/), [runit](http://smarden.org/runit/faq.html#userservices), or [`systemd --user`](https://wiki.archlinux.org/title/Systemd/User).
If you would like to run a script or command automatically at startup, you can
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 does not have the ability to affect the environment of dwl or of any processes that it spawns. If you need to set environment variables that affect the entire 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 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.:
Note: The `-s` command is run as a *child process* of dwl, which means that it
does not have the ability to affect the environment of dwl or of any processes
that it spawns. If you need to set environment variables that affect the entire
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
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
@@ -64,28 +126,55 @@ Note: The `-s` command is run as a *child process* of dwl, which means that it d
### Status information
Information about selected layouts, current window title, and 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:
Information about selected layouts, current window title, app-id, and
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 <&-'
If your startup command is a shell script, you can achieve the same inside the script with the line
If your startup command is a shell script, you can achieve the same inside the
script with the line
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 Wayland applications on the sway wiki](https://github.com/swaywm/sway/wiki/i3-Migration-Guide).
## IRC channel
dwl's IRC channel is #dwl on irc.freenode.net.
You can find a [list of useful resources on our wiki].
## Acknowledgements
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.
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.
Many thanks to suckless.org and the dwm developers and community for the inspiration, and to the various contributors to the project, including:
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
- 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
[Discord server]: https://discord.gg/jJxZnrGPWN
[#dwl on Libera Chat]: https://web.libera.chat/?channels=#dwl
/* See LICENSE.dwm file for copyright and license details. */
voiddie(constchar*fmt,...);
void*ecalloc(size_tnmemb,size_tsize);
intfd_set_nonblock(intfd);
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
Leonardo Hernández Hernández