chore: update to dwl v0.3.1

.github/ISSUE_TEMPLATE/bug_report.md

@@ -7,4 +7,16 @@ assignees: ''
 
 ---
 
+## Info
+dwl's commit:
+wlroots version:
+## Description
+<!--
+Only report bugs that can be reproduced on the main line
+Report patch issues to their respective authors
+If the patch author doesn't respond within a reasonable time, email me:
 
+Leonardo Hernández Hernández <[email protected]>
+
+but note that I'm NOT making any promises
+-->

LICENSE

@@ -2,7 +2,7 @@ dwl - dwm for Wayland
 
 Copyright © 2020 dwl team
 
-See also the files LICENSE.tinywl and LICENSE.dwm.
+See also the files LICENSE.tinywl, LICENSE.dwm and LICENSE.sway.
 
 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

LICENSE.sway

@@ -0,0 +1,19 @@
+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.

Makefile

@@ -15,10 +15,11 @@ clean:
 	rm -f dwl *.o *-protocol.h *-protocol.c
 
 install: dwl
-	install -D dwl $(PREFIX)/bin/dwl
+	install -Dm755 dwl $(PREFIX)/bin/dwl
+	install -Dm644 dwl.1 $(MANDIR)/man1/dwl.1
 
 uninstall:
-	rm -f $(PREFIX)/bin/dwl
+	rm -f $(PREFIX)/bin/dwl $(MANDIR)/man1/dwl.1
 
 .PHONY: all clean install uninstall
 
@@ -65,6 +66,6 @@ dscm-unstable-v1-protocol.c:
 
 dscm-unstable-v1-protocol.o: dscm-unstable-v1-protocol.h
 
-dwl.o: dscm-utils.h dscm-bindings.h dscm-config.h client.h xdg-shell-protocol.h wlr-layer-shell-unstable-v1-protocol.h idle-protocol.h dscm-unstable-v1-protocol.h
+dwl.o: dscm-utils.h dscm-bindings.h dscm-config.h client.h xdg-shell-protocol.h wlr-layer-shell-unstable-v1-protocol.h idle-protocol.h dscm-unstable-v1-protocol.h util.h
 
-dwl: xdg-shell-protocol.o wlr-layer-shell-unstable-v1-protocol.o idle-protocol.o dscm-unstable-v1-protocol.o
+dwl: xdg-shell-protocol.o wlr-layer-shell-unstable-v1-protocol.o idle-protocol.o util.o dscm-unstable-v1-protocol.o

client.h

@@ -5,170 +5,241 @@
  * that they will simply compile out if the chosen #defines leave them unused.
  */
 
-/* Leave this function first; it's used in the others */
+/* Leave these functions first; they're used in the others */
 static inline int
 client_is_x11(Client *c)
 {
 #ifdef XWAYLAND
-	return c->type == X11Managed || c->type == X11Unmanaged;
+        return c->type == X11Managed || c->type == X11Unmanaged;
 #else
-	return 0;
+        return 0;
 #endif
 }
 
+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;
+}
+
 /* The others */
 static inline void
 client_activate_surface(struct wlr_surface *s, int activated)
 {
 #ifdef XWAYLAND
-	if (wlr_surface_is_xwayland_surface(s)) {
-		wlr_xwayland_surface_activate(
-				wlr_xwayland_surface_from_wlr_surface(s), activated);
-		return;
-	}
+        if (wlr_surface_is_xwayland_surface(s)) {
+                wlr_xwayland_surface_activate(
+                                wlr_xwayland_surface_from_wlr_surface(s), activated);
+                return;
+        }
 #endif
-	if (wlr_surface_is_xdg_surface(s))
-		wlr_xdg_toplevel_set_activated(
-				wlr_xdg_surface_from_wlr_surface(s), activated);
+        if (wlr_surface_is_xdg_surface(s))
+                wlr_xdg_toplevel_set_activated(
+                                wlr_xdg_surface_from_wlr_surface(s), activated);
 }
 
 static inline void
 client_for_each_surface(Client *c, wlr_surface_iterator_func_t fn, void *data)
 {
+        wlr_surface_for_each_surface(client_surface(c), fn, data);
 #ifdef XWAYLAND
-	if (client_is_x11(c)) {
-		wlr_surface_for_each_surface(c->surface.xwayland->surface,
-				fn, data);
-		return;
-	}
+        if (client_is_x11(c))
+                return;
 #endif
-	wlr_xdg_surface_for_each_surface(c->surface.xdg, fn, data);
+        wlr_xdg_surface_for_each_popup_surface(c->surface.xdg, fn, data);
 }
 
 static inline const char *
 client_get_appid(Client *c)
 {
 #ifdef XWAYLAND
-	if (client_is_x11(c))
-		return c->surface.xwayland->class;
+        if (client_is_x11(c))
+                return c->surface.xwayland->class;
 #endif
-	return c->surface.xdg->toplevel->app_id;
+        return c->surface.xdg->toplevel->app_id;
 }
 
 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;
-	}
+        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
-	wlr_xdg_surface_get_geometry(c->surface.xdg, geom);
+        wlr_xdg_surface_get_geometry(c->surface.xdg, geom);
 }
 
 static inline const char *
 client_get_title(Client *c)
 {
 #ifdef XWAYLAND
-	if (client_is_x11(c))
-		return c->surface.xwayland->title;
+        if (client_is_x11(c))
+                return c->surface.xwayland->title;
 #endif
-	return c->surface.xdg->toplevel->title;
+        return c->surface.xdg->toplevel->title;
 }
 
 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;
+                struct wlr_xwayland_surface_size_hints *size_hints;
+                if (surface->modal)
+                        return 1;
+
+                for (size_t i = 0; i < surface->window_type_len; i++)
+                        if (surface->window_type[i] == netatom[NetWMWindowTypeDialog] ||
+                                        surface->window_type[i] == netatom[NetWMWindowTypeSplash] ||
+                                        surface->window_type[i] == netatom[NetWMWindowTypeToolbar] ||
+                                        surface->window_type[i] == netatom[NetWMWindowTypeUtility])
+                                return 1;
+
+                size_hints = surface->size_hints;
+                if (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))
+                        return 1;
+
+                return 0;
+        }
+#endif
+
+        toplevel = c->surface.xdg->toplevel;
+        state = toplevel->current;
+        return (state.min_width != 0 && state.min_height != 0
+                && (state.min_width == state.max_width
+                || state.min_height == state.max_height))
+                || toplevel->parent;
+}
+
+static inline int
+client_wants_fullscreen(Client *c)
 {
 #ifdef XWAYLAND
-	if (client_is_x11(c))
-		for (size_t i = 0; i < c->surface.xwayland->window_type_len; i++)
-			if (c->surface.xwayland->window_type[i] == netatom[NetWMWindowTypeDialog] ||
-					c->surface.xwayland->window_type[i] == netatom[NetWMWindowTypeSplash] ||
-					c->surface.xwayland->window_type[i] == netatom[NetWMWindowTypeToolbar] ||
-					c->surface.xwayland->window_type[i] == netatom[NetWMWindowTypeUtility])
-				return 1;
+        if (client_is_x11(c))
+                return c->surface.xwayland->fullscreen;
 #endif
-	return 0;
+        return c->surface.xdg->toplevel->requested.fullscreen;
 }
 
 static inline int
 client_is_unmanaged(Client *c)
 {
 #ifdef XWAYLAND
-	return c->type == X11Unmanaged;
+        return c->type == X11Unmanaged;
 #endif
-	return 0;
+        return 0;
 }
 
 static inline void
 client_send_close(Client *c)
 {
 #ifdef XWAYLAND
-	if (client_is_x11(c)) {
-		wlr_xwayland_surface_close(c->surface.xwayland);
-		return;
-	}
+        if (client_is_x11(c)) {
+                wlr_xwayland_surface_close(c->surface.xwayland);
+                return;
+        }
 #endif
-	wlr_xdg_toplevel_send_close(c->surface.xdg);
+        wlr_xdg_toplevel_send_close(c->surface.xdg);
 }
 
 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;
-	}
+        if (client_is_x11(c)) {
+                wlr_xwayland_surface_set_fullscreen(c->surface.xwayland, fullscreen);
+                return;
+        }
 #endif
-	wlr_xdg_toplevel_set_fullscreen(c->surface.xdg, fullscreen);
+        wlr_xdg_toplevel_set_fullscreen(c->surface.xdg, fullscreen);
 }
 
 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->geom.y, width, height);
-		return 0;
-	}
+        if (client_is_x11(c)) {
+                wlr_xwayland_surface_configure(c->surface.xwayland,
+                                c->geom.x, c->geom.y, width, height);
+                return 0;
+        }
 #endif
-	return wlr_xdg_toplevel_set_size(c->surface.xdg, width, height);
+        return wlr_xdg_toplevel_set_size(c->surface.xdg, width, height);
 }
 
 static inline void
 client_set_tiled(Client *c, uint32_t edges)
 {
 #ifdef XWAYLAND
-	if (client_is_x11(c))
-		return;
+        if (client_is_x11(c))
+                return;
 #endif
-	wlr_xdg_toplevel_set_tiled(c->surface.xdg, WLR_EDGE_TOP |
-			WLR_EDGE_BOTTOM | WLR_EDGE_LEFT | WLR_EDGE_RIGHT);
+        wlr_xdg_toplevel_set_tiled(c->surface.xdg, edges);
 }
 
 static inline struct wlr_surface *
-client_surface(Client *c)
+client_surface_at(Client *c, double cx, double cy, double *sx, double *sy)
 {
 #ifdef XWAYLAND
-	if (client_is_x11(c))
-		return c->surface.xwayland->surface;
+        if (client_is_x11(c))
+                return wlr_surface_surface_at(c->surface.xwayland->surface,
+                                cx, cy, sx, sy);
 #endif
-	return c->surface.xdg->surface;
+        return wlr_xdg_surface_surface_at(c->surface.xdg, cx, cy, sx, sy);
 }
 
-static inline struct wlr_surface *
-client_surface_at(Client *c, double cx, double cy, double *sx, double *sy)
+static inline void
+client_min_size(Client *c, int *width, int *height)
 {
+        struct wlr_xdg_toplevel *toplevel;
+        struct wlr_xdg_toplevel_state *state;
 #ifdef XWAYLAND
-	if (client_is_x11(c))
-		return wlr_surface_surface_at(c->surface.xwayland->surface,
-				cx, cy, sx, sy);
+        if (client_is_x11(c)) {
+                struct wlr_xwayland_surface_size_hints *size_hints;
+                size_hints = c->surface.xwayland->size_hints;
+                *width = size_hints->min_width;
+                *height = size_hints->min_height;
+                return;
+        }
 #endif
-	return wlr_xdg_surface_surface_at(c->surface.xdg, cx, cy, sx, sy);
+        toplevel = c->surface.xdg->toplevel;
+        state = &toplevel->current;
+        *width = state->min_width;
+        *height = state->min_height;
+}
+
+static inline Client *
+client_from_popup(struct wlr_xdg_popup *popup)
+{
+        struct wlr_xdg_surface *surface = popup->base;
+
+        while (1) {
+                switch (surface->role) {
+                case WLR_XDG_SURFACE_ROLE_POPUP:
+                        if (!wlr_surface_is_xdg_surface(surface->popup->parent))
+                                return NULL;
+
+                        surface = wlr_xdg_surface_from_wlr_surface(surface->popup->parent);
+                        break;
+                case WLR_XDG_SURFACE_ROLE_TOPLEVEL:
+                                return surface->data;
+                case WLR_XDG_SURFACE_ROLE_NONE:
+                        return NULL;
+                }
+        }
 }

config.mk

@@ -1,8 +1,9 @@
 # paths
 PREFIX = /usr/local
+MANDIR = $(PREFIX)/share/man
 
 # Default compile flags (overridable by environment)
-CFLAGS ?= -g -Wall -Wextra -Werror -Wno-unused-parameter -Wno-sign-compare -Wno-unused-function -Wno-unused-variable -Wdeclaration-after-statement
+CFLAGS ?= -g -Wall -Wextra -Werror -Wno-unused-parameter -Wno-sign-compare -Wno-unused-function -Wno-unused-variable -Wno-unused-result -Wdeclaration-after-statement
 
 # Uncomment to build XWayland support
 #CFLAGS += -DXWAYLAND