2020-12-25 06:33:55 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2021-09-05 16:41:23 +00:00
|
|
|
/* Leave these functions first; they're used in the others */
|
2020-12-25 06:33:55 +00:00
|
|
|
static inline int
|
|
|
|
client_is_x11(Client *c)
|
|
|
|
{
|
|
|
|
#ifdef XWAYLAND
|
|
|
|
return c->type == X11Managed || c->type == X11Unmanaged;
|
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2022-08-27 21:29:23 +00:00
|
|
|
static inline void
|
|
|
|
client_get_size_hints(Client *c, struct wlr_box *max, struct wlr_box *min)
|
|
|
|
{
|
|
|
|
struct wlr_xdg_toplevel *toplevel;
|
|
|
|
struct wlr_xdg_toplevel_state *state;
|
|
|
|
#ifdef XWAYLAND
|
|
|
|
if (client_is_x11(c)) {
|
2022-10-02 04:30:47 +00:00
|
|
|
xcb_size_hints_t *size_hints = c->surface.xwayland->size_hints;
|
2022-08-27 21:29:23 +00:00
|
|
|
if (size_hints) {
|
|
|
|
max->width = size_hints->max_width;
|
|
|
|
max->height = size_hints->max_height;
|
|
|
|
min->width = size_hints->min_width;
|
|
|
|
min->height = size_hints->min_height;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
toplevel = c->surface.xdg->toplevel;
|
|
|
|
state = &toplevel->current;
|
|
|
|
max->width = state->max_width;
|
|
|
|
max->height = state->max_height;
|
|
|
|
min->width = state->min_width;
|
|
|
|
min->height = state->min_height;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2022-12-03 21:17:43 +00:00
|
|
|
static inline int
|
|
|
|
toplevel_from_wlr_surface(struct wlr_surface *s, Client **pc, LayerSurface **pl)
|
2022-12-03 20:31:18 +00:00
|
|
|
{
|
|
|
|
struct wlr_xdg_surface *xdg_surface;
|
|
|
|
struct wlr_surface *root_surface;
|
|
|
|
struct wlr_layer_surface_v1 *layer_surface;
|
2022-12-03 21:17:43 +00:00
|
|
|
Client *c = NULL;
|
|
|
|
LayerSurface *l = NULL;
|
|
|
|
int type = -1;
|
2022-12-03 20:31:18 +00:00
|
|
|
#ifdef XWAYLAND
|
|
|
|
struct wlr_xwayland_surface *xsurface;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (!s)
|
2022-12-03 21:17:43 +00:00
|
|
|
return type;
|
2022-12-03 20:31:18 +00:00
|
|
|
root_surface = wlr_surface_get_root_surface(s);
|
|
|
|
|
|
|
|
#ifdef XWAYLAND
|
2023-02-01 19:09:45 +00:00
|
|
|
if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(root_surface))) {
|
2022-12-03 21:17:43 +00:00
|
|
|
c = xsurface->data;
|
|
|
|
type = c->type;
|
|
|
|
goto end;
|
|
|
|
}
|
2022-12-03 20:31:18 +00:00
|
|
|
#endif
|
|
|
|
|
2023-02-02 16:30:24 +00:00
|
|
|
if ((layer_surface = wlr_layer_surface_v1_try_from_wlr_surface(root_surface))) {
|
2022-12-03 21:17:43 +00:00
|
|
|
l = layer_surface->data;
|
|
|
|
type = LayerShell;
|
|
|
|
goto end;
|
|
|
|
}
|
2022-12-03 20:31:18 +00:00
|
|
|
|
2023-02-02 16:30:24 +00:00
|
|
|
if ((xdg_surface = wlr_xdg_surface_try_from_wlr_surface(root_surface))) {
|
2022-12-03 20:31:18 +00:00
|
|
|
while (1) {
|
|
|
|
switch (xdg_surface->role) {
|
|
|
|
case WLR_XDG_SURFACE_ROLE_POPUP:
|
|
|
|
if (!xdg_surface->popup->parent)
|
2022-12-03 21:17:43 +00:00
|
|
|
return -1;
|
2023-02-02 16:30:24 +00:00
|
|
|
else if (!wlr_xdg_surface_try_from_wlr_surface(xdg_surface->popup->parent))
|
2022-12-03 21:17:43 +00:00
|
|
|
return toplevel_from_wlr_surface(xdg_surface->popup->parent, pc, pl);
|
2022-12-03 20:31:18 +00:00
|
|
|
|
2023-02-02 16:30:24 +00:00
|
|
|
xdg_surface = wlr_xdg_surface_try_from_wlr_surface(xdg_surface->popup->parent);
|
2022-12-03 20:31:18 +00:00
|
|
|
break;
|
|
|
|
case WLR_XDG_SURFACE_ROLE_TOPLEVEL:
|
2022-12-03 21:17:43 +00:00
|
|
|
c = xdg_surface->data;
|
|
|
|
type = c->type;
|
|
|
|
goto end;
|
2022-12-03 20:31:18 +00:00
|
|
|
case WLR_XDG_SURFACE_ROLE_NONE:
|
2022-12-03 21:17:43 +00:00
|
|
|
return -1;
|
2022-12-03 20:31:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-03 21:17:43 +00:00
|
|
|
end:
|
|
|
|
if (pl)
|
|
|
|
*pl = l;
|
|
|
|
if (pc)
|
|
|
|
*pc = c;
|
|
|
|
return type;
|
2022-12-03 20:31:18 +00:00
|
|
|
}
|
|
|
|
|
2020-12-25 06:33:55 +00:00
|
|
|
/* The others */
|
|
|
|
static inline void
|
|
|
|
client_activate_surface(struct wlr_surface *s, int activated)
|
|
|
|
{
|
2022-05-14 05:24:06 +00:00
|
|
|
struct wlr_xdg_surface *surface;
|
2020-12-25 06:33:55 +00:00
|
|
|
#ifdef XWAYLAND
|
2022-05-14 05:24:06 +00:00
|
|
|
struct wlr_xwayland_surface *xsurface;
|
2023-02-01 19:09:45 +00:00
|
|
|
if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(s))) {
|
2022-05-14 05:24:06 +00:00
|
|
|
wlr_xwayland_surface_activate(xsurface, activated);
|
2020-12-25 06:33:55 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
2023-02-02 16:30:24 +00:00
|
|
|
if ((surface = wlr_xdg_surface_try_from_wlr_surface(s))
|
2022-05-14 05:24:06 +00:00
|
|
|
&& surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL)
|
2022-05-17 20:31:31 +00:00
|
|
|
wlr_xdg_toplevel_set_activated(surface->toplevel, activated);
|
2020-12-25 06:33:55 +00:00
|
|
|
}
|
|
|
|
|
2022-06-09 17:45:42 +00:00
|
|
|
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
|
2022-07-15 05:27:31 +00:00
|
|
|
if (c->surface.xdg->client->shell->version >=
|
2022-12-15 22:34:03 +00:00
|
|
|
XDG_TOPLEVEL_CONFIGURE_BOUNDS_SINCE_VERSION && width >= 0 && height >= 0)
|
2022-07-15 05:27:31 +00:00
|
|
|
return wlr_xdg_toplevel_set_bounds(c->surface.xdg->toplevel, width, height);
|
|
|
|
return 0;
|
2022-06-09 17:45:42 +00:00
|
|
|
}
|
|
|
|
|
2020-12-25 06:33:55 +00:00
|
|
|
static inline void
|
|
|
|
client_for_each_surface(Client *c, wlr_surface_iterator_func_t fn, void *data)
|
|
|
|
{
|
2021-09-05 16:41:23 +00:00
|
|
|
wlr_surface_for_each_surface(client_surface(c), fn, data);
|
2020-12-25 06:33:55 +00:00
|
|
|
#ifdef XWAYLAND
|
2021-09-05 16:41:23 +00:00
|
|
|
if (client_is_x11(c))
|
2020-12-25 06:33:55 +00:00
|
|
|
return;
|
|
|
|
#endif
|
2021-09-05 16:41:23 +00:00
|
|
|
wlr_xdg_surface_for_each_popup_surface(c->surface.xdg, fn, data);
|
2020-12-25 06:33:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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_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
|
|
|
|
wlr_xdg_surface_get_geometry(c->surface.xdg, geom);
|
|
|
|
}
|
|
|
|
|
2022-12-03 20:30:38 +00:00
|
|
|
static inline Client *
|
|
|
|
client_get_parent(Client *c)
|
|
|
|
{
|
2022-12-03 21:17:43 +00:00
|
|
|
Client *p = NULL;
|
2022-12-03 20:30:38 +00:00
|
|
|
#ifdef XWAYLAND
|
|
|
|
if (client_is_x11(c) && c->surface.xwayland->parent)
|
2022-12-03 21:17:43 +00:00
|
|
|
toplevel_from_wlr_surface(c->surface.xwayland->parent->surface, &p, NULL);
|
2022-12-03 20:30:38 +00:00
|
|
|
#endif
|
|
|
|
if (c->surface.xdg->toplevel->parent)
|
2022-12-03 21:17:43 +00:00
|
|
|
toplevel_from_wlr_surface(c->surface.xdg->toplevel->parent->base->surface, &p, NULL);
|
2022-12-03 20:30:38 +00:00
|
|
|
|
2022-12-03 21:17:43 +00:00
|
|
|
return p;
|
2022-12-03 20:30:38 +00:00
|
|
|
}
|
|
|
|
|
2020-12-25 06:33:55 +00:00
|
|
|
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)
|
|
|
|
{
|
2022-06-25 00:15:24 +00:00
|
|
|
struct wlr_box min = {0}, max = {0};
|
|
|
|
client_get_size_hints(c, &max, &min);
|
2022-03-21 19:52:33 +00:00
|
|
|
|
2020-12-25 06:33:55 +00:00
|
|
|
#ifdef XWAYLAND
|
2022-03-21 19:52:33 +00:00
|
|
|
if (client_is_x11(c)) {
|
|
|
|
struct wlr_xwayland_surface *surface = c->surface.xwayland;
|
|
|
|
if (surface->modal)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
for (size_t i = 0; i < surface->window_type_len; i++)
|
2022-06-25 00:15:24 +00:00
|
|
|
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])
|
2020-12-25 06:33:55 +00:00
|
|
|
return 1;
|
2022-03-21 19:52:33 +00:00
|
|
|
}
|
2020-12-25 06:33:55 +00:00
|
|
|
#endif
|
2022-06-25 00:15:24 +00:00
|
|
|
return ((min.width > 0 || min.height > 0 || max.width > 0 || max.height > 0)
|
2022-12-02 02:49:49 +00:00
|
|
|
&& (min.width == max.width || min.height == max.height));
|
2020-12-25 06:33:55 +00:00
|
|
|
}
|
|
|
|
|
2022-08-18 21:59:38 +00:00
|
|
|
static inline int
|
|
|
|
client_is_mapped(Client *c)
|
|
|
|
{
|
|
|
|
#ifdef XWAYLAND
|
|
|
|
if (client_is_x11(c))
|
|
|
|
return c->surface.xwayland->mapped;
|
|
|
|
#endif
|
|
|
|
return c->surface.xdg->mapped;
|
2020-12-25 06:33:55 +00:00
|
|
|
}
|
|
|
|
|
2022-12-06 20:47:55 +00:00
|
|
|
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;
|
|
|
|
if (!c->scene->node.enabled)
|
|
|
|
return 0;
|
|
|
|
wl_list_for_each(s, &client_surface(c)->current_outputs, link)
|
|
|
|
if (s->output == m->wlr_output)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-12-21 20:28:27 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2022-03-14 02:54:44 +00:00
|
|
|
static inline int
|
2022-08-27 21:29:23 +00:00
|
|
|
client_is_unmanaged(Client *c)
|
2022-03-14 02:54:44 +00:00
|
|
|
{
|
|
|
|
#ifdef XWAYLAND
|
2022-08-27 21:29:23 +00:00
|
|
|
return c->type == X11Unmanaged;
|
2022-03-14 02:54:44 +00:00
|
|
|
#endif
|
2022-08-27 21:29:23 +00:00
|
|
|
return 0;
|
2022-03-14 02:54:44 +00:00
|
|
|
}
|
|
|
|
|
2022-08-27 21:05:12 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2022-08-27 21:29:23 +00:00
|
|
|
static inline void
|
|
|
|
client_restack_surface(Client *c)
|
2020-12-25 06:33:55 +00:00
|
|
|
{
|
|
|
|
#ifdef XWAYLAND
|
2022-08-27 21:29:23 +00:00
|
|
|
if (client_is_x11(c))
|
|
|
|
wlr_xwayland_surface_restack(c->surface.xwayland, NULL,
|
|
|
|
XCB_STACK_MODE_ABOVE);
|
2020-12-25 06:33:55 +00:00
|
|
|
#endif
|
2022-08-27 21:29:23 +00:00
|
|
|
return;
|
2020-12-25 06:33:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
client_send_close(Client *c)
|
|
|
|
{
|
|
|
|
#ifdef XWAYLAND
|
|
|
|
if (client_is_x11(c)) {
|
|
|
|
wlr_xwayland_surface_close(c->surface.xwayland);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
2022-02-04 03:54:44 +00:00
|
|
|
wlr_xdg_toplevel_send_close(c->surface.xdg->toplevel);
|
2020-12-25 06:33:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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
|
2022-02-04 03:54:44 +00:00
|
|
|
wlr_xdg_toplevel_set_fullscreen(c->surface.xdg->toplevel, fullscreen);
|
2020-12-25 06:33:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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
|
2022-12-15 05:21:58 +00:00
|
|
|
if (width == c->surface.xdg->toplevel->current.width
|
|
|
|
&& height ==c->surface.xdg->toplevel->current.height)
|
|
|
|
return 0;
|
2022-02-04 03:54:44 +00:00
|
|
|
return wlr_xdg_toplevel_set_size(c->surface.xdg->toplevel, width, height);
|
2020-12-25 06:33:55 +00:00
|
|
|
}
|
|
|
|
|
2021-05-23 23:28:13 +00:00
|
|
|
static inline void
|
|
|
|
client_set_tiled(Client *c, uint32_t edges)
|
|
|
|
{
|
|
|
|
#ifdef XWAYLAND
|
|
|
|
if (client_is_x11(c))
|
|
|
|
return;
|
|
|
|
#endif
|
2022-03-10 16:34:43 +00:00
|
|
|
wlr_xdg_toplevel_set_tiled(c->surface.xdg->toplevel, edges);
|
2021-05-23 23:28:13 +00:00
|
|
|
}
|
|
|
|
|
2020-12-25 06:33:55 +00:00
|
|
|
static inline struct wlr_surface *
|
|
|
|
client_surface_at(Client *c, double cx, double cy, double *sx, double *sy)
|
|
|
|
{
|
|
|
|
#ifdef XWAYLAND
|
|
|
|
if (client_is_x11(c))
|
|
|
|
return wlr_surface_surface_at(c->surface.xwayland->surface,
|
|
|
|
cx, cy, sx, sy);
|
|
|
|
#endif
|
|
|
|
return wlr_xdg_surface_surface_at(c->surface.xdg, cx, cy, sx, sy);
|
|
|
|
}
|
2022-03-18 07:25:53 +00:00
|
|
|
|
2022-06-16 21:05:07 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2022-08-27 21:29:23 +00:00
|
|
|
static inline int
|
|
|
|
client_wants_fullscreen(Client *c)
|
2022-03-18 07:25:53 +00:00
|
|
|
{
|
|
|
|
#ifdef XWAYLAND
|
2022-06-16 20:54:13 +00:00
|
|
|
if (client_is_x11(c))
|
2022-08-27 21:29:23 +00:00
|
|
|
return c->surface.xwayland->fullscreen;
|
2022-03-18 07:25:53 +00:00
|
|
|
#endif
|
2022-08-27 21:29:23 +00:00
|
|
|
return c->surface.xdg->toplevel->requested.fullscreen;
|
2022-03-18 07:25:53 +00:00
|
|
|
}
|