swayfx/sway/desktop/xwayland.c

333 lines
11 KiB
C
Raw Normal View History

2017-12-04 22:19:36 +11:00
#define _POSIX_C_SOURCE 199309L
#include <stdbool.h>
#include <stdlib.h>
#include <wayland-server.h>
2017-12-06 03:02:31 +11:00
#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/input/input-manager.h"
#include "sway/input/seat.h"
#include "sway/output.h"
#include "sway/server.h"
#include "sway/tree/container.h"
#include "sway/tree/layout.h"
#include "sway/tree/view.h"
2017-12-04 22:19:36 +11:00
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);
}
2018-04-06 07:08:30 +10:00
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;
2018-04-06 08:48:35 +10:00
if (xsurface->x != surface->lx || xsurface->y != surface->ly) {
// Surface has moved
desktop_damage_surface(xsurface->surface, surface->lx, surface->ly,
true);
2018-04-06 08:48:35 +10:00
surface->lx = xsurface->x;
surface->ly = xsurface->y;
desktop_damage_surface(xsurface->surface, surface->lx, surface->ly,
true);
2018-04-06 08:48:35 +10:00
} else {
desktop_damage_surface(xsurface->surface, xsurface->x, xsurface->y,
false);
2018-04-06 08:48:35 +10:00
}
2018-04-06 07:08:30 +10:00
}
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;
2018-04-06 08:48:35 +10:00
2018-04-06 07:08:30 +10:00
wl_list_insert(&root_container.sway_root->xwayland_unmanaged,
&surface->link);
2018-04-06 08:48:35 +10:00
2018-04-06 07:08:30 +10:00
wl_signal_add(&xsurface->surface->events.commit, &surface->commit);
surface->commit.notify = unmanaged_handle_commit;
2018-04-06 08:48:35 +10:00
surface->lx = xsurface->x;
surface->ly = xsurface->y;
desktop_damage_surface(xsurface->surface, surface->lx, surface->ly, true);
if (!wlr_xwayland_surface_is_unmanaged(xsurface)) {
struct sway_seat *seat = input_manager_current_seat(input_manager);
struct wlr_xwayland *xwayland = seat->input->server->xwayland;
wlr_xwayland_set_seat(xwayland, seat->wlr_seat);
seat_set_focus_surface(seat, xsurface->surface);
}
// TODO: we don't send surface enter/leave events to xwayland unmanaged
// surfaces, but xwayland doesn't support HiDPI anyway
2018-04-06 07:08:30 +10:00
}
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);
2018-04-06 07:08:30 +10:00
wl_list_remove(&surface->link);
wl_list_remove(&surface->commit.link);
}
static void unmanaged_handle_destroy(struct wl_listener *listener, void *data) {
2018-04-06 07:08:30 +10:00
struct sway_xwayland_unmanaged *surface =
wl_container_of(listener, surface, destroy);
struct wlr_xwayland_surface *xsurface = surface->wlr_xwayland_surface;
if (xsurface->mapped) {
unmanaged_handle_unmap(&surface->unmap, xsurface);
}
wl_list_remove(&surface->map.link);
wl_list_remove(&surface->unmap.link);
wl_list_remove(&surface->destroy.link);
free(surface);
}
2018-04-06 07:08:30 +10:00
static struct sway_xwayland_unmanaged *create_unmanaged(
struct wlr_xwayland_surface *xsurface) {
struct sway_xwayland_unmanaged *surface =
calloc(1, sizeof(struct sway_xwayland_unmanaged));
2018-04-06 07:08:30 +10:00
if (surface == NULL) {
wlr_log(L_ERROR, "Allocation failed");
return NULL;
}
2018-04-06 07:08:30 +10:00
surface->wlr_xwayland_surface = xsurface;
wl_signal_add(&xsurface->events.request_configure,
&surface->request_configure);
surface->request_configure.notify = unmanaged_handle_request_configure;
2018-04-06 07:08:30 +10:00
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;
2018-04-06 07:08:30 +10:00
return surface;
}
2018-04-06 01:38:14 +10:00
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;
}
2017-12-04 22:19:36 +11:00
static const char *get_prop(struct sway_view *view, enum sway_view_prop prop) {
2018-04-06 01:38:14 +10:00
if (xwayland_view_from_view(view) == NULL) {
2017-12-04 22:19:36 +11:00
return NULL;
}
switch (prop) {
case VIEW_PROP_TITLE:
return view->wlr_xwayland_surface->title;
case VIEW_PROP_CLASS:
return view->wlr_xwayland_surface->class;
default:
return NULL;
}
}
2018-04-03 00:57:45 +10:00
static void configure(struct sway_view *view, double ox, double oy, int width,
int height) {
2018-04-06 01:38:14 +10:00
struct sway_xwayland_view *xwayland_view = xwayland_view_from_view(view);
if (xwayland_view == NULL) {
2017-12-04 22:19:36 +11:00
return;
}
struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
struct sway_container *output = container_parent(view->swayc, C_OUTPUT);
2017-12-06 03:02:31 +11:00
if (!sway_assert(output, "view must be within tree to set position")) {
return;
}
struct sway_container *root = container_parent(output, C_ROOT);
2017-12-06 03:02:31 +11:00
if (!sway_assert(root, "output must be within tree to set position")) {
return;
}
2017-12-13 06:02:01 +11:00
struct wlr_output_layout *layout = root->sway_root->output_layout;
2017-12-06 03:02:31 +11:00
struct wlr_output_layout_output *loutput =
wlr_output_layout_get(layout, output->sway_output->wlr_output);
if (!sway_assert(loutput, "output must be within layout to set position")) {
return;
}
2018-04-03 00:57:45 +10:00
view_update_position(view, ox, oy);
2017-12-06 03:02:31 +11:00
2018-04-06 01:38:14 +10:00
xwayland_view->pending_width = width;
xwayland_view->pending_height = height;
2018-04-03 00:57:45 +10:00
wlr_xwayland_surface_configure(xsurface, ox + loutput->x, oy + loutput->y,
width, height);
2017-12-06 03:02:31 +11:00
}
2017-12-06 23:34:33 +11:00
static void set_activated(struct sway_view *view, bool activated) {
2018-04-06 01:38:14 +10:00
if (xwayland_view_from_view(view) == NULL) {
2017-12-06 23:34:33 +11:00
return;
}
struct wlr_xwayland_surface *surface = view->wlr_xwayland_surface;
wlr_xwayland_surface_activate(surface, activated);
}
2018-04-16 20:36:40 +10:00
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);
}
2018-04-01 08:07:44 +10:00
static void _close(struct sway_view *view) {
2018-04-06 01:38:14 +10:00
if (xwayland_view_from_view(view) == NULL) {
2018-01-21 06:10:11 +11:00
return;
}
wlr_xwayland_surface_close(view->wlr_xwayland_surface);
}
2018-04-06 01:38:14 +10:00
static void destroy(struct sway_view *view) {
struct sway_xwayland_view *xwayland_view = xwayland_view_from_view(view);
if (xwayland_view == NULL) {
return;
}
wl_list_remove(&xwayland_view->destroy.link);
wl_list_remove(&xwayland_view->request_configure.link);
2018-04-16 20:36:40 +10:00
wl_list_remove(&xwayland_view->request_fullscreen.link);
2018-04-06 01:38:14 +10:00
wl_list_remove(&xwayland_view->map.link);
wl_list_remove(&xwayland_view->unmap.link);
free(xwayland_view);
}
2018-04-01 08:07:44 +10:00
static const struct sway_view_impl view_impl = {
.get_prop = get_prop,
2018-04-03 00:57:45 +10:00
.configure = configure,
2018-04-01 08:07:44 +10:00
.set_activated = set_activated,
2018-04-16 20:36:40 +10:00
.set_fullscreen = set_fullscreen,
2018-04-01 08:07:44 +10:00
.close = _close,
2018-04-06 07:08:30 +10:00
.destroy = destroy,
2018-04-01 08:07:44 +10:00
};
2017-12-04 22:19:36 +11:00
static void handle_commit(struct wl_listener *listener, void *data) {
2018-04-06 01:38:14 +10:00
struct sway_xwayland_view *xwayland_view =
wl_container_of(listener, xwayland_view, commit);
struct sway_view *view = &xwayland_view->view;
2017-12-04 22:19:36 +11:00
// NOTE: We intentionally discard the view's desired width here
// TODO: Let floating views do whatever
2018-04-06 01:38:14 +10:00
view_update_size(view, xwayland_view->pending_width,
xwayland_view->pending_height);
view_damage(view, false);
2017-12-04 22:19:36 +11:00
}
static void handle_unmap(struct wl_listener *listener, void *data) {
2018-04-06 01:38:14 +10:00
struct sway_xwayland_view *xwayland_view =
wl_container_of(listener, xwayland_view, unmap);
wl_list_remove(&xwayland_view->commit.link);
view_unmap(&xwayland_view->view);
2018-01-15 05:19:21 +11:00
}
static void handle_map(struct wl_listener *listener, void *data) {
2018-04-06 01:38:14 +10:00
struct sway_xwayland_view *xwayland_view =
wl_container_of(listener, xwayland_view, map);
2018-01-15 05:19:21 +11:00
struct wlr_xwayland_surface *xsurface = data;
2018-04-06 01:38:14 +10:00
struct sway_view *view = &xwayland_view->view;
// 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;
2018-01-16 01:38:05 +11:00
2018-04-06 01:38:14 +10:00
// Put it back into the tree
wlr_xwayland_surface_set_maximized(xsurface, true);
view_map(view, xsurface->surface);
if (xsurface->fullscreen) {
view_set_fullscreen(view, true);
}
2017-12-04 22:19:36 +11:00
}
static void handle_destroy(struct wl_listener *listener, void *data) {
struct sway_xwayland_view *xwayland_view =
wl_container_of(listener, xwayland_view, destroy);
view_destroy(&xwayland_view->view);
}
2018-04-01 02:30:15 +11:00
static void handle_request_configure(struct wl_listener *listener, void *data) {
2018-04-06 01:38:14 +10:00
struct sway_xwayland_view *xwayland_view =
wl_container_of(listener, xwayland_view, request_configure);
2017-12-04 22:19:36 +11:00
struct wlr_xwayland_surface_configure_event *ev = data;
2018-04-06 01:38:14 +10:00
struct sway_view *view = &xwayland_view->view;
2017-12-04 22:19:36 +11:00
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;
}
// TODO: Let floating views do whatever
configure(view, view->swayc->x, view->swayc->y, view->width, view->height);
2017-12-04 22:19:36 +11:00
}
2018-04-16 20:36:40 +10:00
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;
}
2018-04-16 20:36:40 +10:00
view_set_fullscreen(view, xsurface->fullscreen);
}
2017-12-04 22:19:36 +11:00
void handle_xwayland_surface(struct wl_listener *listener, void *data) {
2018-04-06 01:38:14 +10:00
struct sway_server *server = wl_container_of(listener, server,
xwayland_surface);
2017-12-04 22:19:36 +11:00
struct wlr_xwayland_surface *xsurface = data;
if (wlr_xwayland_surface_is_unmanaged(xsurface) ||
xsurface->override_redirect) {
wlr_log(L_DEBUG, "New xwayland unmanaged surface");
create_unmanaged(xsurface);
return;
}
2018-01-06 08:32:51 +11:00
wlr_log(L_DEBUG, "New xwayland surface title='%s' class='%s'",
xsurface->title, xsurface->class);
2017-12-04 22:19:36 +11:00
2018-04-06 01:38:14 +10:00
struct sway_xwayland_view *xwayland_view =
calloc(1, sizeof(struct sway_xwayland_view));
if (!sway_assert(xwayland_view, "Failed to allocate view")) {
2017-12-04 22:19:36 +11:00
return;
}
2018-04-06 01:38:14 +10:00
view_init(&xwayland_view->view, SWAY_VIEW_XWAYLAND, &view_impl);
xwayland_view->view.wlr_xwayland_surface = xsurface;
2017-12-04 22:19:36 +11:00
// TODO:
// - Look up pid and open on appropriate workspace
2017-12-13 06:02:01 +11:00
2018-04-06 01:38:14 +10:00
wl_signal_add(&xsurface->events.destroy, &xwayland_view->destroy);
xwayland_view->destroy.notify = handle_destroy;
2018-01-15 05:19:21 +11:00
2017-12-04 22:19:36 +11:00
wl_signal_add(&xsurface->events.request_configure,
2018-04-06 01:38:14 +10:00
&xwayland_view->request_configure);
xwayland_view->request_configure.notify = handle_request_configure;
2018-01-15 05:19:21 +11:00
2018-04-16 20:36:40 +10:00
wl_signal_add(&xsurface->events.request_fullscreen,
&xwayland_view->request_fullscreen);
xwayland_view->request_fullscreen.notify = handle_request_fullscreen;
2018-04-06 01:38:14 +10:00
wl_signal_add(&xsurface->events.unmap, &xwayland_view->unmap);
xwayland_view->unmap.notify = handle_unmap;
2018-01-15 05:19:21 +11:00
2018-04-06 01:38:14 +10:00
wl_signal_add(&xsurface->events.map, &xwayland_view->map);
xwayland_view->map.notify = handle_map;
2017-12-04 22:19:36 +11:00
}