update to wlroots 0.19

feat:wlr_alpha_modifier_v1 protocol

client.h

@@ -6,371 +6,399 @@
  */
 
 /* Leave these functions first; they're used in the others */
-static inline int client_is_x11(Client *c) {
+static inline int
+client_is_x11(Client *c)
+{
 #ifdef XWAYLAND
-  return c->type == X11;
+	return c->type == X11;
 #endif
-  return 0;
+	return 0;
 }
 
-static inline struct wlr_surface *client_surface(Client *c) {
+static inline struct wlr_surface *
+client_surface(Client *c)
+{
 #ifdef XWAYLAND
-  if (client_is_x11(c))
+	if (client_is_x11(c))
-    return c->surface.xwayland->surface;
+		return c->surface.xwayland->surface;
 #endif
-  return c->surface.xdg->surface;
+	return c->surface.xdg->surface;
 }
 
-static inline int toplevel_from_wlr_surface(struct wlr_surface *s, Client **pc,
+static inline int
-                                            LayerSurface **pl) {
+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_xdg_surface *xdg_surface, *tmp_xdg_surface;
-  struct wlr_layer_surface_v1 *layer_surface;
+	struct wlr_surface *root_surface;
-  Client *c = NULL;
+	struct wlr_layer_surface_v1 *layer_surface;
-  LayerSurface *l = NULL;
+	Client *c = NULL;
-  int type = -1;
+	LayerSurface *l = NULL;
+	int type = -1;
 #ifdef XWAYLAND
-  struct wlr_xwayland_surface *xsurface;
+	struct wlr_xwayland_surface *xsurface;
 #endif
 
-  if (!s)
+	if (!s)
-    return -1;
+		return -1;
-  root_surface = wlr_surface_get_root_surface(s);
+	root_surface = wlr_surface_get_root_surface(s);
 
 #ifdef XWAYLAND
-  if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(root_surface))) {
+	if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(root_surface))) {
-    c = xsurface->data;
+		c = xsurface->data;
-    type = c->type;
+		type = c->type;
-    goto end;
+		goto end;
-  }
+	}
 #endif
 
-  if ((layer_surface =
+	if ((layer_surface = wlr_layer_surface_v1_try_from_wlr_surface(root_surface))) {
-           wlr_layer_surface_v1_try_from_wlr_surface(root_surface))) {
+		l = layer_surface->data;
-    l = layer_surface->data;
+		type = LayerShell;
-    type = LayerShell;
+		goto end;
-    goto end;
+	}
-  }
 
-  xdg_surface = wlr_xdg_surface_try_from_wlr_surface(root_surface);
+	xdg_surface = wlr_xdg_surface_try_from_wlr_surface(root_surface);
-  while (xdg_surface) {
+	while (xdg_surface) {
-    tmp_xdg_surface = NULL;
+		tmp_xdg_surface = NULL;
-    switch (xdg_surface->role) {
+		switch (xdg_surface->role) {
-    case WLR_XDG_SURFACE_ROLE_POPUP:
+		case WLR_XDG_SURFACE_ROLE_POPUP:
-      if (!xdg_surface->popup || !xdg_surface->popup->parent)
+			if (!xdg_surface->popup || !xdg_surface->popup->parent)
-        return -1;
+				return -1;
 
-      tmp_xdg_surface =
+			tmp_xdg_surface = wlr_xdg_surface_try_from_wlr_surface(xdg_surface->popup->parent);
-          wlr_xdg_surface_try_from_wlr_surface(xdg_surface->popup->parent);
 
-      if (!tmp_xdg_surface)
+			if (!tmp_xdg_surface)
-        return toplevel_from_wlr_surface(xdg_surface->popup->parent, pc, pl);
+				return toplevel_from_wlr_surface(xdg_surface->popup->parent, pc, pl);
 
-      xdg_surface = tmp_xdg_surface;
+			xdg_surface = tmp_xdg_surface;
-      break;
+			break;
-    case WLR_XDG_SURFACE_ROLE_TOPLEVEL:
+		case WLR_XDG_SURFACE_ROLE_TOPLEVEL:
-      c = xdg_surface->data;
+			c = xdg_surface->data;
-      type = c->type;
+			type = c->type;
-      goto end;
+			goto end;
-    case WLR_XDG_SURFACE_ROLE_NONE:
+		case WLR_XDG_SURFACE_ROLE_NONE:
-      return -1;
+			return -1;
-    }
+		}
-  }
+	}
 
 end:
-  if (pl)
+	if (pl)
-    *pl = l;
+		*pl = l;
-  if (pc)
+	if (pc)
-    *pc = c;
+		*pc = c;
-  return type;
+	return type;
 }
 
 /* The others */
-static inline void client_activate_surface(struct wlr_surface *s,
+static inline void
-                                           int activated) {
+client_activate_surface(struct wlr_surface *s, int activated)
-  struct wlr_xdg_toplevel *toplevel;
+{
+	struct wlr_xdg_toplevel *toplevel;
 #ifdef XWAYLAND
-  struct wlr_xwayland_surface *xsurface;
+	struct wlr_xwayland_surface *xsurface;
-  if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(s))) {
+	if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(s))) {
-    wlr_xwayland_surface_activate(xsurface, activated);
+		wlr_xwayland_surface_activate(xsurface, activated);
-    return;
+		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 ((toplevel = wlr_xdg_toplevel_try_from_wlr_surface(s)))
+	if (wl_resource_get_version(c->surface.xdg->toplevel->resource)
-    wlr_xdg_toplevel_set_activated(toplevel, activated);
+			>= 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 uint32_t client_set_bounds(Client *c, int32_t width,
+static inline void
-                                         int32_t height) {
+client_set_suspended(Client *c, int suspended)
+{
 #ifdef XWAYLAND
-  if (client_is_x11(c))
+	if (client_is_x11(c))
-    return 0;
+		return;
-#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;
-#endif
-  return c->surface.xdg->toplevel->app_id;
-}
-
-static inline void client_get_clip(Client *c, struct wlr_box *clip) {
-  struct wlr_box xdg_geom = {0};
-  *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
 
-  wlr_xdg_surface_get_geometry(c->surface.xdg, &xdg_geom);
+	wlr_xdg_toplevel_set_suspended(c->surface.xdg->toplevel, suspended);
-  clip->x = xdg_geom.x;
-  clip->y = xdg_geom.y;
 }
 
-static inline void client_get_geometry(Client *c, struct wlr_box *geom) {
+static inline int
+client_wants_focus(Client *c)
+{
 #ifdef XWAYLAND
-  if (client_is_x11(c)) {
+	return client_is_unmanaged(c)
-    geom->x = c->surface.xwayland->x;
+		&& wlr_xwayland_surface_override_redirect_wants_focus(c->surface.xwayland)
-    geom->y = c->surface.xwayland->y;
+		&& wlr_xwayland_surface_icccm_input_model(c->surface.xwayland) != WLR_ICCCM_INPUT_MODEL_NONE;
-    geom->width = c->surface.xwayland->width;
-    geom->height = c->surface.xwayland->height;
-    return;
-  }
 #endif
-  wlr_xdg_surface_get_geometry(c->surface.xdg, geom);
+	return 0;
 }
 
-static inline Client *client_get_parent(Client *c) {
+static inline int
-  Client *p = NULL;
+client_wants_fullscreen(Client *c)
+{
 #ifdef XWAYLAND
-  if (client_is_x11(c)) {
+	if (client_is_x11(c))
-    if (c->surface.xwayland->parent)
+		return c->surface.xwayland->fullscreen;
-      toplevel_from_wlr_surface(c->surface.xwayland->parent->surface, &p, NULL);
-    return p;
-  }
 #endif
-  if (c->surface.xdg->toplevel->parent)
+	return c->surface.xdg->toplevel->requested.fullscreen;
-    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;
-#endif
-  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;
-    xcb_size_hints_t *size_hints = surface->size_hints;
-    size_t i;
-    if (surface->modal)
-      return 1;
-
-    for (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;
-
-    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_restack_surface(Client *c) {
-#ifdef XWAYLAND
-  if (client_is_x11(c))
-    wlr_xwayland_surface_restack(c->surface.xwayland, NULL,
-                                 XCB_STACK_MODE_ABOVE);
-#endif
-  return;
-}
-
-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->geom.y,
-                                   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))
-    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_or_surface_wants_focus(c->surface.xwayland) &&
-         wlr_xwayland_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;
 }

maomao.c

@@ -20,6 +20,9 @@
 #include <wlr/types/wlr_compositor.h>
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/types/wlr_data_control_v1.h>
+#include <wlr/types/wlr_alpha_modifier_v1.h>
+#include <wlr/types/wlr_linux_dmabuf_v1.h>
+#include <wlr/types/wlr_linux_drm_syncobj_v1.h>
 #include <wlr/types/wlr_data_device.h>
 #include <wlr/types/wlr_drm.h>
 #include <wlr/types/wlr_export_dmabuf_v1.h>
@@ -4824,7 +4827,7 @@ void setup(void) {
 
   init_baked_points();
 
-  int i, sig[] = {SIGCHLD, SIGINT, SIGTERM, SIGPIPE};
+  int drm_fd, i, sig[] = {SIGCHLD, SIGINT, SIGTERM, SIGPIPE};
   struct sigaction sa = {.sa_flags = SA_RESTART, .sa_handler = handlesig};
   sigemptyset(&sa.sa_mask);
 
@@ -4875,6 +4878,10 @@ void setup(void) {
         scene, wlr_linux_dmabuf_v1_create_with_renderer(dpy, 5, drw));
   }
 
+	if ((drm_fd = wlr_renderer_get_drm_fd(drw)) >= 0 && drw->features.timeline
+			&& backend->features.timeline)
+		wlr_linux_drm_syncobj_manager_v1_create(dpy, 1, drm_fd);
+
   /* Create a default allocator */
   if (!(alloc = wlr_allocator_autocreate(backend, drw)))
     die("couldn't create allocator");
@@ -4894,8 +4901,9 @@ void setup(void) {
   wlr_viewporter_create(dpy);
   wlr_single_pixel_buffer_manager_v1_create(dpy);
   wlr_fractional_scale_manager_v1_create(dpy, 1);
-  wlr_presentation_create(dpy, backend);
+  wlr_presentation_create(dpy, backend, 2);
   wlr_subcompositor_create(dpy);
+  wlr_alpha_modifier_v1_create(dpy);
 
   /* Initializes the interface used to implement urgency hints */
   activation = wlr_xdg_activation_v1_create(dpy);

meson.build

@@ -33,7 +33,7 @@ libm = cc.find_library('m')
 xcb = dependency('xcb', required : get_option('xwayland'))
 xlibs = dependency('xcb-icccm', required : get_option('xwayland'))
 wayland_server_dep = dependency('wayland-server')
-wlroots_dep = dependency('wlroots-0.18')
+wlroots_dep = dependency('wlroots-0.19')
 xkbcommon_dep = dependency('xkbcommon')
 libinput_dep = dependency('libinput')
 libwayland_client_dep = dependency('wayland-client')