bdae625cb3
I originally put the rebase at the end of view_map, but at this point the view is still at its native size and will ignore the motion event if it falls outside of its native size. The only way to do this properly is to rebase the cursor later - either after sending the configure, after the view commits with the new size, or after applying the transaction. I chose to do it after applying the transaction for simplicity. I then attempted to just call cursor_rebase after applying every transaction, but this causes crashes when exiting sway (and possibly other places) because cursor_rebase assumes the tree is in a valid state. So my chosen solution introduces transaction_commit_dirty_with_callback which allows handle_map to register a callback which will run when the transaction is applied.
690 lines
22 KiB
C
690 lines
22 KiB
C
#define _POSIX_C_SOURCE 199309L
|
|
#include <stdbool.h>
|
|
#include <stdlib.h>
|
|
#include <wayland-server.h>
|
|
#include <wlr/types/wlr_output_layout.h>
|
|
#include <wlr/types/wlr_output.h>
|
|
#include <wlr/xwayland.h>
|
|
#include "log.h"
|
|
#include "sway/desktop.h"
|
|
#include "sway/desktop/transaction.h"
|
|
#include "sway/input/cursor.h"
|
|
#include "sway/input/input-manager.h"
|
|
#include "sway/input/seat.h"
|
|
#include "sway/output.h"
|
|
#include "sway/server.h"
|
|
#include "sway/tree/arrange.h"
|
|
#include "sway/tree/container.h"
|
|
#include "sway/tree/view.h"
|
|
#include "sway/tree/workspace.h"
|
|
|
|
static const char *atom_map[ATOM_LAST] = {
|
|
"_NET_WM_WINDOW_TYPE_NORMAL",
|
|
"_NET_WM_WINDOW_TYPE_DIALOG",
|
|
"_NET_WM_WINDOW_TYPE_UTILITY",
|
|
"_NET_WM_WINDOW_TYPE_TOOLBAR",
|
|
"_NET_WM_WINDOW_TYPE_SPLASH",
|
|
"_NET_WM_WINDOW_TYPE_MENU",
|
|
"_NET_WM_WINDOW_TYPE_DROPDOWN_MENU",
|
|
"_NET_WM_WINDOW_TYPE_POPUP_MENU",
|
|
"_NET_WM_WINDOW_TYPE_TOOLTIP",
|
|
"_NET_WM_WINDOW_TYPE_NOTIFICATION",
|
|
"_NET_WM_STATE_MODAL",
|
|
};
|
|
|
|
static void unmanaged_handle_request_configure(struct wl_listener *listener,
|
|
void *data) {
|
|
struct sway_xwayland_unmanaged *surface =
|
|
wl_container_of(listener, surface, request_configure);
|
|
struct wlr_xwayland_surface *xsurface = surface->wlr_xwayland_surface;
|
|
struct wlr_xwayland_surface_configure_event *ev = data;
|
|
wlr_xwayland_surface_configure(xsurface, ev->x, ev->y,
|
|
ev->width, ev->height);
|
|
}
|
|
|
|
static void unmanaged_handle_commit(struct wl_listener *listener, void *data) {
|
|
struct sway_xwayland_unmanaged *surface =
|
|
wl_container_of(listener, surface, commit);
|
|
struct wlr_xwayland_surface *xsurface = surface->wlr_xwayland_surface;
|
|
|
|
if (xsurface->x != surface->lx || xsurface->y != surface->ly) {
|
|
// Surface has moved
|
|
desktop_damage_surface(xsurface->surface, surface->lx, surface->ly,
|
|
true);
|
|
surface->lx = xsurface->x;
|
|
surface->ly = xsurface->y;
|
|
desktop_damage_surface(xsurface->surface, surface->lx, surface->ly,
|
|
true);
|
|
} else {
|
|
desktop_damage_surface(xsurface->surface, xsurface->x, xsurface->y,
|
|
false);
|
|
}
|
|
}
|
|
|
|
static void unmanaged_handle_map(struct wl_listener *listener, void *data) {
|
|
struct sway_xwayland_unmanaged *surface =
|
|
wl_container_of(listener, surface, map);
|
|
struct wlr_xwayland_surface *xsurface = surface->wlr_xwayland_surface;
|
|
|
|
wl_list_insert(root->xwayland_unmanaged.prev, &surface->link);
|
|
|
|
wl_signal_add(&xsurface->surface->events.commit, &surface->commit);
|
|
surface->commit.notify = unmanaged_handle_commit;
|
|
|
|
surface->lx = xsurface->x;
|
|
surface->ly = xsurface->y;
|
|
desktop_damage_surface(xsurface->surface, surface->lx, surface->ly, true);
|
|
|
|
if (wlr_xwayland_or_surface_wants_focus(xsurface)) {
|
|
struct sway_seat *seat = input_manager_current_seat();
|
|
struct wlr_xwayland *xwayland = server.xwayland.wlr_xwayland;
|
|
wlr_xwayland_set_seat(xwayland, seat->wlr_seat);
|
|
seat_set_focus_surface(seat, xsurface->surface, false);
|
|
}
|
|
}
|
|
|
|
static void unmanaged_handle_unmap(struct wl_listener *listener, void *data) {
|
|
struct sway_xwayland_unmanaged *surface =
|
|
wl_container_of(listener, surface, unmap);
|
|
struct wlr_xwayland_surface *xsurface = surface->wlr_xwayland_surface;
|
|
desktop_damage_surface(xsurface->surface, xsurface->x, xsurface->y, true);
|
|
wl_list_remove(&surface->link);
|
|
wl_list_remove(&surface->commit.link);
|
|
|
|
struct sway_seat *seat = input_manager_current_seat();
|
|
if (seat->wlr_seat->keyboard_state.focused_surface ==
|
|
xsurface->surface) {
|
|
// Restore focus
|
|
struct sway_node *previous = seat_get_focus_inactive(seat, &root->node);
|
|
if (previous) {
|
|
// Hack to get seat to re-focus the return value of get_focus
|
|
seat_set_focus(seat, NULL);
|
|
seat_set_focus(seat, previous);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void unmanaged_handle_destroy(struct wl_listener *listener, void *data) {
|
|
struct sway_xwayland_unmanaged *surface =
|
|
wl_container_of(listener, surface, destroy);
|
|
wl_list_remove(&surface->map.link);
|
|
wl_list_remove(&surface->unmap.link);
|
|
wl_list_remove(&surface->destroy.link);
|
|
free(surface);
|
|
}
|
|
|
|
static struct sway_xwayland_unmanaged *create_unmanaged(
|
|
struct wlr_xwayland_surface *xsurface) {
|
|
struct sway_xwayland_unmanaged *surface =
|
|
calloc(1, sizeof(struct sway_xwayland_unmanaged));
|
|
if (surface == NULL) {
|
|
wlr_log(WLR_ERROR, "Allocation failed");
|
|
return NULL;
|
|
}
|
|
|
|
surface->wlr_xwayland_surface = xsurface;
|
|
|
|
wl_signal_add(&xsurface->events.request_configure,
|
|
&surface->request_configure);
|
|
surface->request_configure.notify = unmanaged_handle_request_configure;
|
|
wl_signal_add(&xsurface->events.map, &surface->map);
|
|
surface->map.notify = unmanaged_handle_map;
|
|
wl_signal_add(&xsurface->events.unmap, &surface->unmap);
|
|
surface->unmap.notify = unmanaged_handle_unmap;
|
|
wl_signal_add(&xsurface->events.destroy, &surface->destroy);
|
|
surface->destroy.notify = unmanaged_handle_destroy;
|
|
|
|
return surface;
|
|
}
|
|
|
|
|
|
static struct sway_xwayland_view *xwayland_view_from_view(
|
|
struct sway_view *view) {
|
|
if (!sway_assert(view->type == SWAY_VIEW_XWAYLAND,
|
|
"Expected xwayland view")) {
|
|
return NULL;
|
|
}
|
|
return (struct sway_xwayland_view *)view;
|
|
}
|
|
|
|
static const char *get_string_prop(struct sway_view *view, enum sway_view_prop prop) {
|
|
if (xwayland_view_from_view(view) == NULL) {
|
|
return NULL;
|
|
}
|
|
switch (prop) {
|
|
case VIEW_PROP_TITLE:
|
|
return view->wlr_xwayland_surface->title;
|
|
case VIEW_PROP_CLASS:
|
|
return view->wlr_xwayland_surface->class;
|
|
case VIEW_PROP_INSTANCE:
|
|
return view->wlr_xwayland_surface->instance;
|
|
case VIEW_PROP_WINDOW_ROLE:
|
|
return view->wlr_xwayland_surface->role;
|
|
default:
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static uint32_t get_int_prop(struct sway_view *view, enum sway_view_prop prop) {
|
|
if (xwayland_view_from_view(view) == NULL) {
|
|
return 0;
|
|
}
|
|
switch (prop) {
|
|
case VIEW_PROP_X11_WINDOW_ID:
|
|
return view->wlr_xwayland_surface->window_id;
|
|
case VIEW_PROP_X11_PARENT_ID:
|
|
if (view->wlr_xwayland_surface->parent) {
|
|
return view->wlr_xwayland_surface->parent->window_id;
|
|
}
|
|
return 0;
|
|
case VIEW_PROP_WINDOW_TYPE:
|
|
return *view->wlr_xwayland_surface->window_type;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static uint32_t configure(struct sway_view *view, double lx, double ly, int width,
|
|
int height) {
|
|
struct sway_xwayland_view *xwayland_view = xwayland_view_from_view(view);
|
|
if (xwayland_view == NULL) {
|
|
return 0;
|
|
}
|
|
struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
|
|
|
|
wlr_xwayland_surface_configure(xsurface, lx, ly, width, height);
|
|
|
|
// xwayland doesn't give us a serial for the configure
|
|
return 0;
|
|
}
|
|
|
|
static void set_activated(struct sway_view *view, bool activated) {
|
|
if (xwayland_view_from_view(view) == NULL) {
|
|
return;
|
|
}
|
|
struct wlr_xwayland_surface *surface = view->wlr_xwayland_surface;
|
|
wlr_xwayland_surface_activate(surface, activated);
|
|
}
|
|
|
|
static void set_tiled(struct sway_view *view, bool tiled) {
|
|
if (xwayland_view_from_view(view) == NULL) {
|
|
return;
|
|
}
|
|
struct wlr_xwayland_surface *surface = view->wlr_xwayland_surface;
|
|
wlr_xwayland_surface_set_maximized(surface, tiled);
|
|
}
|
|
|
|
static void set_fullscreen(struct sway_view *view, bool fullscreen) {
|
|
if (xwayland_view_from_view(view) == NULL) {
|
|
return;
|
|
}
|
|
struct wlr_xwayland_surface *surface = view->wlr_xwayland_surface;
|
|
wlr_xwayland_surface_set_fullscreen(surface, fullscreen);
|
|
}
|
|
|
|
static bool wants_floating(struct sway_view *view) {
|
|
if (xwayland_view_from_view(view) == NULL) {
|
|
return false;
|
|
}
|
|
struct wlr_xwayland_surface *surface = view->wlr_xwayland_surface;
|
|
struct sway_xwayland *xwayland = &server.xwayland;
|
|
|
|
if (surface->modal) {
|
|
return true;
|
|
}
|
|
|
|
for (size_t i = 0; i < surface->window_type_len; ++i) {
|
|
xcb_atom_t type = surface->window_type[i];
|
|
if (type == xwayland->atoms[NET_WM_WINDOW_TYPE_DIALOG] ||
|
|
type == xwayland->atoms[NET_WM_WINDOW_TYPE_UTILITY] ||
|
|
type == xwayland->atoms[NET_WM_WINDOW_TYPE_TOOLBAR] ||
|
|
type == xwayland->atoms[NET_WM_WINDOW_TYPE_SPLASH]) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
struct wlr_xwayland_surface_size_hints *size_hints = surface->size_hints;
|
|
if (size_hints != NULL &&
|
|
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 true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static void handle_set_decorations(struct wl_listener *listener, void *data) {
|
|
struct sway_xwayland_view *xwayland_view =
|
|
wl_container_of(listener, xwayland_view, set_decorations);
|
|
struct sway_view *view = &xwayland_view->view;
|
|
struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
|
|
|
|
bool csd = xsurface->decorations != WLR_XWAYLAND_SURFACE_DECORATIONS_ALL;
|
|
view_update_csd_from_client(view, csd);
|
|
}
|
|
|
|
static bool is_transient_for(struct sway_view *child,
|
|
struct sway_view *ancestor) {
|
|
if (xwayland_view_from_view(child) == NULL) {
|
|
return false;
|
|
}
|
|
struct wlr_xwayland_surface *surface = child->wlr_xwayland_surface;
|
|
while (surface) {
|
|
if (surface->parent == ancestor->wlr_xwayland_surface) {
|
|
return true;
|
|
}
|
|
surface = surface->parent;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void _close(struct sway_view *view) {
|
|
if (xwayland_view_from_view(view) == NULL) {
|
|
return;
|
|
}
|
|
wlr_xwayland_surface_close(view->wlr_xwayland_surface);
|
|
}
|
|
|
|
static void destroy(struct sway_view *view) {
|
|
struct sway_xwayland_view *xwayland_view = xwayland_view_from_view(view);
|
|
if (xwayland_view == NULL) {
|
|
return;
|
|
}
|
|
free(xwayland_view);
|
|
}
|
|
|
|
static const struct sway_view_impl view_impl = {
|
|
.get_string_prop = get_string_prop,
|
|
.get_int_prop = get_int_prop,
|
|
.configure = configure,
|
|
.set_activated = set_activated,
|
|
.set_tiled = set_tiled,
|
|
.set_fullscreen = set_fullscreen,
|
|
.wants_floating = wants_floating,
|
|
.is_transient_for = is_transient_for,
|
|
.close = _close,
|
|
.destroy = destroy,
|
|
};
|
|
|
|
static void get_geometry(struct sway_view *view, struct wlr_box *box) {
|
|
box->x = box->y = 0;
|
|
if (view->surface) {
|
|
box->width = view->surface->current.width;
|
|
box->height = view->surface->current.height;
|
|
} else {
|
|
box->width = 0;
|
|
box->height = 0;
|
|
}
|
|
}
|
|
|
|
static void handle_commit(struct wl_listener *listener, void *data) {
|
|
struct sway_xwayland_view *xwayland_view =
|
|
wl_container_of(listener, xwayland_view, commit);
|
|
struct sway_view *view = &xwayland_view->view;
|
|
struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
|
|
struct wlr_surface_state *state = &xsurface->surface->current;
|
|
|
|
if (view->container->node.instruction) {
|
|
get_geometry(view, &view->geometry);
|
|
transaction_notify_view_ready_by_size(view,
|
|
state->width, state->height);
|
|
} else {
|
|
struct wlr_box new_geo;
|
|
get_geometry(view, &new_geo);
|
|
|
|
if ((new_geo.width != view->width || new_geo.height != view->height) &&
|
|
container_is_floating(view->container)) {
|
|
// A floating view has unexpectedly sent a new size
|
|
// eg. The Firefox "Save As" dialog when downloading a file
|
|
desktop_damage_view(view);
|
|
view_update_size(view, new_geo.width, new_geo.height);
|
|
memcpy(&view->geometry, &new_geo, sizeof(struct wlr_box));
|
|
desktop_damage_view(view);
|
|
transaction_commit_dirty();
|
|
} else {
|
|
memcpy(&view->geometry, &new_geo, sizeof(struct wlr_box));
|
|
}
|
|
}
|
|
|
|
view_damage_from(view);
|
|
}
|
|
|
|
static void handle_destroy(struct wl_listener *listener, void *data) {
|
|
struct sway_xwayland_view *xwayland_view =
|
|
wl_container_of(listener, xwayland_view, destroy);
|
|
struct sway_view *view = &xwayland_view->view;
|
|
|
|
if (view->surface) {
|
|
view_unmap(view);
|
|
wl_list_remove(&xwayland_view->commit.link);
|
|
}
|
|
|
|
wl_list_remove(&xwayland_view->destroy.link);
|
|
wl_list_remove(&xwayland_view->request_configure.link);
|
|
wl_list_remove(&xwayland_view->request_fullscreen.link);
|
|
wl_list_remove(&xwayland_view->request_move.link);
|
|
wl_list_remove(&xwayland_view->request_resize.link);
|
|
wl_list_remove(&xwayland_view->request_activate.link);
|
|
wl_list_remove(&xwayland_view->set_title.link);
|
|
wl_list_remove(&xwayland_view->set_class.link);
|
|
wl_list_remove(&xwayland_view->set_role.link);
|
|
wl_list_remove(&xwayland_view->set_window_type.link);
|
|
wl_list_remove(&xwayland_view->set_hints.link);
|
|
wl_list_remove(&xwayland_view->set_decorations.link);
|
|
wl_list_remove(&xwayland_view->map.link);
|
|
wl_list_remove(&xwayland_view->unmap.link);
|
|
view_begin_destroy(&xwayland_view->view);
|
|
}
|
|
|
|
static void handle_unmap(struct wl_listener *listener, void *data) {
|
|
struct sway_xwayland_view *xwayland_view =
|
|
wl_container_of(listener, xwayland_view, unmap);
|
|
struct sway_view *view = &xwayland_view->view;
|
|
|
|
if (!sway_assert(view->surface, "Cannot unmap unmapped view")) {
|
|
return;
|
|
}
|
|
|
|
view_unmap(view);
|
|
|
|
wl_list_remove(&xwayland_view->commit.link);
|
|
}
|
|
|
|
static void do_rebase(void *data) {
|
|
struct sway_cursor *cursor = data;
|
|
cursor_rebase(cursor);
|
|
}
|
|
|
|
static void handle_map(struct wl_listener *listener, void *data) {
|
|
struct sway_xwayland_view *xwayland_view =
|
|
wl_container_of(listener, xwayland_view, map);
|
|
struct wlr_xwayland_surface *xsurface = data;
|
|
struct sway_view *view = &xwayland_view->view;
|
|
|
|
if (xsurface->override_redirect) {
|
|
// This window used not to have the override redirect flag and has it
|
|
// now. Switch to unmanaged.
|
|
handle_destroy(&xwayland_view->destroy, view);
|
|
struct sway_xwayland_unmanaged *unmanaged = create_unmanaged(xsurface);
|
|
unmanaged_handle_map(&unmanaged->map, xsurface);
|
|
return;
|
|
}
|
|
|
|
view->natural_width = xsurface->width;
|
|
view->natural_height = xsurface->height;
|
|
|
|
// Wire up the commit listener here, because xwayland map/unmap can change
|
|
// the underlying wlr_surface
|
|
wl_signal_add(&xsurface->surface->events.commit, &xwayland_view->commit);
|
|
xwayland_view->commit.notify = handle_commit;
|
|
|
|
// Put it back into the tree
|
|
view_map(view, xsurface->surface, xsurface->fullscreen, false);
|
|
|
|
struct sway_seat *seat = input_manager_current_seat();
|
|
transaction_commit_dirty_with_callback(do_rebase, seat->cursor);
|
|
}
|
|
|
|
static void handle_request_configure(struct wl_listener *listener, void *data) {
|
|
struct sway_xwayland_view *xwayland_view =
|
|
wl_container_of(listener, xwayland_view, request_configure);
|
|
struct wlr_xwayland_surface_configure_event *ev = data;
|
|
struct sway_view *view = &xwayland_view->view;
|
|
struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
|
|
if (!xsurface->mapped) {
|
|
wlr_xwayland_surface_configure(xsurface, ev->x, ev->y,
|
|
ev->width, ev->height);
|
|
return;
|
|
}
|
|
if (container_is_floating(view->container)) {
|
|
configure(view, view->container->current.view_x,
|
|
view->container->current.view_y, ev->width, ev->height);
|
|
} else {
|
|
configure(view, view->container->current.view_x,
|
|
view->container->current.view_y,
|
|
view->container->current.view_width,
|
|
view->container->current.view_height);
|
|
}
|
|
}
|
|
|
|
static void handle_request_fullscreen(struct wl_listener *listener, void *data) {
|
|
struct sway_xwayland_view *xwayland_view =
|
|
wl_container_of(listener, xwayland_view, request_fullscreen);
|
|
struct sway_view *view = &xwayland_view->view;
|
|
struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
|
|
if (!xsurface->mapped) {
|
|
return;
|
|
}
|
|
container_set_fullscreen(view->container, xsurface->fullscreen);
|
|
|
|
arrange_workspace(view->container->workspace);
|
|
transaction_commit_dirty();
|
|
}
|
|
|
|
static void handle_request_move(struct wl_listener *listener, void *data) {
|
|
struct sway_xwayland_view *xwayland_view =
|
|
wl_container_of(listener, xwayland_view, request_move);
|
|
struct sway_view *view = &xwayland_view->view;
|
|
struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
|
|
if (!xsurface->mapped) {
|
|
return;
|
|
}
|
|
if (!container_is_floating(view->container)) {
|
|
return;
|
|
}
|
|
struct sway_seat *seat = input_manager_current_seat();
|
|
seat_begin_move_floating(seat, view->container, seat->last_button);
|
|
}
|
|
|
|
static void handle_request_resize(struct wl_listener *listener, void *data) {
|
|
struct sway_xwayland_view *xwayland_view =
|
|
wl_container_of(listener, xwayland_view, request_resize);
|
|
struct sway_view *view = &xwayland_view->view;
|
|
struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
|
|
if (!xsurface->mapped) {
|
|
return;
|
|
}
|
|
if (!container_is_floating(view->container)) {
|
|
return;
|
|
}
|
|
struct wlr_xwayland_resize_event *e = data;
|
|
struct sway_seat *seat = input_manager_current_seat();
|
|
seat_begin_resize_floating(seat, view->container,
|
|
seat->last_button, e->edges);
|
|
}
|
|
|
|
static void handle_request_activate(struct wl_listener *listener, void *data) {
|
|
struct sway_xwayland_view *xwayland_view =
|
|
wl_container_of(listener, xwayland_view, request_activate);
|
|
struct sway_view *view = &xwayland_view->view;
|
|
struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
|
|
if (!xsurface->mapped) {
|
|
return;
|
|
}
|
|
view_request_activate(view);
|
|
|
|
transaction_commit_dirty();
|
|
}
|
|
|
|
static void handle_set_title(struct wl_listener *listener, void *data) {
|
|
struct sway_xwayland_view *xwayland_view =
|
|
wl_container_of(listener, xwayland_view, set_title);
|
|
struct sway_view *view = &xwayland_view->view;
|
|
struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
|
|
if (!xsurface->mapped) {
|
|
return;
|
|
}
|
|
view_update_title(view, false);
|
|
view_execute_criteria(view);
|
|
}
|
|
|
|
static void handle_set_class(struct wl_listener *listener, void *data) {
|
|
struct sway_xwayland_view *xwayland_view =
|
|
wl_container_of(listener, xwayland_view, set_class);
|
|
struct sway_view *view = &xwayland_view->view;
|
|
struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
|
|
if (!xsurface->mapped) {
|
|
return;
|
|
}
|
|
view_execute_criteria(view);
|
|
}
|
|
|
|
static void handle_set_role(struct wl_listener *listener, void *data) {
|
|
struct sway_xwayland_view *xwayland_view =
|
|
wl_container_of(listener, xwayland_view, set_role);
|
|
struct sway_view *view = &xwayland_view->view;
|
|
struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
|
|
if (!xsurface->mapped) {
|
|
return;
|
|
}
|
|
view_execute_criteria(view);
|
|
}
|
|
|
|
static void handle_set_window_type(struct wl_listener *listener, void *data) {
|
|
struct sway_xwayland_view *xwayland_view =
|
|
wl_container_of(listener, xwayland_view, set_window_type);
|
|
struct sway_view *view = &xwayland_view->view;
|
|
struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
|
|
if (!xsurface->mapped) {
|
|
return;
|
|
}
|
|
view_execute_criteria(view);
|
|
}
|
|
|
|
static void handle_set_hints(struct wl_listener *listener, void *data) {
|
|
struct sway_xwayland_view *xwayland_view =
|
|
wl_container_of(listener, xwayland_view, set_hints);
|
|
struct sway_view *view = &xwayland_view->view;
|
|
struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
|
|
if (!xsurface->mapped) {
|
|
return;
|
|
}
|
|
if (!xsurface->hints_urgency && view->urgent_timer) {
|
|
// The view is is in the timeout period. We'll ignore the request to
|
|
// unset urgency so that the view remains urgent until the timer clears
|
|
// it.
|
|
return;
|
|
}
|
|
if (view->allow_request_urgent) {
|
|
view_set_urgent(view, (bool)xsurface->hints_urgency);
|
|
}
|
|
}
|
|
|
|
struct sway_view *view_from_wlr_xwayland_surface(
|
|
struct wlr_xwayland_surface *xsurface) {
|
|
return xsurface->data;
|
|
}
|
|
|
|
void handle_xwayland_surface(struct wl_listener *listener, void *data) {
|
|
struct sway_server *server = wl_container_of(listener, server,
|
|
xwayland_surface);
|
|
struct wlr_xwayland_surface *xsurface = data;
|
|
|
|
if (xsurface->override_redirect) {
|
|
wlr_log(WLR_DEBUG, "New xwayland unmanaged surface");
|
|
create_unmanaged(xsurface);
|
|
return;
|
|
}
|
|
|
|
wlr_log(WLR_DEBUG, "New xwayland surface title='%s' class='%s'",
|
|
xsurface->title, xsurface->class);
|
|
|
|
struct sway_xwayland_view *xwayland_view =
|
|
calloc(1, sizeof(struct sway_xwayland_view));
|
|
if (!sway_assert(xwayland_view, "Failed to allocate view")) {
|
|
return;
|
|
}
|
|
|
|
view_init(&xwayland_view->view, SWAY_VIEW_XWAYLAND, &view_impl);
|
|
xwayland_view->view.wlr_xwayland_surface = xsurface;
|
|
|
|
wl_signal_add(&xsurface->events.destroy, &xwayland_view->destroy);
|
|
xwayland_view->destroy.notify = handle_destroy;
|
|
|
|
wl_signal_add(&xsurface->events.request_configure,
|
|
&xwayland_view->request_configure);
|
|
xwayland_view->request_configure.notify = handle_request_configure;
|
|
|
|
wl_signal_add(&xsurface->events.request_fullscreen,
|
|
&xwayland_view->request_fullscreen);
|
|
xwayland_view->request_fullscreen.notify = handle_request_fullscreen;
|
|
|
|
wl_signal_add(&xsurface->events.request_activate,
|
|
&xwayland_view->request_activate);
|
|
xwayland_view->request_activate.notify = handle_request_activate;
|
|
|
|
wl_signal_add(&xsurface->events.request_move,
|
|
&xwayland_view->request_move);
|
|
xwayland_view->request_move.notify = handle_request_move;
|
|
|
|
wl_signal_add(&xsurface->events.request_resize,
|
|
&xwayland_view->request_resize);
|
|
xwayland_view->request_resize.notify = handle_request_resize;
|
|
|
|
wl_signal_add(&xsurface->events.set_title, &xwayland_view->set_title);
|
|
xwayland_view->set_title.notify = handle_set_title;
|
|
|
|
wl_signal_add(&xsurface->events.set_class, &xwayland_view->set_class);
|
|
xwayland_view->set_class.notify = handle_set_class;
|
|
|
|
wl_signal_add(&xsurface->events.set_role, &xwayland_view->set_role);
|
|
xwayland_view->set_role.notify = handle_set_role;
|
|
|
|
wl_signal_add(&xsurface->events.set_window_type,
|
|
&xwayland_view->set_window_type);
|
|
xwayland_view->set_window_type.notify = handle_set_window_type;
|
|
|
|
wl_signal_add(&xsurface->events.set_hints, &xwayland_view->set_hints);
|
|
xwayland_view->set_hints.notify = handle_set_hints;
|
|
|
|
wl_signal_add(&xsurface->events.set_decorations,
|
|
&xwayland_view->set_decorations);
|
|
xwayland_view->set_decorations.notify = handle_set_decorations;
|
|
|
|
wl_signal_add(&xsurface->events.unmap, &xwayland_view->unmap);
|
|
xwayland_view->unmap.notify = handle_unmap;
|
|
|
|
wl_signal_add(&xsurface->events.map, &xwayland_view->map);
|
|
xwayland_view->map.notify = handle_map;
|
|
|
|
xsurface->data = xwayland_view;
|
|
}
|
|
|
|
void handle_xwayland_ready(struct wl_listener *listener, void *data) {
|
|
struct sway_server *server =
|
|
wl_container_of(listener, server, xwayland_ready);
|
|
struct sway_xwayland *xwayland = &server->xwayland;
|
|
|
|
xcb_connection_t *xcb_conn = xcb_connect(NULL, NULL);
|
|
int err = xcb_connection_has_error(xcb_conn);
|
|
if (err) {
|
|
wlr_log(WLR_ERROR, "XCB connect failed: %d", err);
|
|
return;
|
|
}
|
|
|
|
xcb_intern_atom_cookie_t cookies[ATOM_LAST];
|
|
for (size_t i = 0; i < ATOM_LAST; i++) {
|
|
cookies[i] =
|
|
xcb_intern_atom(xcb_conn, 0, strlen(atom_map[i]), atom_map[i]);
|
|
}
|
|
for (size_t i = 0; i < ATOM_LAST; i++) {
|
|
xcb_generic_error_t *error = NULL;
|
|
xcb_intern_atom_reply_t *reply =
|
|
xcb_intern_atom_reply(xcb_conn, cookies[i], &error);
|
|
if (reply != NULL && error == NULL) {
|
|
xwayland->atoms[i] = reply->atom;
|
|
}
|
|
free(reply);
|
|
|
|
if (error != NULL) {
|
|
wlr_log(WLR_ERROR, "could not resolve atom %s, X11 error code %d",
|
|
atom_map[i], error->error_code);
|
|
free(error);
|
|
break;
|
|
}
|
|
}
|
|
|
|
xcb_disconnect(xcb_conn);
|
|
}
|